test_smsc.c File Reference

#include <unistd.h>
#include "gwlib/gwlib.h"
#include "gw/smsc/smpp_pdu.h"
#include <string.h>

Go to the source code of this file.

Data Structures
struct	Event
struct	smsc_emu_arg
struct	smpp_emu_arg
struct	httpd_emu_arg

Macros
#define	TYPE(name)   case name: return #name;

Typedefs
typedef List	EventQueue
typedef struct Event	Event

Enumerations
enum	{ MAX_THREADS = 2 }
enum	{ SMPP_MAX_QUEUE = 10 }
enum	{ MAX_IN_AVERAGE = 100 }
enum	{ MAX_RTT = 1 }
enum	{ MAX_WAITING = 100 }
enum	{ MAX_IN_QUEUE = 1000 }

Functions
static const char *	eq_type (Event *e)
static Event *	eq_create_event (enum event_type type)
static Event *	eq_create_submit (Connection *conn, long sequence_number, Octstr *body)
static Event *	eq_create_http_request (HTTPClient *client, Octstr *body)
static void	eq_destroy_event (Event *e)
static EventQueue *	eq_create (void)
static void	eq_add_producer (EventQueue *eq)
static void	eq_remove_producer (EventQueue *eq)
static void	eq_destroy (EventQueue *eq)
static void	eq_append (EventQueue *eq, Event *e)
static Event *	eq_extract (EventQueue *eq)
static void	eq_log (Event *e)
static void	eq_init (void)
static void	eq_shutdown (void)
static long	eq_round_trip_time (Event *e)
static void	smpp_emu_writer (void *arg)
static void	smpp_emu_handle_pdu (struct smpp_emu_arg *p, SMPP_PDU *pdu)
static void	smpp_emu_reader (void *arg)
static void	smpp_emu (void *arg)
static void	smsc_emu_create (EventQueue *eq)
static void	smsc_emu_destroy (void)
static void	smsc_emu_deliver (void)
static void	smsc_emu_submit_ack (Event *e)
static void	smsc_emu_init (void)
static void	smsc_emu_shutdown (void)
static void	httpd_emu (void *arg)
static void	httpd_emu_create (EventQueue *eq)
static void	httpd_emu_destroy (void)
static void	httpd_emu_reply (Event *e)
static void	httpd_emu_init (void)
static void	httpd_emu_shutdown (void)
static void	kill_kannel (void)
static void	sustained_level_benchmark (void)
static void	n_messages_benchmark (void)
int	main (int argc, char **argv)

Variables
static long	http_port = 8080
static long	admin_port = 13000
static char *	admin_password = "bar"
static long	smpp_port = 2345
static long	num_messages = 1
static Counter *	event_id_counter = NULL
static EventQueue *	undelivered_messages = NULL
static Counter *	smpp_emu_counter = NULL
static long	smpp_emu_id = -1
static List *	httpd_emu_headers = NULL
static long	httpd_emu_tid = -1

Macro Definition Documentation

TYPE

#define TYPE

(

name

)

case name: return #name;

Referenced by eq_type().

Typedef Documentation

Event

typedef struct Event Event

EventQueue

typedef List EventQueue

Definition at line 97 of file test_smsc.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
MAX_THREADS

Definition at line 279 of file test_smsc.c.

{ MAX_THREADS = 2 };

anonymous enum

anonymous enum

Enumerator
SMPP_MAX_QUEUE

Definition at line 280 of file test_smsc.c.

{ SMPP_MAX_QUEUE = 10 };

anonymous enum

anonymous enum

Enumerator
MAX_IN_AVERAGE

Definition at line 720 of file test_smsc.c.

{ MAX_IN_AVERAGE = 100 };

anonymous enum

anonymous enum

Enumerator
MAX_RTT

Definition at line 721 of file test_smsc.c.

{ MAX_RTT = 1 };

anonymous enum

anonymous enum

Enumerator
MAX_WAITING

Definition at line 722 of file test_smsc.c.

{ MAX_WAITING = 100 };

anonymous enum

anonymous enum

Enumerator
MAX_IN_QUEUE

Definition at line 820 of file test_smsc.c.

{ MAX_IN_QUEUE = 1000 };

Function Documentation

eq_add_producer()

static void eq_add_producer ( EventQueue *  eq )

static

Definition at line 201 of file test_smsc.c.

References gwlist_add_producer().

