446 lines
12 KiB
C
446 lines
12 KiB
C
#include "selfcare_proxy.h"
|
||
#include "utils_queue.h"
|
||
#include "selfcare_udp.h"
|
||
#include "selfcare_endecode.h"
|
||
#include "selfcare_res.h"
|
||
#include "log.h"
|
||
|
||
extern int get_proxy_run_mode();
|
||
extern int rest_query_recharge_card_proc( struct rest_msg_s *rest_ptr);
|
||
extern int rest_query_tariff_proc(struct rest_msg_s *rest_ptr);
|
||
extern int rest_update_plan_info_proc(struct rest_msg_s *rest_ptr);
|
||
extern int rest_update_ocs_del_result(struct rest_msg_s *rest_ptr);
|
||
extern int rest_rent_charge_behalf_on_ocs(struct rest_msg_s *rest_ptr);
|
||
extern int rest_update_subs_info_proc(struct rest_msg_s *rest_ptr);
|
||
static int _httpserv_handle_udpresp(char *buff, int len)
|
||
{
|
||
/* ½âÂëocs·¢ËÍÀ´»Ø¸´µÄudpÏûÏ¢ */
|
||
int ret;
|
||
_rest_msg_s msg;
|
||
memset(&msg, 0x00, sizeof(msg));
|
||
ret = decode_rest_api_msg((u8*)buff, len, &msg);
|
||
if(ret != 1)
|
||
{
|
||
LOG_E("[udp-handle] decode ocs resp err.ret[%d]\n", ret);
|
||
return ret;
|
||
}
|
||
|
||
if(get_proxy_run_mode() == 4)//OCS+CRM mode
|
||
{
|
||
if(msg.msg_type == REST_UPDATE_RECHARGE_CARD_REQ)
|
||
{
|
||
LOG_E("[udp-handle] proc ocs REST_UPDATE_RECHARGE_CARD_REQ\n");
|
||
|
||
rest_query_recharge_card_proc(&msg);
|
||
|
||
return ret;
|
||
}
|
||
|
||
if(msg.msg_type == REST_CRM_QUERY_TARIFF_REQ)
|
||
{
|
||
// LOG_E("[udp-handle] proc ocs REST_CRM_QUERY_TARIFF_REQ\n");
|
||
|
||
rest_query_tariff_proc(&msg);
|
||
|
||
return ret;
|
||
}
|
||
|
||
if(msg.msg_type == REST_CRM_UPDATE_PLAN_INFO_REQ)
|
||
{
|
||
// LOG_E("[udp-handle] proc ocs REST_CRM_UPDATE_PLAN_INFO_REQ\n");
|
||
|
||
rest_update_plan_info_proc( &msg);
|
||
|
||
return ret;
|
||
}
|
||
|
||
if(msg.msg_type == REST_CRM_DELETE_SUBS_RES)
|
||
{
|
||
// LOG_E("[udp-handle] proc ocs REST_CRM_DELETE_SUBS_RES\n");
|
||
|
||
rest_update_ocs_del_result( &msg);
|
||
|
||
return ret;
|
||
}
|
||
if(msg.msg_type == REST_CRM_RENT_CHARGE)
|
||
{
|
||
// LOG_E("[udp-handle] proc ocs REST_CRM_RENT_CHARGE\n");
|
||
|
||
rest_rent_charge_behalf_on_ocs( &msg);
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
if(msg.msg_type == REST_CRM_UPDATE_SUBS_REQ)
|
||
{
|
||
// LOG_E("[udp-handle] proc ocs REST_CRM_UPDATE_SUBS_INFO_REQ\n");
|
||
|
||
rest_update_subs_info_proc( &msg);
|
||
|
||
return ret;
|
||
}
|
||
|
||
|
||
|
||
}
|
||
|
||
int res_id = msg.header.dst_ref;
|
||
if(res_id >= SELFCARE_RES_NUM)
|
||
{
|
||
LOG_E("[udp-handle] proc ocs resp err. res_id[%d], msg_type=%d\n", res_id, msg.msg_type);
|
||
return FAILURE;
|
||
}
|
||
|
||
if(g_res_arr[res_id].state != SELFCARE_WAIT_OCS_RESP)
|
||
{
|
||
LOG_E("[udp-handle] recv udp err.res_id[%d] state[%s] expect[%s] \n",
|
||
res_id,
|
||
selfcare_res_stateprint(g_res_arr[res_id].state),
|
||
selfcare_res_stateprint(SELFCARE_WAIT_OCS_RESP) );
|
||
return SUCCESS;
|
||
}
|
||
|
||
_rest_msg_s *resp = &g_res_arr[res_id].resp;
|
||
memcpy(resp, &msg, sizeof(msg));
|
||
if(g_res_arr[res_id].local_init_flag == 1)
|
||
g_res_arr[res_id].state = SELFCARE_LOCAL_INIT_RESP;
|
||
else
|
||
g_res_arr[res_id].state = SELFCARE_WAIT_SEND2SELFCARE_RESP;
|
||
|
||
LOG_D("[udp-handle] recv udp suc.res_id[%d] state[%s=>%s]\n",
|
||
res_id,
|
||
selfcare_res_stateprint(SELFCARE_WAIT_OCS_RESP),
|
||
selfcare_res_stateprint(g_res_arr[res_id].state) );
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
static int _httpserv_handle_httpreq(struct evhttp_request *req, void *arg, SELFCARE_URL_E req_type)
|
||
{
|
||
int ret;
|
||
|
||
ret = selfcare_httpsrv_check(req, arg);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] check failed\n");
|
||
return ret;
|
||
}
|
||
|
||
int res_id;
|
||
ret = selfcare_res_get(&res_id);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_D("[httpserv] no res.\n");
|
||
// send http-resp failed
|
||
return ret;
|
||
}
|
||
|
||
selfcare_res_s *res = &g_res_arr[res_id];
|
||
memset(res, 0x00, sizeof(selfcare_res_s));
|
||
res->id = res_id;
|
||
res->state = SELFCARE_WAIT_SEND2OCS_REQ;
|
||
res->req = req;
|
||
res->arg = arg;
|
||
res->req_type = req_type;
|
||
|
||
LOG_D("[httpserv] res_id[%d] get suc. state[%s] for type[%d]\n", res->id, selfcare_res_stateprint(res->state), req_type);
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
selfcare_res_s *selfcare_assign_res()
|
||
{
|
||
int res_id, ret;
|
||
selfcare_res_s *res=NULL;
|
||
|
||
ret = selfcare_res_get(&res_id);
|
||
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_D("[httpserv] no res.\n");
|
||
return NULL;
|
||
}
|
||
|
||
res = &g_res_arr[res_id];
|
||
memset(res, 0x00, sizeof(selfcare_res_s));
|
||
res->id = res_id;
|
||
|
||
LOG_D("[httpserv] res_id[%d] get suc. state[%s]\n", res->id, selfcare_res_stateprint(res->state));
|
||
|
||
return res;
|
||
}
|
||
|
||
static void _httpserv_handle_authcode(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_AUTHCODE);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle authcode err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle authcode suc.req[%p]\n", req);
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_queryuserdata(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_QUERY_USERDATA);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle queryuserdata err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle queryuserdata suc.\n");
|
||
return ;
|
||
}
|
||
static void _httpserv_handle_bundlesubs(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_BUNDLE_SUBS);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle bundlesubs err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle bundlesubs suc.\n");
|
||
return ;
|
||
}
|
||
static void _httpserv_handle_bundleusage(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_BUNDLE_USAGE);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle bundleusage err.\n");
|
||
return;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle bundleusage suc.\n");
|
||
return ;
|
||
}
|
||
static void _httpserv_handle_recharge(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_RECHARGE);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle recharge err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle recharge suc.\n");
|
||
return ;
|
||
}
|
||
static void _httpserv_handle_transfer(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_TRANSFER);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle transfer err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle transfer suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_rechargecard(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_RECHARGE_CARD );
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle rechargecard err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle rechargecard suc.\n");
|
||
return ;
|
||
}
|
||
static void _httpserv_handle_checkbalance(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_CHECK_BALANCE );
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle checkbalance err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle checkbalance suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_querybalane(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_QUERY_BALANCE );
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle querybalane err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle querybalane suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_payment(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_CRM_PAYMENT );
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle crm payment err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle crm payment suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_smsdeliver(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_SMS_DELIVER);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle sms_deliver err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle sms_deliver suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_createaccount(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_CREATE_ACCT);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] handle create_account err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] handle create_account suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_updatesubs(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_UPDATE_SUBS);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] _httpserv_handle_updatesubs err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] _httpserv_handle_updatesubs suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static void _httpserv_handle_deletesubs(struct evhttp_request *req, void *arg)
|
||
{
|
||
int ret;
|
||
ret = _httpserv_handle_httpreq(req, arg, SELFCARE_DELETE_SUBS);
|
||
if(ret != SUCCESS)
|
||
{
|
||
LOG_E("[httpserv] _httpserv_handle_updatesubs err.\n");
|
||
return ;
|
||
}
|
||
|
||
LOG_D("[httpserv] _httpserv_handle_updatesubs suc.\n");
|
||
return ;
|
||
}
|
||
|
||
static int _selfcare_proxy_reg(const SELFCARE_URL_E url_type,
|
||
const char *url_addr,
|
||
void (*handle)(struct evhttp_request *req, void *arg) )
|
||
{
|
||
selfcare_elem_s elem;
|
||
memset(&elem, 0x00, sizeof(elem));
|
||
|
||
elem.url_type = url_type;
|
||
strncpy(elem.url_addr, url_addr, SELFCARE_URL_LEN);
|
||
elem.handle = handle;
|
||
|
||
return selfcare_httpsrv_reg(&elem);
|
||
}
|
||
|
||
|
||
int selfcare_proxy_init(int argc, char **argv)
|
||
{
|
||
int ret;
|
||
/* ³õʼ»¯ÅäÖà */
|
||
ret = selfcare_config_init(NULL);
|
||
if(ret != SUCCESS)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* ³õʼ»¯udp socket */
|
||
ret = selfcare_udp_init();
|
||
if(ret != SUCCESS)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
/* ×¢²áselfcareÇëÇó»Øµ÷º¯Êý */
|
||
ret = _selfcare_proxy_reg(SELFCARE_AUTHCODE, selfcare_config_get()->authcode_url, _httpserv_handle_authcode);
|
||
ret += _selfcare_proxy_reg(SELFCARE_QUERY_USERDATA, selfcare_config_get()->query_userdata_url, _httpserv_handle_queryuserdata);
|
||
ret += _selfcare_proxy_reg(SELFCARE_BUNDLE_SUBS, selfcare_config_get()->bundle_subs_url, _httpserv_handle_bundlesubs);
|
||
ret += _selfcare_proxy_reg(SELFCARE_BUNDLE_USAGE, selfcare_config_get()->bundle_usage_url, _httpserv_handle_bundleusage);
|
||
ret += _selfcare_proxy_reg(SELFCARE_RECHARGE, selfcare_config_get()->recharge_url, _httpserv_handle_recharge);
|
||
ret += _selfcare_proxy_reg(SELFCARE_TRANSFER, selfcare_config_get()->transfer_url, _httpserv_handle_transfer);
|
||
ret += _selfcare_proxy_reg(SELFCARE_RECHARGE_CARD, selfcare_config_get()->recharge_card_url, _httpserv_handle_rechargecard);
|
||
ret += _selfcare_proxy_reg(SELFCARE_CHECK_BALANCE, selfcare_config_get()->check_balance_url, _httpserv_handle_checkbalance);
|
||
ret += _selfcare_proxy_reg(SELFCARE_QUERY_BALANCE, selfcare_config_get()->query_balane_url, _httpserv_handle_querybalane);
|
||
ret += _selfcare_proxy_reg(SELFCARE_CRM_PAYMENT, selfcare_config_get()->payment_url , _httpserv_handle_payment);
|
||
ret += _selfcare_proxy_reg(SELFCARE_SMS_DELIVER, selfcare_config_get()->sms_deliver_url, _httpserv_handle_smsdeliver);
|
||
ret += _selfcare_proxy_reg(SELFCARE_CREATE_ACCT, selfcare_config_get()->create_account_url, _httpserv_handle_createaccount);
|
||
ret += _selfcare_proxy_reg(SELFCARE_UPDATE_SUBS, selfcare_config_get()->update_subs_url, _httpserv_handle_updatesubs);
|
||
ret += _selfcare_proxy_reg(SELFCARE_DELETE_SUBS, selfcare_config_get()->delete_subs_url, _httpserv_handle_deletesubs);
|
||
|
||
/* ×¢²áocs udpÏûÏ¢»Øµ÷º¯Êý */
|
||
selfcare_udp_handle_s handle;
|
||
handle.handle = _httpserv_handle_udpresp;
|
||
ret = selfcare_udp_reg(&handle);
|
||
if(ret != SUCCESS)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
ret = selfcare_res_init(argc, argv);
|
||
if(ret != SUCCESS)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
ret = selfcare_httpsrv_init(argc, argv);
|
||
if(ret != SUCCESS)
|
||
{
|
||
return ret;
|
||
}
|
||
|
||
return SUCCESS;
|
||
}
|
||
|
||
void selfcare_proxy_uninit(void)
|
||
{
|
||
selfcare_config_uninit();
|
||
selfcare_udp_uninit();
|
||
selfcare_httpsrv_uninit();
|
||
|
||
selfcare_res_uninit();
|
||
}
|
||
|