test_xmlrpc.c File Reference

#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include "gwlib/gwlib.h"
#include "gwlib/http.h"
#include "gwlib/xmlrpc.h"

Go to the source code of this file.

Macros
#define	MAX_THREADS   1024
#define	MAX_IN_QUEUE   128

Functions
static void	start_request (HTTPCaller *caller, List *reqh, long i)
static int	receive_reply (HTTPCaller *caller)
static void	client_thread (void *arg)
static void	help (void)
int	main (int argc, char **argv)

Variables
static Counter *	counter = NULL
static long	max_requests = 1
static Octstr *	auth_username = NULL
static Octstr *	auth_password = NULL
static Octstr *	ssl_client_certkey_file = NULL
static Octstr *	extra_headers = NULL
static Octstr *	content_file = NULL
static Octstr *	url = NULL
static int	file = 0
static XMLRPCDocument *	msg

Macro Definition Documentation

MAX_IN_QUEUE

#define MAX_IN_QUEUE   128

Definition at line 74 of file test_xmlrpc.c.

Referenced by client_thread().

MAX_THREADS

#define MAX_THREADS   1024

Definition at line 73 of file test_xmlrpc.c.

Referenced by main().

Function Documentation

client_thread()

static void client_thread ( void *  arg )

static

Definition at line 188 of file test_xmlrpc.c.

References auth_password, auth_username, caller, counter, counter_increase(), gwlist_create, gwthread_self(), gwthread_sleep(), http_add_basic_auth(), http_caller_destroy(), http_header_add(), info(), MAX_IN_QUEUE, max_requests, receive_reply(), and start_request().

Referenced by main().

{
    List *reqh;
    long i, succeeded, failed;
    HTTPCaller *caller;
    char buf[1024];
    long in_queue;

    caller = arg;
    succeeded = 0;
    failed = 0;
    reqh = gwlist_create();

    sprintf(buf, "%ld", (long) gwthread_self());
    http_header_add(reqh, "X-Thread", buf);
    if (auth_username != NULL && auth_password != NULL)
        http_add_basic_auth(reqh, auth_username, auth_password);

    in_queue = 0;
    
    for (;;) {
        while (in_queue < MAX_IN_QUEUE) {
            i = counter_increase(counter);
            if (i >= max_requests)
                goto receive_rest;
            start_request(caller, reqh, i);
#if 1
            gwthread_sleep(0.1);
#endif
            ++in_queue;
        }
        while (in_queue >= MAX_IN_QUEUE) {
            if (receive_reply(caller) == -1)
                ++failed;
            else
                ++succeeded;
            --in_queue;
        }
    }
    
receive_rest:
    while (in_queue > 0) {
        if (receive_reply(caller) == -1)
            ++failed;
        else
            ++succeeded;
        --in_queue;
    }

    http_caller_destroy(caller);
    info(0, "This thread: %ld succeeded, %ld failed.", succeeded, failed);
}

help()

static void help ( void  )

static

Definition at line 242 of file test_xmlrpc.c.

References info().

Referenced by main().