Referenced by httpd_emu(), smpp_emu(), and smsc_emu_init().

{
    gwlist_add_producer(eq);
}

eq_append()

static void eq_append ( EventQueue *  eq, Event *  e  )

static

Definition at line 219 of file test_smsc.c.

References gwlist_produce().

Referenced by httpd_emu(), smpp_emu_handle_pdu(), and smsc_emu_deliver().

{
    gwlist_produce(eq, e);
}

eq_create()

static EventQueue* eq_create ( void  )

static

Definition at line 195 of file test_smsc.c.

References gwlist_create.

Referenced by n_messages_benchmark(), smsc_emu_init(), and sustained_level_benchmark().

{
    return gwlist_create();
}

eq_create_event()

static Event* eq_create_event ( enum event_type  type )

static

Definition at line 142 of file test_smsc.c.

References Event::body, Event::client, Event::conn, counter_increase(), date_universal_now(), event_id_counter, Event::id, Event::sequence_number, Event::time, Event::type, and type.

Referenced by eq_create_http_request(), eq_create_submit(), smpp_emu_handle_pdu(), and smsc_emu_deliver().

{
    Event *e;
    
    e = gw_malloc(sizeof(*e));
    e->type = type;
    e->time = date_universal_now();
    e->id = counter_increase(event_id_counter);
    e->conn = NULL;
    e->sequence_number = -1;
    e->client = NULL;
    e->body = NULL;
    return e;
}

eq_create_http_request()

static Event* eq_create_http_request ( HTTPClient *  client, Octstr *  body  )

static

Definition at line 174 of file test_smsc.c.

References Event::body, client(), Event::client, eq_create_event(), gw_assert(), and octstr_duplicate.

Referenced by httpd_emu().

{
    Event *e;
    
    gw_assert(client != NULL);
    gw_assert(body != NULL);

    e = eq_create_event(http_request);
    e->client = client;
    e->body = octstr_duplicate(body);
    return e;
}

eq_create_submit()

static Event* eq_create_submit ( Connection *  conn, long  sequence_number, Octstr *  body  )

static

Definition at line 158 of file test_smsc.c.

References Event::body, Event::conn, eq_create_event(), gw_assert(), octstr_duplicate, and Event::sequence_number.

Referenced by smpp_emu_handle_pdu().

{
    Event *e;
    
    gw_assert(conn != NULL);
    gw_assert(sequence_number >= 0);

    e = eq_create_event(submit);
    e->conn = conn;
    e->sequence_number = sequence_number;
    e->body = octstr_duplicate(body);
    return e;
}

eq_destroy()

static void eq_destroy ( EventQueue *  eq )

static

Definition at line 213 of file test_smsc.c.

References gwlist_destroy().

Referenced by n_messages_benchmark(), smsc_emu_shutdown(), and sustained_level_benchmark().

{
    gwlist_destroy(eq, NULL);
}

eq_destroy_event()

static void eq_destroy_event ( Event *  e )

static

Definition at line 188 of file test_smsc.c.

References Event::body, and octstr_destroy().

Referenced by n_messages_benchmark(), smpp_emu_writer(), and sustained_level_benchmark().

{
    octstr_destroy(e->body);
    gw_free(e);
}

eq_extract()

static Event* eq_extract ( EventQueue *  eq )

static

Definition at line 225 of file test_smsc.c.

References gwlist_consume().

Referenced by n_messages_benchmark(), smpp_emu_writer(), and sustained_level_benchmark().

{
    return gwlist_consume(eq);
}

eq_init()

static void eq_init ( void  )

static

Definition at line 237 of file test_smsc.c.

References counter_create(), and event_id_counter.

Referenced by main().

{
    event_id_counter = counter_create();
}

eq_log()

static void eq_log ( Event *  e )

static

Definition at line 231 of file test_smsc.c.

References eq_type(), Event::id, info(), and Event::time.

Referenced by n_messages_benchmark(), smpp_emu_writer(), and sustained_level_benchmark().

{
    info(0, "Event %ld, type %s, time %ld", e->id, eq_type(e), e->time);
}

eq_remove_producer()

static void eq_remove_producer ( EventQueue *  eq )

static

Definition at line 207 of file test_smsc.c.

References gwlist_remove_producer().

Referenced by httpd_emu(), smpp_emu(), and smsc_emu_destroy().

{
    gwlist_remove_producer(eq);
}

eq_round_trip_time()

