void loopback_udp(uint8 ch, uint16 port)
{
int ret;
uint32 destip = 0;
uint16 destport;
ret = UDPRecv(ch, data_buf, TX_RX_MAX_BUF_SIZE, (uint8*)&destip, &destport);
if(ret > 0) { // Received
ret = UDPSend(ch, data_buf, ret, (uint8*)&destip ,destport);
if(ret == ERROR_TIME_OUT) {
ERR("Timeout");
UDPClose(ch);
DBG("UDP Socket Close");
}
} else if(ret == ERROR_NOT_UDP_SOCKET) { // Not UDP Socket, It's TCP Socket
DBG("TCP Socket Close");
TCPClose(ch);
} else if(ret == ERROR_CLOSED) { // Socket Closed
LOGA("UDP Loop-Back Started - ch(%d)",(uint16)ch);
UDPOpen(ch, port);
}
}
int NET::RecvBlock(void * dest, int destsize, int timeout)
{
int r = UDPRecv(pin, 0, timeout);
Uint8 * destdata = (Uint8 *) dest;
if (r == UDP_SUCCESS)
{
int i;
int mins = pin->len;
if (destsize < mins)
{
mins = destsize;
if (NET_DEBUG)
cout << "net: RecvBlock: overflow (" << pin->len << ">" << destsize << endl;
}
for (i = 0; i < mins; i++)
{
destdata[i] = pin->data[i];
}
return mins;
}
else
return r;
}
bool NET::ClientHandshake()
{
string handshake = HANDSHAKESTR;
string handshake_reply = HANDSHAKEREPLYSTR;
int timeout = HANDSHAKETIMEOUT;
bool err = false;
WriteToPacket(pout, CONTROL_HANDSHAKE, (void *) handshake.c_str(), handshake.length());
UDPSend(pout, 0);
int ret = UDPRecv(pin, 0, timeout);
if (ret == UDP_SUCCESS)
{
if (IsEqualToPacket(pin, CONTROL_HANDSHAKE, (void *) handshake_reply.c_str(), handshake_reply.length()))
{
connected = true;
if (NET_DEBUG)
cout << "net: Connection complete." << endl;
}
else
{
if (NET_DEBUG)
cout << "net: Invalid handshake reply." << endl;
err = true;
}
}
if (ret == UDP_TIMEOUT)
{
err = true;
if (NET_DEBUG)
cout << "net: Handshake timeout, couldn't connect" << endl;
}
if (ret == UDP_FAILURE)
{
err = true;
if (NET_DEBUG)
cout << "net: Handshake error." << endl;
}
return err;
}
/**
* 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);
}
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);
}
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;
}
