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

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

手机WAP编程

开发平台：

WINDOWS

fakewap.c：源码内容
  1. /*
  2.  * fakewap.c - simulate wap clients talking directly to wap gw.
  3.  *
  4.  * This module can be built also in Windows where you should
  5.  * add unzipped ".wininc" to your include directories.
  6.  *
  7.  * The protocol:
  8.  *
  9.  *
  10.  *    A)    Fakewap -> Gateway
  11.  *
  12.  *        WTP: Invoke PDU
  13.  *        WSP: Connect PDU
  14.  *
  15.  *    B)    Gateway -> Fakewap
  16.  *
  17.  *        WTP: Result PDU
  18.  *        WSP: ConnectReply PDU
  19.  *
  20.  *    C)    Fakewap -> Gateway
  21.  *
  22.  *        WTP: Ack PDU
  23.  *
  24.  *    D)    Fakewap -> Gateway
  25.  *
  26.  *        WTP: Invoke PDU
  27.  *        WSP: Get PDU (data: URL)
  28.  *
  29.  *    E)    Gateway -> Fakewap
  30.  *
  31.  *        WTP: Result PDU (data: WML page)
  32.  *        WSP: Reply PDU
  33.  *
  34.  *    F)    Fakewap -> Gateway
  35.  *
  36.  *        WTP: Ack PDU
  37.  *
  38.  *    G)    Fakewap -> Gateway
  39.  *
  40.  *        WTP: Invoke PDU
  41.  *        WSP: Disconnect PDU
  42.  *
  43.  *
  44.  *    Packets A-C open a WAP session. Packets D-F fetch a WML page.
  45.  *    Packet G closes the session.
  46.  *
  47.  * The test terminates when all packets have been sent.
  48.  *
  49.  * Tid verification uses following protocol (at WTP level only):
  50.  *
  51.  *    A)   Fakewap -> Gateway
  52.  *
  53.  *         Either WSP Connect PDU with tid_new flag set on or same PDU with a 
  54.  *         *seriously* wrapped up tid (only WTP header affected). Seriously
  55.  *         means tid being out of the window:
  56.  *
  57.  *         |----------------------------|
  58.  *                  tid space
  59.  *
  60.  *         |-------------|
  61.  *          wrapping up
  62.  *          tid window
  63.  *
  64.  *    B)   Gateway -> Fakewap
  65.  *
  66.  *         Ack PDU, tid verification flag set on.
  67.  *
  68.  *    C)   Fakewap -> Gateway
  69.  *
  70.  *         Ack PDU, tid verification flag set on (this means a positive 
  71.  *         answer). 
  72.  *
  73.  * Antti Saarenheimo for WapIT Ltd.
  74.  */
  76. #define MAX_SEND (0)
  78. static char usage[] = "
  79. Usage: fakewap [options] url ...n
  80. n
  81. where options are:n
  82. n
  83. -h helpn
  84. -v verbosen
  85. -g hostname hostname or IP number of gateway (default: localhost)n
  86. -p port port number of gateway (default: 9201)n
  87. -m max maximum number of requests fakewap will make (default: 1)n
  88. -i interval interval between requests (default: 1.0 seconds)n
  89. -c threads number concurrent of clients simulated (default: 1)n
  90. -V protoversion protocol version field, as an integer (default: 0)n
  91. -T pdu-type PDU type, as an integer (default: 1)n
  92. -t tcl transaction class, as an integer (default: 2)n
  93. -n set tid_new flag in packets, forces gateway to flush cachen
  94.                 (default: off)n
  95. -s              test separation, by concatenating ack and disconnect pdusn
  96.                 (default: off)n
  97. -d difference difference between successive tid numbers (default: 1)n
  98. -F Accept failure and continue rather than exitingn
  99. -w Write/print recieved data (experimental)n
  100. n
  101. The urls are fetched in random order.n
  102. ";
  104. #include <errno.h>
  105. #include <ctype.h>
  106. #include <math.h>
  107. #include <stdio.h>
  108. #include <stdlib.h>
  109. #include <string.h>
  110. #include <time.h>
  111. #include <unistd.h>
  112. #include <sys/time.h>
  113. #include <sys/types.h>
  114. #include <sys/socket.h>
  115. #include <netinet/in.h>
  116. #include <netdb.h>
  117. #include <sys/param.h>
  118. #include <math.h>
  119. #include <signal.h>
  121. #include "gwlib/gwlib.h"
  123. #define GET_WTP_PDU_TYPE(hdr)  (hdr[0] >> 3)
  124. static int get_wtp_pdu_type(Octstr *hdr) {
  125. return octstr_get_char(hdr, 0) >> 3;
  126. }
  128. #define WTP_PDU_INVOKE  1
  129. #define WTP_PDU_RESULT  2
  130. #define WTP_PDU_ACK     3
  131. #define WTP_PDU_ABORT   4
  133. /*
  134. **  Common parameters
  135. */
  136. char **urls;
  137. int num_urls;
  139. Octstr *hostname = NULL;
  140. Octstr *gateway_addr = NULL;
  141. double interval = 1.0;
  142. unsigned short port = 9201;
  143. int max_send = 1;
  144. unsigned short tid_addition = 1;
  145. Mutex *mutex;
  146. int threads = 1;
  147. int num_sent = 0;
  148. time_t start_time, end_time;
  149. double totaltime = 0, besttime = 1000000L,  worsttime = 0;
  150. int verbose = 0;
  151. int nofailexit = 0;
  152. int writedata = 0;
  153. int test_separation = 0;
  155. /*
  156.  * PDU type, version number and transaction class are supplied by a 
  157.  * command line argument. WSP_Concat is a concatenation of WTP_Ack and 
  158.  * WSP_Disconnect PDUs.
  159.  */
  160. unsigned char WSP_Connect[] = {0x06, 0x00, 0x00, 0x00, 0x01, 0x10, 0x00, 
  161. 0x00 };
  162. unsigned char WSP_ConnectReply[] = {0x16, 0x80, 0x00, 0x02 };
  163. unsigned char WTP_Ack[] =          {0x18, 0x00, 0x00 };
  164. unsigned char WTP_TidVe[] =        {0x1C, 0x00, 0x00 };
  165. unsigned char WTP_Abort[] =        {0x20, 0x00, 0x00, 0x00 };
  166. unsigned char WSP_Get[] =          {0x0E, 0x00, 0x00, 0x02, 0x40 };
  167. /* This used to also expect a content-type of 0x94, but that's too difficult
  168.  * to check now that Kannel does full header encoding. */
  169. unsigned char WSP_Reply[] =        {0x16, 0x80, 0x00, 0x04, 0x20 };
  170. unsigned char WSP_Disconnect[] =   {0x0E, 0x00, 0x00, 0x00, 0x05 };
  171. unsigned char WSP_Concat[] = {0x00, 0x03, 0x18, 0x00, 0x00, 0x05, 0x0E, 0x00, 0x00, 0x00, 0x05 };
  173. /*
  174. **  In this case it does not matter what is the byte order
  175. */
  176. #define SET_GTR( hdr ) hdr[0] |= 0x04
  177. #define SET_TID( hdr, tid) 
  178. hdr[1] |= (0x7f & ((tid) >> 8)); 
  179. hdr[2] = (char)(tid)
  180. #define GET_TID( hdr ) (((hdr[1] & 0x7f) << 8) + hdr[2])
  181. #define CONSTRUCT_EXPECTED_REPLY_HDR( dest, template, tid ) 
  182.     if (sizeof(dest) < sizeof(template)) panic(0,"buffer overflow.");
  183.     memcpy( dest, template, sizeof(template));
  184.     SET_TID( dest, tid )
  186. static void set_tid(Octstr *hdr, int tid) {
  187. int c;
  189. c = octstr_get_char(hdr, 1);
  190. c |= 0x7f & (tid >> 8);
  191. octstr_set_char(hdr, 1, c);
  192. octstr_set_char(hdr, 2, (unsigned char) tid);
  193. }
  195. /* Use this only on Invoke packets, the others have no tid_new field */
  196. static void set_tid_new(Octstr *hdr) {
  197. int c;
  199. c = octstr_get_char(hdr, 3);
  200. c |= 0x40;
  201. octstr_set_char(hdr, 3, c);
  202. }
  205. #ifndef min
  206. #define min(a,b) (a < b ? a : b)
  207. #endif
  210. /*
  211. **  if -v option has been defined, function prints the trace message and
  212. **  the first bytes in the message header
  213. */
  214. static void print_msg( const char * trace, unsigned char * msg,
  215.                 int msg_len ) {
  216.     int i;
  217.     if (verbose) {
  218.         mutex_lock( mutex );
  219.         printf( "%s (len %d): ", trace, msg_len );
  220.         for (i = 0; i < msg_len && i < 16; i++) printf( "%02X ", msg[i] );
  221.         printf( "n");
  222.         mutex_unlock( mutex );
  223.     }
  224. }
  225. /*
  226. **  if -w option has been defined, function prints the trace message and
  227. **  the first bytes in the message header
  228. */   
  229. static void print_data( const char * trace, unsigned char * msg,
  230.                 int msg_len ) {
  231.     int i;
  233.     if (verbose || writedata) {
  234.         mutex_lock( mutex );
  235.         printf( "%s (len %d): ", trace, msg_len );
  236.         for (i = 0; i < msg_len && i < msg_len; i++)
  237.              printf( "%c", isprint(msg[i]) ? msg[i] : '_');
  238.         printf( "n");
  239.         mutex_unlock( mutex );
  240.     }
  241. }
  243. /* Choose a random message from a table of messages. */
  244. static char *choose_message(char **urls, int num_urls) {
  245.     /* the following doesn't give an even distribution, but who cares */
  246.     return urls[gw_rand() % num_urls];
  247. }
  250. /* returns next tid, given current tid.  Every thread has its own
  251.  * port, so has its own tid space. */
  252. static unsigned short next_tid(unsigned short old_tid) { 
  253.     return (old_tid + tid_addition) % (1 << 15);
  254. }
  257. /*
  258. **  Function stores WAP/WSP variable length integer to buffer and returns 
  259. **  actual len
  260. */
  261. static int StoreVarInt( unsigned char *buf, unsigned long varInt )
  262. {
  263.     int i, len = 1, non_zero_bits = 7;
  265.     /*
  266.     **    Skip all zero high bits
  267.     */
  268.     while ((varInt >> non_zero_bits) != 0) {
  269.         non_zero_bits += 7;
  270.         len++;
  271.     }
  272.     /*
  273.     **    Read the higest bits first.
  274.     */
  275.     for (i = 0; i < len; i++)
  276.     {
  277.         buf[i] = ((unsigned char)(varInt >> (non_zero_bits-7)) & 0x7f) | 0x80;
  278.         non_zero_bits -= 7;
  279.     }
  280.     buf[len-1] &= 0x7f;
  281.     return len;
  282. }
  285. /*
  286. **  Function length of WAP/WSP variable length integer in the buffer
  287. */
  288. static int ReadVarIntLen( const unsigned char *buf )
  289. {
  290.     int    len = 1;
  292.     while (buf[len-1] & 0x80) len++;
  293.     return len;
  294. }
  297. /*
  298. **  Function sends message to WAP GW
  299. */
  300. static int
  301. wap_msg_send( int fd, unsigned char * hdr,
  302.             int hdr_len, unsigned short tid, int tid_new, unsigned char * data,
  303.             int data_len )
  304. {
  305.     int ret;
  306.     Octstr *datagram;
  308.     datagram = octstr_create("");
  309.     if (hdr != NULL)
  310.      octstr_append_data(datagram, hdr, hdr_len);
  312.     set_tid(datagram, tid);
  313.     if (get_wtp_pdu_type(datagram) == WTP_PDU_INVOKE) {
  314. /* request ack every time */
  315. int c;
  316. c = octstr_get_char(datagram, 3);
  317. octstr_set_char(datagram, 3, c | 0x10);
  318. if (tid_new)
  319. set_tid_new(datagram);
  320.     }
  322.     if (data != NULL)
  323. octstr_append_data(datagram, data, data_len);
  324.     
  325. #if 0
  326.     debug("fakewap", 0, "Sending WDP datagram:");
  327.     octstr_dump(datagram, 0);
  328. #endif
  329.     ret = udp_sendto(fd, datagram, gateway_addr);
  331.     if (ret == -1) {
  332.         error(0, "Sending to socket failed");
  333.         return -1;
  334.     }
  336.     if (verbose) {
  337. debug("", 0, "Sent packet:");
  338. octstr_dump(datagram, 0);
  339.     }
  340.     octstr_destroy(datagram);
  341.     return ret;
  342. }
  344. /*
  345. **  Function receives a wap wtl/wsp message. If the headers has been
  346. **  given, it must match with the received message.
  347. **  Return value:
  348. **      >  0 => length of received data
  349. **      == 0 => got acknowlengement or abort but not the expected data
  350. **      < 0  => error,
  351. */
  352. static int
  353. wap_msg_recv( int fd, const char * hdr, int hdr_len,
  354.               unsigned short tid, unsigned char * data, int data_len,
  355.               int timeout )
  356. {
  357.     int ret;
  358.     unsigned char msg[1024*64];
  359.     int msg_len = 0;
  360.     int    fResponderIsDead = 1;  /* assume this by default */
  361.     Octstr *datagram, *dummy;
  363.     /*
  364.     **  Loop until we get the expected response or do timeout
  365.     */
  366.     for (;;)
  367.     {
  368.         if (timeout != 0)
  369.         {
  370.     ret = read_available(fd, timeout * 1000 * 1000);
  371.     if (ret <= 0) {
  372.                 info(0, "Timeout while receiving from socket.n");
  373. if(nofailexit){
  374.     continue;
  375. }else{
  376.     return fResponderIsDead ? -1 : 0;
  377. }
  378. /* continue if we got ack? */
  379.     }
  380.         }
  382. ret = udp_recvfrom(fd, &datagram, &dummy);
  383. if (ret == 0) {
  384. octstr_get_many_chars(msg, datagram, 0, octstr_len(datagram));
  385. msg_len = octstr_len(datagram);
  386. }
  387. octstr_destroy(datagram);
  388. octstr_destroy(dummy);
  390.         if (ret == -1) {
  391.             error(0, "recv() from socket failed");
  392.             return -1;
  393.         }
  395.         if (hdr != NULL) {
  396.             /*
  397.             **  Ignore extra header bits, WAP GWs return different values
  398.             */
  399.             if (msg_len >= hdr_len &&
  400.                 GET_WTP_PDU_TYPE(msg) == GET_WTP_PDU_TYPE(hdr) &&
  401.                 (hdr_len <= 3 || !memcmp( msg+3, hdr+3, hdr_len-3 ))) {
  402.                 break;
  403.             }
  404.             /*
  405.             **  Handle TID test, the answer is: Yes, we have an outstanding
  406.             **  transaction with this tid. We must turn on TID_OK-flag, too.
  407.             **  We have a separate tid verification PDU.
  408.             */
  409.             else if (GET_WTP_PDU_TYPE(msg) == WTP_PDU_ACK &&
  410.                      GET_TID(msg) == tid) {
  411.                 print_msg( "Received tid verification", msg, msg_len );
  412.                 wap_msg_send( fd, WTP_TidVe, sizeof(WTP_TidVe), tid, 0,
  413.                               NULL, 0 );
  414.             }
  415.             else if (GET_WTP_PDU_TYPE(msg) == WTP_PDU_ABORT) {
  416.                 print_msg( "Received WTP Abort", msg, msg_len );
  417.             }
  418.             else {
  419.                 print_msg( "Received unexpected message", msg, msg_len );
  420.             }
  421.             fResponderIsDead = 0;
  422.         }
  423.         else {
  424.             hdr_len = 0;
  425.             break;
  426.         }
  427.     }
  428.     print_msg( "Received packet", msg, msg_len );
  429.     print_data( "Received data", msg, msg_len );
  431.     if (data != NULL && msg_len > hdr_len) {
  432.         data_len = min( data_len, msg_len - hdr_len );
  433.         memcpy( data, msg+hdr_len, data_len);
  434.     }
  435.     else  data_len = 0;
  436.     return data_len;
  437. }
  440. static int get_next_transaction(void) {
  441.     int i_this;
  442.     mutex_lock( mutex );
  443.     i_this = num_sent + 1;
  444.     if (max_send == MAX_SEND || num_sent < max_send) num_sent++;
  445.     mutex_unlock( mutex );
  446.     return i_this;
  447. }
  449. /*
  450. **  Function (or thread) sets up a dgram socket.  Then it loops: WTL/WSP
  451. **  Connect, Get a url and Disconnect until all requests are have been done.
  452. */
  453. static void client_session( void * arg)
  454. {
  455.     int fd;
  456.     int ret;
  457.     int url_len = 0, url_off = 0;
  458.     double nowsec, lastsec, tmp, sleepTime;
  459.     long uSleepTime;
  460.     struct timeval now;
  461.     struct timezone tz;
  462.     char * url;
  463.     unsigned char  sid[20];
  464.     int            sid_len = 0;
  465.     unsigned char  buf[64*1024];
  466.     unsigned char reply_hdr[32];
  467.     long timeout = 10;  /* wap gw is broken if no input */
  468.     unsigned short tid = 0;
  469.     unsigned short old_tid;
  470.     int tid_new = 0;
  471.     int connection_retries = 0;
  472.     int i_this;
  474.     fd = udp_client_socket();
  475.     if (fd == -1)
  476.         panic(0, "Couldn't create socket.");
  478.     /*
  479.     **  Loop until all URLs have been requested
  480.     */
  481.     for (;;) {
  482. /*
  483.  ** Get start time of this request
  484.  */
  485.      gettimeofday(&now, &tz);
  486.      lastsec = (double) now.tv_sec + now.tv_usec / 1e6;
  488.         /*
  489.         **  Get next transaction number or exit if too many transactions
  490.         */
  491.         i_this = get_next_transaction();
  492.         if (max_send != MAX_SEND  && i_this > max_send) break;
  494.         /*
  495.         **  Connect, save sid from reply and finally ack the reply
  496.         */
  497. old_tid = tid;
  498.         tid = next_tid(old_tid);
  499. tid_new = (tid < old_tid);  /* Did we wrap? */
  500.         ret = wap_msg_send( fd, WSP_Connect, sizeof(WSP_Connect),
  501.                             tid, tid_new, NULL, 0 );
  503.         if (ret == -1) panic(0, "Send WSP_Connect failed");
  505.         CONSTRUCT_EXPECTED_REPLY_HDR( reply_hdr, WSP_ConnectReply, tid );
  506.         ret = wap_msg_recv( fd, reply_hdr, sizeof(WSP_ConnectReply),
  507.                             tid, buf, sizeof(buf), timeout );
  509.         if (ret == -1) panic(0, "Receive WSP_ConnectReply failed");
  511.         if (ret > 2)
  512.         {
  513.             sid_len = ReadVarIntLen(buf);
  514.             memcpy( sid, buf, sid_len);
  515.         }
  516.         /*
  517.         **  Send abort and continue if we get an unexpected reply
  518.         */
  519.         if (ret == 0)  {
  520.             if (connection_retries++ > 3) {
  521.                 panic(0, "Cannot connect WAP GW!");
  522.             }
  523.             wap_msg_send( fd, WTP_Abort, sizeof(WTP_Abort), tid, tid_new,
  524.                           NULL, 0 );
  525.             continue;
  526.         }
  527.         else {
  528.             connection_retries = 0;
  529.         }
  530.         ret = wap_msg_send( fd, WTP_Ack, sizeof(WTP_Ack), tid, tid_new,
  531.                             NULL, 0 );
  533.         if (ret == -1) panic(0, "Send WTP_Ack failed");
  535.         /*
  536.         **  Request WML page with the given URL
  537.         */
  538. old_tid = tid;
  539.         tid = next_tid(old_tid);
  540. tid_new = (tid < old_tid);  /* Did we wrap? */
  541.         url = choose_message(urls, num_urls);
  542.         url_len = strlen(url);
  543.         url_off = StoreVarInt( buf, url_len );
  544.         memcpy( buf+url_off, url, url_len );
  545.         ret = wap_msg_send( fd, WSP_Get, sizeof(WSP_Get), tid, tid_new,
  546.     buf, url_len+url_off );
  547.         if (ret == -1) break;
  549.         CONSTRUCT_EXPECTED_REPLY_HDR( reply_hdr, WSP_Reply, tid );
  550.         ret = wap_msg_recv( fd, reply_hdr, sizeof(WSP_Reply),
  551.                             tid, buf, sizeof(buf), timeout );
  552.         if (ret == -1) break;
  553.         /*
  554. ** If we are testing separation, we concatenate WTP_Ack and 
  555.         ** WSP_Disconnect messages.
  556.         */
  557.         if (test_separation){
  558.            ret = wap_msg_send(fd, WSP_Concat, sizeof(WSP_Concat), tid, tid_new,
  559.      sid, sid_len);
  560.            
  561.            if (ret == -1) break;
  562.         } else {
  563.            ret = wap_msg_send( fd, WTP_Ack, sizeof(WTP_Ack), tid, tid_new,
  564.     NULL, 0 );
  566.            if (ret == -1) break;
  568.         /*
  569.         **  Finally disconnect with the sid returned by connect reply
  570.         */
  571.            ret = wap_msg_send( fd, WSP_Disconnect, sizeof(WSP_Disconnect),
  572.             tid, tid_new, sid, sid_len );
  574.            if (ret == -1) break;
  575.         }
  577. /*
  578.  ** Get end time of the request
  579.  */
  580.         gettimeofday(&now, &tz);
  581.         nowsec = (double) now.tv_sec + now.tv_usec / 1e6;
  582.         tmp = nowsec - lastsec; /* Duration of request */
  583. sleepTime = interval-tmp; /* Amount of time left to sleep */
  584. uSleepTime = sleepTime * 1e6;
  586.         mutex_lock( mutex );
  587.         if (tmp < besttime) besttime = tmp;
  588.         if (tmp > worsttime) worsttime = tmp;
  589.         totaltime += tmp;
  590.         mutex_unlock( mutex );
  592. if (verbose == 1)
  593. {
  594. info(0, "fakewap: finished session # %d", i_this);
  595. }
  597. /*
  598.  ** If we've done all the requests, then don't bother to sleep
  599.  */
  600.         if (i_this >= max_send) break;
  602.         if (tmp < (double)interval) {
  603.             usleep( uSleepTime );
  604.         }
  605.     }
  606.     close(fd);
  608.     /* The last end_time stays */
  609.     mutex_lock( mutex );
  610.     time(&end_time);
  611.     mutex_unlock( mutex );
  612. }
  615. static void help(void) {
  616. info(0, "n%s", usage);
  617. }
  621. /* The main program. */
  622. int main(int argc, char **argv)
  623. {
  624.     int i, opt;
  625.     double delta;
  626.     int proto_version, pdu_type, tcl, tid_new;
  627. #ifdef SunOS
  628.     struct sigaction alrm;
  630.     alrm.sa_handler = SIG_IGN;
  632.     sigaction(SIGALRM,&alrm,NULL);
  633. #endif
  634.     gwlib_init();
  636.     proto_version = 0;
  637.     pdu_type = 1;
  638.     tcl = 2;
  639.     tid_new = 0;
  641.     hostname = octstr_create("localhost");
  643.     while ((opt = getopt(argc, argv, "Fhvc:g:p:P:m:i:t:V:T:t:nsd:w")) != EOF) {
  644. switch (opt) {
  645. case 'g':
  646.     octstr_destroy(hostname);
  647.     hostname = octstr_create(optarg);
  648.     break;
  650. case 'p':
  651.     port = atoi(optarg);
  652.     break;
  654. case 'm':
  655.     max_send = atoi(optarg);
  656.     break;
  658. case 'i':
  659.     interval = atof(optarg);
  660.     break;
  662. case 'c':
  663.     threads = atoi(optarg);
  664.     break;
  666. case 'V':
  667.     proto_version = atoi(optarg);
  668.     break;
  670. case 'T':
  671.     pdu_type = atoi(optarg);
  672.     break;
  674. case 't':
  675.     tcl = atoi(optarg);
  676.     break;
  678. case 'n':
  679.     tid_new = 1;
  680.     break;
  682.         case 's':
  683.     test_separation = 1;
  684.             break;
  686. case 'd':
  687.     tid_addition = atoi(optarg);
  688.     break;
  690. case 'v':
  691.     verbose = 1;
  692.     break;
  693.     
  694. case 'h':
  695.     help();
  696.     exit(0);
  697.     break;
  699. case 'F':
  700.     nofailexit=1;
  701.     break;
  703.         case 'w':
  704.             writedata = 1;
  705.             break;
  707. case '?':
  708. default:
  709.     error(0, "Unknown option %c", opt);
  710.     help();
  711.     panic(0, "Stopping.");
  712. }
  713.     }
  715.     time(&start_time);
  717.     if (optind >= argc)
  718.         panic(0, "%s", usage);
  720. if (verbose != 1)
  721. {
  722. log_set_output_level (GW_INFO);
  723. }
  724.     WSP_Connect[3] += (proto_version&3)<<6;
  725.     WSP_Connect[0] += (pdu_type&15)<<3;
  726.     WSP_Connect[3] += tcl&3;
  727.     WSP_Connect[3] += (tid_new&1)<<5;
  728.     
  729.     gateway_addr = udp_create_address(hostname, port);
  731.     urls = argv + optind;
  732.     num_urls = argc - optind;
  734.     srand((unsigned int) time(NULL));
  736.     mutex = mutex_create();
  738.     info(0, "fakewap starting");
  740.     if (threads < 1) threads = 1;
  742.     /*
  743.     **  Start 'extra' client threads and finally execute the
  744.     **  session of main thread
  745.     */
  746.     for (i = 1; i < threads; i++)
  747.         gwthread_create(client_session, NULL);
  748.     client_session(NULL);
  750.     /* Wait for the other sessions to complete */
  751.     gwthread_join_every(client_session);
  753.     info(0, "fakewap complete.");
  754.     info(0, "fakewap: %d client threads made total %d transactions.", 
  755.      threads, num_sent);
  756.     delta = difftime(end_time, start_time);
  757.     info( 0, "fakewap: total running time %.1f seconds", delta);
  758.     info( 0, "fakewap: %.1f messages/seconds on average", num_sent / delta);
  759.     info( 0, "fakewap: time of best, worst and average transaction: "
  760.              "%.1f s, %.1f s, %.1f s",
  761.          besttime, worsttime, totaltime / num_sent );
  763.     octstr_destroy(hostname);
  764.     octstr_destroy(gateway_addr);
  765.     mutex_destroy(mutex);
  766.     gwlib_shutdown();
  767.     return 0;
  768. }