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

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

手机WAP编程

开发平台：

WINDOWS

drive_smpp.c：源码内容
  1. /*
  2.  * drive_smpp.c - SMPP server for testing purposes
  3.  *
  4.  * Lars Wirzenius
  5.  */
  8. #include <errno.h>
  9. #include <signal.h>
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  13. #include "gwlib/gwlib.h"
  14. #include "gw/smsc/smpp_pdu.h"
  15. #include "gw/msg.h"
  18. static int quitting = 0;
  19. static Octstr *smsc_system_id;
  20. static Octstr *smsc_source_addr;
  21. static Counter *message_id_counter;
  22. static Octstr *bearerbox_host;
  23. static int port_for_smsbox;
  24. static Counter *num_to_esme;
  25. static long max_to_esme;
  26. static Counter *num_from_bearerbox;
  27. static Counter *num_to_bearerbox;
  28. static Counter *num_from_esme;
  29. static time_t start_time = (time_t) -1;
  30. static time_t first_to_esme = (time_t) -1;
  31. static time_t last_to_esme = (time_t) -1;
  32. static time_t last_from_esme = (time_t) -1;
  33. static time_t first_from_bb = (time_t) -1;
  34. static time_t last_to_bb = (time_t) -1;
  35. static long enquire_interval = 1; /* Measured in messages, not time. */
  38. static void quit(void)
  39. {
  40.     quitting = 1;
  41.     gwthread_wakeup_all();
  42. }
  45. typedef struct {
  46.     Connection *conn;
  47.     int transmitter;
  48.     int receiver;
  49. } ESME;
  52. static ESME *esme_create(Connection *conn)
  53. {
  54.     ESME *esme;
  55.     
  56.     esme = gw_malloc(sizeof(*esme));
  57.     esme->conn = conn;
  58.     esme->transmitter = 0;
  59.     esme->receiver = 0;
  60.     return esme;
  61. }
  64. static void esme_destroy(ESME *esme)
  65. {
  66.     if (esme != NULL) {
  67. conn_destroy(esme->conn);
  68. gw_free(esme);
  69.     }
  70. }
  73. static SMPP_PDU *handle_bind_transmitter(ESME *esme, SMPP_PDU *pdu)
  74. {
  75.     SMPP_PDU *resp;
  76.     
  77.     esme->transmitter = 1;
  78.     resp = smpp_pdu_create(bind_transmitter_resp,
  79.                    pdu->u.bind_transmitter.sequence_number);
  80. #if 0 /* XXX system_id is not implemented in the PDU at the moment */
  81.     resp->u.bind_transmitter_resp.system_id = 
  82.      octstr_duplicate(smsc_system_id);
  83. #endif
  84.     return resp;
  85. }
  88. static SMPP_PDU *handle_bind_receiver(ESME *esme, SMPP_PDU *pdu)
  89. {
  90.     SMPP_PDU *resp;
  91.     
  92.     esme->receiver = 1;
  93.     resp = smpp_pdu_create(bind_receiver_resp,
  94.                    pdu->u.bind_receiver.sequence_number);
  95. #if 0 /* XXX system_id is not implemented in the PDU at the moment */
  96.     resp->u.bind_receiver_resp.system_id = octstr_duplicate(smsc_system_id);
  97. #endif
  98.     return resp;
  99. }
  102. static SMPP_PDU *handle_submit_sm(ESME *esme, SMPP_PDU *pdu)
  103. {
  104.     SMPP_PDU *resp;
  105.     unsigned long id;
  106.     
  107.     debug("test.smpp", 0, "submit_sm: short_message = <%s>",
  108.        octstr_get_cstr(pdu->u.submit_sm.short_message));
  109.     id = counter_increase(num_from_esme) + 1;
  110.     if (id == max_to_esme)
  111.      info(0, "ESME has submitted all messages to SMSC.");
  112.     time(&last_from_esme);
  114.     resp = smpp_pdu_create(submit_sm_resp, pdu->u.submit_sm.sequence_number);
  115. #if 0 /* XXX message_id is not implemented in the PDU at the moment */
  116.     resp->u.submit_sm_resp.message_id = 
  117.      octstr_format("%ld", counter_increase(message_id_counter));
  118. #endif
  119.     return resp;
  120. }
  123. static SMPP_PDU *handle_deliver_sm_resp(ESME *esme, SMPP_PDU *pdu)
  124. {
  125.     return NULL;
  126. }
  129. static SMPP_PDU *handle_unbind(ESME *esme, SMPP_PDU *pdu)
  130. {
  131.     SMPP_PDU *resp;
  132.     
  133.     resp = smpp_pdu_create(unbind_resp, pdu->u.unbind.sequence_number);
  134.     return resp;
  135. }
  138. static SMPP_PDU *handle_enquire_link(ESME *esme, SMPP_PDU *pdu)
  139. {
  140.     return smpp_pdu_create(enquire_link_resp, 
  141.                   pdu->u.enquire_link.sequence_number);
  142. }
  145. static SMPP_PDU *handle_enquire_link_resp(ESME *esme, SMPP_PDU *pdu)
  146. {
  147.     return NULL;
  148. }
  151. static struct {
  152.     unsigned long type;
  153.     SMPP_PDU *(*handler)(ESME *, SMPP_PDU *);
  154. } handlers[] = {
  155.     #define HANDLER(name) { name, handle_ ## name },
  156.     HANDLER(bind_transmitter)
  157.     HANDLER(bind_receiver)
  158.     HANDLER(submit_sm)
  159.     HANDLER(deliver_sm_resp)
  160.     HANDLER(unbind)
  161.     HANDLER(enquire_link)
  162.     HANDLER(enquire_link_resp)
  163.     #undef HANDLER
  164. };
  165. static int num_handlers = sizeof(handlers) / sizeof(handlers[0]);
  168. static void handle_pdu(ESME *esme, SMPP_PDU *pdu)
  169. {
  170.     SMPP_PDU *resp;
  171.     Octstr *os;
  172.     int i;
  174.     debug("test.smpp", 0, "Handling SMPP PDU of type %s", pdu->type_name);
  175.     for (i = 0; i < num_handlers; ++i) {
  176.      if (handlers[i].type == pdu->type) {
  177.     resp = handlers[i].handler(esme, pdu);
  178.     if (resp != NULL) {
  179.      os = smpp_pdu_pack(resp);
  180. conn_write(esme->conn, os);
  181. octstr_destroy(os);
  182. smpp_pdu_destroy(resp);
  183.     }
  184.     return;
  185. }
  186.     }
  188.     error(0, "Unhandled SMPP PDU.");
  189.     smpp_pdu_dump(pdu);
  190. }
  193. static void send_smpp_thread(void *arg)
  194. {
  195.     ESME *esme;
  196.     Octstr *os;
  197.     SMPP_PDU *pdu;
  198.     unsigned long id;
  200.     esme = arg;
  201.     
  202.     id = 0;
  203.     while (!quitting && counter_value(num_to_esme) < max_to_esme) {
  204. id = counter_increase(num_to_esme) + 1;
  205.      while (!quitting && counter_value(num_from_esme) + 500 < id)
  206.     gwthread_sleep(1.0);
  207. if (quitting)
  208.     break;
  209. pdu = smpp_pdu_create(deliver_sm,
  210.        counter_increase(message_id_counter));
  211. pdu->u.deliver_sm.source_addr = octstr_create("456");
  212. pdu->u.deliver_sm.destination_addr = octstr_create("123");
  213. pdu->u.deliver_sm.short_message = octstr_format("%ld", id);
  214. os = smpp_pdu_pack(pdu);
  215. conn_write(esme->conn, os);
  216. octstr_destroy(os);
  217. smpp_pdu_destroy(pdu);
  218. if (first_to_esme == (time_t) -1)
  219.     time(&first_to_esme);
  220. debug("test.smpp", 0, 
  221.       "Delivered SMS %ld of %ld to bearerbox via SMPP.",
  222.       id, max_to_esme);
  224.      if ((id % enquire_interval) == 0) {
  225.     pdu = smpp_pdu_create(enquire_link, 
  226.                  counter_increase(message_id_counter));
  227.     os = smpp_pdu_pack(pdu);
  228.     conn_write(esme->conn, os);
  229.     octstr_destroy(os);
  230.     smpp_pdu_destroy(pdu);
  231.     debug("test.smpp", 0, "Sent enquire_link to bearerbox.");
  232. }
  233.     }
  234.     time(&last_to_esme);
  235.     if (id == max_to_esme)
  236. info(0, "All messages sent to ESME.");
  237.     debug("test.smpp", 0, "%s terminates.", __func__);
  238. }
  241. static void receive_smpp_thread(void *arg)
  242. {
  243.     ESME *esme;
  244.     Octstr *os;
  245.     long len;
  246.     long sender_id;
  247.     SMPP_PDU *pdu;
  249.     esme = arg;
  250.     
  251.     sender_id = -1;
  252.     len = 0;
  253.     while (!quitting && conn_wait(esme->conn, -1.0) != -1) {
  254.      for (;;) {
  255.     if (len == 0) {
  256. len = smpp_pdu_read_len(esme->conn);
  257. if (len == -1) {
  258.     error(0, "Client sent garbage, closing connection.");
  259.     goto error;
  260. } else if (len == 0) {
  261.     if (conn_eof(esme->conn) || conn_read_error(esme->conn))
  262.      goto error;
  263.     break;
  264. }
  265.     }
  266.     
  267.          gw_assert(len > 0);
  268.     os = smpp_pdu_read_data(esme->conn, len);
  269.     if (os != NULL) {
  270.           len = 0;
  271. pdu = smpp_pdu_unpack(os);
  272. if (pdu == NULL) {
  273.     error(0, "PDU unpacking failed!");
  274.     octstr_dump(os, 0);
  275. } else {
  276.     handle_pdu(esme, pdu);
  277.     smpp_pdu_destroy(pdu);
  278. }
  279. octstr_destroy(os);
  280.     } else if (conn_eof(esme->conn) || conn_read_error(esme->conn))
  281.      goto error;
  282.     else
  283. break;
  284. }
  286.      if (!quitting && esme->receiver && sender_id == -1)
  287.     sender_id = gwthread_create(send_smpp_thread, esme);
  288.     }
  290. error:
  291.     if (sender_id != -1) {
  292. quit();
  293. gwthread_join(sender_id);
  294.     }
  295.     esme_destroy(esme);
  296.     quit();
  297.     debug("test.smpp", 0, "%s terminates.", __func__);
  298. }
  301. static void smsbox_thread(void *arg)
  302. {
  303.     Connection *conn;
  304.     Msg *msg;
  305.     Octstr *os;
  306.     Octstr *reply_msg;
  307.     unsigned long count;
  308.     
  309.     msg = msg_create(sms);
  310.     msg->sms.sender = octstr_create("123");
  311.     msg->sms.receiver = octstr_create("456");
  312.     msg->sms.msgdata = octstr_create("hello world");
  313.     reply_msg = msg_pack(msg);
  314.     msg_destroy(msg);
  316.     gwthread_sleep(1.0);
  317.     conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
  318.     if (conn == NULL) {
  319. gwthread_sleep(2.0);
  320. conn = conn_open_tcp(bearerbox_host, port_for_smsbox, NULL);
  321.      if (conn == NULL)
  322.     panic(0, "Couldn't connect to bearerbox as smsbox");
  323.     }
  325.     while (!quitting && conn_wait(conn, -1.0) != -1) {
  326.      for (;;) {
  327.     os = conn_read_withlen(conn);
  328.     if (os == NULL) {
  329. if (conn_eof(conn) || conn_read_error(conn))
  330.     goto error;
  331. break;
  332.     }
  333.     
  334.     msg = msg_unpack(os);
  335.     if (msg == NULL || msg->type == wdp_datagram)
  336. error(0, "Bearerbox sent garbage to smsbox");
  338.     if (msg->type == sms) {
  339. if (first_from_bb == (time_t) -1)
  340.     time(&first_from_bb);
  341. count = counter_increase(num_from_bearerbox) + 1;
  342. debug("test.smpp", 0, 
  343.       "Bearerbox sent sms #%ld <%s> to smsbox, sending reply.",
  344.       count, octstr_get_cstr(msg->sms.msgdata));
  345. if (count == max_to_esme)
  346.     info(0, "Bearerbox has sent all messages to smsbox.");
  347. conn_write_withlen(conn, reply_msg);
  348. counter_increase(num_to_bearerbox);
  349.     }
  350.     msg_destroy(msg);
  351.     octstr_destroy(os);
  352.     time(&last_to_bb);
  353. }
  354.     }
  355.     
  356. error:
  357.     conn_destroy(conn);
  358.     octstr_destroy(reply_msg);
  359.     debug("test.smpp", 0, "%s terminates.", __func__);
  360. }
  363. static void accept_thread(void *arg)
  364. {
  365.     int fd;
  366.     int new_fd;
  367.     int port;
  368.     socklen_t addrlen;
  369.     struct sockaddr addr;
  370.     long smsbox_thread_id;
  371.     
  372.     port = *(int *) arg;
  373.     fd = make_server_socket(port, NULL);
  374.     if (fd == -1)
  375.      panic(0, "Couldn't create SMPP listen port.");
  376.     
  377.     smsbox_thread_id = -1;
  378.     for (;;) {
  379. if (gwthread_pollfd(fd, POLLIN, -1.0) != POLLIN)
  380.     break;
  381. addrlen = sizeof(addr);
  382. new_fd = accept(fd, &addr, &addrlen);
  383.      if (start_time == (time_t) -1)
  384.     time(&start_time);
  385. gwthread_create(receive_smpp_thread, 
  386. esme_create(conn_wrap_fd(new_fd, 0)));
  387. if (smsbox_thread_id == -1)
  388.     smsbox_thread_id = gwthread_create(smsbox_thread, NULL);
  389.     }
  390.     debug("test.smpp", 0, "%s terminates.", __func__);
  391. }
  394. static void handler(int signal)
  395. {
  396.     panic(0, "Caught signal %d.", signal);
  397. }
  400. static void help(void)
  401. {
  402.     info(0, "drive_smpp [-h] [-v level]燵-p port]");
  403. }
  406. int main(int argc, char **argv)
  407. {
  408.     struct sigaction act;
  409.     int http_port;
  410.     int port;
  411.     int opt;
  412.     double run_time;
  413.     char *log_file;
  415.     gwlib_init();
  417.     act.sa_handler = handler;
  418.     sigemptyset(&act.sa_mask);
  419.     act.sa_flags = 0;
  420.     sigaction(SIGTERM, &act, NULL);
  421.     sigaction(SIGINT, &act, NULL);
  423.     port = 2345;
  424.     http_port = 8080;
  425.     smsc_system_id = octstr_create("kannel_smpp");
  426.     smsc_source_addr = octstr_create("123456");
  427.     message_id_counter = counter_create();
  428.     bearerbox_host = octstr_create("localhost");
  429.     port_for_smsbox = 13001;
  430.     max_to_esme = 1;
  431.     num_to_esme = counter_create();
  432.     num_from_esme = counter_create();
  433.     num_to_bearerbox = counter_create();
  434.     num_from_bearerbox = counter_create();
  435.     log_file = NULL;
  437.     while ((opt = getopt(argc, argv, "hv:p:P:m:l:")) != EOF) {
  438. switch (opt) {
  439. case 'v':
  440.     log_set_output_level(atoi(optarg));
  441.     break;
  443. case 'h':
  444.     help();
  445.     exit(0);
  447. case 'm':
  448.     max_to_esme = atoi(optarg);
  449.     break;
  451. case 'p':
  452.     port = atoi(optarg);
  453.     break;
  455. case 'P':
  456.     http_port = atoi(optarg);
  457.     break;
  459.      case 'l':
  460.     log_file = optarg;
  461.     break;
  463. case '?':
  464. default:
  465.     error(0, "Invalid option %c", opt);
  466.     help();
  467.     panic(0, "Stopping.");
  468. }
  469.     }
  471.     if (log_file != NULL)
  472.      log_open(log_file, GW_DEBUG);
  474.     info(0, "Starting drive_smpp test.");
  475.     gwthread_create(accept_thread, &port);
  476.     gwthread_join_all();
  477.     debug("test.smpp", 0, "Program exiting normally.");
  479.     run_time = difftime(last_from_esme, first_to_esme);
  481.     info(0, "Number of messages sent to ESME: %ld",
  482.       counter_value(num_to_esme));
  483.     info(0, "Number of messages sent to smsbox: %ld",
  484.       counter_value(num_from_bearerbox));
  485.     info(0, "Number of messages sent to bearerbox: %ld",
  486.       counter_value(num_to_bearerbox));
  487.     info(0, "Number of messages sent to SMSC: %ld",
  488.       counter_value(num_from_esme));
  489.     info(0, "Time: %.0f secs", run_time);
  490.     info(0, "Time until all sent to ESME: %.0f secs", 
  491.       difftime(last_to_esme, start_time));
  492.     info(0, "Time from first from bb to last to bb: %.0f secs", 
  493.       difftime(last_to_bb, first_from_bb));
  494.     info(0, "Time until all sent to SMSC: %.0f secs", 
  495.       difftime(last_from_esme, start_time));
  496.     info(0, "SMPP messages SMSC to ESME: %.1f msgs/sec",
  497.       counter_value(num_to_esme) / run_time);
  498.     info(0, "SMPP messages ESME to SMSC: %.1f msgs/sec",
  499.       counter_value(num_from_esme) / run_time);
  501.     octstr_destroy(smsc_system_id);
  502.     octstr_destroy(smsc_source_addr);
  503.     octstr_destroy(bearerbox_host);
  504.     counter_destroy(num_to_esme);
  505.     counter_destroy(num_from_esme);
  506.     counter_destroy(num_to_bearerbox);
  507.     counter_destroy(num_from_bearerbox);
  508.     counter_destroy(message_id_counter);
  510.     gwlib_shutdown();
  511.     return 0;
  512. }