Annotation of embedaddon/libpdel/structs/structs_xmlrpc.3, revision 1.1

1.1     ! misho       1: .\" Copyright (c) 2001-2002 Packet Design, LLC.
        !             2: .\" All rights reserved.
        !             3: .\" 
        !             4: .\" Subject to the following obligations and disclaimer of warranty,
        !             5: .\" use and redistribution of this software, in source or object code
        !             6: .\" forms, with or without modifications are expressly permitted by
        !             7: .\" Packet Design; provided, however, that:
        !             8: .\" 
        !             9: .\"    (i)  Any and all reproductions of the source or object code
        !            10: .\"         must include the copyright notice above and the following
        !            11: .\"         disclaimer of warranties; and
        !            12: .\"    (ii) No rights are granted, in any manner or form, to use
        !            13: .\"         Packet Design trademarks, including the mark "PACKET DESIGN"
        !            14: .\"         on advertising, endorsements, or otherwise except as such
        !            15: .\"         appears in the above copyright notice or in the software.
        !            16: .\" 
        !            17: .\" THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
        !            18: .\" TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
        !            19: .\" REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
        !            20: .\" THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
        !            21: .\" WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
        !            22: .\" OR NON-INFRINGEMENT.  PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
        !            23: .\" OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
        !            24: .\" OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
        !            25: .\" RELIABILITY OR OTHERWISE.  IN NO EVENT SHALL PACKET DESIGN BE
        !            26: .\" LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
        !            27: .\" OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
        !            28: .\" INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
        !            29: .\" DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
        !            30: .\" USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
        !            31: .\" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
        !            32: .\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
        !            33: .\" THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
        !            34: .\" THE POSSIBILITY OF SUCH DAMAGE.
        !            35: .\"
        !            36: .\" Author: Archie Cobbs <archie@freebsd.org>
        !            37: .\"
        !            38: .\" $Id: structs_xmlrpc.3,v 1.16 2004/06/02 17:24:38 archie Exp $
        !            39: .\"
        !            40: .Dd April 22, 2002
        !            41: .Dt STRUCTS_XMLRPC 3
        !            42: .Os
        !            43: .Sh NAME
        !            44: .Nm structs_xmlrpc
        !            45: .Nd structs support for XML-RPC
        !            46: .Sh LIBRARY
        !            47: PDEL Library (libpdel, \-lpdel)
        !            48: .Sh SYNOPSIS
        !            49: .In sys/types.h
        !            50: .In pdel/structs/structs.h
        !            51: .In pdel/structs/type/array.h
        !            52: .In pdel/structs/type/union.h
        !            53: .In pdel/structs/xmlrpc.h
        !            54: .Ft int
        !            55: .Fn structs_struct2xmlrpc "const struct structs_type *type" "const void *data" "const char *sname" "const struct structs_type *xtype" "void *xdata" "const char *xname"
        !            56: .Ft int
        !            57: .Fn structs_xmlrpc2struct "const struct structs_type *xtype" "const void *xdata" "const char *xname" "const struct structs_type *type" "void *data" "const char *sname" "char *ebuf" "size_t emax"
        !            58: .Ft "struct xmlrpc_request *"
        !            59: .Fn structs_xmlrpc_build_request "const char *mtype" "const char *methodName" "u_int nparams" "const struct structs_type **types" "const void **params"
        !            60: .Ft "struct xmlrpc_response_union *"
        !            61: .Fn structs_xmlrpc_build_response "const char *mtype" "const struct structs_type *type" "const void *data"
        !            62: .Ft "struct xmlrpc_response_union *"
        !            63: .Fn structs_xmlrpc_build_fault_response "const char *mtype" "const struct xmlrpc_compact_fault *fault"
        !            64: .Vt extern const struct structs_type structs_type_xmlrpc_value ;
        !            65: .Vt extern const struct structs_type structs_type_xmlrpc_array ;
        !            66: .Vt extern const struct structs_type structs_type_xmlrpc_member ;
        !            67: .Vt extern const struct structs_type structs_type_xmlrpc_struct ;
        !            68: .Vt extern const struct structs_type structs_type_xmlrpc_request ;
        !            69: .Vt extern const struct structs_type structs_type_xmlrpc_response ;
        !            70: .Vt extern const struct structs_type structs_type_xmlrpc_fault ;
        !            71: .Vt extern const struct structs_type structs_type_xmlrpc_compact_fault ;
        !            72: .Sh DESCRIPTION
        !            73: These functions and
        !            74: .Xr structs 3
        !            75: types provide support for XML-RPC, i.e.,
        !            76: conversion between XML-RPC values and native C data types.
        !            77: .\"
        !            78: .Ss Compact and Exploded Types
        !            79: .\"
        !            80: For any XML-RPC data structure, there are two
        !            81: .Xr structs 3
        !            82: types that describe it: a
        !            83: .Dq compact
        !            84: type and an
        !            85: .Dq exploded
        !            86: type.
        !            87: Applications usually work with compact (or native C) types, i.e., where
        !            88: XML-RPC i32's are represented by C int32_t's, XML-RPC struct's are
        !            89: represented by C structures, and so on.
        !            90: In order to convert between native data structures and XML-RPC, intermediate
        !            91: .Dq exploded
        !            92: types are used.
        !            93: This man page describes
        !            94: .Xr structs 3
        !            95: types for the exploded XML-RPC data structures and functions to convert
        !            96: between the compact and exploded forms.
        !            97: .Pp
        !            98: That is, XML-RPC is just a special case of
        !            99: .Xr structs 3
        !           100: types converted into XML with lots of extra nesting so that a fixed set
        !           101: of XML tags may be used.
        !           102: The exploded types are simply the
        !           103: .Xr structs 3
        !           104: types that include the extra nesting so that when they are converted
        !           105: to XML in the normal fashion (see
        !           106: .Xr structs_xml_output 3) ,
        !           107: the result is a well-formed XML-RPC request or response.
        !           108: .Pp
        !           109: The following types data structures are defined in the header file
        !           110: .Li "<pdel/structs/xmlrpc.h>" :
        !           111: .Pp
        !           112: .Fa structs_type_xmlrpc_value
        !           113: is a
        !           114: .Xr structs 3
        !           115: type representing an exploded XML-RPC value, i.e., a
        !           116: .Li "struct xmlrpc_value_union" .
        !           117: .Pp
        !           118: .Fa structs_type_xmlrpc_array
        !           119: is a
        !           120: .Xr structs 3
        !           121: type representing an exploded XML-RPC array, i.e., a
        !           122: .Li "struct xmlrpc_array" .
        !           123: .Pp
        !           124: .Fa structs_type_xmlrpc_member
        !           125: is a
        !           126: .Xr structs 3
        !           127: type representing an exploded XML-RPC structure member, i.e., a
        !           128: .Li "struct xmlrpc_member" .
        !           129: .Pp
        !           130: .Fa structs_type_xmlrpc_struct
        !           131: is a
        !           132: .Xr structs 3
        !           133: type representing an exploded XML-RPC structure, i.e., a
        !           134: .Li "struct xmlrpc_struct" .
        !           135: .Pp
        !           136: .Fa structs_type_xmlrpc_request
        !           137: is a
        !           138: .Xr structs 3
        !           139: type representing an exploded XML-RPC request, i.e., a
        !           140: .Li "struct xmlrpc_request" .
        !           141: .Pp
        !           142: .Fa structs_type_xmlrpc_response
        !           143: is a
        !           144: .Xr structs 3
        !           145: type representing an exploded XML-RPC response, i.e., a
        !           146: .Li "struct xmlrpc_response_union" .
        !           147: .Pp
        !           148: .Fa structs_type_xmlrpc_fault
        !           149: is a
        !           150: .Xr structs 3
        !           151: type representing an exploded XML-RPC fault, i.e., a
        !           152: .Li "struct xmlrpc_fault" .
        !           153: .Pp
        !           154: .Fa structs_type_xmlrpc_compact_fault
        !           155: is a
        !           156: .Xr structs 3
        !           157: type representing an XML-RPC fault in a compact form, i.e., a
        !           158: .Li "struct xmlrpc_compact_fault" :
        !           159: .Bd -literal -offset 3n
        !           160: struct xmlrpc_compact_fault {
        !           161:     int32_t     faultCode;      /* XML-RPC fault code */
        !           162:     char        *faultString;   /* XML-RPC fault string */
        !           163: };
        !           164: .Ed
        !           165: .\"
        !           166: .Ss Conversion Routines
        !           167: .\"
        !           168: .Fn structs_struct2xmlrpc
        !           169: converts an arbitrary compact
        !           170: .Xr structs 3
        !           171: instance into an
        !           172: .Dq exploded
        !           173: XML-RPC value.
        !           174: The original instance should be pointed to by
        !           175: .Fa data
        !           176: and have
        !           177: .Xr structs 3
        !           178: type
        !           179: .Fa type ,
        !           180: while the XML-RPC instance should be pointed to by
        !           181: .Fa xdata
        !           182: and have
        !           183: .Xr structs 3
        !           184: type
        !           185: .Fa xtype .
        !           186: .Fa sname
        !           187: and
        !           188: .Fa xname
        !           189: may be non-
        !           190: .Dv NULL
        !           191: to name specific sub-fields of
        !           192: .Fa data
        !           193: and
        !           194: .Fa xdata ,
        !           195: respectively, to convert.
        !           196: The
        !           197: .Fa xdata
        !           198: instance must already be initialized, and the sub-field of
        !           199: .Fa xdata
        !           200: specified by
        !           201: .Fa xname
        !           202: must have type
        !           203: .Fa structs_type_xmlrpc_value ,
        !           204: i.e., it must be a
        !           205: .Li "struct xmlrpc_value_union" .
        !           206: .Pp
        !           207: The following primitive
        !           208: .Xr structs 3
        !           209: types are specially recognized by
        !           210: .Fn structs_struct2xmlrpc :
        !           211: .Bl -tag -width "xxxxx" -offset indent
        !           212: .It Xo
        !           213: .Va structs_type_int32 ,
        !           214: and
        !           215: .Va structs_type_int
        !           216: when
        !           217: .Li "sizeof(int) == 4"
        !           218: .Xc
        !           219: Converted to <i4>.
        !           220: .It Xo
        !           221: .Va structs_type_boolean
        !           222: and all variants
        !           223: .Xc
        !           224: Converted to <boolean>.
        !           225: .It Va structs_type_float
        !           226: Converted to <double>.
        !           227: .It Va structs_type_double
        !           228: Converted to <double>.
        !           229: .It Va structs_type_time_iso8601
        !           230: Converted to <dateTime.iso8601>.
        !           231: .It Xo
        !           232: .Va structs_type_data
        !           233: or any variant using the default character set
        !           234: .Xc
        !           235: Converted to <base64>.
        !           236: .It Xo
        !           237: Variable and fixed length array types
        !           238: .Xc
        !           239: Converted to <array>.
        !           240: .It Xo
        !           241: Structure types
        !           242: .Xc
        !           243: Converted to <struct>.
        !           244: .It Xo
        !           245: Union types
        !           246: .Xc
        !           247: Converted to <struct>.
        !           248: .El
        !           249: .Pp
        !           250: All other primitive types are converted to XML-RPC <string>'s.
        !           251: .Pp
        !           252: .Fn structs_xmlrpc2struct
        !           253: converts an XML-RPC value back into a
        !           254: .Dq compact
        !           255: data structure, essentially the reverse of
        !           256: .Fn structs_struct2xmlrpc .
        !           257: As before,
        !           258: .Fa xname ,
        !           259: .Fa xdata ,
        !           260: and
        !           261: .Fa xtype
        !           262: describe the XML-RPC value and
        !           263: .Fa sname ,
        !           264: .Fa data ,
        !           265: and
        !           266: .Fa type
        !           267: describe the normal, native instance.
        !           268: The
        !           269: .Fa data
        !           270: instance must already be initialized.
        !           271: The sub-field of
        !           272: .Fa xdata
        !           273: specified by
        !           274: .Fa xname
        !           275: must have type
        !           276: .Fa structs_type_xmlrpc_value ,
        !           277: i.e., it must be a
        !           278: .Li "struct xmlrpc_value_union" .
        !           279: In addition, an error buffer pointed to by
        !           280: .Fa ebuf
        !           281: having size
        !           282: .Fa emax
        !           283: may be provided; if so, any errors from the decoding will be written into it.
        !           284: .Pp
        !           285: Scalar XML-RPC values are converted into primitive types by simply calling
        !           286: .Xr structs_set_string 3 .
        !           287: There is no checking that the XML-RPC tag is consistent with the
        !           288: primitive structs type; i.e., if the primitive type successfully parses
        !           289: the string, then it's assumed to be OK.
        !           290: .Pp
        !           291: Array XML-RPC values are converted into array types.
        !           292: Structure XML-RPC values are converted into structure types or union types,
        !           293: depending on the destination type provided.
        !           294: In the union case, the last field specified in the XML-RPC structure is
        !           295: chosen for the union.
        !           296: Other fields specified must be valid for the union, but are otherwise ignored.
        !           297: .\"
        !           298: .Ss XML-RPC Requests and Responses
        !           299: .\"
        !           300: .Fn structs_xmlrpc_build_request
        !           301: creates an XML-RPC request instance from native,
        !           302: .Dq compact
        !           303: parameter data structures.
        !           304: .Fa methodName
        !           305: is the XML-RPC request method name.
        !           306: There will be
        !           307: .Fa nparams
        !           308: parameters in the request;
        !           309: .Fa types
        !           310: must point to an array of
        !           311: .Fa nparams
        !           312: .Xr structs 3
        !           313: parameter types and
        !           314: .Fa params
        !           315: an array of
        !           316: .Fa nparams
        !           317: parameter values having the corresponding types.
        !           318: .Pp
        !           319: To build the request directly out of
        !           320: .Dq exploded
        !           321: XML-RPC parameter values, set
        !           322: .Fa types
        !           323: to
        !           324: .Dv NULL .
        !           325: Then it will be assumed that each parameter in the
        !           326: .Fa params
        !           327: array is an instance of
        !           328: .Fa structs_type_xmlrpc_value ,
        !           329: i.e., a
        !           330: .Li "struct xmlrpc_value_union" .
        !           331: .Pp
        !           332: If successful,
        !           333: .Fn structs_xmlrpc_build_request
        !           334: returns an instance of type
        !           335: .Fa structs_type_xmlrpc_request ,
        !           336: i.e., a
        !           337: .Li "struct xmlrpc_request" ,
        !           338: in a memory block allocated with
        !           339: .Xr typed_mem
        !           340: type
        !           341: .Fa mtype ,
        !           342: which the caller is responsible for unintializing and freeing.
        !           343: .Pp
        !           344: .Fn structs_xmlrpc_build_response
        !           345: creates an XML-RPC response.
        !           346: The response data structure (i.e., the XML-RPC return value)
        !           347: pointed to by
        !           348: .Fa data
        !           349: should be
        !           350: .Dq compact
        !           351: and have
        !           352: .Xr structs 3
        !           353: type
        !           354: .Fa type .
        !           355: .Pp
        !           356: To directly send an
        !           357: .Dq exploded
        !           358: XML-RPC return value, set
        !           359: .Fa type
        !           360: to
        !           361: .Dv NULL .
        !           362: Then it will be assumed that
        !           363: .Fa data
        !           364: points to an instance of
        !           365: .Fa structs_type_xmlrpc_value ,
        !           366: i.e., a
        !           367: .Li "struct xmlrpc_value_union" .
        !           368: .Pp
        !           369: If successful,
        !           370: .Fn structs_xmlrpc_build_response
        !           371: returns an instance of type
        !           372: .Fa structs_type_xmlrpc_response ,
        !           373: i.e., a
        !           374: .Li "struct xmlrpc_response_union" ,
        !           375: in a memory block allocated with
        !           376: .Xr typed_mem
        !           377: type
        !           378: .Fa mtype ,
        !           379: which the caller is responsible for unintializing and freeing.
        !           380: .Pp
        !           381: .Fn structs_xmlrpc_build_fault_response
        !           382: builds an XML-RPC fault response.
        !           383: If successful, it returns an instance of
        !           384: .Fa structs_type_xmlrpc_response ,
        !           385: i.e., a
        !           386: .Li "struct xmlrpc_response_union" ,
        !           387: in a memory block allocated with
        !           388: .Xr typed_mem
        !           389: type
        !           390: .Fa mtype ,
        !           391: which the caller is responsible for unintializing and freeing.
        !           392: .Sh RETURN VALUES
        !           393: The above functions indicate an error by returning either -1 or
        !           394: .Dv NULL
        !           395: and setting
        !           396: .Va errno
        !           397: to an appropriate value.
        !           398: .Sh SEE ALSO
        !           399: .Xr http_servlet_xmlrpc 3 ,
        !           400: .Xr http_xml 3 ,
        !           401: .Xr libpdel 3 ,
        !           402: .Xr structs 3 ,
        !           403: .Xr structs_type 3 ,
        !           404: .Xr structs_xml_input 3 ,
        !           405: .Xr typed_mem 3
        !           406: .Rs
        !           407: .%T "XML-RPC Home Page"
        !           408: .%O "http://www.xmlrpc.org/"
        !           409: .Re
        !           410: .Sh HISTORY
        !           411: The PDEL library was developed at Packet Design, LLC.
        !           412: .Dv "http://www.packetdesign.com/"
        !           413: .Sh AUTHORS
        !           414: .An Archie Cobbs Aq archie@freebsd.org

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>