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

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

手机WAP编程

开发平台：

WINDOWS

wtp_pdu.c：源码内容
  1. /* wtp_pdu.c - pack and unpack WTP packets
  2.  *
  3.  * Generates packing and unpacking code from wtp_pdu.def.
  4.  *
  5.  * Richard Braakman
  6.  */
  8. #include "gwlib/gwlib.h"
  9. #include "wtp_pdu.h"
  11. WTP_PDU *wtp_pdu_create(int type) {
  12. WTP_PDU *pdu;
  14. pdu = gw_malloc(sizeof(*pdu));
  15. pdu->type = type;
  16. pdu->options = NULL;
  18. switch (pdu->type) {
  19. #define PDU(name, docstring, fields, is_valid) 
  20. case name: {
  21. struct name *p; p = &pdu->u.name; 
  22. fields 
  23. } break;
  24. #define UINT(field, docstring, bits) p->field = 0;
  25. #define UINTVAR(field, docstring) p->field = 0;
  26. #define OCTSTR(field, docstring, lengthfield) p->field = NULL;
  27. #define REST(field, docstring) p->field = NULL;
  28. #define TYPE(bits, value) 
  29. #define RESERVED(bits) 
  30. #define TPI(confield)
  31. #include "wtp_pdu.def"
  32. #undef TPI
  33. #undef RESERVED
  34. #undef TYPE
  35. #undef REST
  36. #undef OCTSTR
  37. #undef UINTVAR
  38. #undef UINT
  39. #undef PDU
  40. default:
  41. warning(0, "Cannot destroy unknown WTP PDU type %d", pdu->type);
  42. break;
  43. }
  45. return pdu;
  46. }
  48. void wtp_pdu_destroy(WTP_PDU *pdu) {
  49. if (pdu == NULL)
  50. return;
  52. switch (pdu->type) {
  53. #define PDU(name, docstring, fields, is_valid) 
  54. case name: {
  55. struct name *p; p = &pdu->u.name; 
  56. fields 
  57. } break;
  58. #define UINT(field, docstring, bits)
  59. #define UINTVAR(field, docstring)
  60. #define OCTSTR(field, docstring, lengthfield) octstr_destroy(p->field);
  61. #define REST(field, docstring) octstr_destroy(p->field);
  62. #define TYPE(bits, value)
  63. #define RESERVED(bits)
  64. #define TPI(confield)
  65. #include "wtp_pdu.def"
  66. #undef TPI
  67. #undef RESERVED
  68. #undef TYPE
  69. #undef REST
  70. #undef OCTSTR
  71. #undef UINTVAR
  72. #undef UINT
  73. #undef PDU
  74. default:
  75. warning(0, "Cannot destroy unknown WTP PDU type %d", pdu->type);
  76. break;
  77. }
  79. if (pdu->options) {
  80. while (list_len(pdu->options)) {
  81. wtp_tpi_destroy(list_consume(pdu->options));
  82. }
  83. list_destroy(pdu->options, NULL);
  84. }
  86. gw_free(pdu);
  87. }
  89. void wtp_tpi_destroy(WTP_TPI *p) {
  90. if (p == NULL)
  91. return;
  93. octstr_destroy(p->data);
  94. gw_free(p);
  95. }
  97. void wtp_pdu_append_tpi(WTP_PDU *pdu, int type, Octstr *data) {
  98. WTP_TPI *tpi;
  100. tpi = gw_malloc(sizeof(*tpi));
  101. tpi->type = type;
  102. tpi->data = data;
  103. if (pdu->options == NULL)
  104. pdu->options = list_create();
  105. list_append(pdu->options, tpi);
  106. }
  108. static long unpack_tpis(Octstr *data, long bitpos, WTP_PDU *pdu) {
  109. long length;
  110. int type;
  111. Octstr *tpidata;
  112. int another;
  114. do {
  115. another = octstr_get_bits(data, bitpos, 1);
  116. type = octstr_get_bits(data, bitpos + 1, 4);
  117. if (octstr_get_bits(data, bitpos + 5, 1)) {
  118. /* Long TPI */
  119. length = octstr_get_bits(data, bitpos + 8, 8);
  120. bitpos += 16;
  121. } else {
  122. /* Short TPI */
  123. length = octstr_get_bits(data, bitpos + 6, 2);
  124. bitpos += 8;
  125. }
  126. gw_assert(bitpos % 8 == 0);
  127. tpidata = octstr_copy(data, bitpos / 8, length);
  128. bitpos += 8 * length;
  129. wtp_pdu_append_tpi(pdu, type, tpidata);
  130. } while (another);
  132. return bitpos;
  133. }
  135. static long pack_tpis(Octstr *data, long bitpos, List *tpis) {
  136. long length;
  137. WTP_TPI *tpi;
  138. int i;
  139. int num_tpis;
  141. num_tpis = list_len(tpis);
  142. for (i = 0; i < num_tpis; i++) {
  143. tpi = list_get(tpis, i);
  144. length = octstr_len(tpi->data);
  145. octstr_set_bits(data, bitpos, 1, i + 1 < num_tpis);
  146. octstr_set_bits(data, bitpos + 1, 4, tpi->type);
  147. if (length >= 4) {
  148. /* Long TPI */
  149. octstr_set_bits(data, bitpos + 5, 1, 1);
  150. octstr_set_bits(data, bitpos + 8, 8, length);
  151. bitpos += 16;
  152. } else {
  153. /* Short TPI */
  154. octstr_set_bits(data, bitpos + 5, 1, 0);
  155. octstr_set_bits(data, bitpos + 6, 2, length);
  156. bitpos += 8;
  157. }
  158. gw_assert(bitpos % 8 == 0);
  159. octstr_append(data, tpi->data);
  160. bitpos += 8 * length;
  161. }
  163. return bitpos;
  164. }
  166. static void dump_tpis(List *tpis, int level) {
  167. int i;
  168. int num_tpis;
  169. WTP_TPI *tpi;
  171. if (tpis == NULL)
  172. return;
  174. num_tpis = list_len(tpis);
  175. for (i = 0; i < num_tpis; i++) {
  176. tpi = list_get(tpis, i);
  177. debug("wap.wtp", 0, "%*s TPI type %u:", level, "", tpi->type);
  178. octstr_dump(tpi->data, level + 1);
  179. }
  180. }
  182. /* Determine which type of PDU this is, using the TYPE macros in
  183.  * the definition file. */
  184. static int wtp_pdu_type(Octstr *data) {
  185. long bitpos;
  186. long lastpos = -1;
  187. long lastnumbits = -1;
  188. long lastval = -1;
  189. int thistype;
  191. /* This code looks slow, but an optimizing compiler will
  192.  * reduce it considerably.  gcc -O2 will produce a single
  193.  * call to octstr_get_bits, folllowed by a sequence of
  194.  * tests on lastval. */
  196. /* Only UINT and RESERVED fields may precede the TYPE */
  197. #define PDU(name, docstring, fields, is_valid) 
  198. bitpos = 0; 
  199. thistype = name; 
  200. fields
  201. #define UINT(field, docstring, bits) bitpos += (bits);
  202. #define UINTVAR(field, docstring)
  203. #define OCTSTR(field, docstring, lengthfield)
  204. #define REST(field, docstring)
  205. #define TYPE(bits, value) 
  206. if ((bits) != lastnumbits || bitpos != lastpos) { 
  207. lastval = octstr_get_bits(data, bitpos, (bits)); 
  208. } 
  209. if (lastval == (value)) 
  210. return thistype; 
  211. lastnumbits = (bits); 
  212. lastpos = bitpos;
  213. #define RESERVED(bits) bitpos += (bits);
  214. #define TPI(confield)
  215. #include "wtp_pdu.def"
  216. #undef TPI
  217. #undef RESERVED
  218. #undef TYPE
  219. #undef REST
  220. #undef OCTSTR
  221. #undef UINTVAR
  222. #undef UINT
  223. #undef PDU
  225. return -1;
  226. }
  228. WTP_PDU *wtp_pdu_unpack(Octstr *data) {
  229. WTP_PDU *pdu = NULL;
  230. long bitpos = 0;
  232. gw_assert(data != NULL);
  234. pdu = gw_malloc(sizeof(*pdu));
  236. pdu->type = wtp_pdu_type(data);
  237. pdu->options = NULL;
  239. switch (pdu->type) {
  240. #define PDU(name, docstring, fields, is_valid) 
  241. case name: { 
  242. struct name *p = &pdu->u.name; 
  243. fields 
  244. gw_assert(bitpos % 8 == 0); 
  245. if (bitpos / 8 != octstr_len(data)) { 
  246. warning(0, "Bad length for " #name " PDU, " 
  247. "expected %ld", bitpos / 8); 
  248. } 
  249. if (!(is_valid)) { 
  250. warning(0, #name " PDU failed %s", #is_valid); 
  251.                         return NULL; 
  252. } 
  253. } break;
  254. #define UINT(field, docstring, bits) 
  255. p->field = octstr_get_bits(data, bitpos, (bits)); 
  256. bitpos += (bits);
  257. #define UINTVAR(field, docstring) 
  258. gw_assert(bitpos % 8 == 0); 
  259. p->field = octstr_get_bits(data, bitpos + 1, 7); 
  260. while (octstr_get_bits(data, bitpos, 1)) { 
  261. bitpos += 8; 
  262. p->field <<= 7; 
  263. p->field |= octstr_get_bits(data, bitpos + 1, 7); 
  264. } 
  265. bitpos += 8;
  266. #define OCTSTR(field, docstring, lengthfield) 
  267. gw_assert(bitpos % 8 == 0); 
  268. p->field = octstr_copy(data, bitpos / 8, p->lengthfield); 
  269. bitpos += 8 * p->lengthfield;
  270. #define REST(field, docstring) 
  271. gw_assert(bitpos % 8 == 0); 
  272. if (bitpos / 8 <= octstr_len(data)) { 
  273. p->field = octstr_copy(data, bitpos / 8, 
  274. octstr_len(data) - bitpos / 8); 
  275. bitpos = octstr_len(data) * 8; 
  276. } else { 
  277. p->field = octstr_create(""); 
  278. }
  279. #define TYPE(bits, value) bitpos += (bits);
  280. #define RESERVED(bits) bitpos += (bits);
  281. #define TPI(confield) 
  282. if (p->confield) { 
  283. pdu->options = list_create(); 
  284. bitpos = unpack_tpis(data, bitpos, pdu); 
  285. }
  286. #include "wtp_pdu.def"
  287. #undef TPI
  288. #undef RESERVED
  289. #undef TYPE
  290. #undef REST
  291. #undef OCTSTR
  292. #undef UINTVAR
  293. #undef UINT
  294. #undef PDU
  295. default:
  296. warning(0, "WTP PDU with unknown type %d", pdu->type);
  297. gw_free(pdu);
  298. return NULL;
  299. }
  301. return pdu;
  302. }
  304. static void fixup_length_fields(WTP_PDU *pdu) {
  305. switch (pdu->type) {
  306. #define PDU(name, docstring, fields, is_valid) 
  307. case name: { 
  308. struct name *p = &pdu->u.name; 
  309. fields 
  310. } break;
  311. #define UINT(field, docstring, bits)
  312. #define UINTVAR(field, docstring)
  313. #define OCTSTR(field, docstring, lengthfield) 
  314. p->lengthfield = octstr_len(p->field);
  315. #define REST(field, docstring)
  316. #define TYPE(bits, value)
  317. #define RESERVED(bits)
  318. #define TPI(confield) 
  319. p->confield = pdu->options != NULL && list_len(pdu->options) > 0;
  320. #include "wtp_pdu.def"
  321. #undef TPI
  322. #undef RESERVED
  323. #undef TYPE
  324. #undef REST
  325. #undef OCTSTR
  326. #undef UINTVAR
  327. #undef UINT
  328. #undef PDU
  329. }
  330. }
  332. Octstr *wtp_pdu_pack(WTP_PDU *pdu) {
  333. Octstr *data;
  334. long bitpos;
  336. /* We rely on octstr_set_bits to lengthen our octstr as needed. */
  337. data = octstr_create("");
  339. fixup_length_fields(pdu);
  341. bitpos = 0;
  342. switch (pdu->type) {
  343. #define PDU(name, docstring, fields, is_valid) 
  344. case name: { 
  345. struct name *p = &pdu->u.name; 
  346. fields 
  347. gw_assert(bitpos % 8 == 0); 
  348. } break;
  349. #define UINT(field, docstring, bits) 
  350. octstr_set_bits(data, bitpos, (bits), p->field); 
  351. bitpos += (bits);
  352. #define UINTVAR(field, docstring) 
  353. gw_assert(bitpos % 8 == 0); 
  354. octstr_append_uintvar(data, p->field); 
  355. bitpos = 8 * octstr_len(data);
  356. #define OCTSTR(field, docstring, lengthfield) 
  357. gw_assert(bitpos % 8 == 0); 
  358. if (p->field != NULL) 
  359. octstr_append(data, p->field); 
  360. bitpos += 8 * octstr_len(p->field);
  361. #define REST(field, docstring) 
  362. gw_assert(bitpos % 8 == 0); 
  363. if (p->field != NULL) 
  364. octstr_append(data, p->field); 
  365. bitpos += 8 * octstr_len(p->field);
  366. #define TYPE(bits, value) 
  367. octstr_set_bits(data, bitpos, (bits), (value)); 
  368. bitpos += (bits);
  369. #define RESERVED(bits) bitpos += (bits);
  370. #define TPI(confield) 
  371. if (p->confield) { 
  372. bitpos = pack_tpis(data, bitpos, pdu->options); 
  373. }
  374. #include "wtp_pdu.def"
  375. #undef TPI
  376. #undef RESERVED
  377. #undef TYPE
  378. #undef REST
  379. #undef OCTSTR
  380. #undef UINTVAR
  381. #undef UINT
  382. #undef PDU
  383. default:
  384. panic(0, "Packing unknown WTP PDU type %ld", (long) pdu->type);
  385. }
  387. return data;
  388. }
  390. void wtp_pdu_dump(WTP_PDU *pdu, int level) {
  391. unsigned char *dbg = "wap.wtp";
  393. switch (pdu->type) {
  394. #define PDU(name, docstring, fields, is_valid) 
  395. case name: { 
  396. struct name *p = &pdu->u.name; 
  397. debug(dbg, 0, "%*sWTP %s PDU at %p:", 
  398. level, "", #name, (void *)pdu); 
  399. fields 
  400. } break;
  401. #define UINT(field, docstring, bits) 
  402. debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
  403. #define UINTVAR(field, docstring) 
  404. debug(dbg, 0, "%*s %s: %lu", level, "", docstring, p->field);
  405. #define OCTSTR(field, docstring, lengthfield) 
  406. debug(dbg, 0, "%*s %s:", level, "", docstring); 
  407. octstr_dump(p->field, level + 1);
  408. #define REST(field, docstring) 
  409. debug(dbg, 0, "%*s %s:", level, "", docstring); 
  410. octstr_dump(p->field, level + 1);
  411. #define TYPE(bits, value)
  412. #define RESERVED(bits)
  413. #define TPI(confield) dump_tpis(pdu->options, level);
  414. #include "wtp_pdu.def"
  415. #undef TPI
  416. #undef RESERVED
  417. #undef TYPE
  418. #undef REST
  419. #undef OCTSTR
  420. #undef UINTVAR
  421. #undef UINT
  422. #undef PDU
  423. default:
  424. debug(dbg, 0, "%*sWTP PDU at %p:", level, "", (void *)pdu);
  425. debug(dbg, 0, "%*s unknown type %u", level, "", pdu->type);
  426. break;
  427. }
  428. }