static long eq_round_trip_time ( Event *  e )

static

Definition at line 249 of file test_smsc.c.

References Event::body, date_universal_now(), and octstr_parse_long().

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    long now, then;
    
    now = date_universal_now();
    if (octstr_parse_long(&then, e->body, 0, 10) == -1)
        return 0;
    return now - then;
}

eq_shutdown()

static void eq_shutdown ( void  )

static

Definition at line 243 of file test_smsc.c.

References counter_destroy(), and event_id_counter.

Referenced by main().

{
    counter_destroy(event_id_counter);
}

eq_type()

static const char* eq_type ( Event *  e )

static

Definition at line 125 of file test_smsc.c.

References Event::type, and TYPE.

Referenced by eq_log(), n_messages_benchmark(), and sustained_level_benchmark().

{
#define TYPE(name) case name: return #name;
    switch (e->type) {
    TYPE(got_smsc)
    TYPE(deliver)
    TYPE(deliver_ack)
    TYPE(http_request)
    TYPE(http_response)
    TYPE(submit)
    TYPE(got_enquire_link)
    }
#undef TYPE
    return "unknown";
}

httpd_emu()

static void httpd_emu ( void *  arg )

static

Definition at line 584 of file test_smsc.c.

References client(), httpd_emu_arg::eq, eq_add_producer(), eq_append(), eq_create_http_request(), eq_remove_producer(), http_accept_request(), http_cgi_variable(), http_destroy_cgiargs(), http_destroy_headers(), octstr_destroy(), httpd_emu_arg::port, httpd_emu_arg::sema, semaphore_up(), and url.

Referenced by httpd_emu_create().

{
    HTTPClient *client;
    Octstr *ip;
    Octstr *url;
    List *headers;
    Octstr *body;
    List *cgivars;
    struct httpd_emu_arg *p;
    EventQueue *eq;

    p = arg;
    eq = p->eq;
    eq_add_producer(eq);
    semaphore_up(p->sema);

    for (;;) {
    client = http_accept_request(p->port, &ip, &url, &headers, &body, 
                                 &cgivars);
    if (client == NULL)
        break;
        
    eq_append(eq, eq_create_http_request(client, 
                                http_cgi_variable(cgivars, "arg")));
        octstr_destroy(ip);
        octstr_destroy(url);
    http_destroy_headers(headers);
        octstr_destroy(body);
        http_destroy_cgiargs(cgivars);
    }
    eq_remove_producer(eq);
    gw_free(p);
}

httpd_emu_create()

static void httpd_emu_create ( EventQueue *  eq )

static

Definition at line 630 of file test_smsc.c.

References httpd_emu_arg::eq, gw_assert(), gwthread_create, http_open_port(), http_port, httpd_emu(), httpd_emu_tid, panic, httpd_emu_arg::port, httpd_emu_arg::sema, semaphore_create(), semaphore_destroy(), semaphore_down(), and ssl.

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    struct httpd_emu_arg *arg;
    int ssl = 0;   /* indicate if SSL-enabled server should be used */

    if (http_open_port(http_port, ssl) == -1)
        panic(0, "Can't open HTTP server emulator port %ld.", http_port);

    gw_assert(httpd_emu_tid == -1);
    arg = gw_malloc(sizeof(*arg));
    arg->port = http_port;
    arg->sema = semaphore_create(0);
    arg->eq = eq;
    httpd_emu_tid = gwthread_create(httpd_emu, arg);
    if (httpd_emu_tid == -1)
        panic(0, "Can't start the HTTP server emulator thread.");
    semaphore_down(arg->sema);
    semaphore_destroy(arg->sema);
}

httpd_emu_destroy()

static void httpd_emu_destroy ( void  )

static

Definition at line 655 of file test_smsc.c.

References gw_assert(), gwthread_join(), http_close_all_ports(), and httpd_emu_tid.

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    gw_assert(httpd_emu_tid != -1);
    http_close_all_ports();
    gwthread_join(httpd_emu_tid);
    httpd_emu_tid = -1;
}

httpd_emu_init()

static void httpd_emu_init ( void  )

static

Definition at line 673 of file test_smsc.c.

References http_create_empty_headers(), http_header_add(), and httpd_emu_headers.

Referenced by main().

{
    httpd_emu_headers = http_create_empty_headers();
    http_header_add(httpd_emu_headers, "Content-Type", "text/plain");
}

httpd_emu_reply()

