ocs init

plat/radius/src/radius_fsm.c

@@ -0,0 +1,340 @@
+#include "./include/radius_pub.h"
+
+#define	test_nowsms_enable		0
+#define test_css_enable			0
+
+#define radius_set_pid_state(val) do { \
+	pid_ptr->state = val; \
+	radius_log_event("[%05d] \33[32m%s\33[0m transfer to state \33[36m%s\33[0m\r\n", pid, __FUNCTION__, #val); \
+} while(0)
+
+#define radius_set_pid_timer(val) do { \
+	pid_ptr->timer = val; \
+} while(0)
+
+#if(test_nowsms_enable)
+static void radius_test(int pid, BYTE sap_index, WORD *usr_pid, RADIUS_MSG *ptr_radius)
+{
+	RADIUS_MSG				pdu;
+
+	if(usr_pid == NULL || ptr_radius == NULL)
+		return;
+	memset(&pdu, 0, sizeof(RADIUS_MSG));
+	pdu.msg_type = RADIUS_MSG_TYPE_ACCESS_ACCEPT;
+	pdu.msg.access_accept.message_authenticator.flag = 1;
+	radius_send_access_accept(sap_index, pid, *usr_pid, &pdu);
+	return;
+}
+#elif(test_css_enable)
+static void radius_test(int pid, BYTE sap_index, WORD *usr_pid, RADIUS_MSG *ptr_radius)
+{
+	static BYTE				user_id = 0;
+	BYTE					count = 0;
+	int						num, i;
+	RADIUS_MSG				pdu;
+	RADIUS_ACCESS_ACCEPT	*access_accept;
+	RADIUS_VENDOR_SPECIFIC	*vendor_specific;
+	RADIUS_VENDOR_ATTRIBUTE_3GPP2_PPAC		*ppac;
+	RADIUS_VENDOR_ATTRIBUTE_3GPP2_PPAQ		*ppaq;
+
+	if(usr_pid == NULL || ptr_radius == NULL)
+		return;
+	if(ptr_radius->msg.access_request.user_password.flag == 1)
+	{
+		count = 1;
+		*usr_pid = user_id;
+		user_id++;
+	}
+	else if((num = ptr_radius->msg.access_request.vendor_specific.num) > 0)
+	{
+		for(i = 0; i < num; i++)
+		{
+			vendor_specific = &ptr_radius->msg.access_request.vendor_specific;
+			ppaq = &vendor_specific->vendor_specific[i].attribute_3gpp2.ppaq;
+			if((vendor_specific->vendor_specific[i].vendor_type == RADIUS_VENDOR_TYPE_3GPP2_PPAQ) && (ppaq->qid.flag == 1))
+			{
+				*usr_pid = (ppaq->qid.qid.value >> 16) & 0xFF;
+				count = (ppaq->qid.qid.value & 0xFF) + 1;
+			}
+		}
+	}
+	
+	memset(&pdu, 0, sizeof(RADIUS_MSG));
+	pdu.msg_type = RADIUS_MSG_TYPE_ACCESS_ACCEPT;
+	access_accept = &pdu.msg.access_accept;
+	vendor_specific = &access_accept->vendor_specific;
+	num = vendor_specific->num;
+	vendor_specific->vendor_specific[num].flag = 1;
+	vendor_specific->vendor_specific[num].vendor_type = RADIUS_VENDOR_TYPE_3GPP2_PPAC;
+	ppac = &vendor_specific->vendor_specific[num].attribute_3gpp2.ppac;
+	ppac->sfs.flag = 1;
+	//ppac->sfs.sfs = 2;	//dt && dq
+	ppac->sfs.sfs = 1;	//vt && vq
+	vendor_specific->num++;
+	num = vendor_specific->num;
+	vendor_specific->vendor_specific[num].vendor_type = RADIUS_VENDOR_TYPE_3GPP2_PPAQ;
+	ppaq = &vendor_specific->vendor_specific[num].attribute_3gpp2.ppaq;
+	ppaq->qid.flag = 1;
+	ppaq->qid.qid.value = ((*usr_pid) << 16) | (count * 1);
+
+	if(ppac->sfs.sfs == 1)
+	{
+		ppaq->vq.flag = 1;
+		ppaq->vq.vq.integer = (count + 1) * 1024 * 20;
+		ppaq->vq.vq.exponent = 1;
+		ppaq->vt.flag = 1;
+		ppaq->vt.vt.integer = (count + 1) * 1024 * 20 - 1024 * 2;
+		ppaq->vt.vt.exponent = 1;
+	}
+	else if(ppac->sfs.sfs == 2)
+	{
+		ppaq->dq.flag = 1;
+		ppaq->dq.dq.value = count * 20;
+		ppaq->dt.flag = 1;
+		ppaq->dt.dt.value = count * 20 - 2;
+	}
+	
+	vendor_specific->num++;
+	access_accept->message_authenticator.flag = 1;
+	radius_send_access_accept(sap_index, pid, *usr_pid, &pdu);
+	return;
+}
+#endif
+
+int radius_pid_indication_process(int pid)
+{
+	BYTE		sap_index;
+	RADIUS_PID	*pid_ptr;
+
+	pid_ptr = radius_get_pid_ptr(pid);
+
+	sap_index = pid_ptr->sap_index;
+
+	switch (pid_ptr->state)
+	{
+	case RADIUS_PID_IND_STATE_IDLE:
+		if (pid_ptr->rv_msg_flag != 0)
+		{
+			pid_ptr->rv_msg_flag = 0;
+
+			if (radius_sap[sap_index].radius_ind == NULL)
+				return 1;
+#if(test_nowsms_enable || test_css_enable)
+{
+			radius_test(pid, sap_index, &pid_ptr->usr_pid, &radius_msg_pdu);
+}
+#else
+			if (radius_sap[sap_index].radius_ind(&pid_ptr->usr_pid, pid, &radius_msg_pdu) < 0)
+			{
+				radius_log_err("[%04d] %s: radius_ind error! usr_pid=%d\r\n", pid, __FUNCTION__, pid_ptr->usr_pid);
+				return 1;
+			}
+#endif
+			radius_log_event("[%04d] %s: recv indication and send it to up layer\r\n", pid, __FUNCTION__);
+
+			radius_set_pid_state(RADIUS_PID_IND_STATE_WAIT_FOR_USER_RESP);
+			radius_set_pid_timer(RADIUS_TIMER_16S);
+		}
+		else
+		{
+			return 1;
+		}
+		break;
+	case RADIUS_PID_IND_STATE_WAIT_FOR_USER_RESP:
+		if (pid_ptr->sd_msg_flag == 1)
+		{
+			pid_ptr->sd_msg_flag = 0;
+
+			radius_send_msg(pid);
+
+			radius_set_pid_timer(RADIUS_TIMER_16S);
+
+			radius_set_pid_state(RADIUS_PID_IND_STATE_WAIT_FOR_TERMINATE);
+
+			break;
+		}
+
+		if (pid_ptr->timer > 0)
+		{
+			if (--pid_ptr->timer == 0)
+			{
+				radius_log_warn("[%04d] %s: wait user response time out\r\n", pid, __FUNCTION__);
+				radius_set_pid_state(RADIUS_PID_IND_STATE_TERMINATE);
+
+				return 1;
+			}
+		}
+		break;
+	case RADIUS_PID_IND_STATE_WAIT_FOR_TERMINATE:
+		if (pid_ptr->rv_msg_flag != 0)
+		{
+			radius_send_msg(pid);
+
+			pid_ptr->rv_msg_flag = 0;
+		}
+
+		if (pid_ptr->timer > 0)
+		{
+			if (--pid_ptr->timer == 0)
+			{
+				radius_set_pid_state(RADIUS_PID_IND_STATE_TERMINATE);
+				return 1;
+			}
+		}
+		break;
+	}
+
+	return 0;
+}
+
+int radius_pid_indication_fsm(int pid)
+{
+	switch (radius_pid_indication_process(pid))
+	{
+	case 0:
+		break;
+	case 1:
+		radius_init_pid(pid);
+		break;
+	}
+
+	return 0;
+}
+
+int radius_pid_request_process(int pid)
+{
+	BYTE			sap_index;
+	RADIUS_PID		*pid_ptr;
+
+	pid_ptr = radius_get_pid_ptr(pid);
+	sap_index = pid_ptr->sap_index;
+
+	switch (pid_ptr->state)
+	{
+	case RADIUS_PID_REQ_STATE_IDLE:
+		if (pid_ptr->sd_msg_flag == 1)
+		{
+			pid_ptr->sd_msg_flag = 0;
+
+			radius_send_msg(pid);
+
+			radius_set_pid_state(RADIUS_PID_REQ_STATE_WAIT_FOR_PEER_RESP);
+
+			radius_set_pid_timer(RADIUS_TIMER_16S);
+
+			break;
+		}
+
+		if (pid_ptr->timer > 0)
+		{
+			if (--pid_ptr->timer == 0)
+			{
+				return 1;
+			}
+		}
+		else
+		{
+			return 1;
+		}
+
+		break;
+	case RADIUS_PID_REQ_STATE_WAIT_FOR_PEER_RESP:
+		if (pid_ptr->rv_msg_flag != 0)
+		{
+			radius_log_event("[%04d]%s: recv peer response and send it to up layer\r\n", pid, __FUNCTION__);
+
+			radius_set_pid_state(RADIUS_PID_REQ_STATE_TERMINATE);
+
+			if (radius_sap[sap_index].radius_cnf == NULL)
+			{
+				radius_log_err("[%04d] %s: radius_cnf error! usr_pid=%d\r\n", pid, __FUNCTION__, pid_ptr->usr_pid);
+				return 1;
+			}
+
+			radius_sap[sap_index].radius_cnf(pid_ptr->usr_pid, pid, &radius_msg_pdu);
+
+			return 1;
+		}
+
+		if (pid_ptr->timer > 0)
+		{
+			if (--pid_ptr->timer == 0)
+			{
+				radius_log_warn("[%04d] %s: wait peer response time out\r\n", pid, __FUNCTION__);
+				radius_set_pid_state(RADIUS_PID_REQ_STATE_TERMINATE);
+
+				return 1;
+			}
+			else
+			{
+				if ((pid_ptr->timer % RADIUS_RETRANS_TIMER) == 0)
+				{
+					radius_send_msg(pid);
+				}
+			}
+		}
+
+		break;
+	default:
+		return 1;
+	}
+
+	return 0;
+}
+
+int radius_pid_request_fsm(int pid)
+{
+	switch (radius_pid_request_process(pid))
+	{
+	case 0:
+		break;
+	case 1:
+		radius_init_pid(pid);
+		break;
+	}
+
+	return 0;
+}
+
+int radius_p_fsm(int pid)
+{
+	RADIUS_PID		*pid_ptr;
+
+	if ((pid_ptr = radius_get_pid_ptr(pid)) == NULL)
+		return -1;
+
+	switch (pid_ptr->type)
+	{
+	case RADIUS_PID_TYPE_IND:
+		radius_pid_indication_fsm(pid);
+		break;
+	case RADIUS_PID_TYPE_REQ:
+		radius_pid_request_fsm(pid);
+		break;
+	default:
+		radius_init_pid(pid);
+		break;
+	}
+
+	return 0;
+}
+
+int radius_fsm(void)
+{
+	int				i;
+	RADIUS_PID		*pid_ptr;
+
+	for (i = 0; i < RADIUS_MAX_NUM_OF_PID; i++)
+	{
+		pid_ptr = radius_get_pid_ptr(i);
+
+		if (pid_ptr->flag != 1)
+			continue;
+
+		radius_p_fsm(i);
+	}
+
+	return 0;
+}
+
+