nq_soc_core.c

mtk socket编程

	if(soc_notify == NULL)
	{
		
		__NQ_ZH_DEBUG(" nq_zh_core_soc_socket_notify , null");
		return;
	}

	__NQ_ZH_DEBUG(" nq_zh_core_soc_socket_notify , soc_notify->event_type = %d, soc_notify->result = %d", soc_notify->event_type, soc_notify->result);

	index = nq_zh_core_get_socket_index_by_id(soc_notify->socket_id);

	if(index == NQ_ZH_FAILED)
	{
		return;
	}

	nq_zh_core_soc_stop_timer(index);
	
	if(soc_notify->result == KAL_FALSE)
	{
		__NQ_ZH_SET_SOC_STATE(index, NQ_ZH_SOC_STATE_ERR);
		if(g_nq_zh_core_soc_cntx_p[index].notify_handler.error_notify)
		{
			g_nq_zh_core_soc_cntx_p[index].notify_handler.error_notify(index, soc_notify->error_cause, NQ_ZH_SOC_NOTIFY_UNKNOWN);
		}
		return;
	}

	switch( soc_notify->event_type)
	{
		case NQ_ZH_SOC_NOTIFY_CONNECT:
		{
			__NQ_ZH_ASSERT(__NQ_ZH_GET_SOC_STATE(index) == NQ_ZH_SOC_STATE_CONNECTING);
			
			if(g_nq_zh_core_soc_cntx_p[index].notify_handler.connect_notify)
			{
				g_nq_zh_core_soc_cntx_p[index].notify_handler.connect_notify(index, soc_notify->error_cause, NQ_ZH_SOC_NOTIFY_CONNECT);
			}
			break;
		}
		case NQ_ZH_SOC_NOTIFY_WRITE:
		{
			if(g_nq_zh_core_soc_cntx_p[index].notify_handler.write_notify)
			{
				g_nq_zh_core_soc_cntx_p[index].notify_handler.write_notify(index, soc_notify->error_cause, NQ_ZH_SOC_NOTIFY_WRITE);
			}
			break;
		}
		case NQ_ZH_SOC_NOTIFY_READ:
		{
			if(g_nq_zh_core_soc_cntx_p[index].notify_handler.read_notify)
			{
				g_nq_zh_core_soc_cntx_p[index].notify_handler.read_notify(index, soc_notify->error_cause, NQ_ZH_SOC_NOTIFY_READ);
			}
			break;
		}
		case NQ_ZH_SOC_NOTIFY_CLOSE:
		{
			if(g_nq_zh_core_soc_cntx_p[index].notify_handler.close_notify)
			{
				g_nq_zh_core_soc_cntx_p[index].notify_handler.close_notify(index, soc_notify->error_cause, NQ_ZH_SOC_NOTIFY_CLOSE);
			}
			break;
		}
		case NQ_ZH_SOC_NOTIFY_ACCEPT:
		{
			if(g_nq_zh_core_soc_cntx_p[index].notify_handler.accept_notify)
			{
				g_nq_zh_core_soc_cntx_p[index].notify_handler.accept_notify(index, soc_notify->error_cause, NQ_ZH_SOC_NOTIFY_ACCEPT);
			}
			break;
		}
		default:
		{
			__NQ_ZH_SET_SOC_STATE(index, NQ_ZH_SOC_STATE_ERR);
			if(g_nq_zh_core_soc_cntx_p[index].notify_handler.error_notify)
			{
				g_nq_zh_core_soc_cntx_p[index].notify_handler.error_notify(index, soc_notify->error_cause, NQ_ZH_SOC_NOTIFY_UNKNOWN);
			}
			break;
		}
	}
}