static void httpd_emu_reply ( Event *  e )

static

Definition at line 667 of file test_smsc.c.

References Event::body, Event::client, HTTP_OK, http_send_reply(), and httpd_emu_headers.

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    http_send_reply(e->client, HTTP_OK, httpd_emu_headers, e->body);
}

httpd_emu_shutdown()

static void httpd_emu_shutdown ( void  )

static

Definition at line 680 of file test_smsc.c.

References http_destroy_headers(), and httpd_emu_headers.

Referenced by main().

{
    http_destroy_headers(httpd_emu_headers);
}

kill_kannel()

static void kill_kannel ( void  )

static

Definition at line 691 of file test_smsc.c.

References admin_password, admin_port, http_create_empty_headers(), http_destroy_headers(), http_get_real(), http_header_add(), HTTP_METHOD_GET, octstr_destroy(), octstr_format(), and url.

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    Octstr *url;
    Octstr *final_url;
    List *req_headers;
    List *reply_headers;
    Octstr *reply_body;
    int ret;
    
    url = octstr_format("http://localhost:%ld/shutdown?password=%s",
                        admin_port, admin_password);
    req_headers = http_create_empty_headers();
    http_header_add(req_headers, "Content-Type", "text/plain");
    ret = http_get_real(HTTP_METHOD_GET, url, req_headers, &final_url, 
                        &reply_headers, &reply_body);
    if (ret != -1) {
        octstr_destroy(final_url);
    http_destroy_headers(reply_headers);
        octstr_destroy(reply_body);
    }
    octstr_destroy(url);
    http_destroy_headers(req_headers);
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 902 of file test_smsc.c.

References eq_init(), eq_shutdown(), getopt(), gwlib_init(), gwlib_shutdown(), httpd_emu_init(), httpd_emu_shutdown(), n_messages_benchmark(), name, num_messages, optarg, smsc_emu_init(), smsc_emu_shutdown(), and sustained_level_benchmark().

{
    int opt;
    char *main_name;
    int i;
    static struct {
    char *name;
    void (*func)(void);
    } tab[] = {
    { "n_messages", n_messages_benchmark },
    { "sustained_level", sustained_level_benchmark },
    };

    gwlib_init();
    eq_init();
    httpd_emu_init();
    smsc_emu_init();

    main_name = "n_messages_benchmark";

    while ((opt = getopt(argc, argv, "m:r:")) != EOF) {
    switch (opt) {
    case 'm':
        main_name = optarg;
        break;
    case 'r':
        num_messages = atoi(optarg);
        break;
    }
    }

    for (i = 0; (size_t) i < sizeof(tab) / sizeof(tab[0]); ++i) {
    if (strcmp(main_name, tab[i].name) == 0) {
        tab[i].func();
        break;
    }
    }

    smsc_emu_shutdown();
    httpd_emu_shutdown();
    eq_shutdown();
    gwlib_shutdown();
    return 0;
}

n_messages_benchmark()

static void n_messages_benchmark ( void  )

static

Definition at line 822 of file test_smsc.c.

References debug(), httpd_emu_arg::eq, eq_create(), eq_destroy(), eq_destroy_event(), eq_extract(), eq_log(), eq_round_trip_time(), eq_type(), httpd_emu_create(), httpd_emu_destroy(), httpd_emu_reply(), kill_kannel(), MAX_IN_QUEUE, num_messages, smsc_emu_create(), smsc_emu_deliver(), smsc_emu_destroy(), smsc_emu_submit_ack(), and Event::type.

Referenced by main().

