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

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

手机WAP编程

开发平台：

WINDOWS

wtls-secmgr.c：源码内容
  1. /*
  2.  * gw/wtls-secmgr.c - wapbox wtls security manager
  3.  *
  4.  * The security manager's interface consists of two functions:
  5.  *
  6.  *      wtls_secmgr_start()
  7.  *              This starts the security manager thread.
  8.  *
  9.  *      wtls_secmgr_dispatch(event)
  10.  *              This adds a new event to the security manager's event
  11.  *              queue.
  12.  *
  13.  * The wtls security manager is a thread that reads events from its event
  14.  * queue, and feeds back events to the WTLS layer. Here is where various
  15.  * approvals or rejections are made to requested security settings.
  16.  *
  17.  */
  19. #include <string.h>
  21. #include "gwlib/gwlib.h"
  23. #if (HAVE_WTLS_OPENSSL)
  25. #include "wtls.h"
  27. /*
  28.  * Give the status the module:
  29.  *
  30.  *      limbo
  31.  *              not running at all
  32.  *      running
  33.  *              operating normally
  34.  *      terminating
  35.  *              waiting for operations to terminate, returning to limbo
  36.  */
  37. static enum { limbo, running, terminating } run_status = limbo;
  40. /*
  41.  * The queue of incoming events.
  42.  */
  43. static List *secmgr_queue = NULL;
  45. /*
  46.  * Private functions.
  47.  */
  49. static void main_thread(void *);
  51. /***********************************************************************
  52.  * The public interface to the application layer.
  53.  */
  55. void wtls_secmgr_init(void) {
  56.         gw_assert(run_status == limbo);
  57.         secmgr_queue = list_create();
  58.         list_add_producer(secmgr_queue);
  59.         run_status = running;
  60.         gwthread_create(main_thread, NULL);
  61. }
  64. void wtls_secmgr_shutdown(void) {
  65.         gw_assert(run_status == running);
  66.         list_remove_producer(secmgr_queue);
  67.         run_status = terminating;
  68.         
  69.         gwthread_join_every(main_thread);
  70.         
  71.         list_destroy(secmgr_queue, wap_event_destroy_item);
  72. }
  75. void wtls_secmgr_dispatch(WAPEvent *event) {
  76.         gw_assert(run_status == running);
  77.         list_produce(secmgr_queue, event);
  78. }
  81. long wtls_secmgr_get_load(void) {
  82.         gw_assert(run_status == running);
  83.         return list_len(secmgr_queue);
  84. }
  87. /***********************************************************************
  88.  * Private functions.
  89.  */
  92. static void main_thread(void *arg) {
  93.         WAPEvent *ind, *res, *req, *term;
  94.         
  95.         while (run_status == running && (ind = list_consume(secmgr_queue)) != NULL) {
  96.                 switch (ind->type) {
  97.                 case SEC_Create_Ind:
  98.                         /* Process the cipherlist */
  99.                         /* Process the MAClist */
  100.                         /* Process the PKIlist */
  101.                         /* Dispatch a SEC_Create_Res */
  102.                         res = wap_event_create(SEC_Create_Res);
  103.                         res->u.SEC_Create_Res.addr_tuple =
  104.                                 wap_addr_tuple_duplicate(ind->u.SEC_Create_Ind.addr_tuple);
  105.                         wtls_dispatch_event(res);
  106.                         debug("wtls_secmgr : main_thread", 0,"Dispatching SEC_Create_Res event");
  107.                         /* Dispatch a SEC_Exchange_Req or maybe a SEC_Commit_Req */
  108.                         req = wap_event_create(SEC_Exchange_Req);
  109.                         req->u.SEC_Exchange_Req.addr_tuple =
  110.                                 wap_addr_tuple_duplicate(ind->u.SEC_Create_Ind.addr_tuple);
  111.                         wtls_dispatch_event(req);
  112.                         debug("wtls_secmgr : main_thread", 0,"Dispatching SEC_Exchange_Req event");
  113.                         wap_event_destroy(ind);
  114.                         break;
  115.                 case SEC_Terminate_Req:
  116.                         /* Dispatch a SEC_Terminate_Req */
  117.                         term = wap_event_create(SEC_Terminate_Req);
  118.                         term->u.SEC_Terminate_Req.addr_tuple =
  119.                                 wap_addr_tuple_duplicate(ind->u.SEC_Create_Ind.addr_tuple);
  120.                         term->u.SEC_Terminate_Req.alert_desc = 0;
  121.                         term->u.SEC_Terminate_Req.alert_level = 3;
  122.                        wtls_dispatch_event(term);
  123.                 default:
  124.                         panic(0, "WTLS-secmgr: Can't handle %s event",
  125.                               wap_event_name(ind->type));
  126.                         break;
  127.                 }
  128.         }
  129. }
  131. #endif