void act_mevt_a(int8 id)
{
int8 event;
if(event_dequeue(&id, &event) != RET_OK) {
CMD_RESP_RET(RET_NO_DATA, VAL_NONE);
}
if(id <= ATC_SOCK_NUM_END && event == SOCKEVENT_RECV)
EVENT_RESP_SIZE(id, event, GetSocketRxRecvBufferSize(id));
else EVENT_RESP(id, event);
}
void act_nrecv(int8 sock, uint16 maxlen)
{
uint8 dstip[4], i;
uint16 dstport;
int32 len;
DBGA("Asock(%d)", sock);
if(sock == VAL_NONE) {
if(recvnum == 0) CMD_RESP_RET(RET_NO_DATA, VAL_NONE);
for(i=ATC_SOCK_NUM_START; i<=ATC_SOCK_NUM_END; i++) {
if(recvord[i] == recvnum) {
sock = i;
break;
}
}
}DBGA("Bsock(%d)", sock);
if(sockstat[sock] == SOCK_STAT_IDLE) CMD_RESP_RET(RET_SOCK_CLS, VAL_NONE);
if(sockstat[sock] & SOCK_STAT_TCP_MASK) { // TCP
if(!(sockstat[sock] & SOCK_STAT_CONNECTED)) CMD_RESP_RET(RET_NOT_CONN, VAL_NONE);
if(GetSocketRxRecvBufferSize(sock) == 0) CMD_RESP_RET(RET_NO_DATA, VAL_NONE);
len = TCPRecv(sock, atci.recvbuf, maxlen);
} else { // UDP
if(GetSocketRxRecvBufferSize(sock) == 0) CMD_RESP_RET(RET_NO_DATA, VAL_NONE);
len = UDPRecv(sock, atci.recvbuf, maxlen, dstip, &dstport);
if(len == 0) CMD_RESP_RET(RET_NO_DATA, VAL_NONE);
else if(len == SOCKERR_CLOSED) CMD_RESP_RET(RET_SOCK_CLS, VAL_NONE);
else if(len < 0) CMD_RESP_RET(RET_UNSPECIFIED, VAL_NONE);
}
atci.recvbuf[len] = 0;
MAKE_TCMD_DIGIT(atci.tcmd.arg1, len);
MAKE_TCMD_ADDR(atci.tcmd.arg2, dstip[0], dstip[1], dstip[2], dstip[3]);
MAKE_TCMD_DIGIT(atci.tcmd.arg3, dstport);
cmd_resp(RET_RECV, sock);
printf("%s\r\n", atci.recvbuf);
sockwatch_set(sock, WATCH_SOCK_RECV);
}
/**
* SNMP Process Handler.
* UDP Socket and SNMP transaction handling.
*
* @param none
* @return none
*/
void SnmpXDaemon_process(void)
{
int32 len = 0;
uint8 svr_addr[6];
uint16 svr_port;
//UDPOpen(SOCK_SNMP, 161);
//if ( (len = getSn_RX_RSR(SOCK_SNMP)) > 0)
if((len = GetSocketRxRecvBufferSize(SOCK_SNMP)) > 0)
{
request_msg.len= UDPRecv(SOCK_SNMP, (int8 *)&request_msg.buffer[0], len, svr_addr, &svr_port);
}
else
{
request_msg.len = 0;
//continue;
}
if (request_msg.len > 0)
{
dumpCode("\r\n[Request]\r\n", "\r\n", request_msg.buffer, request_msg.len);
request_msg.index = 0;
response_msg.index = 0;
errorStatus = errorIndex = 0;
if (parseSNMPMessage() != -1)
{
UDPSend(SOCK_SNMP, (int8 *)response_msg.buffer, response_msg.index, svr_addr, svr_port);
}
dumpCode("\r\n[Response]\r\n", "\r\n", response_msg.buffer, response_msg.index);
}
//UDPClose(SOCK_SNMP);
}
static int8 recv_handler(void)
{
uint8 *cur, *end;
uint8 recv_ip[4], opt_len, msg_type;
int32 recv_len;
uint16 recv_port;
recv_len = GetSocketRxRecvBufferSize(di.sock);
if(recv_len == 0) return RET_NOK;
else memset(&dm, 0, sizeof(struct dhcp_msg));
recv_len = UDPRecv(di.sock, (int8*)&dm, sizeof(struct dhcp_msg), recv_ip, &recv_port);
if(recv_len < 0) {
ERRA("UDPRecv fail - ret(%d)", recv_len);
return RET_NOK;
}
//DBGFUNC(print_dump(&dm, sizeof(dm))); // For debugging received packet
DBGA("DHCP_SIP:%d.%d.%d.%d",di.srv_ip[0],di.srv_ip[1],di.srv_ip[2],di.srv_ip[3]);
DBGA("DHCP_RIP:%d.%d.%d.%d",di.srv_ip_real[0],di.srv_ip_real[1],di.srv_ip_real[2],di.srv_ip_real[3]);
DBGA("recv_ip:%d.%d.%d.%d",recv_ip[0],recv_ip[1],recv_ip[2],recv_ip[3]);
if(dm.op != DHCP_BOOTREPLY || recv_port != DHCP_SERVER_PORT) {
if(dm.op != DHCP_BOOTREPLY) DBG("DHCP : NO DHCP MSG");
if(recv_port != DHCP_SERVER_PORT) DBG("DHCP : WRONG PORT");
return RET_NOK;
}
if(memcmp(dm.chaddr, storage.mac, 6) != 0 || dm.xid != htonl(di.xid)) {
DBG("No My DHCP Message. This message is ignored.");
DBGA("SRC_MAC_ADDR(%02X:%02X:%02X:%02X:%02X:%02X)",
storage.mac[0], storage.mac[1], storage.mac[2],
storage.mac[3], storage.mac[4], storage.mac[5]);
DBGA("chaddr(%02X:%02X:%02X:%02X:%02X:%02X)", dm.chaddr[0],
dm.chaddr[1], dm.chaddr[2], dm.chaddr[3], dm.chaddr[4], dm.chaddr[5]);
DBGA("DHCP_XID(%08lX), xid(%08lX), yiaddr(%d.%d.%d.%d)", htonl(di.xid),
dm.xid, dm.yiaddr[0], dm.yiaddr[1], dm.yiaddr[2], dm.yiaddr[3]);
return RET_NOK;
}
if( *((uint32*)di.srv_ip) != 0x00000000 ) {
if( *((uint32*)di.srv_ip_real) != *((uint32*)recv_ip) &&
*((uint32*)di.srv_ip) != *((uint32*)recv_ip) ) {
DBG("Another DHCP sever send a response message. This is ignored.");
DBGA("IP:%d.%d.%d.%d",recv_ip[0],recv_ip[1],recv_ip[2],recv_ip[3]);
return RET_NOK;
}
}
memcpy(workinfo.ip, dm.yiaddr, 4);
DBG("DHCP MSG received..");
DBGA("yiaddr : %d.%d.%d.%d",workinfo.ip[0],workinfo.ip[1],workinfo.ip[2],workinfo.ip[3]);
msg_type = 0;
cur = (uint8 *)(&dm.op);
cur = cur + 240;
end = cur + (recv_len - 240); //printf("cur : 0x%08X end : 0x%08X recv_len : %d\r\n", cur, end, recv_len);
while ( cur < end )
{
switch ( *cur++ )
{
case padOption:
break;
case endOption:
return msg_type;
case dhcpMessageType:
opt_len = *cur++;
msg_type = *cur;
DBGA("dhcpMessageType : %x", msg_type);
break;
case subnetMask:
opt_len =* cur++;
memcpy(workinfo.sn,cur,4);
DBGA("subnetMask : %d.%d.%d.%d",
workinfo.sn[0],workinfo.sn[1],workinfo.sn[2],workinfo.sn[3]);
break;
case routersOnSubnet:
opt_len = *cur++;
memcpy(workinfo.gw,cur,4);
DBGA("routersOnSubnet : %d.%d.%d.%d",
workinfo.gw[0],workinfo.gw[1],workinfo.gw[2],workinfo.gw[3]);
break;
case dns:
opt_len = *cur++;
memcpy(workinfo.dns,cur,4);
break;
case dhcpIPaddrLeaseTime:
opt_len = *cur++;
di.lease_time = ntohl(*((uint32*)cur));
di.renew_time = di.lease_time / 2; // 0.5
di.rebind_time = di.lease_time / 8 * 7; // 0.875
DBGA("lease(%d), renew(%d), rebind(%d)", di.lease_time, di.renew_time, di.rebind_time);
break;
case dhcpServerIdentifier:
opt_len = *cur++;
DBGA("DHCP_SIP : %d.%d.%d.%d", di.srv_ip[0], di.srv_ip[1], di.srv_ip[2], di.srv_ip[3]);
if( *((uint32*)di.srv_ip) == 0 || *((uint32*)di.srv_ip_real) == *((uint32*)recv_ip) ||
*((uint32*)di.srv_ip) == *((uint32*)recv_ip) ) {
memcpy(di.srv_ip,cur,4);
memcpy(di.srv_ip_real,recv_ip,4); // Copy the real ip address of my DHCP server
DBGA("My dhcpServerIdentifier : %d.%d.%d.%d",
di.srv_ip[0], di.srv_ip[1], di.srv_ip[2], di.srv_ip[3]);
DBGA("My DHCP server real IP address : %d.%d.%d.%d",
di.srv_ip_real[0], di.srv_ip_real[1], di.srv_ip_real[2], di.srv_ip_real[3]);
} else {
DBGA("Another dhcpServerIdentifier : MY(%d.%d.%d.%d)",
di.srv_ip[0], di.srv_ip[1], di.srv_ip[2], di.srv_ip[3]);
DBGA("Another(%d.%d.%d.%d)", recv_ip[0], recv_ip[1], recv_ip[2], recv_ip[3]);
}
break;
default:
opt_len = *cur++;
DBGA("opt_len : %d", opt_len);
break;
} // switch
cur+=opt_len;
} // while
return RET_NOK;
}
void atc_async_cb(uint8 sock, uint8 item, int32 ret)
{
DBGCRTCA(sock<ATC_SOCK_NUM_START||sock>ATC_SOCK_NUM_END, "wrong sock(%d)", sock);
switch(item) {
case WATCH_SOCK_UDP_SEND: DBG("WATCH_SOCK_UDP_SEND");
sockbusy[sock] = VAL_FALSE; //DBGA("WATCH UDP Sent - sock(%d), item(%d)", sock, item);
if(ret == RET_OK) {
cmd_resp(RET_OK, sock);
} else {
DBGA("WATCH_SOCK_UDP_SEND fail - ret(%d)", ret);
cmd_resp(RET_TIMEOUT, sock);
}
break;
case WATCH_SOCK_TCP_SEND: DBG("WATCH_SOCK_TCP_SEND");
if(ret < RET_OK) {
sockbusy[sock] = VAL_FALSE;
DBGA("WATCH_SOCK_TCP_SEND fail - ret(%d)", ret);
sock_put(sock);
cmd_resp(RET_TIMEOUT, sock);
} else {
tcpleft[sock] -= ret;
if(tcpleft[sock] > 0) {
ret = TCPReSendNB(sock);
if(ret != RET_OK) {
if(ret == SOCKERR_BUSY) {
alarm_set(WINDOWFULL_WAIT_TIME, atc_resend_alarm, sock);
} else if(ret == SOCKERR_WINDOW_FULL) {
sockbusy[sock] = VAL_FALSE;
DBGA("WATCH_SOCK_TCP_SEND fail - ret(%d)", ret);
cmd_resp(RET_TIMEOUT, sock);
} else {
sockbusy[sock] = VAL_FALSE;
DBGA("WATCH_SOCK_TCP_SEND fail - ret(%d)", ret);
sock_put(sock);
cmd_resp(RET_TIMEOUT, sock);
}
} else sockwatch_set(sock, WATCH_SOCK_TCP_SEND);
} else {
sockbusy[sock] = VAL_FALSE;
cmd_resp(RET_OK, sock);
}
}
break;
case WATCH_SOCK_CONN_TRY: DBG("WATCH_SOCK_CONN_TRY");
sockbusy[sock] = VAL_FALSE;
if(ret == RET_OK) {
BITSET(sockstat[sock], SOCK_STAT_CONNECTED);
sockwatch_set(sock, WATCH_SOCK_CLS_EVT);
sockwatch_set(sock, WATCH_SOCK_RECV);
cmd_resp(RET_ASYNC, sock);
} else {
DBGA("WATCH_SOCK_CONN_EVT fail - ret(%d)", ret);
sock_put(sock);
cmd_resp(RET_TIMEOUT, sock);
}
break;
case WATCH_SOCK_CLS_TRY: DBG("WATCH_SOCK_CLS_TRY");
sockbusy[sock] = VAL_FALSE;
if(ret == RET_OK) {
sock_put(sock);
cmd_resp(RET_ASYNC, sock);
} else {
CRITICAL_ERRA("WATCH_SOCK_CONN_EVT fail - ret(%d)", ret);
}
break;
case WATCH_SOCK_CONN_EVT: DBG("WATCH_SOCK_CONN_EVT");
if(ret == RET_OK) {
BITSET(sockstat[sock], SOCK_STAT_CONNECTED);
sockwatch_set(sock, WATCH_SOCK_CLS_EVT);
sockwatch_set(sock, WATCH_SOCK_RECV);
if(atci.poll != POLL_MODE_FULL) EVENT_RESP(sock, SOCKEVENT_CONN);
else event_enqueue(sock, SOCKEVENT_CONN);
} else {
CRITICAL_ERRA("WATCH_SOCK_CONN_EVT fail - ret(%d)", ret);
}
break;
case WATCH_SOCK_CLS_EVT: DBG("WATCH_SOCK_CLS_EVT");
sockbusy[sock] = VAL_FALSE;
if(ret == RET_OK) {
if(sockwatch_chk(sock, WATCH_SOCK_CLS_TRY) == RET_OK)
cmd_resp(RET_OK, sock);
sock_put(sock);
if(atci.poll != POLL_MODE_FULL) EVENT_RESP(sock, SOCKEVENT_CLS);
else event_enqueue(sock, SOCKEVENT_CLS);
} else {
CRITICAL_ERRA("WATCH_SOCK_CONN_EVT fail - ret(%d)", ret);
}
break;
case WATCH_SOCK_RECV: DBG("WATCH_SOCK_RECV");
{
int8 i;
if(atci.poll != POLL_MODE_NONE) {
recvnum++;
if(recvord[sock] == 0) {
for(i=ATC_SOCK_NUM_START; i<=ATC_SOCK_NUM_END; i++)
if(recvord[i] != 0) recvord[i]++;
} else {
for(i=ATC_SOCK_NUM_START; i<=ATC_SOCK_NUM_END; i++)
if(recvord[i] != 0 && recvord[i] < recvord[sock]) recvord[i]++;
}
recvord[sock] = 1;
if(atci.poll != POLL_MODE_FULL)
EVENT_RESP_SIZE(sock, SOCKEVENT_RECV, GetSocketRxRecvBufferSize(sock));
else event_enqueue(sock, SOCKEVENT_RECV);
} else {
act_nrecv(sock, WORK_BUF_SIZE);
}
}
break;
default: CRITICAL_ERRA("wrong item(0x%x)", item);
}
}
