/***************************************************************************** * * FILE: sxmlrpc.h * DESCRIPTION: Skimpy XML-RPC library header file * DATE: Sat, Mar 18 2006 * UPDATED: Tue, Sep 4 2007 * AUTHOR: Kouichi ABE (WALL) / °¤Éô¹¯°ì * E-MAIL: kouichi@MysticWALL.COM * URL: http://www.MysticWALL.COM/ * COPYRIGHT: (c) 2006-2007 °¤Éô¹¯°ì¡¿Kouichi ABE (WALL), All rights reserved. * NOTES: http://www.xmlrpc.com/spec * LICENSE: * * Copyright (c) 2006-2007 Kouichi ABE (WALL) , * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $Id: sxmlrpc.h,v 1.10 2007/09/04 08:18:02 kouichi Exp $ * *****************************************************************************/ #ifndef _SXMLRPC_H #define _SXMLRPC_H #include #include /****************************************************************************** * * Macros and structures definition * *****************************************************************************/ /* * Numeric release version identifier: * MNNFFPPS: major minor fix patch status * The status nibble has one of the values 0 for development, * 1 to e for betas 1 to 14, and f for release. * The patch level is exactly that. */ #define SXMLRPC_VERSION_NUMBER 0x10004000L #define SXMLRPC_VERSION "SXMLRPC/1.0.4" #define SXMLRPC_VERSION_TEXT SXMLRPC_VERSION " (2007/09/04)" #define SXMLRPC_VERSION_TEXT_LONG \ "Skimpy XML-RPC Library 1.0.4, Tue, Sep 4 2007" /* XML-RPC server/client */ typedef enum { SXMLRPC_ROLE_SERVER, SXMLRPC_ROLE_CLIENT } sxmlrpc_role_t; /* XML-RPC payload type */ typedef enum { SXMLRPC_METHOD_NONE, SXMLRPC_METHOD_CALL, SXMLRPC_METHOD_RESPONSE, SXMLRPC_METHOD_RESPONSE_FAULT } sxmlrpc_method_t; /* XML-RPC value type */ typedef enum { SXMLRPC_VALUE_INTEGER, SXMLRPC_VALUE_DOUBLE, SXMLRPC_VALUE_BOOLEAN, SXMLRPC_VALUE_STRING, SXMLRPC_VALUE_DATETIME, SXMLRPC_VALUE_BASE64, SXMLRPC_VALUE_STRUCT, SXMLRPC_VALUE_ARRAY } sxmlrpc_value_type_t; /* XML-RPC integer */ typedef int32_t sxmlrpc_int_t; /* XML-RPC double */ typedef double sxmlrpc_double_t; /* XML-RPC boolean */ #ifndef _BOOL_T #define _BOOL_T typedef enum { false = 0, true = 1 } sxmlrpc_boolean_t; typedef sxmlrpc_boolean_t bool; #endif /* _BOOL_T */ /* XML-RPC string (or dateTime.iso8601, base64) */ typedef u_int8_t * sxmlrpc_string_t; /* XML-RPC struct */ typedef struct _sxmlrpc_struct_t { size_t size; struct _sxmlrpc_member_t * member; } sxmlrpc_struct_t; #define sxmlrpc_set_struct(t,s,m) \ do { \ (t)->size = s; \ (t)->member = m; \ } while (0) /* XML-RPC array */ typedef struct _sxmlrpc_array_t { size_t size; struct _sxmlrpc_value_t * value; } sxmlrpc_array_t; #define sxmlrpc_set_array(a,s,v) \ do { \ (a)->size = s; \ (a)->value = v; \ } while (0) /* XML-RPC value */ typedef struct _sxmlrpc_value_t { sxmlrpc_value_type_t type; union { sxmlrpc_int_t ival; sxmlrpc_double_t dval; sxmlrpc_boolean_t bval; sxmlrpc_string_t sval; /* string | dateTime | base64 */ sxmlrpc_struct_t tval; sxmlrpc_array_t aval; } u; } sxmlrpc_value_t; #define sxmlrpc_get_value_type(v) ((v)->type) #define sxmlrpc_get_value_int(v) ((v)->u.ival) #define sxmlrpc_get_value_double(v) ((v)->u.dval) #define sxmlrpc_get_value_boolean(v) ((v)->u.bval) #define sxmlrpc_get_value_string(v) ((v)->u.sval) #define sxmlrpc_get_value_datetime(v) ((v)->u.sval) #define sxmlrpc_get_value_base64(v) ((v)->u.sval) #define sxmlrpc_get_value_struct(v) ((v)->u.tval) #define sxmlrpc_get_value_array(v) ((v)->u.aval) #define sxmlrpc_get_struct_size(v) ((v)->u.tval.size) #define sxmlrpc_get_struct_member(v) ((v)->u.tval.member) #define sxmlrpc_get_array_size(v) ((v)->u.aval.size) #define sxmlrpc_get_array_value(v) ((v)->u.aval.value) /* member of XML-RPC struct */ typedef struct _sxmlrpc_member_t { sxmlrpc_string_t name; sxmlrpc_value_t value; } sxmlrpc_member_t; /* XML-RPC param */ typedef struct _sxmlrpc_param_t { sxmlrpc_value_t value; } sxmlrpc_param_t; /* XML-RPC params */ typedef struct _sxmlrpc_params_t { size_t size; sxmlrpc_param_t * param; } sxmlrpc_params_t; /* XML-RPC */ typedef struct { sxmlrpc_role_t role; sxmlrpc_method_t method; char * hostname; char * servname; char * path; char * encoding; /* XML-RPC Call/Response payload */ union { #define call_method u.call.method_name #define call_params u.call.params struct { char * method_name; sxmlrpc_params_t params; } call; #define response_value u.response #define fault_code u.response.u.tval.member[0].value.u.ival #define fault_string u.response.u.tval.member[1].value.u.sval sxmlrpc_value_t response; } u; /* HTTP-Request/Response Header/Body */ struct { #define msghdr_text mesg.head.text #define msghdr_size mesg.head.size struct { char * text; int size; } head; #define msgbdy_fd mesg.body.fd #define msgbdy_size mesg.body.size struct { int fd; size_t size; } body; } mesg; } sxmlrpc_t; #define sxmlrpc_method_name(x) ((x)->call_method) #define sxmlrpc_call_params(x) ((x)->call_params) #define sxmlrpc_response_ok(x) ((x)->method=SXMLRPC_METHOD_RESPONSE) #define sxmlrpc_response_fault(x) \ ((x)->method=SXMLRPC_METHOD_RESPONSE_FAULT) /* the type for a callback function */ typedef int (*sxmlrpc_callback_t)( const char * client, /* client IP address */ const char * method, /* method name */ sxmlrpc_params_t * params, /* parameters for method */ sxmlrpc_param_t * param /* parameter returned as result */ ); /****************************************************************************** * * Global functions declaration * *****************************************************************************/ /* * create new object for XML-RPC */ sxmlrpc_t * sxmlrpc_new( const char * hostname, /* server/client IP address */ const char * servname, /* server/client port number */ const char * path); /* server/client request-URI */ /* * free object of XML-RPC */ void sxmlrpc_free(sxmlrpc_t * sxRPC); /* * clear old response value of XML-RPC object */ void sxmlrpc_flush(sxmlrpc_t * sxRPC); /* * clear dynamic allocated area of value */ void sxmlrpc_flush_value(sxmlrpc_value_t * v); /* * call method of XML-RPC server */ int sxmlrpc_call( sxmlrpc_t * sxRPC, /* an object of XML-RPC */ const char * methodName, /* method name */ sxmlrpc_param_t * param, /* parameter for method */ size_t param_num); /* number of parameter */ /* * reply to a request from XML-RPC client */ int sxmlrpc_server( sxmlrpc_t * sxRPC, /* an object of XML-RPC */ const int backlog, /* backlog of listen(2) */ sxmlrpc_callback_t callback); /* callback function to process request */ /*****************************************************************************/ /* * set value functions */ int sxmlrpc_set_value_int(sxmlrpc_value_t *, sxmlrpc_int_t); int sxmlrpc_set_value_double(sxmlrpc_value_t *, sxmlrpc_double_t); int sxmlrpc_set_value_boolean(sxmlrpc_value_t *, sxmlrpc_boolean_t); int sxmlrpc_set_value_string(sxmlrpc_value_t *, sxmlrpc_string_t); int sxmlrpc_set_value_datetime(sxmlrpc_value_t *, sxmlrpc_string_t); int sxmlrpc_set_value_base64(sxmlrpc_value_t *, sxmlrpc_string_t); int sxmlrpc_set_value_struct(sxmlrpc_value_t *, sxmlrpc_struct_t); int sxmlrpc_set_value_array(sxmlrpc_value_t *, sxmlrpc_array_t); int sxmlrpc_set_param(sxmlrpc_param_t * param, sxmlrpc_value_t value); /* * set fault response */ int sxmlrpc_set_fault( sxmlrpc_param_t * param, /* parameter for response */ int faultCode, /* value of */ sxmlrpc_string_t faultString); /* value of */ /*****************************************************************************/ int sxmlrpc_get_fault_code(sxmlrpc_t *); sxmlrpc_string_t sxmlrpc_get_fault_string(sxmlrpc_t *); sxmlrpc_value_t * sxmlrpc_get_response_value(sxmlrpc_t *); /*****************************************************************************/ void sxmlrpc_print_value(sxmlrpc_value_t * value, FILE * output); void sxmlrpc_copy_value(sxmlrpc_value_t * dst_value, sxmlrpc_value_t * src_value); /*****************************************************************************/ const char * sxmlrpc_get_datetime_iso8601(const time_t); const char * sxmlrpc_get_current_datetime_iso8601(void); int sxmlrpc_base64_encode( /* >0: successful, -1: error */ const char * text, /* input text */ char * buf, /* return buffer of base64 encoded text */ size_t len); /* buffer size */ int sxmlrpc_base64_decode( /* >0: successful, -1: error */ const char * text, /* input text */ char * buf, /* return buffer of base64 decoded text */ size_t len); /* buffer size */ /*****************************************************************************/ int sxmlrpc_get_call_params(sxmlrpc_t *, int input_fd); int sxmlrpc_set_response_param(sxmlrpc_t *, sxmlrpc_param_t * param, int output_fd); void sxmlrpc_set_encoding(sxmlrpc_t *, const char * ctype); #endif /* _SXMLRPC_H */