Annotation of embedaddon/php/ext/xmlrpc/libxmlrpc/xmlrpc_introspection.c, revision 1.1.1.1
1.1 misho 1: /*
2: This file is part of libXMLRPC - a C library for xml-encoded function calls.
3:
4: Author: Dan Libby (dan@libby.com)
5: Epinions.com may be contacted at feedback@epinions-inc.com
6: */
7:
8: /*
9: Copyright 2001 Epinions, Inc.
10:
11: Subject to the following 3 conditions, Epinions, Inc. permits you, free
12: of charge, to (a) use, copy, distribute, modify, perform and display this
13: software and associated documentation files (the "Software"), and (b)
14: permit others to whom the Software is furnished to do so as well.
15:
16: 1) The above copyright notice and this permission notice shall be included
17: without modification in all copies or substantial portions of the
18: Software.
19:
20: 2) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT ANY WARRANTY OR CONDITION OF
21: ANY KIND, EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION ANY
22: IMPLIED WARRANTIES OF ACCURACY, MERCHANTABILITY, FITNESS FOR A PARTICULAR
23: PURPOSE OR NONINFRINGEMENT.
24:
25: 3) IN NO EVENT SHALL EPINIONS, INC. BE LIABLE FOR ANY DIRECT, INDIRECT,
26: SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES OR LOST PROFITS ARISING OUT
27: OF OR IN CONNECTION WITH THE SOFTWARE (HOWEVER ARISING, INCLUDING
28: NEGLIGENCE), EVEN IF EPINIONS, INC. IS AWARE OF THE POSSIBILITY OF SUCH
29: DAMAGES.
30:
31: */
32:
33:
34: /****h* ABOUT/xmlrpc_introspection
35: * AUTHOR
36: * Dan Libby, aka danda (dan@libby.com)
37: * HISTORY
38: * $Log$
39: * Revision 1.4 2003/12/16 21:00:21 sniper
40: * Fix some compile warnings (patch by Joe Orton)
41: *
42: * Revision 1.3 2002/07/05 04:43:53 danda
43: * merged in updates from SF project. bring php repository up to date with xmlrpc-epi version 0.51
44: *
45: * Revision 1.9 2001/09/29 21:58:05 danda
46: * adding cvs log to history section
47: *
48: * 4/10/2001 -- danda -- initial introspection support
49: * TODO
50: * NOTES
51: *******/
52:
53:
54: #ifdef _WIN32
55: #include "xmlrpc_win32.h"
56: #endif
57: #include "queue.h"
58: #include "xmlrpc.h"
59: #include "xmlrpc_private.h"
60: #include "xmlrpc_introspection_private.h"
61: #include <string.h>
62: #include <stdlib.h>
63: #include <stdarg.h>
64:
65:
66: /* forward declarations for static (non public, non api) funcs */
67: static XMLRPC_VALUE xi_system_describe_methods_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData);
68: static XMLRPC_VALUE xi_system_list_methods_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData);
69: static XMLRPC_VALUE xi_system_method_signature_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData);
70: static XMLRPC_VALUE xi_system_method_help_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData);
71:
72:
73: /*-**********************************
74: * Introspection Callbacks (methods) *
75: ************************************/
76:
77: /* iterates through a list of structs and finds the one with key "name" matching
78: * needle. slow, would benefit from a struct key hash.
79: */
80: static inline XMLRPC_VALUE find_named_value(XMLRPC_VALUE list, const char* needle) {
81: XMLRPC_VALUE xIter = XMLRPC_VectorRewind(list);
82: while(xIter) {
83: const char* name = XMLRPC_VectorGetStringWithID(xIter, xi_token_name);
84: if(name && !strcmp(name, needle)) {
85: return xIter;
86: }
87: xIter = XMLRPC_VectorNext(list);
88: }
89: return NULL;
90: }
91:
92:
93: /* iterates through docs callbacks and calls any that have not yet been called */
94: static void check_docs_loaded(XMLRPC_SERVER server, void* userData) {
95: if(server) {
96: q_iter qi = Q_Iter_Head_F(&server->docslist);
97: while( qi ) {
98: doc_method* dm = Q_Iter_Get_F(qi);
99: if(dm && !dm->b_called) {
100: dm->method(server, userData);
101: dm->b_called = 1;
102: }
103: qi = Q_Iter_Next_F(qi);
104: }
105: }
106: }
107:
108:
109: /* utility function for xi_system_describe_methods_cb */
110: static inline void describe_method(XMLRPC_SERVER server, XMLRPC_VALUE vector, const char* method) {
111: if(method) {
112: server_method* sm = find_method(server, method);
113: if(sm) {
114: XMLRPC_AddValueToVector(vector, sm->desc);
115: }
116: }
117: }
118:
119:
120:
121: /* system.describeMethods() callback */
122: static XMLRPC_VALUE xi_system_describe_methods_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
123: XMLRPC_VALUE xParams = XMLRPC_VectorRewind(XMLRPC_RequestGetData(input));
124: XMLRPC_VALUE xResponse = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
125: XMLRPC_VALUE xMethodList = XMLRPC_CreateVector("methodList", xmlrpc_vector_array);
126: XMLRPC_VALUE xTypeList = NULL;
127: int bAll = 1;
128:
129: /* lazy loading of introspection data */
130: check_docs_loaded(server, userData);
131:
132: xTypeList = XMLRPC_VectorGetValueWithID(server->xIntrospection, "typeList");
133:
134: XMLRPC_AddValueToVector(xResponse, xTypeList);
135: XMLRPC_AddValueToVector(xResponse, xMethodList);
136:
137: /* check if we have any param */
138: if(xParams) {
139: /* check if string or vector (1 or n) */
140: XMLRPC_VALUE_TYPE type = XMLRPC_GetValueType(xParams);
141: if(type == xmlrpc_string) {
142: /* just one. spit it out. */
143: describe_method(server, xMethodList, XMLRPC_GetValueString(xParams));
144: bAll = 0;
145: }
146: else if(type == xmlrpc_vector) {
147: /* multiple. spit all out */
148: XMLRPC_VALUE xIter = XMLRPC_VectorRewind(xParams);
149: while(xIter) {
150: describe_method(server, xMethodList, XMLRPC_GetValueString(xIter));
151: xIter = XMLRPC_VectorNext(xParams);
152: }
153: bAll = 0;
154: }
155: }
156:
157: /* otherwise, default to sending all methods */
158: if(bAll) {
159: q_iter qi = Q_Iter_Head_F(&server->methodlist);
160: while( qi ) {
161: server_method* sm = Q_Iter_Get_F(qi);
162: if(sm) {
163: XMLRPC_AddValueToVector(xMethodList, sm->desc);
164: }
165: qi = Q_Iter_Next_F(qi);
166: }
167: }
168:
169: return xResponse;
170: }
171:
172: /* this complies with system.listMethods as defined at http://xmlrpc.usefulinc.com/doc/reserved.html */
173: static XMLRPC_VALUE xi_system_list_methods_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
174: XMLRPC_VALUE xResponse = XMLRPC_CreateVector(NULL, xmlrpc_vector_array);
175:
176: q_iter qi = Q_Iter_Head_F(&server->methodlist);
177: while( qi ) {
178: server_method* sm = Q_Iter_Get_F(qi);
179: if(sm) {
180: XMLRPC_VectorAppendString(xResponse, 0, sm->name, 0);
181: }
182: qi = Q_Iter_Next_F(qi);
183: }
184: return xResponse;
185: }
186:
187: /* this complies with system.methodSignature as defined at
188: * http://xmlrpc.usefulinc.com/doc/sysmethodsig.html
189: */
190: static XMLRPC_VALUE xi_system_method_signature_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
191: const char* method = XMLRPC_GetValueString(XMLRPC_VectorRewind(XMLRPC_RequestGetData(input)));
192: XMLRPC_VALUE xResponse = NULL;
193:
194: /* lazy loading of introspection data */
195: check_docs_loaded(server, userData);
196:
197: if(method) {
198: server_method* sm = find_method(server, method);
199: if(sm && sm->desc) {
200: XMLRPC_VALUE xTypesArray = XMLRPC_CreateVector(NULL, xmlrpc_vector_array);
201: XMLRPC_VALUE xIter, xParams, xSig, xSigIter;
202: const char* type;
203:
204: /* array of possible signatures. */
205: xResponse = XMLRPC_CreateVector(NULL, xmlrpc_vector_array);
206:
207: /* find first signature */
208: xSig = XMLRPC_VectorGetValueWithID(sm->desc, xi_token_signatures);
209: xSigIter = XMLRPC_VectorRewind( xSig );
210:
211: /* iterate through sigs */
212: while(xSigIter) {
213: /* first type is the return value */
214: type = XMLRPC_VectorGetStringWithID(XMLRPC_VectorRewind(
215: XMLRPC_VectorGetValueWithID(xSigIter, xi_token_returns)),
216: xi_token_type);
217: XMLRPC_AddValueToVector(xTypesArray,
218: XMLRPC_CreateValueString(NULL,
219: type ? type : type_to_str(xmlrpc_none, 0),
220: 0));
221:
222: /* the rest are parameters */
223: xParams = XMLRPC_VectorGetValueWithID(xSigIter, xi_token_params);
224: xIter = XMLRPC_VectorRewind(xParams);
225:
226: /* iter through params, adding to types array */
227: while(xIter) {
228: XMLRPC_AddValueToVector(xTypesArray,
229: XMLRPC_CreateValueString(NULL,
230: XMLRPC_VectorGetStringWithID(xIter, xi_token_type),
231: 0));
232: xIter = XMLRPC_VectorNext(xParams);
233: }
234:
235: /* add types for this signature */
236: XMLRPC_AddValueToVector(xResponse, xTypesArray);
237:
238: xSigIter = XMLRPC_VectorNext( xSig );
239: }
240: }
241: }
242:
243: return xResponse;
244: }
245:
246: /* this complies with system.methodHelp as defined at
247: * http://xmlrpc.usefulinc.com/doc/sysmethhelp.html
248: */
249: static XMLRPC_VALUE xi_system_method_help_cb(XMLRPC_SERVER server, XMLRPC_REQUEST input, void* userData) {
250: const char* method = XMLRPC_GetValueString(XMLRPC_VectorRewind(XMLRPC_RequestGetData(input)));
251: XMLRPC_VALUE xResponse = NULL;
252:
253: /* lazy loading of introspection data */
254: check_docs_loaded(server, userData);
255:
256: if(method) {
257: server_method* sm = find_method(server, method);
258: if(sm && sm->desc) {
259: const char* help = XMLRPC_VectorGetStringWithID(sm->desc, xi_token_purpose);
260:
261: /* returns a documentation string, or empty string */
262: xResponse = XMLRPC_CreateValueString(NULL, help ? help : xi_token_empty, 0);
263: }
264: }
265:
266: return xResponse;
267: }
268:
269: /*-**************************************
270: * End Introspection Callbacks (methods) *
271: ****************************************/
272:
273:
274: /*-************************
275: * Introspection Utilities *
276: **************************/
277:
278: /* performs registration of introspection methods */
279: void xi_register_system_methods(XMLRPC_SERVER server) {
280: XMLRPC_ServerRegisterMethod(server, xi_token_system_list_methods, xi_system_list_methods_cb);
281: XMLRPC_ServerRegisterMethod(server, xi_token_system_method_help, xi_system_method_help_cb);
282: XMLRPC_ServerRegisterMethod(server, xi_token_system_method_signature, xi_system_method_signature_cb);
283: XMLRPC_ServerRegisterMethod(server, xi_token_system_describe_methods, xi_system_describe_methods_cb);
284: }
285:
286: /* describe a value (param, return, type) */
287: static XMLRPC_VALUE describeValue_worker(const char* type, const char* id, const char* desc, int optional, const char* default_val, XMLRPC_VALUE sub_params) {
288: XMLRPC_VALUE xParam = NULL;
289: if(id || desc) {
290: xParam = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
291: XMLRPC_VectorAppendString(xParam, xi_token_name, id, 0);
292: XMLRPC_VectorAppendString(xParam, xi_token_type, type, 0);
293: XMLRPC_VectorAppendString(xParam, xi_token_description, desc, 0);
294: if(optional != 2) {
295: XMLRPC_VectorAppendInt(xParam, xi_token_optional, optional);
296: }
297: if(optional == 1 && default_val) {
298: XMLRPC_VectorAppendString(xParam, xi_token_default, default_val, 0);
299: }
300: XMLRPC_AddValueToVector(xParam, sub_params);
301: }
302: return xParam;
303: }
304:
305:
306: /* convert an xml tree conforming to spec <url tbd> to XMLRPC_VALUE
307: * suitable for use with XMLRPC_ServerAddIntrospectionData
308: */
309: XMLRPC_VALUE xml_element_to_method_description(xml_element* el, XMLRPC_ERROR err) {
310: XMLRPC_VALUE xReturn = NULL;
311:
312: if(el->name) {
313: const char* name = NULL;
314: const char* type = NULL;
315: const char* basetype = NULL;
316: const char* desc = NULL;
317: const char* def = NULL;
318: int optional = 0;
319: xml_element_attr* attr_iter = Q_Head(&el->attrs);
320:
321: /* grab element attributes up front to save redundant while loops */
322: while(attr_iter) {
323: if(!strcmp(attr_iter->key, "name")) {
324: name = attr_iter->val;
325: }
326: else if(!strcmp(attr_iter->key, "type")) {
327: type = attr_iter->val;
328: }
329: else if(!strcmp(attr_iter->key, "basetype")) {
330: basetype = attr_iter->val;
331: }
332: else if(!strcmp(attr_iter->key, "desc")) {
333: desc = attr_iter->val;
334: }
335: else if(!strcmp(attr_iter->key, "optional")) {
336: if(attr_iter->val && !strcmp(attr_iter->val, "yes")) {
337: optional = 1;
338: }
339: }
340: else if(!strcmp(attr_iter->key, "default")) {
341: def = attr_iter->val;
342: }
343: attr_iter = Q_Next(&el->attrs);
344: }
345:
346: /* value and typeDescription behave about the same */
347: if(!strcmp(el->name, "value") || !strcmp(el->name, "typeDescription")) {
348: XMLRPC_VALUE xSubList = NULL;
349: const char* ptype = !strcmp(el->name, "value") ? type : basetype;
350: if(ptype) {
351: if(Q_Size(&el->children) &&
352: (!strcmp(ptype, "array") || !strcmp(ptype, "struct") || !strcmp(ptype, "mixed"))) {
353: xSubList = XMLRPC_CreateVector("member", xmlrpc_vector_array);
354:
355: if(xSubList) {
356: xml_element* elem_iter = Q_Head(&el->children);
357: while(elem_iter) {
358: XMLRPC_AddValueToVector(xSubList,
359: xml_element_to_method_description(elem_iter, err));
360: elem_iter = Q_Next(&el->children);
361: }
362: }
363: }
364: xReturn = describeValue_worker(ptype, name, (desc ? desc : (xSubList ? NULL : el->text.str)), optional, def, xSubList);
365: }
366: }
367:
368: /* these three kids are about equivalent */
369: else if(!strcmp(el->name, "params") ||
370: !strcmp(el->name, "returns") ||
371: !strcmp(el->name, "signature")) {
372: if(Q_Size(&el->children)) {
373: xml_element* elem_iter = Q_Head(&el->children);
374: xReturn = XMLRPC_CreateVector(!strcmp(el->name, "signature") ? NULL : el->name, xmlrpc_vector_struct);
375:
376:
377: while(elem_iter) {
378: XMLRPC_AddValueToVector(xReturn,
379: xml_element_to_method_description(elem_iter, err));
380: elem_iter = Q_Next(&el->children);
381: }
382: }
383: }
384:
385:
386: else if(!strcmp(el->name, "methodDescription")) {
387: xml_element* elem_iter = Q_Head(&el->children);
388: xReturn = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
389:
390: XMLRPC_VectorAppendString(xReturn, xi_token_name, name, 0);
391:
392: while(elem_iter) {
393: XMLRPC_AddValueToVector(xReturn,
394: xml_element_to_method_description(elem_iter, err));
395: elem_iter = Q_Next(&el->children);
396: }
397: }
398:
399: /* items are slightly special */
400: else if(!strcmp(el->name, "item")) {
401: xReturn = XMLRPC_CreateValueString(name, el->text.str, el->text.len);
402: }
403:
404: /* sure. we'll let any ol element with children through */
405: else if(Q_Size(&el->children)) {
406: xml_element* elem_iter = Q_Head(&el->children);
407: xReturn = XMLRPC_CreateVector(el->name, xmlrpc_vector_mixed);
408:
409: while(elem_iter) {
410: XMLRPC_AddValueToVector(xReturn,
411: xml_element_to_method_description(elem_iter, err));
412: elem_iter = Q_Next(&el->children);
413: }
414: }
415:
416: /* or anything at all really, so long as its got some text.
417: * no reason being all snotty about a spec, right?
418: */
419: else if(el->name && el->text.len) {
420: xReturn = XMLRPC_CreateValueString(el->name, el->text.str, el->text.len);
421: }
422: }
423:
424: return xReturn;
425: }
426:
427: /*-****************************
428: * End Introspection Utilities *
429: ******************************/
430:
431:
432:
433: /*-******************
434: * Introspection API *
435: ********************/
436:
437:
438: /****f* VALUE/XMLRPC_IntrospectionCreateDescription
439: * NAME
440: * XMLRPC_IntrospectionCreateDescription
441: * SYNOPSIS
442: * XMLRPC_VALUE XMLRPC_IntrospectionCreateDescription(const char* xml, XMLRPC_ERROR err)
443: * FUNCTION
444: * converts raw xml describing types and methods into an
445: * XMLRPC_VALUE suitable for use with XMLRPC_ServerAddIntrospectionData()
446: * INPUTS
447: * xml - xml data conforming to introspection spec at <url tbd>
448: * err - optional pointer to error struct. filled in if error occurs and not NULL.
449: * RESULT
450: * XMLRPC_VALUE - newly created value, or NULL if fatal error.
451: * BUGS
452: * Currently does little or no validation of xml.
453: * Only parse errors are currently reported in err, not structural errors.
454: * SEE ALSO
455: * XMLRPC_ServerAddIntrospectionData ()
456: * SOURCE
457: */
458: XMLRPC_VALUE XMLRPC_IntrospectionCreateDescription(const char* xml, XMLRPC_ERROR err) {
459: XMLRPC_VALUE xReturn = NULL;
460: xml_element* root = xml_elem_parse_buf(xml, 0, 0, err ? &err->xml_elem_error : NULL);
461:
462: if(root) {
463: xReturn = xml_element_to_method_description(root, err);
464:
465: xml_elem_free(root);
466: }
467:
468: return xReturn;
469:
470: }
471: /*******/
472:
473:
474: /****f* SERVER/XMLRPC_ServerAddIntrospectionData
475: * NAME
476: * XMLRPC_ServerAddIntrospectionData
477: * SYNOPSIS
478: * int XMLRPC_ServerAddIntrospectionData(XMLRPC_SERVER server, XMLRPC_VALUE desc)
479: * FUNCTION
480: * updates server with additional introspection data
481: * INPUTS
482: * server - target server
483: * desc - introspection data, should be a struct generated by
484: * XMLRPC_IntrospectionCreateDescription ()
485: * RESULT
486: * int - 1 if success, else 0
487: * NOTES
488: * - function will fail if neither typeList nor methodList key is present in struct.
489: * - if method or type already exists, it will be replaced.
490: * - desc is never freed by the server. caller is responsible for cleanup.
491: * BUGS
492: * - horribly slow lookups. prime candidate for hash improvements.
493: * - uglier and more complex than I like to see for API functions.
494: * SEE ALSO
495: * XMLRPC_ServerAddIntrospectionData ()
496: * XMLRPC_ServerRegisterIntrospectionCallback ()
497: * XMLRPC_CleanupValue ()
498: * SOURCE
499: */
500: int XMLRPC_ServerAddIntrospectionData(XMLRPC_SERVER server, XMLRPC_VALUE desc) {
501: int bSuccess = 0;
502: if(server && desc) {
503: XMLRPC_VALUE xNewTypes = XMLRPC_VectorGetValueWithID(desc, "typeList");
504: XMLRPC_VALUE xNewMethods = XMLRPC_VectorGetValueWithID(desc, "methodList");
505: XMLRPC_VALUE xServerTypes = XMLRPC_VectorGetValueWithID(server->xIntrospection, "typeList");
506:
507: if(xNewMethods) {
508: XMLRPC_VALUE xMethod = XMLRPC_VectorRewind(xNewMethods);
509:
510: while(xMethod) {
511: const char* name = XMLRPC_VectorGetStringWithID(xMethod, xi_token_name);
512: server_method* sm = find_method(server, name);
513:
514: if(sm) {
515: if(sm->desc) {
516: XMLRPC_CleanupValue(sm->desc);
517: }
518: sm->desc = XMLRPC_CopyValue(xMethod);
519: bSuccess = 1;
520: }
521:
522: xMethod = XMLRPC_VectorNext(xNewMethods);
523: }
524: }
525: if(xNewTypes) {
526: if(!xServerTypes) {
527: if(!server->xIntrospection) {
528: server->xIntrospection = XMLRPC_CreateVector(NULL, xmlrpc_vector_struct);
529: }
530:
531: XMLRPC_AddValueToVector(server->xIntrospection, xNewTypes);
532: bSuccess = 1;
533: }
534: else {
535: XMLRPC_VALUE xIter = XMLRPC_VectorRewind(xNewTypes);
536: while(xIter) {
537: /* get rid of old values */
538: XMLRPC_VALUE xPrev = find_named_value(xServerTypes, XMLRPC_VectorGetStringWithID(xIter, xi_token_name));
539: if(xPrev) {
540: XMLRPC_VectorRemoveValue(xServerTypes, xPrev);
541: }
542: XMLRPC_AddValueToVector(xServerTypes, xIter);
543: bSuccess = 1;
544: xIter = XMLRPC_VectorNext(xNewTypes);
545: }
546: }
547: }
548: }
549: return bSuccess;
550: }
551: /*******/
552:
553:
554: /****f* SERVER/XMLRPC_ServerRegisterIntrospectionCallback
555: * NAME
556: * XMLRPC_ServerRegisterIntrospectionCallback
557: * SYNOPSIS
558: * int XMLRPC_ServerRegisterIntrospectionCallback(XMLRPC_SERVER server, XMLRPC_IntrospectionCallback cb)
559: * FUNCTION
560: * registers a callback for lazy generation of introspection data
561: * INPUTS
562: * server - target server
563: * cb - callback that will generate introspection data
564: * RESULT
565: * int - 1 if success, else 0
566: * NOTES
567: * parsing xml and generating introspection data is fairly expensive, thus a
568: * server may wish to wait until this data is actually requested before generating
569: * it. Any number of callbacks may be registered at any time. A given callback
570: * will only ever be called once, the first time an introspection request is
571: * processed after the time of callback registration.
572: * SEE ALSO
573: * XMLRPC_ServerAddIntrospectionData ()
574: * XMLRPC_IntrospectionCreateDescription ()
575: * SOURCE
576: */
577: int XMLRPC_ServerRegisterIntrospectionCallback(XMLRPC_SERVER server, XMLRPC_IntrospectionCallback cb) {
578: int bSuccess = 0;
579: if(server && cb) {
580:
581: doc_method* dm = calloc(1, sizeof(doc_method));
582:
583: if(dm) {
584: dm->method = cb;
585: dm->b_called = 0;
586:
587: if(Q_PushTail(&server->docslist, dm)) {
588: bSuccess = 1;
589: }
590: else {
591: my_free(dm);
592: }
593: }
594: }
595: return 0;
596: }
597: /*******/
598:
599: /*-**********************
600: * End Introspection API *
601: ************************/
602:
603:
604:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmlrpc_introspection.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / xmlrpc / libxmlrpc