static void nq_zh_core_state_handler(kal_int8 socket_index, kal_int32 err_code, kal_int32 sock_event )
{ 
	kal_int32 recvfinished = 0;
	kal_int32 recvbytes = 0, sendbytes = 0, result = 0;
	kal_int32 wap_flag = 0;

	__NQ_ZH_ASSERT(socket_index >= 0 && socket_index < NQ_ZH_SOC_MAX);

	
	__NQ_ZH_DEBUG(" nq_zh_core_state_handler, sock_event = %d, soc_state = %d", sock_event, __NQ_ZH_GET_SOC_STATE(socket_index));
	
	if( err_code < 0 && err_code != NQ_ZH_SOC_CONNRESET)
	{
		nq_zh_core_close(socket_index);
		__NQ_ZH_SOC_NOTIFY_USER(socket_index, err_code);
		return;
	}

	switch(__NQ_ZH_GET_SOC_STATE(socket_index))
	{
		case NQ_ZH_SOC_STATE_IDLE:
			break;
		case NQ_ZH_SOC_STATE_CONNECTING:
			if( sock_event == NQ_ZH_SOC_NOTIFY_CONNECT )
			{
				__NQ_ZH_SET_SOC_STATE(socket_index, NQ_ZH_SOC_STATE_CONNECTED);
				
				//the 1st packet send
				__NQ_ZH_SET_SOC_SEND_OFFSET(socket_index, 0);
				sendbytes = 0;
				nq_zh_core_soc_start_timer(socket_index);
				
				result = nq_zh_core_send(socket_index, (kal_uint8*)__NQ_ZH_GET_SOC_CURR_SEND_POS(socket_index), __NQ_ZH_GET_SOC_CURR_SEND_REMAIN_LEN(socket_index), &sendbytes);
				if(sendbytes > 0)
				{
					__NQ_ZH_INC_SOC_SEND_OFFSET(socket_index, sendbytes);
				}

				if(result < 0 && result != NQ_ZH_SOC_WOULDBLOCK)
				{
					nq_zh_core_close(socket_index);					
					__NQ_ZH_SOC_NOTIFY_USER(socket_index, sendbytes);
					return;
				}
				
				if(__NQ_ZH_GET_SOC_CURR_SEND_REMAIN_LEN(socket_index) > 0)
				{
					__NQ_ZH_SET_SOC_STATE(socket_index, NQ_ZH_SOC_STATE_SENDING);
				}
			}
			break;
		case NQ_ZH_SOC_STATE_SENDING:
			if(sock_event == NQ_ZH_SOC_NOTIFY_WRITE)
			{
				sendbytes = 0;
				nq_zh_core_soc_start_timer(socket_index);
				result = nq_zh_core_send(socket_index, (kal_uint8*)__NQ_ZH_GET_SOC_CURR_SEND_POS(socket_index), __NQ_ZH_GET_SOC_CURR_SEND_REMAIN_LEN(socket_index), &sendbytes);
				if(sendbytes > 0)
				{
					__NQ_ZH_INC_SOC_SEND_OFFSET(socket_index, sendbytes);
				}

				// send error
				if(sendbytes < 0 && sendbytes != NQ_ZH_SOC_WOULDBLOCK)
				{
					nq_zh_core_close(socket_index);
					__NQ_ZH_SOC_NOTIFY_USER(socket_index, sendbytes);
					return;
				}

				//resend data later
				if(__NQ_ZH_GET_SOC_CURR_SEND_REMAIN_LEN(socket_index) > 0)
				{
					__NQ_ZH_SET_SOC_STATE(socket_index, NQ_ZH_SOC_STATE_SENDING);
				}
			}
			break;
		case NQ_ZH_SOC_STATE_SENT:
			if( sock_event == NQ_ZH_SOC_NOTIFY_READ )
			{
				
				//the 1st packet received
				__NQ_ZH_DEBUG( " nq_zh_core_state_handler, start receive");
				__NQ_ZH_SET_SOC_RECV_OFFSET(socket_index,0);
				recvbytes = 0;	

				result = nq_zh_core_recv(socket_index, (kal_uint8*)__NQ_ZH_GET_SOC_CURR_RECV_POS(socket_index), __NQ_ZH_GET_SOC_CURR_RECV_REMAIN_LEN(socket_index), &recvbytes);
				if(recvbytes > 0)
				{
					__NQ_ZH_INC_SOC_RECV_OFFSET(socket_index,recvbytes);
				}

				//receive error
				if( result < 0 && result != NQ_ZH_SOC_WOULDBLOCK )
				{
					nq_zh_core_close(socket_index);
					__NQ_ZH_SOC_NOTIFY_USER(socket_index, recvbytes);
					return;
				}

				//check isFinished Func
				if(__NQ_ZH_GET_SOC_FINISHED_FUNC(socket_index) != NULL)
				{
					__NQ_ZH_DEBUG( " nq_zh_core_state_handler, call isFinished func,  recvbytes = %d", recvbytes);
					recvfinished = __NQ_ZH_CALL_SOC_FINISHED_FUNC(socket_index, __NQ_ZH_GET_SOC_RECV_BUFFER(socket_index), __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index), &wap_flag);
					
					if(recvfinished)
					{
						if(wap_flag)
						{
							//receive data from gateway, resend again
							__NQ_ZH_SET_SOC_STATE(socket_index, NQ_ZH_SOC_STATE_CONNECTING);
							nq_zh_core_state_handler(socket_index, NQ_ZH_SOC_SUCCESS, NQ_ZH_SOC_NOTIFY_CONNECT);
						}
						else
						{
							//receive finished, notify user
							nq_zh_core_close(socket_index);
							__NQ_ZH_SOC_NOTIFY_USER(socket_index, __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index));
						}
					}
					else
					{
						//receive buffer full, but receive hasn't finished
						if(__NQ_ZH_GET_SOC_CURR_RECV_REMAIN_LEN(socket_index) <= 0 )
						{
							nq_zh_core_close(socket_index);
							__NQ_ZH_SOC_NOTIFY_USER(socket_index, __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index));
						}
					}
				}
				else
				{
					//isFinished func null, notify user received data
					__NQ_ZH_DEBUG( " nq_zh_core_state_handler, isfinished func is null,  recvbytes = %d", recvbytes);
					nq_zh_core_close(socket_index);
					__NQ_ZH_SOC_NOTIFY_USER(socket_index, __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index));
				}
					
			}
			break;
		
		case NQ_ZH_SOC_STATE_RECVING:
			if( sock_event == NQ_ZH_SOC_NOTIFY_READ)
			{
				recvbytes = 0;
				result = nq_zh_core_recv(socket_index, (kal_uint8*)__NQ_ZH_GET_SOC_CURR_RECV_POS(socket_index), __NQ_ZH_GET_SOC_CURR_RECV_REMAIN_LEN(socket_index), &recvbytes);
				if(recvbytes > 0)
				{
					__NQ_ZH_INC_SOC_RECV_OFFSET(socket_index,recvbytes);
				}

				//receive error
				if( result < 0 && result != NQ_ZH_SOC_WOULDBLOCK )
				{
					nq_zh_core_close(socket_index);
					__NQ_ZH_SOC_NOTIFY_USER(socket_index, recvbytes);
					return;
				}

				if(__NQ_ZH_GET_SOC_FINISHED_FUNC(socket_index) != NULL)
				{
					recvfinished = __NQ_ZH_CALL_SOC_FINISHED_FUNC(socket_index, __NQ_ZH_GET_SOC_RECV_BUFFER(socket_index), __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index), &wap_flag);
					
					if(recvfinished)
					{
						if(wap_flag)
						{
							//receive data from gateway, resend again
							__NQ_ZH_SET_SOC_STATE(socket_index, NQ_ZH_SOC_STATE_CONNECTING);
							nq_zh_core_state_handler(socket_index, NQ_ZH_SOC_SUCCESS, NQ_ZH_SOC_NOTIFY_CONNECT);
						}
						else
						{
							//receive finished, notify user
							nq_zh_core_close(socket_index);
							__NQ_ZH_SOC_NOTIFY_USER(socket_index, __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index));
						}
					}
					else
					{
						//receive buffer full, but receive hasn't finished
						if(__NQ_ZH_GET_SOC_CURR_RECV_REMAIN_LEN(socket_index) <= 0 )
						{
							nq_zh_core_close(socket_index);
							__NQ_ZH_SOC_NOTIFY_USER(socket_index, __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index));
						}
					}
				}
				else
				{
					//isFinished func null, notify user received data
					nq_zh_core_close(socket_index);
					__NQ_ZH_SOC_NOTIFY_USER(socket_index, __NQ_ZH_GET_SOC_RECV_OFFSET(socket_index));
				}
				
			}
			else if( sock_event == NQ_ZH_SOC_NOTIFY_CLOSE )
			{
				nq_zh_core_close(socket_index);
				__NQ_ZH_SOC_NOTIFY_USER(socket_index, NQ_ZH_SOC_NOTCONN);
			}				
			break;
			
		case NQ_ZH_SOC_STATE_CLOSE:
		case NQ_ZH_SOC_STATE_ERR:
			nq_zh_core_close(socket_index);
			__NQ_ZH_SOC_NOTIFY_USER(socket_index, NQ_ZH_SOC_NOTCONN);
			break;
		default:
			__NQ_ZH_ASSERT(0);
			break;
	}
}

