Annotation of embedaddon/libpdel/http/http_xml.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include <sys/types.h>
42:
43: #include <netinet/in.h>
44: #include <arpa/inet.h>
45:
46: #include <stdio.h>
47: #include <stdlib.h>
48: #include <stdarg.h>
49: #include <string.h>
50: #include <syslog.h>
51: #include <errno.h>
52: #include <pthread.h>
53:
54: #include <openssl/ssl.h>
55:
56: #include "structs/structs.h"
57: #include "structs/type/array.h"
58: #include "structs/type/union.h"
59: #include "structs/xml.h"
60: #include "structs/xmlrpc.h"
61:
62: #include "io/boundary_fp.h"
63: #include "io/string_fp.h"
64: #include "sys/alog.h"
65: #include "util/typed_mem.h"
66:
67: #include "http/http_defs.h"
68: #include "http/http_server.h"
69: #include "http/xml.h"
70:
71: #define MEM_TYPE "http_xml_send_xmlrpc"
72:
73: /* Context for http_xml_send_xmlrpc() */
74: struct http_xml_send_xmlrpc_ctx {
75: struct xmlrpc_request *xreq;
76: struct xmlrpc_response_union *xrep;
77: };
78:
79: /*
80: * Internal functions
81: */
82: static void http_xml_send_xmlrpc_cleanup(void *arg);
83: static void http_xml_send_cleanup(void *arg);
84:
85: /*
86: * Send an XML-RPC message
87: *
88: * Returns:
89: * 0 Success
90: * -1 System error, errno is set
91: * -2 XML-RPC fault received
92: *
93: * The reply 'rep' may be NULL to ignore any reply value, otherwise
94: * it should already be initialized.
95: *
96: * If an XML-RPC fault is received, and "faultp" is not NULL, then
97: * it will be initialized with the fault received.
98: *
99: * This properly handles the calling thread's being canceled.
100: */
101: int
102: http_xml_send_xmlrpc(struct http_client *client,
103: struct in_addr ip, u_int16_t port, int https,
104: const char *username, const char *password,
105: const char *methodName, u_int nparams,
106: const struct structs_type **ptypes, const void **pdatas,
107: const struct structs_type *rep_type, void *rep,
108: struct xmlrpc_compact_fault *faultp, structs_xmllog_t *rlogger)
109: {
110: const struct structs_type *const xreq_type
111: = &structs_type_xmlrpc_request;
112: const struct structs_type *const xrep_type
113: = &structs_type_xmlrpc_response;
114: const struct structs_type *const ftype
115: = &structs_type_xmlrpc_compact_fault;
116: struct http_xml_send_xmlrpc_ctx *ctx;
117: struct xmlrpc_compact_fault fault;
118: char ebuf[128];
119: int ret = -1;
120: int r;
121:
122: /* Get context */
123: if ((ctx = MALLOC(MEM_TYPE, sizeof(*ctx))) == NULL) {
124: alogf(LOG_ERR, "%s: %m", "malloc");
125: return (-1);
126: }
127: memset(ctx, 0, sizeof(*ctx));
128: pthread_cleanup_push(http_xml_send_xmlrpc_cleanup, ctx);
129:
130: /* Build XML-RPC request and reply */
131: if ((ctx->xreq = structs_xmlrpc_build_request(MEM_TYPE,
132: methodName, nparams, ptypes, pdatas)) == NULL) {
133: alogf(LOG_ERR, "%s: %m", "structs_xmlrpc_build_request");
134: goto fail;
135: }
136: if ((ctx->xrep = MALLOC(MEM_TYPE, xrep_type->size)) == NULL) {
137: alogf(LOG_ERR, "%s: %m", "malloc");
138: goto fail;
139: }
140: if (structs_init(xrep_type, NULL, ctx->xrep) == -1) {
141: alogf(LOG_ERR, "%s: %m", "structs_init");
142: FREE(MEM_TYPE, ctx->xrep);
143: ctx->xrep = NULL;
144: goto fail;
145: }
146:
147: #ifdef XML_RPC_DEBUG
148: printf("%s: sending this XML-RPC request:\n", __FUNCTION__);
149: (void)structs_xml_output(xreq_type, XML_RPC_REQUEST_TAG,
150: NULL, ctx->xreq, stdout, NULL, 0);
151: #endif
152:
153: /* Send request and get reply; note: we could get canceled here. */
154: r = http_xml_send(client, ip, port, https, XML_RPC_URL,
155: username, password, XML_RPC_REQUEST_TAG, NULL, xreq_type,
156: ctx->xreq, STRUCTS_XML_FULL, XML_RPC_REPLY_TAG, NULL, NULL,
157: xrep_type, ctx->xrep, 0, rlogger);
158:
159: #ifdef XML_RPC_DEBUG
160: printf("%s: got this XML-RPC reply (error=%s):\n",
161: __FUNCTION__, r == -1 ? strerror(errno) : "none");
162: (void)structs_xml_output(xrep_type, XML_RPC_REPLY_TAG,
163: NULL, ctx->xrep, stdout, NULL, 0);
164: #endif
165:
166: /* Check error */
167: if (r == -1)
168: goto fail;
169:
170: /* Check for fault */
171: if (structs_init(ftype, NULL, &fault) == -1) {
172: alogf(LOG_ERR, "%s: %m", "structs_init");
173: goto fail;
174: }
175: if (structs_xmlrpc2struct(xrep_type, ctx->xrep,
176: "fault.value", ftype, &fault, NULL, NULL, 0) == 0) {
177: if (faultp != NULL)
178: *faultp = fault;
179: else
180: structs_free(ftype, NULL, &fault);
181: ret = -2; /* -2 indicates fault */
182: goto fail;
183: }
184: structs_free(ftype, NULL, &fault);
185:
186: /* Extract response (if desired) */
187: if (rep != NULL) {
188: if (rep_type != NULL) { /* return compact type */
189: if (structs_xmlrpc2struct(xrep_type, ctx->xrep,
190: "params.0.value", rep_type, rep, NULL, ebuf,
191: sizeof(ebuf)) == -1) {
192: (*rlogger)(LOG_ERR, "error decoding XML-RPC"
193: " response: %s", ebuf);
194: goto fail;
195: }
196: } else { /* return exploded type */
197: if (structs_get(&structs_type_xmlrpc_value,
198: "params.0.value", ctx->xrep, rep) == -1) {
199: alogf(LOG_ERR, "structs_get: %m");
200: goto fail;
201: }
202: }
203: }
204:
205: /* OK */
206: ret = 0;
207:
208: fail:;
209: /* Done */
210: pthread_cleanup_pop(1);
211: return (ret);
212: }
213:
214: /*
215: * Cleanup for http_xml_send_xmlrpc()
216: */
217: static void
218: http_xml_send_xmlrpc_cleanup(void *arg)
219: {
220: struct http_xml_send_xmlrpc_ctx *const ctx = arg;
221: const struct structs_type *const xreq_type
222: = &structs_type_xmlrpc_request;
223: const struct structs_type *const xrep_type
224: = &structs_type_xmlrpc_response;
225:
226: if (ctx->xreq != NULL) {
227: structs_free(xreq_type, NULL, ctx->xreq);
228: FREE(MEM_TYPE, ctx->xreq);
229: }
230: if (ctx->xrep != NULL) {
231: structs_free(xrep_type, NULL, ctx->xrep);
232: FREE(MEM_TYPE, ctx->xrep);
233: }
234: FREE(MEM_TYPE, ctx);
235: }
236:
237: /*
238: * Send a copy of the message, wait for a reply, and return the reply.
239: *
240: * The "reply" should already be initialized.
241: *
242: * This properly handles the calling thread's being canceled.
243: */
244: int
245: http_xml_send(struct http_client *client, struct in_addr ip,
246: u_int16_t port, int https, const char *urlpath, const char *username,
247: const char *password, const char *ptag, const char *pattrs,
248: const struct structs_type *ptype, const void *payload, int pflags,
249: const char *rtag, char **rattrsp, const char *rattrs_mtype,
250: const struct structs_type *rtype, void *reply, int rflags,
251: structs_xmllog_t *rlogger)
252: {
253: struct http_client_connection *cc;
254: struct http_request *req;
255: struct http_response *resp;
256: int ret = -1;
257: u_int code;
258: FILE *fp;
259:
260: /* Get HTTP connection */
261: if ((cc = http_client_connect(client, ip, port, https)) == NULL) {
262: alogf(LOG_ERR, "can't %s for %s:%u: %m",
263: "get HTTP client", inet_ntoa(ip), port);
264: return -1;
265: }
266:
267: /* Push cleanup hook */
268: pthread_cleanup_push(http_xml_send_cleanup, cc);
269:
270: /* Set up request */
271: req = http_client_get_request(cc);
272: if (http_request_set_method(req,
273: payload != NULL ? HTTP_METHOD_POST : HTTP_METHOD_GET) == -1) {
274: alogf(LOG_ERR, "can't %s for %s:%u: %m",
275: "set method", inet_ntoa(ip), port);
276: goto fail;
277: }
278: if (http_request_set_path(req, urlpath) == -1) {
279: alogf(LOG_ERR, "can't %s for %s:%u: %m",
280: "set path", inet_ntoa(ip), port);
281: goto fail;
282: }
283: if (http_request_set_header(req, 0, "Content-Type", "text/xml") == -1) {
284: alogf(LOG_ERR, "can't %s for %s:%u: %m",
285: "set content-type", inet_ntoa(ip), port);
286: goto fail;
287: }
288: if (username != NULL && password != NULL) {
289: char *auth;
290:
291: if ((auth = http_request_encode_basic_auth(TYPED_MEM_TEMP,
292: username, password)) == NULL) {
293: alogf(LOG_ERR, "can't %s for %s:%u: %m",
294: "encode authorization", inet_ntoa(ip), port);
295: goto fail;
296: }
297: if (http_request_set_header(req, 0, "Authorization",
298: "Basic %s", auth) == -1) {
299: alogf(LOG_ERR, "can't %s for %s:%u: %m",
300: "set authorization header", inet_ntoa(ip), port);
301: FREE(TYPED_MEM_TEMP, auth);
302: goto fail;
303: }
304: FREE(TYPED_MEM_TEMP, auth);
305: }
306:
307: /* Write XML data to HTTP client output stream */
308: if (payload != NULL) {
309: if ((fp = http_request_get_output(req, 1)) == NULL) {
310: alogf(LOG_ERR, "can't %s for %s:%u: %m",
311: "get output", inet_ntoa(ip), port);
312: goto fail;
313: }
314: if (structs_xml_output(ptype,
315: ptag, pattrs, payload, fp, NULL, pflags) == -1) {
316: alogf(LOG_ERR, "can't %s for %s:%u: %m",
317: "write XML", inet_ntoa(ip), port);
318: goto fail;
319: }
320: }
321:
322: /* Get response */
323: if ((resp = http_client_get_response(cc)) == NULL) {
324: alogf(LOG_ERR, "can't %s for %s:%u: %m",
325: "get response", inet_ntoa(ip), port);
326: goto fail;
327: }
328: if ((code = http_response_get_code(resp)) != HTTP_STATUS_OK) {
329: alogf(LOG_ERR, "rec'd HTTP error code %d from"
330: "http%s://%s:%u%s: %s", code, https ? "s" : "",
331: inet_ntoa(ip), port, urlpath,
332: http_response_status_msg(code));
333: goto fail;
334: }
335:
336: /* Read XML reply from client input stream */
337: if ((fp = http_response_get_input(resp)) == NULL) {
338: alogf(LOG_ERR, "can't %s for %s:%u: %m",
339: "get input", inet_ntoa(ip), port);
340: goto fail;
341: }
342: if (structs_xml_input(rtype, rtag, rattrsp,
343: rattrs_mtype, fp, reply, rflags, rlogger) == -1) {
344: alogf(LOG_ERR, "can't %s for %s:%u: %m",
345: "read XML reply", inet_ntoa(ip), port);
346: goto fail;
347: }
348:
349: /* OK */
350: ret = 0;
351:
352: fail:;
353: /* Done */
354: pthread_cleanup_pop(1);
355: return (ret);
356: }
357:
358: /*
359: * Cleanup for http_xml_send()
360: */
361: static void
362: http_xml_send_cleanup(void *arg)
363: {
364: struct http_client_connection *cc = arg;
365:
366: http_client_close(&cc);
367: }
368:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to http_xml.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / http