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

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

手机WAP编程

开发平台：

WINDOWS

drive_wapbox.c：源码内容
  1. /* drive_wapbox.c - test wapbox through its bearerbox and http interfaces
  2.  *
  3.  * This program starts a wapbox and pretends to be both the bearer box
  4.  * and the http server, so that it can test and benchmark the wapbox in
  5.  * isolation.
  6.  *
  7.  * Richard Braakman
  8.  */
  10. #include <string.h>
  11. #include <stdlib.h>
  12. #include <unistd.h>
  13. #include <errno.h>
  14. #include <signal.h>
  16. #include <sys/time.h>
  17. #include <sys/types.h>
  18. #include <sys/socket.h>
  20. #include "gwlib/gwlib.h"
  21. #include "gw/msg.h"
  23. /* These should really be in a header file */
  24. enum wsp_types {
  25.         Bad_PDU = -1,
  26.         Connect_PDU = 0x01,
  27.         ConnectReply_PDU = 0x02,
  28.         Redirect_PDU = 0x03,
  29.         Reply_PDU = 0x04,
  30.         Disconnect_PDU = 0x05,
  31.         Push_PDU = 0x06,
  32.         ConfirmedPush_PDU = 0x07,
  33.         Suspend_PDU = 0x08,
  34.         Resume_PDU = 0x09,
  35.         Get_PDU = 0x40,
  36.         Options_PDU = 0x41,
  37.         Head_PDU = 0x42,
  38.         Delete_PDU = 0x43,
  39.         Trace_PDU = 0x44,
  40.         Post_PDU = 0x60,
  41.         Put_PDU = 0x61
  42. };
  44. enum wtp_types {
  45. INVOKE = 1,
  46. RESULT = 2,
  47. ACK = 3
  48. };
  50. #define WSP_VERSION 0x10
  52. #define TIMEOUT 10.0  /* seconds */
  54. static long max_requests = 1;
  55. static long max_clients = 1;
  56. static long req_per_session = 1;
  57. static unsigned short http_port;
  58. static int wapbox_port = 30188;
  59. static Octstr *http_url = NULL;
  61. static int verbose_debug = 0;
  62. static int user_ack = 0;
  64. static long requests_complete = 0;
  65. static volatile sig_atomic_t dying = 0;
  67. enum WTP_type {
  68. TR_Invoke = 1,
  69. TR_Result = 2,
  70. TR_Ack = 3,
  71. TR_Abort = 4
  72. };
  74. struct client_status {
  75. /* True if we expect a WTP reply */
  76. int wtp_invoked;
  78. /* Transaction number for WTP level */
  79. int wtp_tid; /* current tid if wtp_invoked, else next tid to use */
  81. /* True if we're connected at the WSP level */
  82. /* Equal to 2 if we're trying to disconnect */
  83. int wsp_connected;
  85. /* -1 if we're not connected */
  86. long wsp_session_id;
  88. /* Number of successful page fetches this session */
  89. int pages_fetched;
  91. /* Source port to use for this client; should be unique. */
  92. unsigned short port;
  93. };
  94. typedef struct client_status Client;
  96. static Client *clients;
  97. List *ready_clients;
  99. static unsigned long get_varint(Octstr *pdu, int pos) {
  100. int c;
  101. long result = 0;
  103. do {
  104. c = octstr_get_char(pdu, pos++);
  105. result = (result << 7) | (c & 0x7f);
  106. } while (c & 0x80);
  108. return c;
  109. }
  111. static void http_thread(void *arg) {
  112. HTTPClient *client;
  113. Octstr *ip;
  114. Octstr *url;
  115. List *headers;
  116. Octstr *body;
  117. List *cgivars;
  118. Octstr *reply_body = octstr_create(
  119. "<?xml version="1.0"?>n"
  120. "<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN"n"
  121. " "http://www.wapforum.org/DTD/wml_1.1.xml">n"
  122. "<wml>n"
  123. "<card id="main" title="Hello, world" newcontext="true">n"
  124. "        <p>Hello, world.</p>n"
  125. "</card></wml>n");
  126. List *reply_headers = list_create();
  127. int port;
  129.      port = *(int *) arg;
  130. gw_free(arg);
  132. list_append(reply_headers,
  133. octstr_create("Content-Type: text/vnd.wap.wml"));
  135. for (;!dying;) {
  136. client = http_accept_request(port, &ip, &url, &headers, 
  137.                     &body, &cgivars);
  138. if (client == NULL)
  139. break;
  140. http_send_reply(client, HTTP_OK, reply_headers, reply_body);
  141. http_destroy_headers(headers);
  142. octstr_destroy(ip);
  143. octstr_destroy(url);
  144. octstr_destroy(body);
  145. http_destroy_cgiargs(cgivars);
  146. }
  148. octstr_destroy(reply_body);
  149.      http_destroy_headers(reply_headers);
  150. }
  153. static long http_thread_id;
  155. static int start_http_thread(void) {
  156. unsigned short port;
  157. int *port_copy;
  158.     int ssl = 0;   /* indicate if SSL-enabled server should be used */
  160. for (port = 40000; port < 41000; port += 13) {
  161. if (http_open_port(port, ssl) != -1)
  162.     break;
  163. }
  164. if (port == 41000)
  165. panic(0, "No ports available for http server");
  167.      port_copy = gw_malloc(sizeof(*port_copy));
  168. *port_copy = port;
  169. http_thread_id = gwthread_create(http_thread, port_copy);
  170. if (http_thread_id == -1) 
  171. panic(0, "Cannot start http thread");
  172. return port;
  173. }
  175. static Connection *start_wapbox(void) {
  176. int wap_socket;
  177. int wapbox;
  179. wap_socket = make_server_socket(wapbox_port, NULL);
  180. if (wap_socket < 0)
  181. panic(0, "Couldn't make wapbox portn");
  183. wapbox = accept(wap_socket, NULL, NULL);
  184. if (wapbox < 0)
  185. panic(errno, "Wapbox could not connectn");
  187. close(wap_socket);
  189. return conn_wrap_fd(wapbox, 0);
  190. }
  192. static void initialize_clients(void) {
  193. long i;
  195. ready_clients = list_create();
  197. clients = gw_malloc(max_clients * sizeof(*clients));
  198. for (i = 0; i < max_clients; i++) {
  199. clients[i].wtp_invoked = 0;
  200. clients[i].wtp_tid = 0;
  201. clients[i].wsp_connected = 0;
  202. clients[i].wsp_session_id = -1;
  203. clients[i].pages_fetched = 0;
  204. clients[i].port = i;
  205. list_append(ready_clients, &clients[i]);
  206. }
  207. }
  209. static void destroy_clients(void) {
  210. gw_free(clients);
  211. list_destroy(ready_clients, NULL);
  212. }
  214. static Client *find_client(unsigned short port) {
  215. /* It's easy and fast since we assign ports in linear order */
  216. if (port >= max_clients)
  217. return NULL;
  219. return clients + port;
  220. }
  222. static void client_done(Client *client) {
  223. requests_complete++;
  224. list_append(ready_clients, client);
  225. }
  227. static void increment_tid(Client *client) {
  228. if (client->wtp_tid == 0x7fff) 
  229. client->wtp_tid = 0;
  230. else
  231. client->wtp_tid++;
  232. }
  234. /* Set the U/P flag on an Invoke PDU */
  235. static void set_user_ack(Octstr *pdu) {
  236. octstr_set_bits(pdu, 3 * 8 + 3, 1, 1);
  237. }
  239. static Octstr *wtp_invoke_create(int class) {
  240. Octstr *pdu;
  241. /* data describes a TR-Invoke PDU, with GTR=1 and TTR=1 (segmentation
  242.  * not supported), and Transaction class 0 (which we replace below) */
  243. static unsigned char data[] = { 0x0e, 0x00, 0x00, 0x00 };
  244. gw_assert(class >= 0);
  245. gw_assert(class <= 2);
  246. pdu = octstr_create_from_data(data, sizeof(data));
  247. octstr_set_char(pdu, 3, class);
  249. if (user_ack)
  250. set_user_ack(pdu);
  252. return pdu;
  253. }
  255. static Octstr *wtp_ack_create(void) {
  256. static unsigned char data[] = { 0x18, 0x00, 0x00 };
  257. return octstr_create_from_data(data, sizeof(data));
  258. }
  260. static void add_wsp_connect(Octstr *pdu) {
  261. static unsigned char data[] = { Connect_PDU, WSP_VERSION, 68, 0x00,
  262. 0x03, 0x80, 0x90, 0x00, 0x03, 0x81, 0x90, 0x00,
  263. 0x02, 0x82, 0x30, 0x02, 0x83, 0x01, 0x02, 0x84,
  264. 0x01, 0x28, 0x85, 0x50, 0x58, 0x2d, 0x55, 0x50,
  265. 0x2d, 0x41, 0x47, 0x45, 0x54, 0x00, 0x51, 0x58,
  266. 0x2d, 0x55, 0x50, 0x2d, 0x47, 0x45, 0x54, 0x4e,
  267. 0x4f, 0x54, 0x49, 0x46, 0x59, 0x00, 0x70, 0x58,
  268. 0x2d, 0x55, 0x50, 0x2d, 0x41, 0x50, 0x4f, 0x53,
  269. 0x54, 0x00, 0x09, 0x86, 0x02, 0x78, 0x2d, 0x75,
  270. 0x70, 0x2d, 0x31, 0x00 };
  271. octstr_append_data(pdu, data, sizeof(data));
  272. }
  274. static void add_wsp_get(Octstr *pdu) {
  275.      Octstr *urlbuf;
  277. octstr_append_char(pdu, Get_PDU);
  278. if (http_url) {
  279. octstr_append_uintvar(pdu, octstr_len(http_url));
  280. octstr_append(pdu, http_url);
  281. } else {
  282. urlbuf = octstr_format("http://localhost:%ld/hello.wml",
  283.        (long) http_port);
  284. octstr_append_uintvar(pdu, octstr_len(urlbuf));
  285. octstr_append(pdu, urlbuf);
  286. octstr_destroy(urlbuf);
  287. }
  288. }
  290. static void add_wsp_disconnect(Octstr *pdu, long session_id) {
  291. octstr_append_char(pdu, Disconnect_PDU);
  292. octstr_append_uintvar(pdu, session_id);
  293. }
  295. static void set_tid(Octstr *pdu, int tid) {
  296. int c;
  298. /* Tid wraps at 15 bits. */
  299. tid &= 0x7fff;
  301. c = octstr_get_char(pdu, 1);
  302. c = (tid >> 8) | (c & 0x80);
  303. octstr_set_char(pdu, 1, c);
  304. octstr_set_char(pdu, 2, tid & 0xff);
  305. }
  307. static int get_tid(Octstr *pdu) {
  308. return octstr_get_bits(pdu, 8, 16);
  309. }
  311. static int wtp_type(Octstr *pdu) {
  312. return octstr_get_bits(pdu, 1, 4);
  313. }
  315. static Msg *wdp_create(Octstr *data, Client *client) {
  316. Msg *msg;
  318. msg = msg_create(wdp_datagram);
  319. msg->wdp_datagram.source_address = octstr_create("127.0.0.1");
  320. msg->wdp_datagram.source_port = client->port;
  321. msg->wdp_datagram.destination_address = octstr_create("127.0.0.1");
  322. msg->wdp_datagram.destination_port = 9201;
  323. msg->wdp_datagram.user_data = octstr_duplicate(data);
  325. return msg;
  326. }
  328. static void send_pdu(Octstr *pdu, Connection *boxc, Client *client) {
  329. Msg *msg;
  330. Octstr *data;
  332. if (verbose_debug) {
  333. debug("test", 0, "Sending:");
  334. octstr_dump(pdu, 0);
  335. }
  337. msg = wdp_create(pdu, client);
  338. data = msg_pack(msg);
  339. conn_write_withlen(boxc, data);
  341. octstr_destroy(data);
  342. msg_destroy(msg);
  343. }
  345. static void send_invoke_connect(Connection *boxc, Client *client) {
  346. Octstr *pdu;
  348. gw_assert(client != NULL);
  349. gw_assert(client->wtp_invoked == 0);
  350. gw_assert(client->wsp_connected == 0);
  352. pdu = wtp_invoke_create(2);
  353. set_tid(pdu, client->wtp_tid);
  354. add_wsp_connect(pdu);
  356. send_pdu(pdu, boxc, client);
  357. octstr_destroy(pdu);
  359. client->wtp_invoked = 1;
  360. }
  362. static void send_invoke_get(Connection *boxc, Client *client) {
  363. Octstr *pdu;
  365. gw_assert(client != NULL);
  366. gw_assert(client->wtp_invoked == 0);
  367. gw_assert(client->wsp_connected == 1);
  369. pdu = wtp_invoke_create(2);
  370. set_tid(pdu, client->wtp_tid);
  371. add_wsp_get(pdu);
  373. send_pdu(pdu, boxc, client);
  374. octstr_destroy(pdu);
  376. client->wtp_invoked = 1;
  377. }
  379. static void record_disconnect(Client *client) {
  380. client->wsp_connected = 0;
  381. client->wsp_session_id = -1;
  382. client->pages_fetched = 0;
  383. increment_tid(client);
  384. }
  386. static void send_invoke_disconnect(Connection *boxc, Client *client) {
  387. Octstr *pdu;
  389. gw_assert(client != NULL);
  390. gw_assert(client->wtp_invoked == 0);
  391. gw_assert(client->wsp_connected == 1);
  393. /* Kannel can't handle it as class 1 yet, so send class 0 */
  394. pdu = wtp_invoke_create(0);
  395. set_tid(pdu, client->wtp_tid);
  396. add_wsp_disconnect(pdu, client->wsp_session_id);
  398. send_pdu(pdu, boxc, client);
  399. octstr_destroy(pdu);
  401. record_disconnect(client);
  402. client_done(client);
  403. }
  405. static void handle_connect_reply(Connection *boxc, Client *client, Octstr *pdu) {
  406. Octstr *ack;
  408. gw_assert(client);
  409. gw_assert(client->wtp_invoked);
  410. gw_assert(!client->wsp_connected);
  412. if (octstr_get_char(pdu, 3) != ConnectReply_PDU) {
  413. error(0, "Unexpected CONNECT reply");
  414. octstr_dump(pdu, 0);
  415. return;
  416. }
  418. ack = wtp_ack_create();
  419. set_tid(ack, client->wtp_tid);
  420. send_pdu(ack, boxc, client);
  421. octstr_destroy(ack);
  423. client->wtp_invoked = 0;
  424. increment_tid(client);
  425. client->wsp_connected = 1;
  426. client->wsp_session_id = get_varint(pdu, 4);
  428. send_invoke_get(boxc, client);
  429. }
  431. static void handle_get_reply(Connection *boxc, Client *client, Octstr *pdu) {
  432. Octstr *ack;
  434. gw_assert(client);
  435. gw_assert(client->wtp_invoked);
  436. gw_assert(client->wsp_connected);
  438. if (octstr_get_char(pdu, 3) != Reply_PDU) {
  439. error(0, "Unexpected GET reply");
  440. octstr_dump(pdu, 0);
  441. return;
  442. }
  444. ack = wtp_ack_create();
  445. set_tid(ack, client->wtp_tid);
  446. send_pdu(ack, boxc, client);
  447. octstr_destroy(ack);
  449. client->wtp_invoked = 0;
  450. increment_tid(client);
  451. client->pages_fetched++;
  453. if (client->pages_fetched == req_per_session) {
  454. send_invoke_disconnect(boxc, client);
  455. } else {
  456. client_done(client);
  457. }
  458. }
  460. static void handle_reply(Connection *boxc, Msg *reply) {
  461. Client *client;
  462. Octstr *wtp;
  463. int type;
  464. int dumped = 0;
  466. gw_assert(reply != NULL);
  467. gw_assert(reply->type == wdp_datagram);
  469. client = find_client(reply->wdp_datagram.destination_port);
  470. if (client == NULL)
  471. panic(0, "got packet for nonexisting client %ld",
  472. (long) reply->wdp_datagram.destination_port);
  474. wtp = reply->wdp_datagram.user_data;
  475. type = wtp_type(wtp);
  477. if (verbose_debug) {
  478. debug("test", 0, "Received:");
  479. octstr_dump(wtp, 0);
  480. dumped = 1;
  481. }
  483. if (client->wtp_invoked == 0) {
  484. error(0, "Got packet for client that wasn't waiting");
  485. if (!dumped) {
  486. octstr_dump(wtp, 0);
  487. dumped = 1;
  488. }
  489. return;
  490. }
  492. /* Server should invert the MSB of the tid in its replies */
  493. if (get_tid(wtp) != (client->wtp_tid ^ 0x8000)) {
  494. error(0, "Got packet with wrong tid %d, expected %d.",
  495. get_tid(wtp), client->wtp_tid ^ 0x8000);
  496. if (!dumped) {
  497. octstr_dump(wtp, 0);
  498. dumped = 1;
  499. }
  500. return;
  501. }
  503. /* We're going to be stupid here, and assume that replies that
  504.  * look vaguely like what we expect are actually what we wanted. */
  505. if (client->wsp_connected == 0 && type == RESULT) {
  506. handle_connect_reply(boxc, client, wtp);
  507. } else if (client->wsp_connected == 1 && type == RESULT) {
  508. handle_get_reply(boxc, client, wtp);
  509. } else if (client->wsp_connected == 2 && type == ACK) {
  510. record_disconnect(client);
  511. client_done(client);
  512. } else {
  513. error(0, "Got unexpected packet");
  514. if (!dumped) {
  515. octstr_dump(wtp, 0);
  516. dumped = 1;
  517. }
  518. }
  519. }
  521. static void start_request(Connection *boxc, Client *client) {
  522. gw_assert(client != NULL);
  523. gw_assert(client->wsp_connected != 2);
  524. gw_assert(client->wtp_invoked == 0);
  526. if (client->wsp_connected == 0) {
  527. send_invoke_connect(boxc, client); 
  528. } else {
  529. send_invoke_get(boxc, client);
  530. }
  531. }
  533. static long run_requests(Connection *boxc) {
  534. int requests_sent;
  535. Octstr *data;
  536. Msg *msg;
  537. int ret;
  539. requests_sent = 0;
  540. requests_complete = 0;
  542. while (requests_complete < max_requests) {
  543. data = conn_read_withlen(boxc);
  544. if (!data) {
  545. Client *client;
  547. if (requests_sent < max_requests
  548.     && (client = list_extract_first(ready_clients))) {
  549. start_request(boxc, client);
  550. requests_sent++;
  551. }
  552. ret = conn_wait(boxc, TIMEOUT);
  553. if (ret < 0 || conn_eof(boxc))
  554. panic(0, "Wapbox dead.");
  555. if (ret == 1)
  556. break; /* Timed out. */
  557. } else {
  558. msg = msg_unpack(data);
  559. if (!msg) {
  560. octstr_dump(data, 0);
  561. panic(0, "Received bad data from wapbox.");
  562. }
  563. if (msg->type == wdp_datagram)
  564. handle_reply(boxc, msg);
  565. msg_destroy(msg);
  566. }
  567. octstr_destroy(data);
  568. }
  570. if (requests_complete < max_requests)
  571. info(0, "Timeout.  %ld requests unsatisfied.",
  572. max_requests - requests_complete);
  574. return requests_complete;
  575. }
  577. static void help(void) {
  578. info(0, "Usage: drive_wapbox [options...]n");
  579. info(0, "  -r requests  Stop after this many; default 1.");
  580. info(0, "  -c clients   # of concurrent clients; default 1.");
  581. info(0, "  -w wapport   Port wapbox should connect to; default 30188");
  582. info(0, "  -u url       Use this url instead of internal http server");
  583. info(0, "  -g requests  Number of requests per WSP session; default 1");
  584. info(0, "  -U           Set the User ack flag on all WTP transactions");
  585. }
  587. int main(int argc, char **argv) {
  588. int opt;
  589. struct timeval start, end;
  590. Connection *boxc;
  591. long completed;
  592. double run_time;
  594. gwlib_init();
  596. while ((opt = getopt(argc, argv, "hv:r:c:w:du:Ug:")) != EOF) {
  597. switch (opt) {
  598. case 'v':
  599. log_set_output_level(atoi(optarg));
  600. break;
  602. case 'r':
  603. max_requests = atol(optarg);
  604. break;
  606. case 'c':
  607. max_clients = atol(optarg);
  608. break;
  610. case 'w':
  611. wapbox_port = atoi(optarg);
  612. break;
  614. case 'u':
  615. http_url = octstr_create(optarg);
  616. break;
  618. case 'U':
  619. user_ack = 1;
  620. break;
  622. case 'h':
  623. help();
  624. exit(0);
  626. case 'd':
  627. verbose_debug = 1;
  628. break;
  630. case 'g':
  631. req_per_session = atoi(optarg);
  632. break;
  634. case '?':
  635. default:
  636. error(0, "Invalid option %c", opt);
  637. help();
  638. panic(0, "Stopping.");
  639. }
  640. }
  642. if (!http_url)
  643. http_port = start_http_thread();
  644. boxc = start_wapbox();
  646. initialize_clients();
  648. if (gettimeofday(&start, NULL) < 0)
  649. panic(errno, "gettimeofday failed");
  650. completed = run_requests(boxc);
  651. if (gettimeofday(&end, NULL) < 0)
  652. panic(errno, "gettimeofday failed");
  654. conn_destroy(boxc);
  656. run_time = end.tv_sec - start.tv_sec;
  657. run_time += (double) (end.tv_usec - start.tv_usec) / 1000000.0;
  659. /* We must have timed out.  Don't count the waiting time. */
  660. if (completed < max_requests)
  661. run_time -= TIMEOUT;
  663. info(0, "%ld request%s in %0.1f seconds, %0.1f requests/s.",
  664. completed, completed != 1 ? "s" : "",
  665. run_time, max_requests / run_time);
  667. dying = 1;
  668. http_close_all_ports();
  669. if (!http_url)
  670. gwthread_join(http_thread_id);
  672. destroy_clients();
  673. octstr_destroy(http_url);
  675. gwlib_shutdown();
  677. return 0;
  678. }