static void nq_zh_core_soc_timer_callback_1(void)
{
	__NQ_ZH_DEBUG(" nq_zh_core_soc_timer_callback_1");
	nq_zh_core_close(0);	
	__NQ_ZH_SOC_NOTIFY_USER(0, NQ_ZH_SOC_NOTCONN);
}

static void nq_zh_core_soc_timer_callback_2(void)
{
	__NQ_ZH_DEBUG(" nq_zh_core_soc_timer_callback_2");
	nq_zh_core_close(1);
	__NQ_ZH_SOC_NOTIFY_USER(1, NQ_ZH_SOC_NOTCONN);
}
static void nq_zh_core_soc_timer_callback_3(void)
{
	__NQ_ZH_DEBUG(" nq_zh_core_soc_timer_callback_3");
	nq_zh_core_close(2);
	__NQ_ZH_SOC_NOTIFY_USER(2, NQ_ZH_SOC_NOTCONN);
}
static void nq_zh_core_soc_timer_callback_4(void)
{
	__NQ_ZH_DEBUG(" nq_zh_core_soc_timer_callback_4");
	nq_zh_core_close(3);
	__NQ_ZH_SOC_NOTIFY_USER(3, NQ_ZH_SOC_NOTCONN);
}
static void nq_zh_core_soc_timer_callback_5(void)
{
	__NQ_ZH_DEBUG(" nq_zh_core_soc_timer_callback_4");
	nq_zh_core_close(4);
	__NQ_ZH_SOC_NOTIFY_USER(4, NQ_ZH_SOC_NOTCONN);
}