{
    EventQueue *eq;
    Event *e;
    long i;
    long num_submit;
    long num_in_queue;
    long num_deliver;

    eq = eq_create();

    httpd_emu_create(eq);
    smsc_emu_create(eq);
    
    /* Wait for an SMS center client to appear. */
    while ((e = eq_extract(eq)) != NULL && e->type != got_smsc)
        debug("test_smsc", 0, "Discarding event of type %s", eq_type(e));
    debug("test_smsc", 0, "Got event got_smsc.");
    eq_destroy_event(e);

    /* Send the SMS messages, or at least fill the send queue. */
    for (i = 0; i < num_messages && i < MAX_IN_QUEUE; ++i)
        smsc_emu_deliver();
    num_in_queue = i;
    num_deliver = i;

    /* 
     * Wait for results to be processed. When send queue is not full,
     * fill it.
     */
    num_submit = 0;
    while (num_submit < num_messages && (e = eq_extract(eq)) != NULL) {
        while (num_deliver < num_messages && num_in_queue < MAX_IN_QUEUE) {
        smsc_emu_deliver();
        ++num_in_queue;
        ++num_deliver;
    }

    eq_log(e);

    switch (e->type) {
    case deliver_ack:
        break;
        
    case http_request:
        httpd_emu_reply(e);
        break;

    case submit:
        debug("", 0, "RTT = %ld", eq_round_trip_time(e));
        smsc_emu_submit_ack(e);
        ++num_submit;
        --num_in_queue;
        break;
        
        case got_enquire_link:
        break;

    default:
        debug("test_smsc", 0, "Ignoring event of type %s", eq_type(e));
        break;
    }
    
    eq_destroy_event(e);
    }

    kill_kannel();

    debug("test_smsc", 0, "Terminating benchmark.");
    smsc_emu_destroy();
    httpd_emu_destroy();
    eq_destroy(eq);
}

smpp_emu()

static void smpp_emu ( void *  arg )

static

Definition at line 433 of file test_smsc.c.

References smpp_emu_arg::conn, conn_destroy(), conn_wrap_fd(), smsc_emu_arg::eq, smpp_emu_arg::eq, eq_add_producer(), eq_remove_producer(), gw_accept(), gwthread_create, gwthread_join(), gwthread_wakeup(), smpp_emu_arg::id, make_server_socket(), MAX_THREADS, octstr_destroy(), smpp_emu_arg::ok_to_send, panic, smpp_emu_arg::quit, smsc_emu_arg::sema, semaphore_create(), semaphore_destroy(), semaphore_up(), smpp_emu_reader(), SMPP_MAX_QUEUE, smpp_port, warning(), and smpp_emu_arg::writer_id.

Referenced by smsc_emu_create().

{
    EventQueue *eq;
    struct smsc_emu_arg *p;
    int fd;
    int new_fd;
    Octstr *client_addr;
    long i;
    long num_threads;
    struct smpp_emu_arg *thread[MAX_THREADS];
    
    p = arg;
    eq = p->eq;
    eq_add_producer(eq);
    semaphore_up(p->sema);
    
    /*
     * Wait for SMPP clients.
     */
    fd = make_server_socket(smpp_port, NULL);
    if (fd == -1)
        panic(0, "Couldn't create SMPP listen port.");
    
    num_threads = 0;
    for (;;) {
        new_fd = gw_accept(fd, &client_addr);
    if (new_fd == -1)
        break;
        octstr_destroy(client_addr);
        if (num_threads == MAX_THREADS) {
        warning(0, "Too many SMPP client connections.");
        (void) close(new_fd);
    } else {
        thread[num_threads] = gw_malloc(sizeof(*thread[0]));
            thread[num_threads]->conn = conn_wrap_fd(new_fd, 0);
        thread[num_threads]->eq = eq;
        thread[num_threads]->quit = 0;
        thread[num_threads]->writer_id = -1;
        thread[num_threads]->ok_to_send = 
            semaphore_create(SMPP_MAX_QUEUE);
        thread[num_threads]->id = 
            gwthread_create(smpp_emu_reader, thread[num_threads]);
        if (thread[num_threads]->id == -1)
            panic(0, "Couldn't start SMPP subthread.");
            ++num_threads;
    }
    }
    
    for (i = 0; i < num_threads; ++i) {
    thread[i]->quit = 1;
        gwthread_wakeup(thread[i]->id);
    gwthread_join(thread[i]->id);
    conn_destroy(thread[i]->conn);
    semaphore_destroy(thread[i]->ok_to_send);
    gw_free(thread[i]);
    }

    eq_remove_producer(eq);
}

smpp_emu_handle_pdu()

static void smpp_emu_handle_pdu ( struct smpp_emu_arg *  p, SMPP_PDU *  pdu  )

static

Definition at line 325 of file test_smsc.c.

References smpp_emu_arg::conn, conn_write(), smpp_emu_arg::eq, eq_append(), eq_create_event(), eq_create_submit(), error(), gw_assert(), gwthread_create, octstr_destroy(), smpp_emu_arg::ok_to_send, panic, semaphore_up(), smpp_emu_writer(), smpp_pdu_create(), smpp_pdu_destroy(), smpp_pdu_pack(), SMPP_PDU::type, SMPP_PDU::type_name, SMPP_PDU::u, and smpp_emu_arg::writer_id.

