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

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

手机WAP编程

开发平台：

WINDOWS

wsp_server_session_states.def：源码内容
  1. /*
  2.  * wsp_server_session_states.def - states for WSP session state machines
  3.  *
  4.  * Macro calls to generate rows of the state table. See the documentation for
  5.  * guidance how to use and update these.
  6.  *
  7.  * Note that `NULL' state is renamed to `NULL_SESSION' because NULL is
  8.  * reserved by C.
  9.  *
  10.  * Lars Wirzenius
  11.  */
  13. STATE_NAME(NULL_SESSION)
  14. STATE_NAME(CONNECTING)
  15. STATE_NAME(TERMINATING)
  16. STATE_NAME(CONNECTING_2)
  17. STATE_NAME(CONNECTED)
  18. STATE_NAME(SUSPENDED)
  19. STATE_NAME(RESUMING)
  20. STATE_NAME(RESUMING_2)
  22. ROW(NULL_SESSION,
  23. TR_Invoke_Ind,
  24. e->tcl == 2 && pdu->type == Connect,
  25. {
  26. WAPEvent *new_event;
  27. WAPEvent *wtp_event;
  29. /* Send TR-Invoke.res to WTP */
  30. wtp_event = wap_event_create(TR_Invoke_Res);
  31. wtp_event->u.TR_Invoke_Res.handle = e->handle;
  32. dispatch_to_wtp_resp(wtp_event);
  34. /* Assign a session ID for this session.  We do this
  35.  * early, instead of in the CONNECTING state, because
  36.  * we want to use the session id as a way for the
  37.  * application layer to refer back to this machine. */
  38. sm->session_id = next_wsp_session_id();
  40. if (pdu->u.Connect.capabilities_len > 0) {
  41. sm->request_caps = wsp_cap_unpack_list(
  42. pdu->u.Connect.capabilities);
  43. } else {
  44. sm->request_caps = list_create();
  45. }
  47. if (pdu->u.Connect.headers_len > 0) {
  48. List *hdrs;
  50. hdrs = wsp_headers_unpack(pdu->u.Connect.headers, 0);
  51. http_header_pack(hdrs);
  52. gw_assert(sm->http_headers == NULL);
  53. sm->http_headers = hdrs;
  54. }
  56. /* Send S-Connect.ind to application layer */
  57. new_event = wap_event_create(S_Connect_Ind);
  58. new_event->u.S_Connect_Ind.addr_tuple =
  59. wap_addr_tuple_duplicate(e->addr_tuple);
  60. new_event->u.S_Connect_Ind.client_headers =
  61. http_header_duplicate(sm->http_headers);
  62. new_event->u.S_Connect_Ind.requested_capabilities =
  63. wsp_cap_duplicate_list(sm->request_caps);
  64. new_event->u.S_Connect_Ind.session_id = sm->session_id;
  65. dispatch_to_appl(new_event);
  66. },
  67. CONNECTING)
  70. ROW(CONNECTING,
  71. S_Connect_Res,
  72. 1,
  73. {
  74. WAPEvent *wtp_event;
  75. Octstr *ospdu;
  77. sm->reply_caps = wsp_cap_duplicate_list(
  78. e->negotiated_capabilities);
  80. /* Send Disconnect event to existing sessions for client. */
  81. disconnect_other_sessions(sm);
  83. /* Assign a Session_ID for this session. */
  84. /* We've already done that in the NULL_STATE. */
  86. /* TR-Result.req(ConnectReply) */
  87. ospdu = make_connectreply_pdu(sm);
  89. wtp_event = wap_event_create(TR_Result_Req);
  90. wtp_event->u.TR_Result_Req.user_data = ospdu;
  91. wtp_event->u.TR_Result_Req.handle = sm->connect_handle;
  92. dispatch_to_wtp_resp(wtp_event);
  94. /* Release all method transactions in HOLDING state. */
  95. release_holding_methods(sm);
  96. },
  97. CONNECTING_2)
  99. /* MISSING: CONNECTING, S_Disconnect_Req, reason == 301 (moved permanently) or
  100.  * 302 (moved temporarily). */
  102. /* MISSING: CONNECTING, S_Disconnect_Req, reason == anything else */
  104. ROW(CONNECTING,
  105. Disconnect_Event,
  106. 1,
  107. {
  108. /* TR-Abort.req(DISCONNECT) the Connect transaction */
  109. send_abort(WSP_ABORT_DISCONNECT, sm->connect_handle);
  111. /* Abort(DISCONNECT) all method transactions */
  112. abort_methods(sm, WSP_ABORT_DISCONNECT);
  114. /* S-Disconnect.ind(DISCONNECT) */
  115. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  116. },
  117. NULL_SESSION)
  119. ROW(CONNECTING,
  120. Suspend_Event,
  121. 1,
  122. {
  123. /* TR-Abort.req(DISCONNECT) the Connect transaction */
  124. send_abort(WSP_ABORT_DISCONNECT, sm->connect_handle);
  126. /* Abort(DISCONNECT) all method transactions */
  127. abort_methods(sm, WSP_ABORT_DISCONNECT);
  129. /* S-Disconnect.ind(SUSPEND) */
  130. indicate_disconnect(sm, WSP_ABORT_SUSPEND);
  131. },
  132. NULL_SESSION)
  134. ROW(CONNECTING,
  135. TR_Invoke_Ind,
  136. e->tcl == 2 && (pdu->type == Get || pdu->type == Post),
  137. { 
  138. WSPMethodMachine *msm;
  140. /* Start new method transaction */
  141. msm = method_machine_create(sm, e->handle);
  143. /* Hand off the event to the new method machine */
  144. handle_method_event(sm, msm, current_event, pdu);
  145. },
  146. CONNECTING)
  148. ROW(CONNECTING,
  149. TR_Invoke_Ind,
  150. e->tcl == 2 && pdu->type == Resume,
  151. {
  152. /* TR-Abort.req(DISCONNECT) the TR-Invoke */
  153. send_abort(WSP_ABORT_DISCONNECT, e->handle);
  154. },
  155. CONNECTING)
  157. ROW(CONNECTING,
  158. TR_Abort_Ind,
  159. e->handle == sm->connect_handle,
  160. {
  161. /* Abort(DISCONNECT) all method transactions */
  162. abort_methods(sm, WSP_ABORT_DISCONNECT);
  164. /* S-Disconnect.ind(abort reason) */
  165. indicate_disconnect(sm, e->abort_code);
  166. },
  167. NULL_SESSION)
  169. ROW(CONNECTING,
  170. TR_Abort_Ind,
  171. e->handle != sm->connect_handle,
  172. {
  173. WSPMethodMachine *msm;
  175. /* See method state table  */
  176. msm = find_method_machine(sm, e->handle);
  177. handle_method_event(sm, msm, current_event, pdu);
  178. },
  179. CONNECTING)
  181. ROW(TERMINATING,
  182. Disconnect_Event,
  183. 1,
  184. {
  185. /* TR-Abort.req(DISCONNECT) remaining transport transaction */
  186. send_abort(WSP_ABORT_DISCONNECT, sm->connect_handle);
  187. },
  188. NULL_SESSION)
  190. ROW(TERMINATING,
  191. Suspend_Event,
  192. 1,
  193. {
  194. /* TR-Abort.req(SUSPEND) remaining transport transaction */
  195. send_abort(WSP_ABORT_SUSPEND, sm->connect_handle);
  196. },
  197. NULL_SESSION)
  199. ROW(TERMINATING,
  200. TR_Result_Cnf,
  201. 1,
  202. {
  203. /* Ignore */
  204. },
  205. NULL_SESSION)
  207. ROW(TERMINATING,
  208. TR_Abort_Ind,
  209. 1,
  210. {
  211. /* Ignore */
  212. },
  213. NULL_SESSION)
  215. /* MISSING: CONNECTING_2, S-Disconnect.req */
  217. ROW(CONNECTING_2,
  218. Disconnect_Event,
  219. 1,
  220. {
  221. /* TR-Abort.req(DISCONNECT) the Connect transaction */
  222. send_abort(WSP_ABORT_DISCONNECT, sm->connect_handle);
  224. /* Abort(DISCONNECT) all method and push transactions */
  225. abort_methods(sm, WSP_ABORT_DISCONNECT);
  227. /* S-Disconnect.ind(DISCONNECT) */
  228. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  229. },
  230. NULL_SESSION)
  232. ROW(CONNECTING_2,
  233. S_MethodInvoke_Res,
  234. 1,
  235. {
  236. WSPMethodMachine *msm;
  238. /* See method state table */
  239. msm = find_method_machine(sm, e->server_transaction_id);
  240. handle_method_event(sm, msm, current_event, pdu);
  241. },
  242. CONNECTING_2)
  244. ROW(CONNECTING_2,
  245. S_MethodResult_Req,
  246. 1,
  247. {
  248. WSPMethodMachine *msm;
  250. /* See method state table */
  251. msm = find_method_machine(sm, e->server_transaction_id);
  252. handle_method_event(sm, msm, current_event, pdu);
  253. },
  254. CONNECTING_2)
  256. ROW(CONNECTING_2,
  257.         S_Push_Req,
  258.         1,
  259.         {
  260.                 WSP_PDU *pdu;
  262.                 pdu = make_push_pdu(current_event);
  263.                 send_invoke(sm, pdu, current_event, TRANSACTION_CLASS_0);
  264.         },
  265.         CONNECTING_2)
  267. ROW(CONNECTING_2,
  268.         S_ConfirmedPush_Req,
  269.         1,
  270.         {
  271.                 /* Start new push transaction*/
  272.                 WSPPushMachine *spm;
  274.                 spm = push_machine_create(sm, e->server_push_id);
  275.                 handle_push_event(sm, spm, current_event);   
  276.         },
  277.         CONNECTING_2)
  279. ROW(CONNECTING_2,
  280. Suspend_Event,
  281. !resume_enabled,
  282. {
  283. /* Session Resume facility disabled */
  285. /* TR-Abort.req(DISCONNECT) the Connect transaction */
  286. send_abort(WSP_ABORT_DISCONNECT, sm->connect_handle);
  288. /* Abort(DISCONNECT) all method and push transactions */
  289. abort_methods(sm, WSP_ABORT_DISCONNECT);
  291. /* S-Disconnect.ind(SUSPEND) */
  292. indicate_disconnect(sm, WSP_ABORT_SUSPEND);
  293. },
  294. NULL_SESSION)
  296. ROW(CONNECTING_2,
  297. Suspend_Event,
  298. resume_enabled,
  299. {
  300. /* Session Resume facility enabled */
  302. /* TR-Abort.req(SUSPEND) the Connect transaction */
  303. send_abort(WSP_ABORT_SUSPEND, sm->connect_handle);
  305. /* Abort(SUSPEND) all method and push transactions */
  306. abort_methods(sm, WSP_ABORT_SUSPEND);
  308. /* S-Suspend.ind(SUSPEND) */
  309. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  310. },
  311. SUSPENDED)
  313. ROW(CONNECTING_2,
  314. TR_Invoke_Ind,
  315. e->tcl == 2 && (pdu->type == Get || pdu->type == Post),
  316. {
  317. WSPMethodMachine *msm;
  318. WAPEvent *new_event;
  320. /* Start new method transaction */
  321. msm = method_machine_create(sm, e->handle);
  323. /* Hand off the event to the new method machine */
  324. handle_method_event(sm, msm, current_event, pdu);
  326. /* Release the new method transaction */
  327. new_event = wap_event_create(Release_Event);
  328. handle_method_event(sm, msm, new_event, NULL);
  329. wap_event_destroy(new_event);
  330. },
  331. CONNECTING_2)
  333. ROW(CONNECTING_2,
  334. TR_Invoke_Ind,
  335. e->tcl == 2 && pdu->type == Resume && !resume_enabled,
  336. {
  337. /* Resume facility disabled */
  339. /* TR-Abort.req(DISCONNECT) the TR-Invoke */
  340. send_abort(WSP_ABORT_DISCONNECT, e->handle);
  341. },
  342. CONNECTING_2)
  344. ROW(CONNECTING_2,
  345. TR_Invoke_Ind,
  346. e->tcl == 2 && pdu->type == Resume && resume_enabled,
  347. {
  348. /* Resume facility enabled */
  350. WAPEvent *wtp_event;
  351. List *new_headers;
  353. /* TR-Invoke.res */
  354. wtp_event = wap_event_create(TR_Invoke_Res);
  355. wtp_event->u.TR_Invoke_Res.handle = e->handle;
  356. dispatch_to_wtp_resp(wtp_event);
  358. /* TR-Abort.req(RESUME) the Connect transaction */
  359. send_abort(WSP_ABORT_RESUME, sm->connect_handle);
  361. /* Abort(RESUME) all method and push transactions */
  362. abort_methods(sm, WSP_ABORT_RESUME);
  364. /* S-Suspend.ind(RESUME) */
  365. indicate_suspend(sm, WSP_ABORT_RESUME);
  367. /* S-Resume.ind */
  368. new_headers = unpack_new_headers(sm, pdu->u.Resume.headers);
  369. indicate_resume(sm, e->addr_tuple, new_headers);
  370. http_destroy_headers(new_headers);
  372. sm->resume_handle = e->handle;
  373. },
  374. RESUMING)
  376. ROW(CONNECTING_2,
  377. TR_Invoke_Ind,
  378. e->tcl == 0 && pdu->type == Disconnect,
  379. {
  380. /* TR-Abort.req(DISCONNECT) the Connect transaction */
  381. send_abort(WSP_ABORT_DISCONNECT, sm->connect_handle);
  383. /* Abort(DISCONNECT) all method and push transactions */
  384. abort_methods(sm, WSP_ABORT_DISCONNECT);
  386. /* S-Disconnect.ind(DISCONNECT) */
  387. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  388. },
  389. NULL_SESSION)
  391. ROW(CONNECTING_2,
  392. TR_Invoke_Ind,
  393. e->tcl == 0 && pdu->type == Suspend && resume_enabled,
  394. {
  395. /* Resume facility enabled */
  397. /* TR-Abort.req(SUSPEND) the Connect transaction */
  398. send_abort(WSP_ABORT_SUSPEND, sm->connect_handle);
  400. /* Abort(SUSPEND) all method and push transactions */
  401. abort_methods(sm, WSP_ABORT_SUSPEND);
  403. /* S-Suspend.ind(SUSPEND) */
  404. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  405. },
  406. SUSPENDED)
  408. ROW(CONNECTING_2,
  409.         TR_Invoke_Cnf,
  410.         1,
  411.         {
  412.                 /* See push state table*/
  413.                 WSPPushMachine *spm;
  415.                 spm = find_push_machine(sm, e->handle);
  416.                 handle_push_event(sm, spm, current_event);
  417.         },
  418.         CONNECTING_2)
  420. ROW(CONNECTING_2,
  421. TR_Result_Cnf,
  422. e->handle == sm->connect_handle,
  423. {
  424. },
  425. CONNECTED)
  427. ROW(CONNECTING_2,
  428. TR_Result_Cnf,
  429. e->handle != sm->connect_handle,
  430. {
  431. WSPMethodMachine *msm;
  433. /* See method state table */
  434. msm = find_method_machine(sm, e->handle);
  435. handle_method_event(sm, msm, current_event, pdu);
  436. },
  437. CONNECTING_2)
  439. ROW(CONNECTING_2,
  440. TR_Abort_Ind,
  441. e->handle == sm->connect_handle,
  442. {
  443. /* Abort(DISCONNECT) all method and push transactions */
  444. abort_methods(sm, WSP_ABORT_DISCONNECT);
  446. /* S-Disconnect.ind(abort reason) */
  447. indicate_disconnect(sm, e->abort_code);
  448. },
  449. NULL_SESSION)
  451. /* 
  452.  * A separate flag tells is the indicator the initiator or the responder.
  453.  */
  455. ROW(CONNECTING_2,
  456. TR_Abort_Ind,
  457. e->handle != sm->connect_handle && e->ir_flag == RESPONDER_INDICATION,
  458. {
  459. WSPMethodMachine *msm;
  461. /* See method state table */
  462. msm = find_method_machine(sm, e->handle);
  463. handle_method_event(sm, msm, current_event, pdu);
  464. },
  465. CONNECTING_2)
  467. ROW(CONNECTING_2,
  468. TR_Abort_Ind,
  469. e->handle != sm->connect_handle && e->ir_flag == INITIATOR_INDICATION,
  470. {
  471. WSPPushMachine *m;
  473. /* See push state table */
  474. m = find_push_machine(sm, e->handle);
  475. handle_push_event(sm, m, current_event);
  476. },
  477. CONNECTING_2)
  479. /* MISSING: CONNECTED, S-Disconnect.req */
  481. ROW(CONNECTED,
  482. Disconnect_Event,
  483. 1,
  484. {
  485. /* Abort(DISCONNECT) all method and push transactions */
  486. abort_methods(sm, WSP_ABORT_DISCONNECT);
  488. /* S-Disconnect.ind(DISCONNECT) */
  489. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  490. },
  491. NULL_SESSION)
  493. ROW(CONNECTED,
  494. S_MethodInvoke_Res,
  495. 1,
  496. {
  497. WSPMethodMachine *msm;
  499. /* See method state table */
  500. msm = find_method_machine(sm, e->server_transaction_id);
  501. handle_method_event(sm, msm, current_event, pdu);
  502. },
  503. CONNECTED)
  505. ROW(CONNECTED,
  506. S_MethodResult_Req,
  507. 1,
  508. {
  509. WSPMethodMachine *msm;
  511. /* See method state table */
  512. msm = find_method_machine(sm, e->server_transaction_id);
  513. handle_method_event(sm, msm, current_event, pdu);
  514. },
  515. CONNECTED)
  517. ROW(CONNECTED,
  518.         S_Push_Req,
  519.         1,
  520.         {
  521.                WSP_PDU *pdu;
  523.                pdu = make_push_pdu(current_event);
  524.                send_invoke(sm, pdu, current_event, TRANSACTION_CLASS_0);
  525.         },
  526.         CONNECTED)
  528. ROW(CONNECTED,
  529.         S_ConfirmedPush_Req,
  530.         1,
  531.         {
  532.                /* Start new push transaction*/
  533.                 WSPPushMachine *spm;
  535.                 spm = push_machine_create(sm, e->server_push_id);
  536.                 handle_push_event(sm, spm, current_event);
  537.         },
  538.         CONNECTED)
  540. ROW(CONNECTED,
  541. Suspend_Event,
  542. !resume_enabled,
  543. {
  544. /* Session Resume facility disabled */
  546. /* Abort(SUSPEND) all method and push transactions */
  547. abort_methods(sm, WSP_ABORT_SUSPEND);
  549. /* S-Disconnect.ind(SUSPEND) */
  550. indicate_disconnect(sm, WSP_ABORT_SUSPEND);
  551. },
  552. NULL_SESSION)
  554. ROW(CONNECTED,
  555. Suspend_Event,
  556. resume_enabled,
  557. {
  558. /* Session Resume facility enabled */
  560. /* Abort(SUSPEND) all method and push transactions */
  561. abort_methods(sm, WSP_ABORT_SUSPEND);
  563. /* S-Suspend.ind(SUSPEND) */
  564. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  565. },
  566. SUSPENDED)
  568. ROW(CONNECTED,
  569. TR_Invoke_Ind,
  570. e->tcl == 2 && (pdu->type == Get || pdu->type == Post),
  571. {
  572. WSPMethodMachine *msm;
  573. WAPEvent *new_event;
  575. /* Start new method transaction */
  576. msm = method_machine_create(sm, e->handle);
  578. /* Hand off the event to the new method machine */
  579. handle_method_event(sm, msm, current_event, pdu);
  581. /* Release the new method transaction */
  582. new_event = wap_event_create(Release_Event);
  583. handle_method_event(sm, msm, new_event, NULL);
  584. wap_event_destroy(new_event);
  585. },
  586. CONNECTED)
  588. ROW(CONNECTED,
  589. TR_Invoke_Ind,
  590. e->tcl == 2 && pdu->type == Resume && !resume_enabled,
  591. {
  592. /* Resume facility disabled */
  594. /* TR-Abort.req(DISCONNECT) the TR-Invoke */
  595. send_abort(WSP_ABORT_DISCONNECT, e->handle);
  596. },
  597. CONNECTED)
  599. ROW(CONNECTED,
  600. TR_Invoke_Ind,
  601. e->tcl == 2 && pdu->type == Resume && resume_enabled,
  602. {
  603. /* Resume facility enabled */
  605. WAPEvent *wtp_event;
  606. List *new_headers;
  608. /* TR-Invoke.res */
  609. wtp_event = wap_event_create(TR_Invoke_Res);
  610. wtp_event->u.TR_Invoke_Res.handle = e->handle;
  611. dispatch_to_wtp_resp(wtp_event);
  613. /* Abort(RESUME) all method and push transactions */
  614. abort_methods(sm, WSP_ABORT_RESUME);
  616. /* S-Suspend.ind(RESUME) */
  617. indicate_suspend(sm, WSP_ABORT_RESUME);
  619. /* S-Resume.ind */
  620. new_headers = unpack_new_headers(sm, pdu->u.Resume.headers);
  621. indicate_resume(sm, e->addr_tuple, new_headers);
  622. http_destroy_headers(new_headers);
  624. sm->resume_handle = e->handle;
  625. },
  626. RESUMING)
  628. ROW(CONNECTED,
  629. TR_Invoke_Ind,
  630. e->tcl == 0 && pdu->type == Disconnect,
  631. {
  632. /* Abort(DISCONNECT) all method and push transactions */
  633. abort_methods(sm, WSP_ABORT_DISCONNECT);
  635. /* S-Disconnect.ind(DISCONNECT) */
  636. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  637. },
  638. NULL_SESSION)
  640. ROW(CONNECTED,
  641. TR_Invoke_Ind,
  642. e->tcl == 0 && pdu->type == Suspend && resume_enabled,
  643. {
  644. /* Abort(SUSPEND) all method and push transactions */
  645. abort_methods(sm, WSP_ABORT_SUSPEND);
  647. /* S-Suspend.ind(SUSPEND) */
  648. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  649. },
  650. SUSPENDED)
  652. ROW(CONNECTED,
  653.        TR_Invoke_Cnf,
  654.        1,
  655.        {
  656.                 /* See push state table*/
  657.                 WSPPushMachine *spm;
  659.                 spm = find_push_machine(sm, e->handle);
  660.                 handle_push_event(sm, spm, current_event);
  661.        },
  662.        CONNECTED)
  664. ROW(CONNECTED,
  665. TR_Result_Cnf,
  666. e->handle != sm->connect_handle,
  667. {
  668. WSPMethodMachine *msm;
  670. /* See method state table */
  671. msm = find_method_machine(sm, e->handle);
  672. handle_method_event(sm, msm, current_event, pdu);
  673. },
  674. CONNECTED)
  676. /* 
  677.  * Event TR-Abort.ind has a separate flag telling is the indicator the 
  678.  * initiator or the responder.
  679.  */
  680. ROW(CONNECTED,
  681. TR_Abort_Ind,
  682. e->handle != sm->connect_handle  && e->ir_flag == RESPONDER_INDICATION,
  683. {
  684. WSPMethodMachine *msm;
  686. /* See method state table */
  687. msm = find_method_machine(sm, e->handle);
  688. handle_method_event(sm, msm, current_event, pdu);
  689. },
  690. CONNECTED)
  692. ROW(CONNECTED,
  693. TR_Abort_Ind,
  694. e->handle != sm->connect_handle && e->ir_flag == INITIATOR_INDICATION,
  695. {
  696. WSPPushMachine *m;
  698. /* See push state table */
  699. m = find_push_machine(sm, e->handle);
  700. handle_push_event(sm, m, current_event);
  701. },
  702. CONNECTED)
  704. /* MISSING: SUSPENDED, S-Disconnect.req */
  706. ROW(SUSPENDED,
  707. Disconnect_Event,
  708. 1,
  709. {
  710. /* S-Disconnect.ind(DISCONNECT) */
  711. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  712. },
  713. NULL_SESSION)
  715. ROW(SUSPENDED,
  716. TR_Invoke_Ind,
  717. e->tcl == 2 && (pdu->type == Get || pdu->type == Post),
  718. {
  719. /* TR-Abort.req(SUSPEND) the TR-Invoke */
  720. send_abort(WSP_ABORT_SUSPEND, e->handle);
  721. },
  722. SUSPENDED)
  724. ROW(SUSPENDED,
  725. TR_Invoke_Ind,
  726. e->tcl == 2 && pdu->type == Resume,
  727. {
  728. WAPEvent *wtp_event;
  729. List *new_headers;
  731. /* TR-Invoke.res */
  732. wtp_event = wap_event_create(TR_Invoke_Res);
  733. wtp_event->u.TR_Invoke_Res.handle = e->handle;
  734. dispatch_to_wtp_resp(wtp_event);
  736. /* S-Resume.ind */
  737. new_headers = unpack_new_headers(sm, pdu->u.Resume.headers);
  738. indicate_resume(sm, e->addr_tuple, new_headers);
  739. http_destroy_headers(new_headers);
  742. sm->resume_handle = e->handle;
  743. },
  744. RESUMING)
  746. ROW(SUSPENDED,
  747. TR_Invoke_Ind,
  748. e->tcl == 0 && pdu->type == Disconnect,
  749. {
  750. /* S-Disconnect.ind(DISCONNECT) */
  751. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  752. },
  753. NULL_SESSION)
  755. /* MISSING: RESUMING, S-Disconnect.req */
  757. ROW(RESUMING,
  758. Disconnect_Event,
  759. 1,
  760. {
  761. /* TR-Abort.req(DISCONNECT) the Resume transaction */
  762. send_abort(WSP_ABORT_DISCONNECT, sm->resume_handle);
  764. /* Abort(DISCONNECT) all method transactions */
  765. abort_methods(sm, WSP_ABORT_DISCONNECT);
  767. /* S-Disconnect.ind(DISCONNECT) */
  768. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  769. },
  770. NULL_SESSION)
  772. ROW(RESUMING,
  773. S_Resume_Res,
  774. 1,
  775. {
  776. WAPEvent *wtp_event;
  777. Octstr *ospdu;
  779. /* Disconnect any other session for the peer address quadruplet */
  780. disconnect_other_sessions(sm);
  782. /* Bind session to new peer address quadruplet */
  783. /* this happens automatically XXX Not true */
  785. /* TR-Result.req(Reply) */
  786. if (e->server_headers == NULL)
  787. e->server_headers = http_create_empty_headers();
  789. ospdu = make_resume_reply_pdu(sm, e->server_headers);
  790. wtp_event = wap_event_create(TR_Result_Req);
  791. wtp_event->u.TR_Result_Req.user_data = ospdu;
  792. wtp_event->u.TR_Result_Req.handle = sm->resume_handle;
  793. dispatch_to_wtp_resp(wtp_event);
  795. /* Release all method transactions in HOLDING state */
  796. release_holding_methods(sm);
  797. },
  798. RESUMING_2)
  800. ROW(RESUMING,
  801. Suspend_Event,
  802. 1,
  803. {
  804. /* TR-Abort.req(SUSPEND) the Resume transaction */
  805. send_abort(WSP_ABORT_SUSPEND, sm->resume_handle);
  807. /* Abort(SUSPEND) all method transactions */
  808. abort_methods(sm, WSP_ABORT_SUSPEND);
  810. /* S-Suspend.ind(SUSPEND) */
  811. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  812. },
  813. SUSPENDED)
  815. ROW(RESUMING,
  816. TR_Invoke_Ind,
  817. e->tcl == 2 && (pdu->type == Get || pdu->type == Post),
  818. {
  819. /* Start new method transaction (see method state table) */
  820. WSPMethodMachine *msm;
  821. msm = method_machine_create(sm, e->handle);
  822. handle_method_event(sm, msm, current_event, pdu);
  823. },
  824. RESUMING)
  826. ROW(RESUMING,
  827. TR_Invoke_Ind,
  828. e->tcl == 2 && pdu->type == Resume,
  829. {
  830. WAPEvent *wtp_event;
  831. List *new_headers;
  833. /* TR-Invoke.res */
  834. wtp_event = wap_event_create(TR_Invoke_Res);
  835. wtp_event->u.TR_Invoke_Res.handle = e->handle;
  836. dispatch_to_wtp_resp(wtp_event);
  838. /* TR-Abort.req(RESUME) the old Resume transaction */
  839. send_abort(WSP_ABORT_RESUME, sm->resume_handle);
  841. /* Abort(RESUME) all method transactions */
  842. abort_methods(sm, WSP_ABORT_RESUME);
  844. /* S-Suspend.ind(RESUME) */
  845. indicate_suspend(sm, WSP_ABORT_RESUME);
  847. /* S-Resume.ind */
  848. new_headers = unpack_new_headers(sm, pdu->u.Resume.headers);
  849. indicate_resume(sm, e->addr_tuple, new_headers);
  850. http_destroy_headers(new_headers);
  853. sm->resume_handle = e->handle;
  854. },
  855. RESUMING)
  857. ROW(RESUMING,
  858. TR_Invoke_Ind,
  859. e->tcl == 0 && pdu->type == Suspend,
  860. {
  861. /* TR-Abort.req(SUSPEND) the Resume transaction */
  862. send_abort(WSP_ABORT_SUSPEND, sm->resume_handle);
  864. /* Abort(SUSPEND) all method transactions */
  865. abort_methods(sm, WSP_ABORT_SUSPEND);
  867. /* S-Suspend.ind(SUSPEND) */
  868. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  869. },
  870. SUSPENDED)
  872. ROW(RESUMING,
  873. TR_Invoke_Ind,
  874. e->tcl == 0 && pdu->type == Disconnect,
  875. {
  876. /* TR-Abort.req(DISCONNECT) the Resume transaction */
  877. send_abort(WSP_ABORT_DISCONNECT, sm->resume_handle);
  879. /* Abort(DISCONNECT) all method transactions */
  880. abort_methods(sm, WSP_ABORT_DISCONNECT);
  882. /* S-Disconnect.ind(DISCONNECT) */
  883. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  884. },
  885. NULL_SESSION)
  887. ROW(RESUMING,
  888. TR_Abort_Ind,
  889. e->handle == sm->resume_handle,
  890. {
  891. /* Abort(SUSPEND) all method transactions */
  892. abort_methods(sm, WSP_ABORT_SUSPEND);
  894. /* S-Suspend.ind(abort reason) */
  895. indicate_suspend(sm, e->abort_code);
  896. },
  897. SUSPENDED)
  899. /* MISSING: RESUMING_2, S-Disconnect.req */
  901. ROW(RESUMING_2,
  902. Disconnect_Event,
  903. 1,
  904. {
  905. /* TR-Abort.req(DISCONNECT) the Resume */
  906. send_abort(WSP_ABORT_DISCONNECT, sm->resume_handle);
  908. /* Abort(DISCONNECT) all method and push transactions */
  909. abort_methods(sm, WSP_ABORT_DISCONNECT);
  911. /* S-Disconnect.ind(DISCONNECT) */
  912. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  913. },
  914. NULL_SESSION)
  916. ROW(RESUMING_2,
  917. S_MethodInvoke_Res,
  918. 1,
  919. {
  920. WSPMethodMachine *msm;
  922. /* See method state table */
  923. msm = find_method_machine(sm, e->server_transaction_id);
  924. handle_method_event(sm, msm, current_event, pdu);
  925. },
  926. RESUMING_2)
  928. ROW(RESUMING_2,
  929. S_MethodResult_Req,
  930. 1,
  931. {
  932. WSPMethodMachine *msm;
  934. /* See method state table */
  935. msm = find_method_machine(sm, e->server_transaction_id);
  936. handle_method_event(sm, msm, current_event, pdu);
  937. },
  938. RESUMING_2)
  940. ROW(RESUMING_2,
  941.         S_Push_Req,
  942.         1,
  943.         {
  944.                 WSP_PDU *pdu;
  946.                 pdu = make_push_pdu(current_event);
  947.                 send_invoke(sm, pdu, current_event, TRANSACTION_CLASS_0);
  948.         },
  949.         RESUMING_2)
  951. ROW(RESUMING_2,
  952.         S_ConfirmedPush_Req,
  953.         1,
  954.         {
  955.                 /* Start new push transaction*/
  956.                 WSPPushMachine *spm;
  958.                 spm = push_machine_create(sm, e->server_push_id);
  959.                 handle_push_event(sm, spm, current_event);
  960.         },
  961.         RESUMING_2)
  963. ROW(RESUMING_2,
  964. Suspend_Event,
  965. 1,
  966. {
  967. /* TR-Abort.req(SUSPEND) the Resume transaction */
  968. send_abort(WSP_ABORT_SUSPEND, sm->resume_handle);
  970. /* Abort(SUSPEND) all method and push transactions */
  971. abort_methods(sm, WSP_ABORT_SUSPEND);
  973. /* S-Suspend.ind(SUSPEND) */
  974. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  975. },
  976. SUSPENDED)
  978. ROW(RESUMING_2,
  979. TR_Invoke_Ind,
  980. e->tcl == 2 && (pdu->type == Get || pdu->type == Post),
  981. {
  982. WSPMethodMachine *msm;
  983. WAPEvent *new_event;
  985. /* Start new method transaction (see method state table) */
  986. msm = method_machine_create(sm, e->handle);
  987. handle_method_event(sm, msm, current_event, pdu);
  989. /* Release the new method transaction */
  990. new_event = wap_event_create(Release_Event);
  991. handle_method_event(sm, msm, new_event, NULL);
  992. wap_event_destroy(new_event);
  993. },
  994. RESUMING_2)
  996. ROW(RESUMING_2,
  997. TR_Invoke_Ind,
  998. e->tcl == 2 && pdu->type == Resume,
  999. {
  1000. WAPEvent *wtp_event;
  1001. List *new_headers;
  1003. /* TR-Invoke.res */
  1004. wtp_event = wap_event_create(TR_Invoke_Res);
  1005. wtp_event->u.TR_Invoke_Res.handle = e->handle;
  1006. dispatch_to_wtp_resp(wtp_event);
  1008. /* TR-Abort.req(RESUME) the old Resume transaction*/
  1009. send_abort(WSP_ABORT_RESUME, sm->resume_handle);
  1011. /* Abort(RESUME) all method and push transactions */
  1012. abort_methods(sm, WSP_ABORT_RESUME);
  1014. /* S-Suspend.ind(RESUME) */
  1015. indicate_suspend(sm, WSP_ABORT_RESUME);
  1017. /* S-Resume.ind */
  1018. new_headers = unpack_new_headers(sm, pdu->u.Resume.headers);
  1019. indicate_resume(sm, e->addr_tuple, new_headers);
  1020. http_destroy_headers(new_headers);
  1023. sm->resume_handle = e->handle;
  1024. },
  1025. RESUMING)
  1027. ROW(RESUMING_2,
  1028. TR_Invoke_Ind,
  1029. e->tcl == 0 && pdu->type == Suspend,
  1030. {
  1031. /* TR-Abort.req(SUSPEND) the Resume transaction */
  1032. send_abort(WSP_ABORT_SUSPEND, sm->resume_handle);
  1034. /* Abort(SUSPEND) all method and push transactions */
  1035. abort_methods(sm, WSP_ABORT_SUSPEND);
  1037. /* S-Suspend.ind(SUSPEND) */
  1038. indicate_suspend(sm, WSP_ABORT_SUSPEND);
  1039. },
  1040. SUSPENDED)
  1042. ROW(RESUMING_2,
  1043. TR_Invoke_Ind,
  1044. e->tcl == 0 && pdu->type == Disconnect,
  1045. {
  1046. /* TR-Abort.req(DISCONNECT) the Resume */
  1047. send_abort(WSP_ABORT_DISCONNECT, sm->resume_handle);
  1049. /* Abort(DISCONNECT) all method and push transactions */
  1050. abort_methods(sm, WSP_ABORT_DISCONNECT);
  1052. /* S-Disconnect.ind(DISCONNECT) */
  1053. indicate_disconnect(sm, WSP_ABORT_DISCONNECT);
  1054. },
  1055. NULL_SESSION)
  1057. ROW(RESUMING_2,
  1058.         TR_Invoke_Cnf,
  1059.         1,
  1060.         {
  1061.                 /* See push state table*/
  1062.                 WSPPushMachine *spm;
  1064.                 spm = find_push_machine(sm, e->handle);
  1065.                 handle_push_event(sm, spm, current_event);
  1066.         },
  1067.         RESUMING_2)
  1069. ROW(RESUMING_2,
  1070. TR_Result_Cnf,
  1071. e->handle == sm->resume_handle,
  1072. {
  1073. },
  1074. CONNECTED)
  1076. ROW(RESUMING_2,
  1077. TR_Result_Cnf,
  1078. e->handle != sm->resume_handle,
  1079. {
  1080. WSPMethodMachine *msm;
  1082. /* See method state table */
  1083. msm = find_method_machine(sm, e->handle);
  1084. handle_method_event(sm, msm, current_event, pdu);
  1085. },
  1086. RESUMING_2)
  1088. ROW(RESUMING_2,
  1089. TR_Abort_Ind,
  1090. e->handle == sm->resume_handle,
  1091. {
  1092. /* Abort(SUSPEND) all method and push transactions */
  1093. abort_methods(sm, WSP_ABORT_SUSPEND);
  1095. /* S-Suspend.ind(abort reason) */
  1096. indicate_suspend(sm, e->abort_code);
  1097. },
  1098. SUSPENDED)
  1100. /* 
  1101.  * A separate flag tells is the indicator the initiator or the responder
  1102.  */
  1104. ROW(RESUMING_2,
  1105. TR_Abort_Ind,
  1106. e->handle != sm->resume_handle && e->ir_flag == RESPONDER_INDICATION,
  1107. {
  1108. WSPMethodMachine *msm;
  1110. /* See method state table */
  1111. msm = find_method_machine(sm, e->handle);
  1112. handle_method_event(sm, msm, current_event, pdu);
  1113. },
  1114. RESUMING_2)
  1116. ROW(CONNECTING_2,
  1117. TR_Abort_Ind,
  1118. e->handle != sm->connect_handle && e->ir_flag == INITIATOR_INDICATION,
  1119. {
  1120. WSPPushMachine *m;
  1122. /* See push state table */
  1123. m = find_push_machine(sm, e->handle);
  1124. handle_push_event(sm, m, current_event);
  1125. },
  1126. CONNECTING_2)
  1128. #undef ROW
  1129. #undef STATE_NAME