开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
test_smsc.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：18k
源码类别：

手机WAP编程

开发平台：

WINDOWS

test_smsc.c：源码内容
  1. #include <unistd.h>
  2. #include "gwlib/gwlib.h"
  3. #include "gw/smsc/smpp_pdu.h"
  4. #include <string.h>
  6. /***********************************************************************
  7.  * Configurable stuff.
  8.  */
  11. /*
  12.  * The port at which our HTTP server emulator listens.
  13.  */
  14. static long http_port = 8080;
  17. /*
  18.  * The HTTP admin port and password for Kannel, needed to do shutdown.
  19.  */
  20. static long admin_port = 13000;
  21. static char *admin_password = "bar";
  24. /*
  25.  * The port at which the SMPP SMS center emulator listens.
  26.  */
  27. static long smpp_port = 2345;
  30. /*
  31.  * Number of messages to use in the "Send N messages as fast as possible"
  32.  * benchmark.
  33.  */
  34. static long num_messages = 1;
  37. /***********************************************************************
  38.  * Events and event queues.
  39.  */
  41. typedef List EventQueue;
  44. typedef struct Event {
  45.     enum event_type {
  46. got_smsc,
  47. deliver,
  48. deliver_ack,
  49. http_request,
  50. http_response,
  51. submit,
  52. got_enquire_link
  53.     } type;
  54.     long id;
  55.     long time;
  56.     
  57.     Connection *conn;     /* SMPP: Connection for response PDU */
  58.     long sequence_number;   /* SMPP: Sequence number of resp PDU */
  60.     /* HTTP related stuff */
  61.     HTTPClient *client;
  62.     Octstr *body;
  63. } Event;
  66. static Counter *event_id_counter = NULL;
  69. static const char *eq_type(Event *e)
  70. {
  71. #define TYPE(name) case name: return #name;
  72.     switch (e->type) {
  73. TYPE(got_smsc)
  74. TYPE(deliver)
  75. TYPE(deliver_ack)
  76. TYPE(http_request)
  77. TYPE(http_response)
  78. TYPE(submit)
  79. TYPE(got_enquire_link)
  80.     }
  81. #undef TYPE
  82.     return "unknown";
  83. }
  86. static Event *eq_create_event(enum event_type type)
  87. {
  88.     Event *e;
  89.     
  90.     e = gw_malloc(sizeof(*e));
  91.     e->type = type;
  92.     e->time = date_universal_now();
  93.     e->id = counter_increase(event_id_counter);
  94.     e->conn = NULL;
  95.     e->sequence_number = -1;
  96.     e->client = NULL;
  97.     e->body = NULL;
  98.     return e;
  99. }
  102. static Event *eq_create_submit(Connection *conn, long sequence_number, 
  103.                       Octstr *body)
  104. {
  105.     Event *e;
  106.     
  107.     gw_assert(conn != NULL);
  108.     gw_assert(sequence_number >= 0);
  110.     e = eq_create_event(submit);
  111.     e->conn = conn;
  112.     e->sequence_number = sequence_number;
  113.     e->body = octstr_duplicate(body);
  114.     return e;
  115. }
  118. static Event *eq_create_http_request(HTTPClient *client, Octstr *body)
  119. {
  120.     Event *e;
  121.     
  122.     gw_assert(client != NULL);
  123.     gw_assert(body != NULL);
  125.     e = eq_create_event(http_request);
  126.     e->client = client;
  127.     e->body = octstr_duplicate(body);
  128.     return e;
  129. }
  132. static void eq_destroy_event(Event *e)
  133. {
  134.     octstr_destroy(e->body);
  135.     gw_free(e);
  136. }
  139. static EventQueue *eq_create(void)
  140. {
  141.     return list_create();
  142. }
  145. static void eq_add_producer(EventQueue *eq)
  146. {
  147.     list_add_producer(eq);
  148. }
  151. static void eq_remove_producer(EventQueue *eq)
  152. {
  153.     list_remove_producer(eq);
  154. }
  157. static void eq_destroy(EventQueue *eq)
  158. {
  159.     list_destroy(eq, NULL);
  160. }
  163. static void eq_append(EventQueue *eq, Event *e)
  164. {
  165.     list_produce(eq, e);
  166. }
  169. static Event *eq_extract(EventQueue *eq)
  170. {
  171.     return list_consume(eq);
  172. }
  175. static void eq_log(Event *e)
  176. {
  177.     info(0, "Event %ld, type %s, time %ld", e->id, eq_type(e), e->time);
  178. }
  181. static void eq_init(void)
  182. {
  183.     event_id_counter = counter_create();
  184. }
  187. static void eq_shutdown(void)
  188. {
  189.     counter_destroy(event_id_counter);
  190. }
  193. static long eq_round_trip_time(Event *e)
  194. {
  195.     long now, then;
  196.     
  197.     now = date_universal_now();
  198.     if (octstr_parse_long(&then, e->body, 0, 10) == -1)
  199.      return 0;
  200.     return now - then;
  201. }
  204. /***********************************************************************
  205.  * SMS center emulator, declarations.
  206.  */
  209. struct smsc_emu_arg {
  210.     Semaphore *sema;
  211.     EventQueue *eq;
  212. };
  215. static EventQueue *undelivered_messages = NULL;
  218. /***********************************************************************
  219.  * SMS center emulator, SMPP internals.
  220.  */
  223. enum { MAX_THREADS = 2 };
  224. enum { SMPP_MAX_QUEUE = 10 };
  227. struct smpp_emu_arg {
  228.     EventQueue *eq;
  229.     Connection *conn;
  230.     long id;
  231.     Semaphore *ok_to_send;
  232.     long writer_id;
  233.     int quit;
  234. };
  237. static Counter *smpp_emu_counter = NULL;
  240. static void smpp_emu_writer(void *arg)
  241. {
  242.     Event *e;
  243.     SMPP_PDU *pdu;
  244.     Octstr *os;
  245.     struct smpp_emu_arg *p;
  247.     p = arg;
  248.     for (;;) {
  249. semaphore_down(p->ok_to_send);
  250. e = eq_extract(undelivered_messages);
  251. if (e == NULL)
  252.     break;
  253.      e->time = date_universal_now();
  254.      eq_log(e);
  255. pdu = smpp_pdu_create(deliver_sm,
  256.       counter_increase(smpp_emu_counter));
  257.      pdu->u.deliver_sm.source_addr = octstr_create("123");
  258.      pdu->u.deliver_sm.destination_addr = octstr_create("456");
  259. pdu->u.deliver_sm.short_message = octstr_format("%ld", e->time);
  260. os = smpp_pdu_pack(pdu);
  261. conn_write(p->conn, os);
  262. octstr_destroy(os);
  263. smpp_pdu_destroy(pdu);
  264. eq_destroy_event(e);
  265.     }
  266. }
  269. static void smpp_emu_handle_pdu(struct smpp_emu_arg *p, SMPP_PDU *pdu)
  270. {
  271.     SMPP_PDU *resp;
  272.     Octstr *os;
  273.     
  274.     resp = NULL;
  275.     switch (pdu->type) {
  276.      case bind_transmitter:
  277.     resp = smpp_pdu_create(bind_transmitter_resp,
  278.    pdu->u.bind_transmitter.sequence_number);
  279.     break;
  281.      case bind_receiver:
  282.     resp = smpp_pdu_create(bind_receiver_resp,
  283.    pdu->u.bind_receiver.sequence_number);
  284.          eq_append(p->eq, eq_create_event(got_smsc));
  285.     gw_assert(p->writer_id == -1);
  286.     p->writer_id = gwthread_create(smpp_emu_writer, p);
  287.     if (p->writer_id == -1)
  288.      panic(0, "Couldn't create SMPP helper thread.");
  289.          break;
  291.      case submit_sm:
  292.     eq_append(p->eq, 
  293.      eq_create_submit(p->conn, pdu->u.submit_sm.sequence_number,
  294.            pdu->u.submit_sm.short_message));
  295.          break;
  297.      case deliver_sm_resp:
  298.     eq_append(p->eq, eq_create_event(deliver_ack));
  299.     semaphore_up(p->ok_to_send);
  300.     break;
  302.      case enquire_link:
  303.     eq_append(p->eq, eq_create_event(got_enquire_link));
  304.     resp = smpp_pdu_create(enquire_link_resp,
  305.                   pdu->u.enquire_link.sequence_number);
  306.     break;
  308.      case unbind:
  309.     resp = smpp_pdu_create(unbind_resp, 
  310.                   pdu->u.unbind.sequence_number);
  311.     break;
  313.      default:
  314.     error(0, "SMPP: Unhandled PDU type %s", pdu->type_name);
  315.     break;
  316.     }
  318.     if (resp != NULL) {
  319. os = smpp_pdu_pack(resp);
  320. conn_write(p->conn, os);
  321. octstr_destroy(os);
  322. smpp_pdu_destroy(resp);
  323.     }
  324. }
  327. static void smpp_emu_reader(void *arg)
  328. {
  329.     Octstr *os;
  330.     long len;
  331.     SMPP_PDU *pdu;
  332.     struct smpp_emu_arg *p;
  334.     p = arg;
  335.     
  336.     len = 0;
  337.     while (!p->quit && conn_wait(p->conn, -1.0) != -1) {
  338.      for (;;) {
  339.     if (len == 0) {
  340. len = smpp_pdu_read_len(p->conn);
  341. if (len == -1) {
  342.     error(0, "Client sent garbage, closing connection.");
  343.     goto error;
  344. } else if (len == 0) {
  345.     if (conn_eof(p->conn) || conn_read_error(p->conn))
  346.      goto error;
  347.     break;
  348. }
  349.     }
  350.     
  351.          gw_assert(len > 0);
  352.     os = smpp_pdu_read_data(p->conn, len);
  353.     if (os != NULL) {
  354.           len = 0;
  355. pdu = smpp_pdu_unpack(os);
  356. if (pdu == NULL) {
  357.     error(0, "PDU unpacking failed!");
  358.     octstr_dump(os, 0);
  359. } else {
  360.     smpp_emu_handle_pdu(p, pdu);
  361.     smpp_pdu_destroy(pdu);
  362. }
  363. octstr_destroy(os);
  364.     } else if (conn_eof(p->conn) || conn_read_error(p->conn))
  365.      goto error;
  366.     else
  367. break;
  368. }
  369.     }
  371. error:
  372.     if (p->writer_id != -1)
  373. gwthread_join(p->writer_id);
  374. }
  377. static void smpp_emu(void *arg)
  378. {
  379.     EventQueue *eq;
  380.     struct smsc_emu_arg *p;
  381.     int fd;
  382.     int new_fd;
  383.     Octstr *client_addr;
  384.     long i;
  385.     long num_threads;
  386.     struct smpp_emu_arg *thread[MAX_THREADS];
  387.     
  388.     p = arg;
  389.     eq = p->eq;
  390.     eq_add_producer(eq);
  391.     semaphore_up(p->sema);
  392.     
  393.     /*
  394.      * Wait for SMPP clients.
  395.      */
  396.     fd = make_server_socket(smpp_port, NULL);
  397.     if (fd == -1)
  398.      panic(0, "Couldn't create SMPP listen port.");
  399.     
  400.     num_threads = 0;
  401.     for (;;) {
  402.      new_fd = gw_accept(fd, &client_addr);
  403. if (new_fd == -1)
  404.     break;
  405.      octstr_destroy(client_addr);
  406.      if (num_threads == MAX_THREADS) {
  407.     warning(0, "Too many SMPP client connections.");
  408.     (void) close(new_fd);
  409. } else {
  410.     thread[num_threads] = gw_malloc(sizeof(*thread[0]));
  411.          thread[num_threads]->conn = conn_wrap_fd(new_fd, 0);
  412.     thread[num_threads]->eq = eq;
  413.     thread[num_threads]->quit = 0;
  414.     thread[num_threads]->writer_id = -1;
  415.     thread[num_threads]->ok_to_send = 
  416.      semaphore_create(SMPP_MAX_QUEUE);
  417.     thread[num_threads]->id = 
  418.      gwthread_create(smpp_emu_reader, thread[num_threads]);
  419.     if (thread[num_threads]->id == -1)
  420.      panic(0, "Couldn't start SMPP subthread.");
  421.          ++num_threads;
  422. }
  423.     }
  424.     
  425.     for (i = 0; i < num_threads; ++i) {
  426. thread[i]->quit = 1;
  427.      gwthread_wakeup(thread[i]->id);
  428. gwthread_join(thread[i]->id);
  429. conn_destroy(thread[i]->conn);
  430. semaphore_destroy(thread[i]->ok_to_send);
  431. gw_free(thread[i]);
  432.     }
  434.     eq_remove_producer(eq);
  435. }
  438. /***********************************************************************
  439.  * SMS center emulator, generic interface.
  440.  */
  443. static long smpp_emu_id = -1;
  446. /*
  447.  * Start all SMS center emulators.
  448.  */
  449. static void smsc_emu_create(EventQueue *eq)
  450. {
  451.     struct smsc_emu_arg *arg;
  452.     
  453.     gw_assert(smpp_emu_id == -1);
  455.     arg = gw_malloc(sizeof(*arg));
  456.     arg->sema = semaphore_create(0);
  457.     arg->eq = eq;
  458.     smpp_emu_id = gwthread_create(smpp_emu, arg);
  459.     if (smpp_emu_id == -1)
  460.      panic(0, "Couldn't start SMPP emulator thread.");
  461.     semaphore_down(arg->sema);
  462.     semaphore_destroy(arg->sema);
  463.     gw_free(arg);
  464. }
  467. static void smsc_emu_destroy(void)
  468. {
  469.     eq_remove_producer(undelivered_messages);
  470.     gw_assert(smpp_emu_id != -1);
  471.     gwthread_wakeup(smpp_emu_id);
  472.     gwthread_join(smpp_emu_id);
  473. }
  476. static void smsc_emu_deliver(void)
  477. {
  478.     eq_append(undelivered_messages, eq_create_event(deliver));
  479. }
  482. static void smsc_emu_submit_ack(Event *e)
  483. {
  484.     SMPP_PDU *resp;
  485.     Octstr *os;
  487.     resp = smpp_pdu_create(submit_sm_resp, e->sequence_number);
  488.     os = smpp_pdu_pack(resp);
  489.     conn_write(e->conn, os);
  490.     octstr_destroy(os);
  491.     smpp_pdu_destroy(resp);
  492. }
  495. static void smsc_emu_init(void)
  496. {
  497.     smpp_emu_counter = counter_create();
  498.     undelivered_messages = eq_create();
  499.     eq_add_producer(undelivered_messages);
  500. }
  503. static void smsc_emu_shutdown(void)
  504. {
  505.     counter_destroy(smpp_emu_counter);
  506.     eq_destroy(undelivered_messages);
  507. }
  510. /***********************************************************************
  511.  * HTTP server emulator.
  512.  */
  515. static List *httpd_emu_headers = NULL;
  518. struct httpd_emu_arg {
  519.     int port;
  520.     Semaphore *sema;
  521.     EventQueue *eq;
  522. };
  525. /*
  526.  * This is the HTTP server emulator thread.
  527.  */
  528. static void httpd_emu(void *arg)
  529. {
  530.     HTTPClient *client;
  531.     Octstr *ip;
  532.     Octstr *url;
  533.     List *headers;
  534.     Octstr *body;
  535.     List *cgivars;
  536.     struct httpd_emu_arg *p;
  537.     EventQueue *eq;
  539.     p = arg;
  540.     eq = p->eq;
  541.     eq_add_producer(eq);
  542.     semaphore_up(p->sema);
  544.     for (;;) {
  545. client = http_accept_request(p->port, &ip, &url, &headers, &body, 
  546.                     &cgivars);
  547. if (client == NULL)
  548.     break;
  549.     
  550. eq_append(eq, eq_create_http_request(client, 
  551.                    http_cgi_variable(cgivars, "arg")));
  552.      octstr_destroy(ip);
  553.      octstr_destroy(url);
  554. http_destroy_headers(headers);
  555.      octstr_destroy(body);
  556.      http_destroy_cgiargs(cgivars);
  557.     }
  558.     eq_remove_producer(eq);
  559.     gw_free(p);
  560. }
  563. /*
  564.  * Thread id for HTTP server emulator thread. It is needed for proper
  565.  * shutdown.
  566.  */
  567. static long httpd_emu_tid = -1;
  570. /*
  571.  * Start the HTTP server emulator thread and return when it is 
  572.  * ready to accept clients.
  573.  */
  574. static void httpd_emu_create(EventQueue *eq)
  575. {
  576.     struct httpd_emu_arg *arg;
  577.     int ssl = 0;   /* indicate if SSL-enabled server should be used */
  579.     if (http_open_port(http_port, ssl) == -1)
  580.      panic(0, "Can't open HTTP server emulator port %ld.", http_port);
  582.     gw_assert(httpd_emu_tid == -1);
  583.     arg = gw_malloc(sizeof(*arg));
  584.     arg->port = http_port;
  585.     arg->sema = semaphore_create(0);
  586.     arg->eq = eq;
  587.     httpd_emu_tid = gwthread_create(httpd_emu, arg);
  588.     if (httpd_emu_tid == -1)
  589.      panic(0, "Can't start the HTTP server emulator thread.");
  590.     semaphore_down(arg->sema);
  591.     semaphore_destroy(arg->sema);
  592. }
  595. /*
  596.  * Terminate the HTTP server emulator thread. Return when the thread
  597.  * is quite dead.
  598.  */
  599. static void httpd_emu_destroy(void)
  600. {
  601.     gw_assert(httpd_emu_tid != -1);
  602.     http_close_all_ports();
  603.     gwthread_join(httpd_emu_tid);
  604.     httpd_emu_tid = -1;
  605. }
  608. /*
  609.  * Send a reply to an HTTP response.
  610.  */
  611. static void httpd_emu_reply(Event *e)
  612. {
  613.     http_send_reply(e->client, HTTP_OK, httpd_emu_headers, e->body);
  614. }
  617. static void httpd_emu_init(void)
  618. {
  619.     httpd_emu_headers = http_create_empty_headers();
  620.     http_header_add(httpd_emu_headers, "Content-Type", "text/plain");
  621. }
  624. static void httpd_emu_shutdown(void)
  625. {
  626.     http_destroy_headers(httpd_emu_headers);
  627. }
  630. /***********************************************************************
  631.  * Main program for N SMS messages benchmark.
  632.  */
  635. static void kill_kannel(void)
  636. {
  637.     Octstr *url;
  638.     Octstr *final_url;
  639.     List *req_headers;
  640.     List *reply_headers;
  641.     Octstr *reply_body;
  642.     int ret;
  643.     
  644.     url = octstr_format("http://localhost:%ld/shutdown?password=%s",
  645.                admin_port, admin_password);
  646.     req_headers = http_create_empty_headers();
  647.     http_header_add(req_headers, "Content-Type", "text/plain");
  648.     ret = http_get_real(HTTP_METHOD_GET, url, req_headers, &final_url, 
  649.                         &reply_headers, &reply_body);
  650.     if (ret != -1) {
  651.      octstr_destroy(final_url);
  652. http_destroy_headers(reply_headers);
  653.      octstr_destroy(reply_body);
  654.     }
  655.     octstr_destroy(url);
  656.     http_destroy_headers(req_headers);
  657. }
  660. /*
  661.  * This will try to have as large a sustained level of traffic as possible.
  662.  */
  664. enum { MAX_IN_AVERAGE = 100 };
  665. enum { MAX_RTT = 1 };
  666. enum { MAX_WAITING = 100 };
  668. static void sustained_level_benchmark(void)
  669. {
  670.     EventQueue *eq;
  671.     Event *e;
  672.     long i;
  673.     long num_deliver;
  674.     long num_submit;
  675.     long rtt;
  676.     long times[MAX_IN_AVERAGE];
  677.     long next_time;
  678.     double time_sum;
  679.     long num_unanswered;
  681.     eq = eq_create();
  683.     httpd_emu_create(eq);
  684.     smsc_emu_create(eq);
  685.     
  686.     /* Wait for an SMS center client to appear. */
  687.     while ((e = eq_extract(eq)) != NULL && e->type != got_smsc)
  688.      debug("test_smsc", 0, "Discarding event of type %s", eq_type(e));
  689.     debug("test_smsc", 0, "Got event got_smsc.");
  690.     eq_destroy_event(e);
  692.     /* 
  693.      * Send message when there are at most MAX_WAITING unanswered messages
  694.      * and current average round trip time is less than MAX_RTT.
  695.      */
  696.     num_submit = 0;
  697.     for (i = 0; i < MAX_IN_AVERAGE; ++i)
  698.      times[i] = 0;
  699.     next_time = 0;
  700.     time_sum = 0.0;
  701.     num_unanswered = 0;
  702.     num_deliver = 0;
  704.     while (num_submit < num_messages) {
  705. for (;;) {
  706.     if (num_deliver >= num_messages || num_unanswered >= MAX_WAITING)
  707.      break;
  708.          if (time_sum / MAX_IN_AVERAGE >= MAX_RTT && num_unanswered > 0)
  709.      break;
  710.     smsc_emu_deliver();
  711.     ++num_unanswered;
  712.     ++num_deliver;
  713. }
  715.      e = eq_extract(eq);
  716. if (e == NULL)
  717.     break;
  718. eq_log(e);
  720. switch (e->type) {
  721. case deliver_ack:
  722.     break;
  723.     
  724. case http_request:
  725.     httpd_emu_reply(e);
  726.     break;
  728. case submit:
  729.     rtt = eq_round_trip_time(e);
  730.     time_sum -= times[next_time];
  731.     times[next_time] = rtt;
  732.     time_sum += times[next_time];
  733.     debug("", 0, "RTT = %ld", rtt);
  734.     next_time = (next_time + 1) % MAX_IN_AVERAGE;
  735.     ++num_submit;
  736.     --num_unanswered;
  737.     smsc_emu_submit_ack(e);
  738.     break;
  739.     
  740.      case got_enquire_link:
  741.     break;
  743. default:
  744.     debug("test_smsc", 0, "Ignoring event of type %s", eq_type(e));
  745.     break;
  746. }
  748. eq_destroy_event(e);
  749.     }
  751.     kill_kannel();
  753.     debug("test_smsc", 0, "Terminating benchmark.");
  754.     smsc_emu_destroy();
  755.     httpd_emu_destroy();
  756.     eq_destroy(eq);
  757. }
  760. /*
  761.  * This will send `num_messages' SMS messages as quickly as possible.
  762.  */
  764. enum { MAX_IN_QUEUE = 1000 };
  766. static void n_messages_benchmark(void)
  767. {
  768.     EventQueue *eq;
  769.     Event *e;
  770.     long i;
  771.     long num_submit;
  772.     long num_in_queue;
  773.     long num_deliver;
  775.     eq = eq_create();
  777.     httpd_emu_create(eq);
  778.     smsc_emu_create(eq);
  779.     
  780.     /* Wait for an SMS center client to appear. */
  781.     while ((e = eq_extract(eq)) != NULL && e->type != got_smsc)
  782.      debug("test_smsc", 0, "Discarding event of type %s", eq_type(e));
  783.     debug("test_smsc", 0, "Got event got_smsc.");
  784.     eq_destroy_event(e);
  786.     /* Send the SMS messages, or at least fill the send queue. */
  787.     for (i = 0; i < num_messages && i < MAX_IN_QUEUE; ++i)
  788.      smsc_emu_deliver();
  789.     num_in_queue = i;
  790.     num_deliver = i;
  792.     /* 
  793.      * Wait for results to be processed. When send queue is not full,
  794.      * fill it.
  795.      */
  796.     num_submit = 0;
  797.     while (num_submit < num_messages && (e = eq_extract(eq)) != NULL) {
  798.      while (num_deliver < num_messages && num_in_queue < MAX_IN_QUEUE) {
  799.     smsc_emu_deliver();
  800.     ++num_in_queue;
  801.     ++num_deliver;
  802. }
  804. eq_log(e);
  806. switch (e->type) {
  807. case deliver_ack:
  808.     break;
  809.     
  810. case http_request:
  811.     httpd_emu_reply(e);
  812.     break;
  814. case submit:
  815.     debug("", 0, "RTT = %ld", eq_round_trip_time(e));
  816.     smsc_emu_submit_ack(e);
  817.     ++num_submit;
  818.     --num_in_queue;
  819.     break;
  820.     
  821.      case got_enquire_link:
  822.     break;
  824. default:
  825.     debug("test_smsc", 0, "Ignoring event of type %s", eq_type(e));
  826.     break;
  827. }
  829. eq_destroy_event(e);
  830.     }
  832.     kill_kannel();
  834.     debug("test_smsc", 0, "Terminating benchmark.");
  835.     smsc_emu_destroy();
  836.     httpd_emu_destroy();
  837.     eq_destroy(eq);
  838. }
  841. /***********************************************************************
  842.  * Main program.
  843.  */
  846. int main(int argc, char **argv)
  847. {
  848.     int opt;
  849.     char *main_name;
  850.     int i;
  851.     static struct {
  852. char *name;
  853. void (*func)(void);
  854.     } tab[] = {
  855. { "n_messages", n_messages_benchmark },
  856. { "sustained_level", sustained_level_benchmark },
  857.     };
  859.     gwlib_init();
  860.     eq_init();
  861.     httpd_emu_init();
  862.     smsc_emu_init();
  864.     main_name = "n_messages_benchmark";
  866.     while ((opt = getopt(argc, argv, "m:r:")) != EOF) {
  867. switch (opt) {
  868. case 'm':
  869.     main_name = optarg;
  870.     break;
  871. case 'r':
  872.     num_messages = atoi(optarg);
  873.     break;
  874. }
  875.     }
  877.     for (i = 0; (size_t) i < sizeof(tab) / sizeof(tab[0]); ++i) {
  878. if (strcmp(main_name, tab[i].name) == 0) {
  879.     tab[i].func();
  880.     break;
  881. }
  882.     }
  884.     smsc_emu_shutdown();
  885.     httpd_emu_shutdown();
  886.     eq_shutdown();
  887.     gwlib_shutdown();
  888.     return 0;
  889. }