Referenced by smpp_emu_reader().

{
    SMPP_PDU *resp;
    Octstr *os;
    
    resp = NULL;
    switch (pdu->type) {
        case bind_transmitter:
        resp = smpp_pdu_create(bind_transmitter_resp,
                   pdu->u.bind_transmitter.sequence_number);
        break;

        case bind_receiver:
        resp = smpp_pdu_create(bind_receiver_resp,
                   pdu->u.bind_receiver.sequence_number);
            eq_append(p->eq, eq_create_event(got_smsc));
        gw_assert(p->writer_id == -1);
        p->writer_id = gwthread_create(smpp_emu_writer, p);
        if (p->writer_id == -1)
            panic(0, "Couldn't create SMPP helper thread.");
            break;

        case submit_sm:
        eq_append(p->eq, 
            eq_create_submit(p->conn, pdu->u.submit_sm.sequence_number,
                         pdu->u.submit_sm.short_message));
            break;

        case deliver_sm_resp:
        eq_append(p->eq, eq_create_event(deliver_ack));
        semaphore_up(p->ok_to_send);
        break;

        case enquire_link:
        eq_append(p->eq, eq_create_event(got_enquire_link));
        resp = smpp_pdu_create(enquire_link_resp,
                               pdu->u.enquire_link.sequence_number);
        break;

        case unbind:
        resp = smpp_pdu_create(unbind_resp, 
                               pdu->u.unbind.sequence_number);
        break;

        default:
        error(0, "SMPP: Unhandled PDU type %s", pdu->type_name);
        break;
    }
        
    if (resp != NULL) {
    os = smpp_pdu_pack(NULL, resp);
    conn_write(p->conn, os);
    octstr_destroy(os);
    smpp_pdu_destroy(resp);
    }
}

smpp_emu_reader()

static void smpp_emu_reader ( void *  arg )

static

Definition at line 383 of file test_smsc.c.

References smpp_emu_arg::conn, conn_eof(), conn_error(), conn_wait(), error(), gw_assert(), gwthread_join(), octstr_destroy(), octstr_dump, smpp_emu_arg::quit, smpp_emu_handle_pdu(), smpp_pdu_destroy(), smpp_pdu_read_data(), smpp_pdu_read_len(), smpp_pdu_unpack(), and smpp_emu_arg::writer_id.

Referenced by smpp_emu().

{
    Octstr *os;
    long len;
    SMPP_PDU *pdu;
    struct smpp_emu_arg *p;

    p = arg;
    
    len = 0;
    while (!p->quit && conn_wait(p->conn, -1.0) != -1) {
        for (;;) {
        if (len == 0) {
        len = smpp_pdu_read_len(p->conn);
        if (len == -1) {
            error(0, "Client sent garbage, closing connection.");
            goto error;
        } else if (len == 0) {
            if (conn_eof(p->conn) || conn_error(p->conn))
                goto error;
            break;
        }
        }
    
            gw_assert(len > 0);
        os = smpp_pdu_read_data(p->conn, len);
        if (os != NULL) {
                len = 0;
        pdu = smpp_pdu_unpack(NULL, os);
        if (pdu == NULL) {
            error(0, "PDU unpacking failed!");
            octstr_dump(os, 0);
        } else {
            smpp_emu_handle_pdu(p, pdu);
            smpp_pdu_destroy(pdu);
        }
        octstr_destroy(os);
        } else if (conn_eof(p->conn) || conn_error(p->conn))
            goto error;
        else
        break;
    }
    }

error:
    if (p->writer_id != -1)
    gwthread_join(p->writer_id);
}

smpp_emu_writer()

static void smpp_emu_writer ( void *  arg )

static

Definition at line 296 of file test_smsc.c.

References smpp_emu_arg::conn, conn_write(), counter_increase(), date_universal_now(), eq_destroy_event(), eq_extract(), eq_log(), octstr_create, octstr_destroy(), octstr_format(), smpp_emu_arg::ok_to_send, semaphore_down(), smpp_emu_counter, smpp_pdu_create(), smpp_pdu_destroy(), smpp_pdu_pack(), Event::time, SMPP_PDU::u, and undelivered_messages.

Referenced by smpp_emu_handle_pdu().

