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

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

手机WAP编程

开发平台：

WINDOWS

test_cimd2.c：源码内容
  1. /* test_cimd2.c - fake cimd2 smsc
  2.  *
  3.  * This program pretends to be an CIMD 2 SMS center, accessible via IP.
  4.  * It is used to test the Kannel smsc_cimd2 code.
  5.  * 
  6.  * Richard Braakman
  7.  */
  9. /* Note: The CIMD2 parsing code was written as a prototype, and currently
  10.  * its main use is to exercise the *real* CIMD2 code in gw/smsc_cimd2.c.
  11.  * Please don't use this code for anything real.
  12.  * Richard Braakman */
  14. /*
  15.  * TODO: If log level is high and activity level is low, there will be
  16.  * "SND" log entries for packets that are not sent, which is confusing
  17.  * and should be fixed.
  18.  */
  20. #include <stdlib.h>
  21. #include <stdio.h>
  22. #include <string.h>
  23. #include <errno.h>
  24. #include <ctype.h>
  25. #include <stdarg.h>
  26. #include <limits.h>
  28. #include <unistd.h>
  29. #include <time.h>
  30. #include <sys/types.h>
  31. #include <sys/time.h>
  32. #include <sys/socket.h>
  33. #include <netinet/in.h>
  34. #include <arpa/inet.h>
  36. #include "gwlib/gwlib.h"
  38. enum { TIMESTAMP_MAXLEN = 13 };
  40. unsigned char *progname;
  42. /* Set up a fake account for Kannel to use */
  43. unsigned char *username = "foo";
  44. unsigned char *password = "bar";
  46. int port = 6789;
  48. /* This can be useful to get past protocol-ID checks when testing spew. */
  49. unsigned char *intro = "";
  51. enum ACT {
  52. ACT_listen = 0,
  53. ACT_reply = 1,
  54. ACT_deliver = 2,
  55. ACT_flood = 3
  56. };
  58. enum SPEW {
  59. SPEW_nothing = 0,
  60. SPEW_binary = 1,
  61. SPEW_characters = 2,
  62. SPEW_packets = 3
  63. };
  65. enum LOG {
  66. LOG_nothing = 0,
  67. LOG_data = 1,
  68. LOG_packets = 2,
  69. LOG_sms = 3
  70. };
  72. enum CHK {
  73. CHK_nothing = 0,
  74. CHK_packets = 1,
  75. CHK_sums = 2,
  76. CHK_protocol = 3,
  77. CHK_sms = 4
  78. };
  80. int activity = ACT_listen;
  81. int spew = SPEW_nothing;
  82. int logging = LOG_nothing;
  83. int checking = CHK_nothing;
  85. int max_deliveries = -1;
  86. int deliveries = 0;
  87. time_t start_time = 0;
  89. int sockfd = -1;
  91. Octstr *inbuffer;
  92. Octstr *outbuffer;
  93. /* Maximum reasonable outbuffer size.  It can go above this, but we don't
  94.  * deliberately add data when it's already more than this. */
  95. enum { OUTBUFFER_LIMIT = 65536 };
  97. /* Test dependencies on neatly-sized read and write chunks, by using
  98.  * a deliberately evil buffer size.  1021 is the largest prime smaller
  99.  * than 1024. */
  100. enum { EVIL_BUFSIZE = 1021 };
  103. enum CHARS {
  104. STX = 2,
  105. ETX = 3,
  106. TAB = 9,
  107. LF = 10,
  108. CR = 13
  109. };
  111. static void usage(FILE *out) {
  112. fprintf(out, "Usage: %s [options...]n"
  113. "  --help          Print this messagen"
  114. "  --user USER     Allow clients to log in with username USER (default %s)n"
  115. "  --password PASS Allow clients to log in with password PASS (default %s)n"
  116. "  --intro INTRO   Send INTRO string before anything else (default nothing)n"
  117. "  --port PORT     TCP port to listen on (default %d)n"
  118. "  --activity ACT  Activity level of test server (default %d)n"
  119. "      ACT = 0     send nothing, just listenn"
  120. "      ACT = 1     send valid replies, do not initiate any transactionsn"
  121. "      ACT = 2     attempt to deliver a random SMS every few seconds (NI)n"
  122. "      ACT = 3     deliver many random SMSes, measure throughput (NI)n"
  123. "  --spew SPEW     Flood client, overrides --activity (default %d)n"
  124. "      SPEW = 0    don't spew, use --activity insteadn"
  125. "      SPEW = 1    spew random binary gunk at clientn"
  126. "      SPEW = 2    spew random data of the right character set at client (NI)n"
  127. "      SPEW = 3    spew valid packets with random contents at client (NI)n"
  128. "  --logging LOG   Log level of test server (default %d)n"
  129. "      LOG = 0     log nothingn"
  130. "      LOG = 1     log all datan"
  131. "      LOG = 2     log summaries of valid packetsn"
  132. "      LOG = 3     log successfully sent and received SMSes (NI)n"
  133. "  --checking CHK  Check level of test server (default %d)n"
  134. "      CHK = 0     check nothingn"
  135. "      CHK = 1     signal invalid packets (NI)n"
  136. "      CHK = 2     signal checksum errors (NI)n"
  137. "      CHK = 3     signal protocol errors (NI)n"
  138. "      CHK = 4     signal invalid SMS contents (NI)n"
  139. "  --max MAX       With high activity values, stop after MAX deliveriesn"
  140. " NI means Not Implementedn"
  141. , progname, username, password, port,
  142. activity, spew, logging, checking);
  143. }
  145. static void pretty_print(unsigned char *data, size_t length) {
  146. size_t i;
  147. int c;
  149. for (i = 0; i < length; i++) {
  150. c = data[i];
  151. switch(c) {
  152. default:
  153. if (isprint(c))
  154. putchar(c);
  155. else
  156. printf("<%d>", c);
  157. break;
  158. case TAB: fputs("<TAB>", stdout); break;
  159. case LF: fputs("<LF>n", stdout); break;
  160. case CR: fputs("<CR>", stdout); break;
  161. case STX: fputs("<STX>", stdout); break;
  162. case ETX: fputs("<ETX>n", stdout); break;
  163. }
  164. }
  165. fflush(stdout);
  166. }
  168. static void read_data(Octstr *in, int fd) {
  169. unsigned char buf[EVIL_BUFSIZE];
  170. int ret;
  172. ret = read(fd, buf, sizeof(buf));
  173. if (ret > 0) {
  174. octstr_append_data(in, buf, ret);
  175. if (logging == LOG_data)
  176. pretty_print(buf, ret);
  177. } else if (ret == 0) {
  178. fprintf(stderr, "Client closed socketn");
  179. exit(0);
  180. } else {
  181. if (errno == EINTR || errno == EAGAIN)
  182. return;
  183. error(errno, "read_data");
  184. exit(1);
  185. }
  186. }
  188. static void write_data(Octstr *out, int fd) {
  189. unsigned char buf[EVIL_BUFSIZE];
  190. int len;
  191. ssize_t ret;
  193. len = sizeof(buf);
  194. if (len > octstr_len(out))
  195. len = octstr_len(out);
  196. if (len == 0)
  197. return;
  198. octstr_get_many_chars(buf, out, 0, len);
  199. ret = write(fd, buf, len);
  200. if (ret > 0) {
  201. if (logging == LOG_data)
  202. pretty_print(buf, ret);
  203. octstr_delete(out, 0, ret);
  204. } else if (ret == 0) {
  205. warning(0, "empty write");
  206. } else {
  207. if (errno == EINTR || errno == EAGAIN)
  208. return;
  209. error(errno, "write_data");
  210. exit(1);
  211. }
  212. }
  214. static void gen_message(Octstr *out);
  216. /* Return the minimum interval (in microseconds) after which we will
  217.  * want to be called again.  This value is only used if we _don't_
  218.  * generate data this time through. */
  219. static long gen_data(Octstr *out) {
  220. unsigned char buf[EVIL_BUFSIZE];
  221. size_t i;
  222. long interval = -1;
  223. static int last_sms;  /* Used by ACT_deliver */
  224. time_t now;
  226. if (max_deliveries < 0 || deliveries < max_deliveries) {
  227. switch (activity) {
  228. case ACT_deliver:
  229. now = time(NULL);
  230. if (last_sms == 0)
  231. last_sms = now;
  232. while (last_sms < now) {
  233. if (random() % 7 == 1) {
  234. gen_message(out);
  235. last_sms = now;
  236. } else
  237. last_sms++;
  238. }
  239. interval = 1000000;
  240. break;
  241. case ACT_flood:
  242. gen_message(out);
  243. break;
  244. }
  245. }
  247. switch (spew) {
  248. case SPEW_binary:
  249. for (i = 0; i < sizeof(buf); i++) {
  250. buf[i] = random() % 256;
  251. }
  252. octstr_append_data(out, buf, sizeof(buf));
  253. break;
  254. }
  256. return interval;
  257. }
  259. /******************************* CIMD 2 specific code ************************/
  261. int awaiting_response = 0;
  263. /* buf must be at least TIMESTAMP_MAXLEN bytes long. */
  264. static void make_timestamp(unsigned char *buf, time_t fortime) {
  265. /* Is there a thread-safe version of gmtime? */
  266. struct tm tm = gw_gmtime(fortime);
  268. sprintf(buf, "%02d%02d%02d%02d%02d%02d",
  269. tm.tm_year % 100, tm.tm_mon + 1, tm.tm_mday,
  270. tm.tm_hour, tm.tm_min, tm.tm_sec);
  271. }
  274. static void send_packet(Octstr *out, int opcode, int sequence, ...) {
  275. va_list ap;
  276. int parm;
  277. unsigned char *value;
  278. int checksum;
  279. int old_len, new_len;
  281. if (activity == ACT_listen)
  282. return;
  284. old_len = octstr_len(out);
  286. octstr_format_append(out, "%c%02d:%03d%c", STX, opcode, sequence, TAB);
  288. va_start(ap, sequence);
  289. for (parm = va_arg(ap, int); parm != 0; parm = va_arg(ap, int)) {
  290. value = va_arg(ap, unsigned char *);
  291. octstr_format_append(out, "%03d:%s11", parm, value);
  292. }
  293. va_end(ap);
  295. /* Calculate checksum */
  296. checksum = 0;
  297. for (new_len = octstr_len(out); old_len < new_len; old_len++) {
  298. checksum = (checksum + octstr_get_char(out, old_len)) & 0xff;
  299. }
  301. octstr_format_append(out, "%02X%c", checksum, ETX);
  302. }
  304. static void send_error(Octstr *out, int opcode, int sequence,
  305. unsigned char *errorcode, unsigned char *errortext) {
  306. if (logging == LOG_packets)
  307. printf("SND: ERROR, %sn", errortext);
  309. send_packet(out, opcode, sequence, 900, errorcode, 901, errortext, 0);
  310. }
  312. static int eat_char(Octstr *packet, int ch) {
  313. if (octstr_get_char(packet, 0) == ch) {
  314. octstr_delete(packet, 0, 1);
  315. return 0;
  316. }
  317. return -1;
  318. }
  320. static Octstr *eat_string_parm(Octstr *packet, int parm, int maxlen) {
  321. long start, datastart;
  322. long tab;
  323. Octstr *result;
  324. Octstr *parmheader;
  326.      parmheader = octstr_format("%c%03d:", TAB, parm);
  327. start = octstr_search(packet, parmheader, 0);
  328. if (start < 0) {
  329. octstr_destroy(parmheader);
  330. return NULL;
  331. }
  332. datastart = start + octstr_len(parmheader);
  334. tab = octstr_search_char(packet, TAB, datastart + 1);
  335. if (tab < 0) {
  336. tab = octstr_len(packet);
  337. }
  339. result = octstr_copy(packet, datastart, tab - datastart);
  340. octstr_delete(packet, start, tab - start);
  341. octstr_destroy(parmheader);
  342. return result;
  343. }
  345. static long eat_number(Octstr *ostr) {
  346. long result;
  347. long pos;
  349. pos = octstr_parse_long(&result, ostr, 0, 10);
  350. if (pos < 0)
  351. return INT_MIN;
  353. octstr_delete(ostr, 0, pos);
  354. return result;
  355. }
  357. static long eat_int_parm(Octstr *packet, int parm, int maxlen) {
  358. Octstr *value;
  359. long result;
  361. value = eat_string_parm(packet, parm, maxlen);
  362. if (!value)
  363. return INT_MIN;
  365. result = eat_number(value);
  366. if (octstr_len(value) > 0)
  367. result = INT_MIN;
  369. octstr_destroy(value);
  370. return result;
  371. }
  373. static void eat_checksum(Octstr *packet) {
  374. int len;
  375. int ch1, ch2, ch3;
  377. len = octstr_len(packet);
  379. if (len < 3)
  380. return;
  382. ch1 = octstr_get_char(packet, len - 3);
  383. ch2 = octstr_get_char(packet, len - 2);
  384. ch3 = octstr_get_char(packet, len - 1);
  386. if (isxdigit(ch3) && isxdigit(ch2) && ch1 == TAB)
  387. octstr_delete(packet, len - 3, 3);
  388. }
  390. static void handle_login(Octstr *packet, Octstr *out, int sequence) {
  391. Octstr *user = eat_string_parm(packet, 10, 32);
  392. Octstr *pass = eat_string_parm(packet, 11, 32);
  394. if (user == NULL)
  395. user = octstr_create("");
  396. if (pass == NULL)
  397. pass = octstr_create("");
  399. if (logging == LOG_packets)
  400. printf("RCV: Login user '%s', password '%s'n",
  401. octstr_get_cstr(user), octstr_get_cstr(pass));
  403. if (octstr_str_compare(user, username) == 0 &&
  404.     octstr_str_compare(pass, password) == 0) {
  405. if (logging == LOG_packets)
  406. printf("SND: Login OKn");
  407. send_packet(out, 51, sequence, 0);
  408. } else {
  409. send_error(out, 51, sequence, "100", "invalid login");
  410. }
  412. octstr_destroy(user);
  413. octstr_destroy(pass);
  414. }
  416. static void handle_logout(Octstr *packet, Octstr *out, int sequence) {
  417. if (logging == LOG_packets)
  418. printf("RCV: Logoutn");
  419. if (logging == LOG_packets)
  420. printf("SND: Logout OKn");
  421. send_packet(out, 52, sequence, 0);
  422. }
  424. static void handle_submit(Octstr *packet, Octstr *out, int sequence) {
  425. Octstr *dest_addr = eat_string_parm(packet, 21, 20);
  426. Octstr *orig_addr = eat_string_parm(packet, 23, 20);
  427. long DCS = eat_int_parm(packet, 30, 3);
  428. Octstr *UDH = eat_string_parm(packet, 32, 280);
  429. Octstr *text = eat_string_parm(packet, 33, 480);
  430. Octstr *textb = eat_string_parm(packet, 34, 280);
  431. long valid_rel = eat_int_parm(packet, 50, 3);
  432. Octstr *valid_abs = eat_string_parm(packet, 51, 12);
  433. long proto_id = eat_int_parm(packet, 52, 3);
  434. long delivery_rel = eat_int_parm(packet, 53, 3);
  435. Octstr *delivery_abs = eat_string_parm(packet, 54, 12);
  436. long reply_path = eat_int_parm(packet, 55, 1);
  437. long SRR = eat_int_parm(packet, 56, 2);
  438. long cancel = eat_int_parm(packet, 58, 1);
  439. long tariff_class = eat_int_parm(packet, 64, 2);
  440. long service_desc = eat_int_parm(packet, 65, 1);
  441. long priority = eat_int_parm(packet, 67, 1);
  442. List *other_dests = list_create();
  443. Octstr *tmp;
  445. while ((tmp = eat_string_parm(packet, 21, 20)))
  446. list_append(other_dests, tmp);
  448. if (logging == LOG_packets) {
  449. int i;
  450. printf("RCV: Submit to %s", octstr_get_cstr(dest_addr));
  451. for (i = 0; i < list_len(other_dests); i++) {
  452. printf(", %s",
  453. octstr_get_cstr(list_get(other_dests, i)));
  454. }
  455. printf("n");
  457. if (orig_addr)
  458. printf("    From: %sn", octstr_get_cstr(orig_addr));
  459. if (DCS > INT_MIN)
  460. printf("    Data coding: %ldn", DCS);
  461. if (UDH)
  462. printf("    User data header: %sn",
  463. octstr_get_cstr(UDH));
  464. if (text)
  465. printf("    Text: %sn", octstr_get_cstr(text));
  466. if (textb)
  467. printf("    Text (binary): %sn",
  468. octstr_get_cstr(textb));
  469. if (valid_rel > INT_MIN)
  470. printf("    Validity period: %ld (relative)n",
  471. valid_rel);
  472. if (valid_abs)
  473. printf("    Validity period: %s (absolute)n",
  474. octstr_get_cstr(valid_abs));
  475. if (proto_id > INT_MIN)
  476. printf("    Protocol ID: %ldn", proto_id);
  477. if (delivery_rel > INT_MIN)
  478. printf("    First delivery: %ld (relative)n",
  479. delivery_rel);
  480. if (delivery_abs)
  481. printf("    First delivery: %s (absolute)n",
  482. octstr_get_cstr(delivery_abs));
  483. if (reply_path == 0)
  484. printf("    Reply path disabledn");
  485. else if (reply_path == 1)
  486. printf("    Reply path enabledn");
  487. else if (reply_path > INT_MAX)
  488. printf("    Reply path: %ldn", reply_path);
  489. if (SRR > INT_MAX)
  490. printf("    Status report flags: %ldn", SRR);
  491. if (cancel == 0)
  492. printf("    Cancel disabledn");
  493. else if (cancel == 1)
  494. printf("    Cancel enabledn");
  495. else if (cancel > INT_MAX)
  496. printf("    Cancel enabled: %ldn", cancel);
  497. if (tariff_class > INT_MAX)
  498. printf("    Tariff class: %ldn", tariff_class);
  499. if (service_desc > INT_MAX)
  500. printf("    Service description: %ldn", service_desc);
  501. if (priority > INT_MAX)
  502. printf("    Priority: %ldn", priority);
  503. }
  505. if (!dest_addr) {
  506. send_error(out, 53, sequence, "300", "no destination");
  507. } else if (list_len(other_dests) > 0) {
  508. send_error(out, 53, sequence, "301", "too many destinations");
  509. /* TODO: Report many other possible errors here */
  510. } else {
  511. unsigned char buf[TIMESTAMP_MAXLEN];
  513. make_timestamp(buf, time(NULL));
  514. if (logging == LOG_packets)
  515. printf("SND: Submit OKn");
  516. send_packet(out, 53, sequence,
  517.             21, octstr_get_cstr(dest_addr),
  518.     60, buf,
  519.     0);
  520. }
  522. octstr_destroy(dest_addr);
  523. octstr_destroy(orig_addr);
  524. octstr_destroy(UDH);
  525. octstr_destroy(text);
  526. octstr_destroy(textb);
  527. octstr_destroy(valid_abs);
  528. octstr_destroy(delivery_abs);
  529. list_destroy(other_dests, octstr_destroy_item);
  530. }
  532. static void handle_enquire(Octstr *packet, Octstr *out, int sequence) {
  533. Octstr *dest_addr = eat_string_parm(packet, 21, 20);
  534. Octstr *timestamp = eat_string_parm(packet, 60, 12);
  536. if (logging == LOG_packets)
  537. printf("RCV: Enquire status, dest='%s', time='%s'n",
  538. dest_addr ? octstr_get_cstr(dest_addr) : "",
  539. timestamp ? octstr_get_cstr(timestamp) : "");
  541. if (!dest_addr) {
  542. send_error(out, 54, sequence, "400", "no destination");
  543. } else if (!timestamp) {
  544. send_error(out, 54, sequence, "401", "no timestamp");
  545. } else {
  546. if (logging == LOG_packets)
  547. printf("SND: Respond: status unknownn");
  548. send_packet(out, 54, sequence,
  549.     21, octstr_get_cstr(dest_addr),
  550.     60, octstr_get_cstr(timestamp),
  551.     61, "0",
  552.     0);
  553. }
  554. octstr_destroy(dest_addr);
  555. octstr_destroy(timestamp);
  556. }
  558. static void handle_delivery_request(Octstr *packet, Octstr *out, int sequence) {
  559. long mode = eat_int_parm(packet, 68, 1);
  561. if (logging == LOG_packets) {
  562. switch (mode) {
  563. case 0: printf("RCV: Delivery request, messages waiting?n");
  564. break;
  565. case 1: printf("RCV: Delivery request, one messagen");
  566. break;
  567. case 2: printf("RCV: Delivery request, all messagesn");
  568. break;
  569. case INT_MIN:
  570. printf("RCV: Delivery request, no moden");
  571. break;
  572. default:
  573. printf("RCV: Delivery request, mode %ldn", mode);
  574. }
  575. }
  577. if (mode == INT_MIN)
  578. mode = 1;
  580. switch (mode) {
  581. case 0:
  582. if (logging == LOG_packets)
  583. printf("SND: Respond: 0 messagesn");
  584. send_packet(out, 55, sequence,
  585.     66, "0",
  586.     0);
  587. break;
  589. case 1:
  590. send_error(out, 55, sequence, "500", "no messages available");
  591. break;
  593. case 2:
  594. send_error(out, 55, sequence, "500", "no messages available");
  595. break;
  597. default:
  598. send_error(out, 55, sequence, "501", "bad mode");
  599. break;
  600. }
  601. }
  603. static void handle_cancel(Octstr *packet, Octstr *out, int sequence) {
  604. long mode = eat_int_parm(packet, 59, 1);
  605. Octstr *timestamp = eat_string_parm(packet, 60, 12);
  606. Octstr *destination = eat_string_parm(packet, 21, 20);
  608. if (logging == LOG_packets) {
  609. printf("RCV: Cancel");
  610. if (mode != INT_MIN)
  611. printf(", mode %ld", mode);
  612. if (destination)
  613. printf(", dest '%s'", octstr_get_cstr(destination));
  614. if (timestamp)
  615. printf(", time '%s'", octstr_get_cstr(timestamp));
  616. printf("n");
  617. }
  619. if (mode < 0 || mode > 2)
  620. send_error(out, 56, sequence, "602", "bad mode");
  621. else {
  622. if (logging == LOG_packets)
  623. printf("SND: OKn");
  624. send_packet(out, 56, sequence, 0);
  625. }
  626. }
  629. static void handle_set(Octstr *packet, Octstr *out, int sequence) {
  630. Octstr *pass = eat_string_parm(packet, 11, 32);
  632. if (pass) {
  633. if (logging == LOG_packets)
  634. printf("RCV: Set password to '%s'n",
  635. octstr_get_cstr(pass));
  636. send_error(out, 58, sequence,
  637. "801", "changing password not allowed");
  638. } else {
  639. if (logging == LOG_packets)
  640. printf("RCV: Set, unknown parametersn");
  641. send_error(out, 58, sequence, "3", "cannot set");
  642. }
  643. }
  646. static void handle_get(Octstr *packet, Octstr *out, int sequence) {
  647. long number = eat_int_parm(packet, 500, 3);
  649. if (logging == LOG_packets)
  650. printf("RCV: Get parameter #%ldn", number);
  652. if (number == INT_MIN) {
  653. send_error(out, 59, sequence, "900", "missing parameter");
  654. } else if (number == 501) {
  655. unsigned char buf[TIMESTAMP_MAXLEN];
  656. make_timestamp(buf, time(NULL));
  657. if (logging == LOG_packets)
  658. printf("SND: OK, SMSC timestamp is '%s'n", buf);
  659. send_packet(out, 59, sequence,
  660.     501, buf,
  661.     0);
  662. } else {
  663. send_error(out, 59, sequence, "900", "unknown parameter");
  664. }
  665. }
  667. static void handle_alive(Octstr *packet, Octstr *out, int sequence) {
  668. if (logging == LOG_packets)
  669. printf("RCV: Alive?n");
  670. if (logging == LOG_packets)
  671. printf("SND: Alive.n");
  672. send_packet(out, 90, sequence, 0);
  673. }
  675. static void handle_deliver_response(Octstr *packet, Octstr *out, int sequence) {
  676. awaiting_response = 0;
  677. if (logging == LOG_packets)
  678. printf("RCV: Deliver responsen");
  679. deliveries++;
  680. if (max_deliveries > 0 && deliveries == max_deliveries) {
  681. time_t elapsed = time(NULL) - start_time;
  682. printf("LOG: %ld deliveries in %ld secondsn",
  683. (long) max_deliveries, (long) elapsed);
  684. }
  685. /* No need to respond to a response */
  686. }
  688. static void handle_deliver_status_report_response(Octstr *packet, Octstr *out, int sequence) {
  689. awaiting_response = 0;
  690. if (logging == LOG_packets)
  691. printf("RCV: Deliver status report responsen");
  692. /* No need to respond to a response */
  693. }
  695. static void handle_alive_response(Octstr *packet, Octstr *out, int sequence) {
  696. awaiting_response = 0;
  697. if (logging == LOG_packets)
  698. printf("RCV: Alive.n");
  699. /* No need to respond to a response */
  700. }
  702. static void handle_nack(Octstr *packet, Octstr *out, int sequence) {
  703. awaiting_response = 0;
  704. if (logging == LOG_packets)
  705. printf("RCV: NACKn");
  706. /* TODO: We should retransmit if we get a nack, but there's
  707.  * no record of what request we sent. */
  708. }
  710. typedef void (*packet_handler)(Octstr *, Octstr *, int);
  712. struct {
  713. int opcode;
  714. packet_handler handler;
  715. } handlers[] = {
  716. { 1, handle_login },
  717. { 2, handle_logout },
  718. { 3, handle_submit },
  719. { 4, handle_enquire },
  720. { 5, handle_delivery_request },
  721. { 6, handle_cancel },
  722. { 8, handle_set },
  723. { 9, handle_get },
  724. { 40, handle_alive },
  725. { 70, handle_deliver_response },
  726. { 73, handle_deliver_status_report_response },
  727. { 90, handle_alive_response },
  728. { 99, handle_nack },
  729. { -1, NULL },
  730. };
  732. static void parse_packet(Octstr *packet, Octstr *out) {
  733. int opcode, sequence;
  734. int i;
  736. eat_checksum(packet);
  738. opcode = eat_number(packet);
  739. if (opcode < 0 || eat_char(packet, ':') < 0)
  740. return;
  741. sequence = eat_number(packet);
  742. if (sequence < 0)
  743. return;
  745. for (i = 0; handlers[i].opcode >= 0; i++) {
  746. if (handlers[i].opcode == opcode) {
  747. (handlers[i].handler)(packet, out, sequence);
  748. break;
  749. }
  750. }
  752. if (handlers[i].opcode < 0) { /* Loop failed */
  753. if (logging == LOG_packets)
  754. printf("RCV: unknown operation %ldn",
  755. (long) handlers[i].opcode);
  756. send_error(out, 98, sequence, "1", "unexpected operation");
  757. }
  758. }
  760. /* Parse the data stream for packets, and send out replies. */
  761. static void parse_data(Octstr *in, Octstr *out) {
  762. int stx, etx;
  763. Octstr *packet;
  765. for (;;) {
  766. /* Look for start of packet.  Delete everything up to the start
  767.  * marker.  (CIMD2 section 3.1 says we can ignore any data
  768.  * transmitted between packets.) */
  769. stx = octstr_search_char(in, STX, 0);
  770. if (stx < 0)
  771. octstr_delete(in, 0, octstr_len(in));
  772. else if (stx > 0)
  773. octstr_delete(in, 0, stx);
  775. etx = octstr_search_char(in, ETX, 0);
  776. if (etx < 0)
  777. return;  /* Incomplete packet; wait for more data. */
  779. /* Copy the data between stx and etx */
  780. packet = octstr_copy(in, 1, etx - 1);
  781. /* Then cut the packet (including stx and etx) from inbuffer */
  782. octstr_delete(in, 0, etx + 1);
  784. parse_packet(packet, out);
  786. octstr_destroy(packet);
  787. }
  788. }
  790. static void random_address(unsigned char *buf, int size) {
  791. int len = random() % size;
  793. while (len--) {
  794. *buf++ = '0' + random() % 10;
  795. }
  797. *buf++ = '';
  798. }
  800. static void random_message(unsigned char *buf, int size) {
  801. int len = random() % size;
  803. while (len--) {
  804. do {
  805. *buf = random() % 256;
  806. } while (*buf == STX || *buf == ETX || *buf == TAB);
  807. buf++;
  808. }
  810. *buf++ = '';
  811. }
  813. static void random_hex(unsigned char *buf, int size) {
  814. int len = random() % size;
  816. /* Make even */
  817. len -= (len % 2);
  819. while (len--) {
  820. int c = random() % 16;
  821. if (c < 10)
  822. *buf++ = c + '0';
  823. else
  824. *buf++ = c - 10 + 'a';
  825. }
  827. *buf++ = '';
  828. }
  830. static void gen_message(Octstr *out) {
  831. static int send_seq = 0;
  832. unsigned char dest[21];
  833. unsigned char orig[21];
  834. unsigned char scts[TIMESTAMP_MAXLEN];
  835. unsigned char message[481];
  836. unsigned char udh[281];
  838. if (awaiting_response == 1)
  839. return;
  841. random_address(dest, sizeof(dest));
  842. random_address(orig, sizeof(orig));
  843. make_timestamp(scts, time(NULL));
  844. random_message(message, sizeof(message));
  845. if (random() % 2 == 0)
  846. random_hex(udh, sizeof(udh));
  847. else
  848. *udh = 0;
  850. if (logging == LOG_packets)
  851. printf("SND: Deliver message (random)n");
  853. if (*udh) {
  854. send_packet(out, 20, send_seq,
  855. 21, dest,
  856. 23, orig,
  857. 60, scts,
  858. 32, udh,
  859. 33, message,
  860. 0);
  861. } else {
  862. send_packet(out, 20, send_seq,
  863. 21, dest,
  864. 23, orig,
  865. 60, scts,
  866. 33, message,
  867. 0);
  868. }
  870. send_seq += 2;
  871. if (send_seq > 255)
  872. send_seq = 0;
  874. awaiting_response = 1;
  875. }
  877. /************************** CIMD 2 specific code ends ************************/
  879. static void main_loop(void) {
  880. fd_set readfds, writefds;
  881. int n;
  882. static int reported_outfull = 0;
  883. int interval = -1;
  885. inbuffer = octstr_create("");
  886. outbuffer = octstr_create(intro);
  887. start_time = time(NULL);
  889. for (;;) {
  890. if (octstr_len(outbuffer) < OUTBUFFER_LIMIT) {
  891. interval = gen_data(outbuffer);
  892. } else if (!reported_outfull) {
  893. warning(0, "outbuffer getting full; waiting...");
  894. reported_outfull = 1;
  895. }
  897. FD_ZERO(&readfds);
  898. FD_SET(sockfd, &readfds);
  900. if (octstr_len(outbuffer) > 0) {
  901. FD_ZERO(&writefds);
  902. FD_SET(sockfd, &writefds);
  903. n = select(sockfd+1, &readfds, &writefds, NULL, NULL);
  904. } else {
  905. struct timeval tv;
  906. struct timeval *tvp;
  908. if (interval >= 0) {
  909. tv.tv_sec = 0;
  910. tv.tv_usec = interval;
  911. tvp = &tv;
  912. } else {
  913. tvp = NULL;
  914. }
  915. n = select(sockfd+1, &readfds, NULL, NULL, tvp);
  916. }
  918. if (n < 0) {
  919. if (errno == EINTR) {
  920. warning(errno, "main loop, select");
  921. continue;
  922. }
  923. error(errno, "main loop, select");
  924. sleep(1);
  925. continue;
  926. }
  927. if (n > 0) {
  928. if (FD_ISSET(sockfd, &readfds)) {
  929. read_data(inbuffer, sockfd);
  930. parse_data(inbuffer, outbuffer);
  931. }
  932. if (octstr_len(outbuffer) > 0 &&
  933.     FD_ISSET(sockfd, &writefds)) {
  934. write_data(outbuffer, sockfd);
  935. }
  936. if (octstr_len(outbuffer) < OUTBUFFER_LIMIT) {
  937. reported_outfull = 0;
  938. }
  939. }
  940. }
  941. }
  943. static struct {
  944. unsigned char *option;
  945. void *location;
  946. int number;
  947. } options[] = {
  948. { "--user", &username, 0 },
  949. { "--password", &password, 0 },
  950. { "--port", &port, 1 },
  951. { "--intro", &intro, 0 },
  952. { "--activity", &activity, 1 },
  953. { "--spew", &spew, 1 },
  954. { "--logging", &logging, 1 },
  955. { "--checking", &checking, 1 },
  956. { "--max", &max_deliveries, 1 },
  957. { NULL, NULL, 0 },
  958. };
  960. static int wait_for_client(int port) {
  961. struct sockaddr_in sin;
  962. socklen_t addrlen;
  963. int listenfd;
  964. int clientfd;
  965. Octstr *addr;
  967. listenfd = make_server_socket(port, NULL);
  968. if (listenfd < 0) {
  969. fprintf(stderr, "%s: failed to open socket at port %dn",
  970. progname, port);
  971. exit(1);
  972. }
  974. do {
  975. addrlen = sizeof(sin);
  976. clientfd = accept(listenfd, (struct sockaddr *)&sin, &addrlen);
  977. if (clientfd < 0) {
  978. error(errno, "failed to accept new connection");
  979. }
  980. } while (clientfd < 0);
  982. if (socket_set_blocking(clientfd, 0) < 0) {
  983. panic(0, "failed to make client socket nonblocking");
  984. }
  986.      addr = gw_netaddr_to_octstr(AF_INET, &sin.sin_addr);
  987. info(0, "Accepted client from %s:%d",
  988. octstr_get_cstr(addr), ntohs(sin.sin_port));
  989.      octstr_destroy(addr);
  991. close(listenfd);
  993. return clientfd;
  994. }
  997. int main(int argc, char *argv[]) {
  998. int i;
  999. int opt;
  1001. gwlib_init();
  1003. progname = argv[0];
  1004. srandom(0);  /* Make "random" data reproducible */
  1006. for (i = 1; i < argc; i++) {
  1007. for (opt = 0; options[opt].option; opt++) {
  1008. if (strcmp(argv[i], options[opt].option) == 0) {
  1009. if (i + 1 >= argc) {
  1010. fprintf(stderr, "%s: missing argument to %s",
  1011. progname, argv[i]);
  1012. exit(2);
  1013. }
  1014. if (options[opt].number) {
  1015. * (int *) options[opt].location = atoi(argv[i+1]);
  1016. } else {
  1017. * (char **) options[opt].location = argv[i+1];
  1018. }
  1019. i++;
  1020. break;
  1021. }
  1022. }
  1023. if (options[opt].option)
  1024. continue;
  1025. if (strcmp(argv[i], "--help") == 0) {
  1026. usage(stdout);
  1027. exit(0);
  1028. }
  1029. if (argv[i][0] == '-') {
  1030. fprintf(stderr, "%s: unknown option %sn",
  1031. progname, argv[i]);
  1032. usage(stderr);
  1033. exit(2);
  1034. }
  1035. }
  1037. sockfd = wait_for_client(port);
  1038. main_loop();
  1039. return 0;
  1040. }