static void nq_zh_core_soc_start_timer(kal_int8 socket_index)
{
	NQ_zh_FuncPtr timercallback = NULL;
	__NQ_ZH_ASSERT(socket_index >= 0 && socket_index < NQ_ZH_SOC_MAX);

	__NQ_ZH_DEBUG( " nq_zh_core_soc_start_timer, socket_index = %d", socket_index);
	switch(socket_index)
	{
		case 0:
			timercallback = nq_zh_core_soc_timer_callback_1;
			break;
		case 1:
			timercallback = nq_zh_core_soc_timer_callback_2;
			break;
		case 2:
			timercallback = nq_zh_core_soc_timer_callback_3;
			break;
		case 3:
			timercallback = nq_zh_core_soc_timer_callback_4;
			break;
		case 4:
			timercallback = nq_zh_core_soc_timer_callback_5;
			break;
	}
	nq_zh_soc_start_timer(__NQ_ZH_GET_SOC_TIMERID(socket_index), NQ_ZH_SOC_TIMER_OUT, timercallback);

}

static void nq_zh_core_soc_stop_timer(kal_int8 socket_index)
{
	__NQ_ZH_DEBUG( " nq_zh_core_soc_stop_timer, socket_index = %d", socket_index);
	nq_zh_soc_stop_timer(__NQ_ZH_GET_SOC_TIMERID(socket_index));
}