{
    Event *e;
    SMPP_PDU *pdu;
    Octstr *os;
    struct smpp_emu_arg *p;

    p = arg;
    for (;;) {
    semaphore_down(p->ok_to_send);
    e = eq_extract(undelivered_messages);
    if (e == NULL)
        break;
        e->time = date_universal_now();
        eq_log(e);
    pdu = smpp_pdu_create(deliver_sm,
                  counter_increase(smpp_emu_counter));
        pdu->u.deliver_sm.source_addr = octstr_create("123");
        pdu->u.deliver_sm.destination_addr = octstr_create("456");
    pdu->u.deliver_sm.short_message = octstr_format("%ld", e->time);
    os = smpp_pdu_pack(NULL, pdu);
    conn_write(p->conn, os);
    octstr_destroy(os);
    smpp_pdu_destroy(pdu);
    eq_destroy_event(e);
    }
}

smsc_emu_create()

static void smsc_emu_create ( EventQueue *  eq )

static

Definition at line 505 of file test_smsc.c.

References smsc_emu_arg::eq, gw_assert(), gwthread_create, panic, smsc_emu_arg::sema, semaphore_create(), semaphore_destroy(), semaphore_down(), smpp_emu(), and smpp_emu_id.

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    struct smsc_emu_arg *arg;
    
    gw_assert(smpp_emu_id == -1);

    arg = gw_malloc(sizeof(*arg));
    arg->sema = semaphore_create(0);
    arg->eq = eq;
    smpp_emu_id = gwthread_create(smpp_emu, arg);
    if (smpp_emu_id == -1)
        panic(0, "Couldn't start SMPP emulator thread.");
    semaphore_down(arg->sema);
    semaphore_destroy(arg->sema);
    gw_free(arg);
}

smsc_emu_deliver()

static void smsc_emu_deliver ( void  )

static

Definition at line 532 of file test_smsc.c.

References eq_append(), eq_create_event(), and undelivered_messages.

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    eq_append(undelivered_messages, eq_create_event(deliver));
}

smsc_emu_destroy()

static void smsc_emu_destroy ( void  )

static

Definition at line 523 of file test_smsc.c.

References eq_remove_producer(), gw_assert(), gwthread_join(), gwthread_wakeup(), smpp_emu_id, and undelivered_messages.

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    eq_remove_producer(undelivered_messages);
    gw_assert(smpp_emu_id != -1);
    gwthread_wakeup(smpp_emu_id);
    gwthread_join(smpp_emu_id);
}

smsc_emu_init()

static void smsc_emu_init ( void  )

static

Definition at line 551 of file test_smsc.c.

References counter_create(), eq_add_producer(), eq_create(), smpp_emu_counter, and undelivered_messages.

Referenced by main().

{
    smpp_emu_counter = counter_create();
    undelivered_messages = eq_create();
    eq_add_producer(undelivered_messages);
}

smsc_emu_shutdown()

static void smsc_emu_shutdown ( void  )

static

Definition at line 559 of file test_smsc.c.

References counter_destroy(), eq_destroy(), smpp_emu_counter, and undelivered_messages.

Referenced by main().

{
    counter_destroy(smpp_emu_counter);
    eq_destroy(undelivered_messages);
}

smsc_emu_submit_ack()

static void smsc_emu_submit_ack ( Event *  e )

static

Definition at line 538 of file test_smsc.c.

References Event::conn, conn_write(), octstr_destroy(), Event::sequence_number, smpp_pdu_create(), smpp_pdu_destroy(), and smpp_pdu_pack().

Referenced by n_messages_benchmark(), and sustained_level_benchmark().

{
    SMPP_PDU *resp;
    Octstr *os;

    resp = smpp_pdu_create(submit_sm_resp, e->sequence_number);
    os = smpp_pdu_pack(NULL, resp);
    conn_write(e->conn, os);
    octstr_destroy(os);
    smpp_pdu_destroy(resp);
}

sustained_level_benchmark()

static void sustained_level_benchmark ( void  )

static

Definition at line 724 of file test_smsc.c.

References debug(), httpd_emu_arg::eq, eq_create(), eq_destroy(), eq_destroy_event(), eq_extract(), eq_log(), eq_round_trip_time(), eq_type(), httpd_emu_create(), httpd_emu_destroy(), httpd_emu_reply(), kill_kannel(), MAX_IN_AVERAGE, MAX_RTT, MAX_WAITING, num_messages, smsc_emu_create(), smsc_emu_deliver(), smsc_emu_destroy(), smsc_emu_submit_ack(), and Event::type.