{
    info(0, "Usage: test_xmlrpc [options] xml_source");
    info(0, "where options are:");
    info(0, "-u URL");
    info(0, "    send XML-RPC source as POST HTTP request to URL");
    info(0, "-v number");
    info(0, "    set log level for stderr logging");
    info(0, "-q");
    info(0, "    don't print the body or headers of the HTTP response");
    info(0, "-r number");
    info(0, "    make `number' requests, repeating URLs as necessary");
    info(0, "-p domain.name");
    info(0, "    use `domain.name' as a proxy");
    info(0, "-P portnumber");
    info(0, "    connect to proxy at port `portnumber'");
    info(0, "-S");
    info(0, "    use HTTPS scheme to access SSL-enabled proxy server");
    info(0, "-e domain1:domain2:...");
    info(0, "    set exception list for proxy use");
    info(0, "-s");
    info(0, "    use HTTPS scheme to access SSL-enabled HTTP server");
    info(0, "-c ssl_client_cert_key_file");
    info(0, "    use this file as the SSL certificate and key file");
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 269 of file test_xmlrpc.c.

References auth_password, auth_username, client_thread(), content_file, counter, counter_create(), counter_destroy(), error(), extra_headers, file, getopt(), gwlib_init(), gwlib_shutdown(), gwlist_append(), gwlist_create, gwlist_destroy(), gwthread_create, gwthread_join(), help(), http_caller_create(), http_use_proxy(), info(), log_set_output_level(), max_requests, MAX_THREADS, msg, octstr_create, octstr_destroy(), octstr_destroy_item(), octstr_get_cstr, octstr_print(), octstr_read_file(), optarg, optind, panic, proxy_password, proxy_port, proxy_ssl, proxy_username, ssl, ssl_client_certkey_file, start, threads, url, XMLRPC_COMPILE_OK, xmlrpc_destroy_call, xmlrpc_parse_call, xmlrpc_parse_error(), xmlrpc_parse_status(), and xmlrpc_print_call.

{
    int i, opt, num_threads;
    Octstr *proxy;
    List *exceptions;
    long proxy_port;
    int proxy_ssl = 0;
    Octstr *proxy_username;
    Octstr *proxy_password;
    Octstr *exceptions_regex;
    char *p;
    long threads[MAX_THREADS];
    time_t start, end;
    double run_time;
    Octstr *output, *xml_doc; 
    int ssl = 0;
    
    gwlib_init();

    proxy = NULL;
    proxy_port = -1;
    exceptions = gwlist_create();
    proxy_username = NULL;
    proxy_password = NULL;
    exceptions_regex = NULL;
    num_threads = 0;
    file = 0;
    
    while ((opt = getopt(argc, argv, "hvr:t:p:u:P:Se:a:sc:")) != EOF) {
        switch (opt) {
            case 'h':
                help();
                exit(1);
                break;

            case 'v':
                log_set_output_level(atoi(optarg));
                break;

            case 'r':
                max_requests = atoi(optarg);
                break;
    
            case 't':
                num_threads = atoi(optarg);
                if (num_threads > MAX_THREADS)
                    num_threads = MAX_THREADS;
                break;

            case 'p':
                proxy = octstr_create(optarg);
                break;

            case 'u':
                url = octstr_create(optarg);
                break;
    
            case 'P':
                proxy_port = atoi(optarg);
                break;
                
            case 'S':
                proxy_ssl = 1;
                break;
    
            case 'e':
                p = strtok(optarg, ":");
                while (p != NULL) {
                    gwlist_append(exceptions, octstr_create(p));
                    p = strtok(NULL, ":");
                }
                break;

            case 'E':
                exceptions_regex = octstr_create(optarg);
                break;
    
            case 'a':
                p = strtok(optarg, ":");
                if (p != NULL) {
                    auth_username = octstr_create(p);
                    p = strtok(NULL, "");
                    if (p != NULL)
                        auth_password = octstr_create(p);
                }
                break;

            case 's':
                ssl = 1;
                break;

            case 'c':
               octstr_destroy(ssl_client_certkey_file);
               ssl_client_certkey_file = octstr_create(optarg);
                break;

            case '?':
            default:
                error(0, "Invalid option %c", opt);
                help();
                panic(0, "Stopping");
                break;
        }
    }

    if (optind >= argc) {
        error(0, "Missing arguments");
        help();
        panic(0, "Stopping");
    }

#ifdef HAVE_LIBSSL
    /*
     * check if we are doing a SSL-enabled client version here
     * load the required cert and key file
     */
    if (ssl || proxy_ssl) {
        if (ssl_client_certkey_file != NULL) {
            conn_use_global_client_certkey_file(ssl_client_certkey_file);
        } else {
            panic(0, "client certkey file need to be given!");
        }
    }
#endif

    if (proxy != NULL && proxy_port > 0) {
        http_use_proxy(proxy, proxy_port, proxy_ssl, exceptions,
                       proxy_username, proxy_password,
                       exceptions_regex);
    }
    octstr_destroy(proxy);
    octstr_destroy(proxy_username);
    octstr_destroy(proxy_password);
    octstr_destroy(exceptions_regex);
    gwlist_destroy(exceptions, octstr_destroy_item);
    
    counter = counter_create();

    xml_doc = octstr_read_file(argv[optind]);
    if (xml_doc == NULL)
        panic(0, "Cannot read the XML document");

    /*
     * parse the XML source
     */
    msg = xmlrpc_parse_call(xml_doc);

    if ((xmlrpc_parse_status(msg) != XMLRPC_COMPILE_OK) && 
        ((output = xmlrpc_parse_error(msg)) != NULL)) {
        /* parse failure */
        error(0, "%s", octstr_get_cstr(output));
        octstr_destroy(output);
    }

    /*
     * if no POST is desired then dump the re-formated XML
     */
    if (url != NULL) {
        
        time(&start);
        if (num_threads == 0)
           client_thread(http_caller_create());
        else {
            for (i = 0; i < num_threads; ++i)
                threads[i] = gwthread_create(client_thread, http_caller_create());
            for (i = 0; i < num_threads; ++i)
                gwthread_join(threads[i]);
        }
        time(&end);
    
    
        run_time = difftime(end, start);
        info(0, "%ld requests in %f seconds, %f requests/s.",
             max_requests, run_time, max_requests / run_time);
        
        octstr_destroy(url);

    } else {
        output = xmlrpc_print_call(msg);
        if (output != NULL) {
            octstr_print(stderr, output);
            octstr_destroy(output);
        }
    }

    counter_destroy(counter);
    octstr_destroy(auth_username);
    octstr_destroy(auth_password);
    octstr_destroy(ssl_client_certkey_file);
    octstr_destroy(extra_headers);
    octstr_destroy(content_file);


    xmlrpc_destroy_call(msg);
    octstr_destroy(xml_doc);

    gwlib_shutdown();

    return 0;
}

receive_reply()

static int receive_reply ( HTTPCaller *  caller )

static

Definition at line 113 of file test_xmlrpc.c.

References caller, debug(), error(), http_destroy_headers(), http_receive_result, octstr_destroy(), octstr_get_cstr, XMLRPC_COMPILE_OK, xmlrpc_get_faultcode(), xmlrpc_get_faultstring(), xmlrpc_is_fault(), xmlrpc_parse_error(), xmlrpc_parse_response, and xmlrpc_parse_status().

Referenced by client_thread().

{
    void *id;
    int ret;
    Octstr *final_url;
    List *replyh;
    Octstr *replyb;
    Octstr *output;
    XMLRPCDocument *xrdoc;
    /*
    Octstr *type, *os_xrdoc, *os;
    Octstr *charset;
    */
    
    id = http_receive_result(caller, &ret, &final_url, &replyh, &replyb);
    octstr_destroy(final_url);
    if (id == NULL || ret == -1) {
        error(0, "http POST failed");
        gw_free(id);
        return -1;
    }
    debug("", 0, "Done with request %ld", *(long *) id);
    gw_free(id);

/*
    http_header_get_content_type(replyh, &type, &charset);
    debug("", 0, "Content-type is <%s>, charset is <%s>",
          octstr_get_cstr(type), octstr_get_cstr(charset));
    octstr_destroy(type);
    octstr_destroy(charset);
    if (verbose)
        debug("", 0, "Reply headers:");
    while ((os = gwlist_extract_first(replyh)) != NULL) {
        if (verbose)
            octstr_dump(os, 1);
        octstr_destroy(os);
    }
    if (verbose) {
        debug("", 0, "Reply body:");
        octstr_dump(replyb, 1);
    }
*/
    xrdoc = xmlrpc_parse_response(replyb);
    debug("", 0, "Parsed xmlrpc");
    
    if ((xmlrpc_parse_status(xrdoc) != XMLRPC_COMPILE_OK) && 
        ((output = xmlrpc_parse_error(xrdoc)) != NULL)) {
        /* parse failure */
        error(0, "%s", octstr_get_cstr(output));
        octstr_destroy(output);
        return -1;
    } else { 
        /*parse proper xmlrpc */
        if (xmlrpc_is_fault(xrdoc)) {
            Octstr *fstring = xmlrpc_get_faultstring(xrdoc);
            debug("xr", 0, "Got fault response with code:%ld and description: %s",
                           xmlrpc_get_faultcode(xrdoc),
                           octstr_get_cstr(fstring));
            octstr_destroy(fstring);
            http_destroy_headers(replyh);
            octstr_destroy(replyb);
            return -1;
        } 
        /*
        os_xrdoc = xmlrpc_print_response(xrdoc);
        debug("xr", 0, "XMLRPC response:");
        octstr_dump(os_xrdoc, 0);
        */
    }
    http_destroy_headers(replyh);
    octstr_destroy(replyb);
    return 0;
}

start_request()

static void start_request ( HTTPCaller *  caller, List *  reqh, long  i  )

static

Definition at line 89 of file test_xmlrpc.c.

References caller, debug(), info(), msg, url, and xmlrpc_send_call.

Referenced by client_thread().

{
    long *id;

    if ((i % 1000) == 0)
       info(0, "Starting fetch %ld", i);
    id = gw_malloc(sizeof(long));
    *id = i;
                           
    /*
     * not semd the XML-RPC document contained in msg to
     * the URL 'url' using the POST method
     */
    xmlrpc_send_call(msg, caller, url, reqh, id);

    debug("", 0, "Started request %ld.", *id);
    /*
    debug("", 0, "Started request %ld with url:", *id);
    octstr_url_decode(url);
    octstr_dump(url, 0);
    */
}

Variable Documentation

auth_password

Octstr* auth_password = NULL

static

Definition at line 80 of file test_xmlrpc.c.

Referenced by client_thread(), and main().

auth_username

Octstr* auth_username = NULL

static

Definition at line 79 of file test_xmlrpc.c.

Referenced by client_thread(), and main().

content_file

Octstr* content_file = NULL

static

Definition at line 83 of file test_xmlrpc.c.

Referenced by main().

counter

Counter* counter = NULL

static

Definition at line 76 of file test_xmlrpc.c.

Referenced by client_thread(), and main().

extra_headers

Octstr* extra_headers = NULL

static

Definition at line 82 of file test_xmlrpc.c.

Referenced by main().

file

int file = 0

static

Definition at line 85 of file test_xmlrpc.c.

Referenced by main().

max_requests

long max_requests = 1

static

Definition at line 77 of file test_xmlrpc.c.

Referenced by client_thread(), and main().

msg

XMLRPCDocument* msg

static

Definition at line 86 of file test_xmlrpc.c.

Referenced by at2_pdu_decode(), at2_pdu_encode(), at2_send_messages(), at2_send_one_message(), at2_shutdown_cb(), at2_wait_modem_command(), badusage(), bb_alog_sms(), bb_remove_message(), bearerbox_to_smpp(), bearerbox_to_smsbox(), bearerbox_to_sql(), boxc_receiver(), boxc_route_msg_to_smsc(), boxc_sender(), boxc_sent_pop(), brunet_parse_reply(), brunet_receive_sms(), cgw_handle_op(), cgw_open_send_connection(), cgw_send_loop(), cgw_sender(), cgw_shutdown_cb(), charset_processing(), check_multipart(), cimd2_accept_delivery_report_message(), cimd2_receive_msg(), cimd2_shutdown_cb(), cimd2_submit_msg(), cimd_receive_msg(), cimd_submit_msg(), clickatell_parse_reply(), cmp_route(), concat_handling_check_and_handle(), concat_handling_clear_old_parts(), concat_msgids(), convert_charset(), create_dlr_from_msg(), data_sm_to_msg(), delayed_http_reply(), deliver_sms_to_queue(), deliver_to_bearerbox(), deliver_to_bearerbox_real(), destroy_concatMsg(), dispatch(), dispatch_datagram(), dispatch_into_queue(), dlr_add(), dlr_find(), dlr_spool_add(), dlr_spool_get(), do_dump(), dump(), dump_pdu(), emi2_do_send(), emi2_sender(), emi_receive_msg(), empty_msg_lists(), extract_msgdata_part_by_coding(), fake_listener(), fields_to_dcs(), fill_message(), find_translation(), generate_smppid(), generic_parse_reply(), generic_receive_sms(), get_matching_translations(), get_pattern(), get_receiver(), handle_mo_dcs(), handle_operation(), handle_pdu(), handle_split(), heartbeat_thread(), http_queue_thread(), httpsmsc_send(), httpsmsc_send_cb(), httpsmsc_sender(), identify_to_bearerbox(), io_thread(), kannel_parse_reply(), kannel_receive_sms(), main(), main_connection_loop(), Message(), msg_cb(), msg_create_real(), msg_destroy(), msg_destroy_item(), msg_dump(), msg_duplicate(), msg_pack(), msg_to_bb(), msg_to_cgwop(), msg_to_emimsg(), msg_to_pdu(), msg_type(), msg_unpack_real(), obey_request(), obey_request_thread(), ois_adjust_additional_information(), ois_adjust_data_coding_scheme(), ois_adjust_destination_address(), ois_adjust_originating_address(), ois_adjust_sm_text(), ois_append_data_coding_scheme(), ois_append_msisdn(), ois_append_sm_text(), ois_append_submission_options(), ois_append_to_list(), ois_decode_deliver_sm_invoke(), ois_delete_queue(), ois_deliver_sm_invoke(), ois_encode_submit_sm_invoke(), ois_receive_msg(), ois_submit_msg(), ois_submit_sm_invoke(), oisd_accept_delivery_report_message(), oisd_accept_message(), oisd_handle_request(), oisd_receive_msg(), oisd_shutdown_cb(), oisd_submit_msg(), open_send_connection(), ota_pack_message(), ota_tokenize_bookmarks(), ota_tokenize_settings(), pack_ip_datagram(), pack_sms_datagram(), packet_encode_message(), parse_msg_to_rawmessage(), parse_rawmessage_to_msg(), pdu_to_msg(), print_data(), print_msg(), randomize(), read_from_bearerbox(), read_from_bearerbox_real(), read_from_box(), read_messages_from_bearerbox(), read_msg(), reconnect(), remember_receiver(), retry_consumer_thread(), route_incoming_to_boxc(), route_incoming_to_smsc(), route_msg(), run_batch(), run_connects(), run_requests(), run_smsbox(), sema_msg_free(), sema_msg_new(), sema_msglist_pop(), sema_receive_msg(), sema_submit_msg(), send_message(), send_messages(), send_msg_cb(), send_pdu(), send_udp(), service_router(), shutdown_cb(), smpp_msg_create(), smpp_msg_destroy(), sms_msgdata_len(), sms_router(), sms_send(), sms_swap(), sms_to_client(), sms_to_smsboxes(), smsbox_req_handle(), smsbox_req_sendota(), smsbox_sendota_post(), smsbox_thread(), smsbox_to_bearerbox(), smsbox_xmlrpc_post(), smsc2_rout(), smscconn_send(), smscconn_usable(), smscenter_receive_msg(), smscenter_submit_msg(), soap_bouyg_content_attribute(), soap_bouyg_validity_attribute(), soap_client_init_query(), soap_convert_token(), soap_format_xml(), soap_listener(), soap_mobitai_content_attribute(), soap_mobitai_date_attribute(), soap_mobitai_validity_date_attribute(), soap_msgdata_attribute(), soap_msgdata_deps(), soap_msgtype_deps(), soap_o2o_date_attribute(), soap_o2o_dlrmask_smsc_yn_attribute(), soap_o2o_dlrmask_success_01_attribute(), soap_o2o_msgdata_attribute(), soap_o2o_validity30_attribute(), soap_parse_mo(), soap_process_deps(), soap_read_response(), soap_release_dependences(), soap_select_function(), soap_send(), soap_send_loop(), soap_shutdown_cb(), sql_list(), sql_single(), start_request(), status_cb(), store_file_for_each_message(), store_file_load(), store_file_save(), store_file_save_ack(), store_spool_save(), store_spool_save_ack(), store_to_dict(), store_uuid(), type_as_str(), udp_addwdp(), udp_addwdp_from_client(), udp_addwdp_from_server(), udp_receiver(), udp_sender(), udpc_find_mapping(), url_result_thread(), urltrans_find(), urltrans_find_service(), wap_msg_recv(), wdp_create(), wdp_event_dump(), wdp_msg2event(), wdp_router(), wdp_to_wapboxes(), wrapper_receiver(), wrapper_sender(), wrapper_shutdown(), write_msg(), wtp_event_dump(), xidris_parse_reply(), xidris_receive_sms(), xml_error(), and yyerror().

ssl_client_certkey_file

Octstr* ssl_client_certkey_file = NULL

static

Definition at line 81 of file test_xmlrpc.c.

Referenced by main().

url

Octstr* url = NULL

static

Definition at line 84 of file test_xmlrpc.c.

Referenced by brunet_send_sms(), clickatell_send_sms(), client_session(), client_thread(), config_reload(), create_onetrans(), error_converting(), error_requesting(), error_requesting_back(), generic_send_sms(), get_receiver(), http_accept_request(), http_get_real(), http_read_thread(), http_start_request(), http_thread(), httpadmin_run(), httpd_emu(), httpd_serve(), httpsmsc_receiver(), kannel_send_sms(), kill_kannel(), main(), make_url(), numhash_create(), ota_tokenize_bookmarks(), ota_tokenize_settings(), pap_event_create(), pap_event_unpack(), pap_request_thread(), parse_request_line(), parse_url(), proxy_used_for_host(), remember_receiver(), return_reply(), send_post(), send_push_response(), sendsms_thread(), server_create(), set_referer_url(), start_fetch(), start_request(), tell_fatal_error(), url_pattern(), wap_map_add_url(), ws_pragma_use(), xidris_send_sms(), and xmlrpc_doc_send().