/******************************************************************************
 * nq_zh_core_send_req  
 *  
 * Description:
 *   发送数据，包括创建socket、链接、发送，
 *   接收到数据调用usercallback通知用户
 *  
 * Input: 
 *  
 *  
 * Output: 
 *  
 * Returns: 
 *  
 * 
 * modification history
 * -----------------------------------	-------
 * 
 ******************************************************************************/
kal_int8 nq_zh_core_send_req(kal_int8 *sendbuf, kal_int32 sendlen, 
	kal_int8 *recvbuf, kal_int32 max_recvlen, 
	NQ_zh_core_recv_is_finished_Ptr isFinished, NQ_zh_core_PsHttpCallBack usercallback)
{
	kal_int8 socket_index = NQ_ZH_FAILED;
	kal_int8 result = NQ_ZH_FAILED;
	kal_int32 sendbytes = 0;
	
	socket_index = nq_zh_core_createSocket(NQ_ZH_SOCK_STREAM);

	if(socket_index == NQ_ZH_FAILED)
	{
		if(usercallback)
		{
			usercallback(NQ_ZH_SOC_LIMIT_RESOURCE);
			return socket_index;
		}
	}

	__NQ_ZH_SET_SOC_SEND_BUFFER(socket_index, sendbuf);
	__NQ_ZH_SET_SOC_SEND_LEN(socket_index,sendlen);
	__NQ_ZH_SET_SOC_RECV_BUFFER(socket_index,recvbuf);
	__NQ_ZH_SET_SOC_RECV_LEN_MAX(socket_index,max_recvlen);
	__NQ_ZH_SET_SOC_FINISHED_FUNC(socket_index, isFinished);
	__NQ_ZH_SET_SOC_USERCB_FUNC(socket_index, usercallback);

	nq_zh_core_soc_start_timer(socket_index);

	result = nq_zh_core_connect(socket_index,NQ_ZH_SOCKET_NONBLOCK);

	if(result == NQ_ZH_SOC_WOULDBLOCK)
	{
		return socket_index;
	}
	
	if(result < 0)
	{
		nq_zh_core_close(socket_index);
		__NQ_ZH_SOC_NOTIFY_USER(socket_index, result);
		return socket_index;
	}

	if(__NQ_ZH_GET_SOC_STATE(socket_index) == NQ_ZH_SOC_STATE_CONNECTED)
	{
		nq_zh_core_soc_start_timer(socket_index);

		__NQ_ZH_SET_SOC_SEND_OFFSET(socket_index,0);
		sendbytes = 0;
		result = nq_zh_core_send(socket_index, (kal_uint8*)__NQ_ZH_GET_SOC_CURR_SEND_POS(socket_index), __NQ_ZH_GET_SOC_CURR_SEND_REMAIN_LEN(socket_index), &sendbytes);
		if(sendbytes > 0)
		{
			__NQ_ZH_INC_SOC_SEND_OFFSET(socket_index,sendbytes);
		}

		if(result < 0 && result != NQ_ZH_SOC_WOULDBLOCK)
		{
			nq_zh_core_close(socket_index);
			__NQ_ZH_SOC_NOTIFY_USER(socket_index, sendbytes);
			return socket_index;
		}
		
		if(__NQ_ZH_GET_SOC_CURR_SEND_REMAIN_LEN(socket_index) > 0)
		{
			__NQ_ZH_SET_SOC_STATE(socket_index, NQ_ZH_SOC_STATE_SENDING);
		}
	}
	
	return socket_index;
}