Referenced by main().

{
    EventQueue *eq;
    Event *e;
    long i;
    long num_deliver;
    long num_submit;
    long rtt;
    long times[MAX_IN_AVERAGE];
    long next_time;
    double time_sum;
    long num_unanswered;

    eq = eq_create();

    httpd_emu_create(eq);
    smsc_emu_create(eq);
    
    /* Wait for an SMS center client to appear. */
    while ((e = eq_extract(eq)) != NULL && e->type != got_smsc)
        debug("test_smsc", 0, "Discarding event of type %s", eq_type(e));
    debug("test_smsc", 0, "Got event got_smsc.");
    eq_destroy_event(e);

    /* 
     * Send message when there are at most MAX_WAITING unanswered messages
     * and current average round trip time is less than MAX_RTT.
     */
    num_submit = 0;
    for (i = 0; i < MAX_IN_AVERAGE; ++i)
        times[i] = 0;
    next_time = 0;
    time_sum = 0.0;
    num_unanswered = 0;
    num_deliver = 0;

    while (num_submit < num_messages) {
    for (;;) {
        if (num_deliver >= num_messages || num_unanswered >= MAX_WAITING)
            break;
            if (time_sum / MAX_IN_AVERAGE >= MAX_RTT && num_unanswered > 0)
            break;
        smsc_emu_deliver();
        ++num_unanswered;
        ++num_deliver;
    }

        e = eq_extract(eq);
    if (e == NULL)
        break;
    eq_log(e);

    switch (e->type) {
    case deliver_ack:
        break;
        
    case http_request:
        httpd_emu_reply(e);
        break;

    case submit:
        rtt = eq_round_trip_time(e);
        time_sum -= times[next_time];
        times[next_time] = rtt;
        time_sum += times[next_time];
        debug("", 0, "RTT = %ld", rtt);
        next_time = (next_time + 1) % MAX_IN_AVERAGE;
        ++num_submit;
        --num_unanswered;
        smsc_emu_submit_ack(e);
        break;
        
        case got_enquire_link:
        break;

    default:
        debug("test_smsc", 0, "Ignoring event of type %s", eq_type(e));
        break;
    }
    
    eq_destroy_event(e);
    }

    kill_kannel();

    debug("test_smsc", 0, "Terminating benchmark.");
    smsc_emu_destroy();
    httpd_emu_destroy();
    eq_destroy(eq);
}

Variable Documentation

admin_password

char* admin_password = "bar"

static

Definition at line 77 of file test_smsc.c.

Referenced by kill_kannel().

admin_port

long admin_port = 13000

static

Definition at line 76 of file test_smsc.c.

Referenced by kill_kannel().

event_id_counter

Counter* event_id_counter = NULL

static

Definition at line 122 of file test_smsc.c.

Referenced by eq_create_event(), eq_init(), and eq_shutdown().

http_port

long http_port = 8080

static

Definition at line 70 of file test_smsc.c.

Referenced by httpd_emu_create().

httpd_emu_headers

List* httpd_emu_headers = NULL

static

Definition at line 571 of file test_smsc.c.

Referenced by httpd_emu_init(), httpd_emu_reply(), and httpd_emu_shutdown().

httpd_emu_tid

long httpd_emu_tid = -1

static

Definition at line 623 of file test_smsc.c.

Referenced by httpd_emu_create(), and httpd_emu_destroy().

num_messages

long num_messages = 1

static

Definition at line 90 of file test_smsc.c.

Referenced by main(), n_messages_benchmark(), prepend_catenation_udh(), and sustained_level_benchmark().

smpp_emu_counter

Counter* smpp_emu_counter = NULL

static

Definition at line 293 of file test_smsc.c.

Referenced by smpp_emu_writer(), smsc_emu_init(), and smsc_emu_shutdown().

smpp_emu_id

long smpp_emu_id = -1

static

Definition at line 499 of file test_smsc.c.

Referenced by smsc_emu_create(), and smsc_emu_destroy().

smpp_port

long smpp_port = 2345

static

Definition at line 83 of file test_smsc.c.

Referenced by smpp_emu().

undelivered_messages

EventQueue* undelivered_messages = NULL

static

Definition at line 271 of file test_smsc.c.

Referenced by smpp_emu_writer(), smsc_emu_deliver(), smsc_emu_destroy(), smsc_emu_init(), and smsc_emu_shutdown().