1: /*
2: * Copyright (c) 2003-2006 Niels Provos <provos@citi.umich.edu>
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. The name of the author may not be used to endorse or promote products
14: * derived from this software without specific prior written permission.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26: */
27:
28: #ifdef WIN32
29: #include <winsock2.h>
30: #include <windows.h>
31: #endif
32:
33: #ifdef HAVE_CONFIG_H
34: #include "config.h"
35: #endif
36:
37: #include <sys/types.h>
38: #include <sys/stat.h>
39: #ifdef HAVE_SYS_TIME_H
40: #include <sys/time.h>
41: #endif
42: #include <sys/queue.h>
43: #ifndef WIN32
44: #include <sys/socket.h>
45: #include <signal.h>
46: #include <unistd.h>
47: #include <netdb.h>
48: #endif
49: #include <fcntl.h>
50: #include <stdlib.h>
51: #include <stdio.h>
52: #include <string.h>
53: #include <errno.h>
54: #include <assert.h>
55:
56: #include "event.h"
57: #include "evhttp.h"
58: #include "log.h"
59: #include "evrpc.h"
60:
61: #include "regress.gen.h"
62:
63: void rpc_suite(void);
64:
65: extern int test_ok;
66:
67: static struct evhttp *
68: http_setup(short *pport)
69: {
70: int i;
71: struct evhttp *myhttp;
72: short port = -1;
73:
74: /* Try a few different ports */
75: for (i = 0; i < 50; ++i) {
76: myhttp = evhttp_start("127.0.0.1", 8080 + i);
77: if (myhttp != NULL) {
78: port = 8080 + i;
79: break;
80: }
81: }
82:
83: if (port == -1)
84: event_errx(1, "Could not start web server");
85:
86: *pport = port;
87: return (myhttp);
88: }
89:
90: EVRPC_HEADER(Message, msg, kill);
91: EVRPC_HEADER(NeverReply, msg, kill);
92:
93: EVRPC_GENERATE(Message, msg, kill);
94: EVRPC_GENERATE(NeverReply, msg, kill);
95:
96: static int need_input_hook = 0;
97: static int need_output_hook = 0;
98:
99: static void
100: MessageCb(EVRPC_STRUCT(Message)* rpc, void *arg)
101: {
102: struct kill* kill_reply = rpc->reply;
103:
104: if (need_input_hook) {
105: struct evhttp_request* req = EVRPC_REQUEST_HTTP(rpc);
106: const char *header = evhttp_find_header(
107: req->input_headers, "X-Hook");
108: assert(strcmp(header, "input") == 0);
109: }
110:
111: /* we just want to fill in some non-sense */
112: EVTAG_ASSIGN(kill_reply, weapon, "dagger");
113: EVTAG_ASSIGN(kill_reply, action, "wave around like an idiot");
114:
115: /* no reply to the RPC */
116: EVRPC_REQUEST_DONE(rpc);
117: }
118:
119: static EVRPC_STRUCT(NeverReply) *saved_rpc;
120:
121: static void
122: NeverReplyCb(EVRPC_STRUCT(NeverReply)* rpc, void *arg)
123: {
124: test_ok += 1;
125: saved_rpc = rpc;
126: }
127:
128: static void
129: rpc_setup(struct evhttp **phttp, short *pport, struct evrpc_base **pbase)
130: {
131: short port;
132: struct evhttp *http = NULL;
133: struct evrpc_base *base = NULL;
134:
135: http = http_setup(&port);
136: base = evrpc_init(http);
137:
138: EVRPC_REGISTER(base, Message, msg, kill, MessageCb, NULL);
139: EVRPC_REGISTER(base, NeverReply, msg, kill, NeverReplyCb, NULL);
140:
141: *phttp = http;
142: *pport = port;
143: *pbase = base;
144:
145: need_input_hook = 0;
146: need_output_hook = 0;
147: }
148:
149: static void
150: rpc_teardown(struct evrpc_base *base)
151: {
152: assert(EVRPC_UNREGISTER(base, Message) == 0);
153: assert(EVRPC_UNREGISTER(base, NeverReply) == 0);
154:
155: evrpc_free(base);
156: }
157:
158: static void
159: rpc_postrequest_failure(struct evhttp_request *req, void *arg)
160: {
161: if (req->response_code != HTTP_SERVUNAVAIL) {
162:
163: fprintf(stderr, "FAILED (response code)\n");
164: exit(1);
165: }
166:
167: test_ok = 1;
168: event_loopexit(NULL);
169: }
170:
171: /*
172: * Test a malformed payload submitted as an RPC
173: */
174:
175: static void
176: rpc_basic_test(void)
177: {
178: short port;
179: struct evhttp *http = NULL;
180: struct evrpc_base *base = NULL;
181: struct evhttp_connection *evcon = NULL;
182: struct evhttp_request *req = NULL;
183:
184: fprintf(stdout, "Testing Basic RPC Support: ");
185:
186: rpc_setup(&http, &port, &base);
187:
188: evcon = evhttp_connection_new("127.0.0.1", port);
189: if (evcon == NULL) {
190: fprintf(stdout, "FAILED\n");
191: exit(1);
192: }
193:
194: /*
195: * At this point, we want to schedule an HTTP POST request
196: * server using our make request method.
197: */
198:
199: req = evhttp_request_new(rpc_postrequest_failure, NULL);
200: if (req == NULL) {
201: fprintf(stdout, "FAILED\n");
202: exit(1);
203: }
204:
205: /* Add the information that we care about */
206: evhttp_add_header(req->output_headers, "Host", "somehost");
207: evbuffer_add_printf(req->output_buffer, "Some Nonsense");
208:
209: if (evhttp_make_request(evcon, req,
210: EVHTTP_REQ_POST,
211: "/.rpc.Message") == -1) {
212: fprintf(stdout, "FAILED\n");
213: exit(1);
214: }
215:
216: test_ok = 0;
217:
218: event_dispatch();
219:
220: evhttp_connection_free(evcon);
221:
222: rpc_teardown(base);
223:
224: if (test_ok != 1) {
225: fprintf(stdout, "FAILED\n");
226: exit(1);
227: }
228:
229: fprintf(stdout, "OK\n");
230:
231: evhttp_free(http);
232: }
233:
234: static void
235: rpc_postrequest_done(struct evhttp_request *req, void *arg)
236: {
237: struct kill* kill_reply = NULL;
238:
239: if (req->response_code != HTTP_OK) {
240:
241: fprintf(stderr, "FAILED (response code)\n");
242: exit(1);
243: }
244:
245: kill_reply = kill_new();
246:
247: if ((kill_unmarshal(kill_reply, req->input_buffer)) == -1) {
248: fprintf(stderr, "FAILED (unmarshal)\n");
249: exit(1);
250: }
251:
252: kill_free(kill_reply);
253:
254: test_ok = 1;
255: event_loopexit(NULL);
256: }
257:
258: static void
259: rpc_basic_message(void)
260: {
261: short port;
262: struct evhttp *http = NULL;
263: struct evrpc_base *base = NULL;
264: struct evhttp_connection *evcon = NULL;
265: struct evhttp_request *req = NULL;
266: struct msg *msg;
267:
268: fprintf(stdout, "Testing Good RPC Post: ");
269:
270: rpc_setup(&http, &port, &base);
271:
272: evcon = evhttp_connection_new("127.0.0.1", port);
273: if (evcon == NULL) {
274: fprintf(stdout, "FAILED\n");
275: exit(1);
276: }
277:
278: /*
279: * At this point, we want to schedule an HTTP POST request
280: * server using our make request method.
281: */
282:
283: req = evhttp_request_new(rpc_postrequest_done, NULL);
284: if (req == NULL) {
285: fprintf(stdout, "FAILED\n");
286: exit(1);
287: }
288:
289: /* Add the information that we care about */
290: evhttp_add_header(req->output_headers, "Host", "somehost");
291:
292: /* set up the basic message */
293: msg = msg_new();
294: EVTAG_ASSIGN(msg, from_name, "niels");
295: EVTAG_ASSIGN(msg, to_name, "tester");
296: msg_marshal(req->output_buffer, msg);
297: msg_free(msg);
298:
299: if (evhttp_make_request(evcon, req,
300: EVHTTP_REQ_POST,
301: "/.rpc.Message") == -1) {
302: fprintf(stdout, "FAILED\n");
303: exit(1);
304: }
305:
306: test_ok = 0;
307:
308: event_dispatch();
309:
310: evhttp_connection_free(evcon);
311:
312: rpc_teardown(base);
313:
314: if (test_ok != 1) {
315: fprintf(stdout, "FAILED\n");
316: exit(1);
317: }
318:
319: fprintf(stdout, "OK\n");
320:
321: evhttp_free(http);
322: }
323:
324: static struct evrpc_pool *
325: rpc_pool_with_connection(short port)
326: {
327: struct evhttp_connection *evcon;
328: struct evrpc_pool *pool;
329:
330: pool = evrpc_pool_new(NULL);
331: assert(pool != NULL);
332:
333: evcon = evhttp_connection_new("127.0.0.1", port);
334: assert(evcon != NULL);
335:
336: evrpc_pool_add_connection(pool, evcon);
337:
338: return (pool);
339: }
340:
341: static void
342: GotKillCb(struct evrpc_status *status,
343: struct msg *msg, struct kill *kill, void *arg)
344: {
345: char *weapon;
346: char *action;
347:
348: if (need_output_hook) {
349: struct evhttp_request *req = status->http_req;
350: const char *header = evhttp_find_header(
351: req->input_headers, "X-Pool-Hook");
352: assert(strcmp(header, "ran") == 0);
353: }
354:
355: if (status->error != EVRPC_STATUS_ERR_NONE)
356: goto done;
357:
358: if (EVTAG_GET(kill, weapon, &weapon) == -1) {
359: fprintf(stderr, "get weapon\n");
360: goto done;
361: }
362: if (EVTAG_GET(kill, action, &action) == -1) {
363: fprintf(stderr, "get action\n");
364: goto done;
365: }
366:
367: if (strcmp(weapon, "dagger"))
368: goto done;
369:
370: if (strcmp(action, "wave around like an idiot"))
371: goto done;
372:
373: test_ok += 1;
374:
375: done:
376: event_loopexit(NULL);
377: }
378:
379: static void
380: GotKillCbTwo(struct evrpc_status *status,
381: struct msg *msg, struct kill *kill, void *arg)
382: {
383: char *weapon;
384: char *action;
385:
386: if (status->error != EVRPC_STATUS_ERR_NONE)
387: goto done;
388:
389: if (EVTAG_GET(kill, weapon, &weapon) == -1) {
390: fprintf(stderr, "get weapon\n");
391: goto done;
392: }
393: if (EVTAG_GET(kill, action, &action) == -1) {
394: fprintf(stderr, "get action\n");
395: goto done;
396: }
397:
398: if (strcmp(weapon, "dagger"))
399: goto done;
400:
401: if (strcmp(action, "wave around like an idiot"))
402: goto done;
403:
404: test_ok += 1;
405:
406: done:
407: if (test_ok == 2)
408: event_loopexit(NULL);
409: }
410:
411: static int
412: rpc_hook_add_header(struct evhttp_request *req,
413: struct evbuffer *evbuf, void *arg)
414: {
415: const char *hook_type = arg;
416: if (strcmp("input", hook_type) == 0)
417: evhttp_add_header(req->input_headers, "X-Hook", hook_type);
418: else
419: evhttp_add_header(req->output_headers, "X-Hook", hook_type);
420: return (0);
421: }
422:
423: static int
424: rpc_hook_remove_header(struct evhttp_request *req,
425: struct evbuffer *evbuf, void *arg)
426: {
427: const char *header = evhttp_find_header(req->input_headers, "X-Hook");
428: assert(header != NULL);
429: assert(strcmp(header, arg) == 0);
430: evhttp_remove_header(req->input_headers, "X-Hook");
431: evhttp_add_header(req->input_headers, "X-Pool-Hook", "ran");
432:
433: return (0);
434: }
435:
436: static void
437: rpc_basic_client(void)
438: {
439: short port;
440: struct evhttp *http = NULL;
441: struct evrpc_base *base = NULL;
442: struct evrpc_pool *pool = NULL;
443: struct msg *msg;
444: struct kill *kill;
445:
446: fprintf(stdout, "Testing RPC Client: ");
447:
448: rpc_setup(&http, &port, &base);
449:
450: need_input_hook = 1;
451: need_output_hook = 1;
452:
453: assert(evrpc_add_hook(base, EVRPC_INPUT, rpc_hook_add_header, (void*)"input")
454: != NULL);
455: assert(evrpc_add_hook(base, EVRPC_OUTPUT, rpc_hook_add_header, (void*)"output")
456: != NULL);
457:
458: pool = rpc_pool_with_connection(port);
459:
460: assert(evrpc_add_hook(pool, EVRPC_INPUT, rpc_hook_remove_header, (void*)"output"));
461:
462: /* set up the basic message */
463: msg = msg_new();
464: EVTAG_ASSIGN(msg, from_name, "niels");
465: EVTAG_ASSIGN(msg, to_name, "tester");
466:
467: kill = kill_new();
468:
469: EVRPC_MAKE_REQUEST(Message, pool, msg, kill, GotKillCb, NULL);
470:
471: test_ok = 0;
472:
473: event_dispatch();
474:
475: if (test_ok != 1) {
476: fprintf(stdout, "FAILED (1)\n");
477: exit(1);
478: }
479:
480: /* we do it twice to make sure that reuse works correctly */
481: kill_clear(kill);
482:
483: EVRPC_MAKE_REQUEST(Message, pool, msg, kill, GotKillCb, NULL);
484:
485: event_dispatch();
486:
487: rpc_teardown(base);
488:
489: if (test_ok != 2) {
490: fprintf(stdout, "FAILED (2)\n");
491: exit(1);
492: }
493:
494: fprintf(stdout, "OK\n");
495:
496: msg_free(msg);
497: kill_free(kill);
498:
499: evrpc_pool_free(pool);
500: evhttp_free(http);
501: }
502:
503: /*
504: * We are testing that the second requests gets send over the same
505: * connection after the first RPCs completes.
506: */
507: static void
508: rpc_basic_queued_client(void)
509: {
510: short port;
511: struct evhttp *http = NULL;
512: struct evrpc_base *base = NULL;
513: struct evrpc_pool *pool = NULL;
514: struct msg *msg;
515: struct kill *kill_one, *kill_two;
516:
517: fprintf(stdout, "Testing RPC (Queued) Client: ");
518:
519: rpc_setup(&http, &port, &base);
520:
521: pool = rpc_pool_with_connection(port);
522:
523: /* set up the basic message */
524: msg = msg_new();
525: EVTAG_ASSIGN(msg, from_name, "niels");
526: EVTAG_ASSIGN(msg, to_name, "tester");
527:
528: kill_one = kill_new();
529: kill_two = kill_new();
530:
531: EVRPC_MAKE_REQUEST(Message, pool, msg, kill_one, GotKillCbTwo, NULL);
532: EVRPC_MAKE_REQUEST(Message, pool, msg, kill_two, GotKillCb, NULL);
533:
534: test_ok = 0;
535:
536: event_dispatch();
537:
538: rpc_teardown(base);
539:
540: if (test_ok != 2) {
541: fprintf(stdout, "FAILED (1)\n");
542: exit(1);
543: }
544:
545: fprintf(stdout, "OK\n");
546:
547: msg_free(msg);
548: kill_free(kill_one);
549: kill_free(kill_two);
550:
551: evrpc_pool_free(pool);
552: evhttp_free(http);
553: }
554:
555: static void
556: GotErrorCb(struct evrpc_status *status,
557: struct msg *msg, struct kill *kill, void *arg)
558: {
559: if (status->error != EVRPC_STATUS_ERR_TIMEOUT)
560: goto done;
561:
562: /* should never be complete but just to check */
563: if (kill_complete(kill) == 0)
564: goto done;
565:
566: test_ok += 1;
567:
568: done:
569: event_loopexit(NULL);
570: }
571:
572: static void
573: rpc_client_timeout(void)
574: {
575: short port;
576: struct evhttp *http = NULL;
577: struct evrpc_base *base = NULL;
578: struct evrpc_pool *pool = NULL;
579: struct msg *msg;
580: struct kill *kill;
581:
582: fprintf(stdout, "Testing RPC Client Timeout: ");
583:
584: rpc_setup(&http, &port, &base);
585:
586: pool = rpc_pool_with_connection(port);
587:
588: /* set the timeout to 5 seconds */
589: evrpc_pool_set_timeout(pool, 5);
590:
591: /* set up the basic message */
592: msg = msg_new();
593: EVTAG_ASSIGN(msg, from_name, "niels");
594: EVTAG_ASSIGN(msg, to_name, "tester");
595:
596: kill = kill_new();
597:
598: EVRPC_MAKE_REQUEST(NeverReply, pool, msg, kill, GotErrorCb, NULL);
599:
600: test_ok = 0;
601:
602: event_dispatch();
603:
604: /* free the saved RPC structure up */
605: EVRPC_REQUEST_DONE(saved_rpc);
606:
607: rpc_teardown(base);
608:
609: if (test_ok != 2) {
610: fprintf(stdout, "FAILED (1)\n");
611: exit(1);
612: }
613:
614: fprintf(stdout, "OK\n");
615:
616: msg_free(msg);
617: kill_free(kill);
618:
619: evrpc_pool_free(pool);
620: evhttp_free(http);
621: }
622:
623: void
624: rpc_suite(void)
625: {
626: rpc_basic_test();
627: rpc_basic_message();
628: rpc_basic_client();
629: rpc_basic_queued_client();
630: rpc_client_timeout();
631: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to regress_rpc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libevent / test