void act_nsend(uint8 sock, int8 *buf, uint16 len, uint8 *dip, uint16 *dport)
{
int8 ret;
if(sockstat[sock] & SOCK_STAT_TCP_MASK) { // TCP
ret = TCPSendNB(sock, buf, len);
if(ret == SOCKERR_BUSY)
CRITICAL_ERRA("Impossible TCP send busy - len(%d), avail(%d)",
len, GetSocketTxFreeBufferSize(sock));
if(ret != RET_OK) CMD_RESP_RET(RET_NOT_CONN, VAL_NONE);
tcpleft[sock] = len;
sockwatch_set(sock, WATCH_SOCK_TCP_SEND);
sockbusy[sock] = VAL_TRUE;
} else { // UDP
ret = UDPSendNB(sock, buf, len, dip, *dport);
if(ret == SOCKERR_BUSY)
CRITICAL_ERRA("Impossible UDP send busy - len(%d), avail(%d)",
len, GetSocketTxFreeBufferSize(sock));
if(ret < RET_OK) {
DBGA("UDPSendNB fail - ret(%d)", ret);
CMD_RESP_RET(RET_WRONG_ADDR, VAL_NONE);
}
sockwatch_set(sock, WATCH_SOCK_UDP_SEND);
sockbusy[sock] = VAL_TRUE;
}
}
void act_nopen_a(int8 type, int8 save, uint16 sport, uint8 *dip, uint16 dport)
{
int8 ret, sock, i;
for(i=ATC_SOCK_NUM_START; i<=ATC_SOCK_NUM_END; i++) {
if(sockstat[i] != SOCK_STAT_IDLE && sockport[i] == sport) {
DBGA("src port(%d) is using now by sock(%d)", sport, i);
MAKE_TCMD_DIGIT(atci.tcmd.arg1, 2);
CMD_RESP_RET(RET_WRONG_ARG, VAL_NONE);
}
}
if(save == 'S' || save == 'A') {
}
if(save == 'O' || save == 'A') {
if(type == 'S') {
sock = sock_get(SOCK_STAT_TCP_SRV, sport);
if(sock == RET_NOK) CMD_RESP_RET(RET_NO_SOCK, VAL_NONE);
ret = TCPServerOpen(sock, sport);
if(ret != RET_OK) CMD_RESP_RET(RET_UNSPECIFIED, VAL_NONE);
sockwatch_set(sock, WATCH_SOCK_CONN_EVT);
CMD_RESP_RET(RET_OK, sock);
} else if(type == 'C') {
sock = sock_get(SOCK_STAT_TCP_CLT, sport);
if(sock == RET_NOK) CMD_RESP_RET(RET_NO_SOCK, VAL_NONE);
ret = TCPCltOpenNB(sock, sport, dip, dport);
if(ret != RET_OK) {
DBGA("TCPCltOpenNB fail - ret(%d)", ret);
CMD_RESP_RET(RET_WRONG_ADDR, VAL_NONE);
}
sockwatch_set(sock, WATCH_SOCK_CONN_TRY);
sockbusy[sock] = VAL_TRUE;
CMD_RESP_RET(RET_ASYNC, sock);
} else {
if(dip != NULL) {
memcpy(udpip[sock], dip, 4);
udpport[sock] = dport;
}
sock = sock_get(SOCK_STAT_UDP, sport);
if(sock == RET_NOK) CMD_RESP_RET(RET_NO_SOCK, VAL_NONE);
UDPOpen(sock, sport);
sockwatch_set(sock, WATCH_SOCK_RECV);
CMD_RESP_RET(RET_OK, sock);
}
}
}
void act_ncls(uint8 sock)
{
int8 ret;
if(sockbusy[sock] == VAL_TRUE) CMD_RESP_RET(RET_BUSY, VAL_NONE);
if(sockstat[sock] == SOCK_STAT_IDLE) CMD_RESP_RET(RET_SOCK_CLS, VAL_NONE);
if(sockstat[sock] & SOCK_STAT_TCP_MASK) {
ret = TCPCloseNB(sock);
if(ret != RET_OK) CMD_RESP_RET(RET_OK, VAL_NONE);
sockwatch_set(sock, WATCH_SOCK_CLS_TRY);
sockbusy[sock] = VAL_TRUE;
CMD_RESP_RET(RET_ASYNC, sock);
} else {
UDPClose(sock);
sock_put(sock);
CMD_RESP_RET(RET_OK, VAL_NONE);
}
}
static void atc_resend_alarm(int8 arg)
{
int8 ret;
ret = TCPReSendNB(arg);
if(ret != RET_OK) {
if(ret == SOCKERR_BUSY) {
alarm_set(WINDOWFULL_WAIT_TIME, atc_resend_alarm, arg);
} else if(ret == SOCKERR_WINDOW_FULL) {
sockbusy[arg] = VAL_FALSE;
DBGA("WATCH_SOCK_TCP_SEND fail - ret(%d)", ret);
cmd_resp(RET_TIMEOUT, arg);
} else {
sockbusy[arg] = VAL_FALSE;
DBGA("WATCH_SOCK_TCP_SEND fail - ret(%d)", ret);
sock_put(arg);
cmd_resp(RET_TIMEOUT, arg);
}
} else sockwatch_set(arg, WATCH_SOCK_TCP_SEND);
}
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 send_request(void)
{
uint8 srv_ip[4];
int32 len = 0;
memset(&dm, 0, sizeof(struct dhcp_msg));
dm.op = DHCP_BOOTREQUEST;
dm.htype = DHCP_HTYPE10MB;
dm.hlen = DHCP_HLENETHERNET;
dm.hops = DHCP_HOPS;
dm.xid = htonl(di.xid);
dm.secs = htons(DHCP_SECS);
if(di.action == DHCP_ACT_RENEW) {
dm.flags = 0; // For Unicast
memcpy(dm.ciaddr, workinfo.ip, 4);
} else {
dm.flags = htons(DHCP_BROADCAST);
}
memcpy(dm.chaddr, storage.mac, 6);
// MAGIC_COOKIE
*(uint32*)&dm.opt[len] = htonl(MAGIC_COOKIE);
len += 4;
// Option Request Param.
dm.opt[len++] = dhcpMessageType;
dm.opt[len++] = 0x01;
dm.opt[len++] = DHCP_MSG_REQUEST;
dm.opt[len++] = dhcpClientIdentifier;
dm.opt[len++] = 0x07;
dm.opt[len++] = 0x01;
memcpy(&dm.opt[len], storage.mac, 6);
len += 6;
if(di.action != DHCP_ACT_RENEW) {
dm.opt[len++] = dhcpRequestedIPaddr;
dm.opt[len++] = 0x04;
memcpy(&dm.opt[len], workinfo.ip, 4);
len += 4;
dm.opt[len++] = dhcpServerIdentifier;
dm.opt[len++] = 0x04;
memcpy(&dm.opt[len], di.srv_ip, 4);
len += 4;
}
// host name
dm.opt[len++] = hostName;
dm.opt[len++] = strlen(HOST_NAME) + 6; // length of hostname + 3
strcpy((char*)&dm.opt[len], HOST_NAME);
len += strlen(HOST_NAME);
sprintf((char*)&dm.opt[len], "%02x%02x%02x",
storage.mac[3], storage.mac[4], storage.mac[5]);
len += 6;
dm.opt[len++] = dhcpParamRequest;
dm.opt[len++] = 0x08;
dm.opt[len++] = subnetMask;
dm.opt[len++] = routersOnSubnet;
dm.opt[len++] = dns;
dm.opt[len++] = domainName;
dm.opt[len++] = dhcpT1value;
dm.opt[len++] = dhcpT2value;
dm.opt[len++] = performRouterDiscovery;
dm.opt[len++] = staticRoute;
dm.opt[len++] = endOption;
// send broadcasting packet
if(di.action == DHCP_ACT_RENEW) {
memcpy(srv_ip, di.srv_ip, 4);
} else {
srv_ip[0] = srv_ip[1] = srv_ip[2] = srv_ip[3] = 255;
}
if(dhcp_async) {
len = UDPSendNB(di.sock, (int8*)&dm, sizeof(struct dhcp_msg), srv_ip, DHCP_SERVER_PORT);
if(len < sizeof(struct dhcp_msg)) {
if(len < 0) ERRA("UDPSend fail - ret(%d)", len);
else ERRA("UDPSend sent less than size - size(%d), sent(%d)", sizeof(struct dhcp_msg), len);
return RET_NOK;
} else sockwatch_set(di.sock, WATCH_SOCK_UDP_SEND);
} else {
len = UDPSend(di.sock, (int8*)&dm, sizeof(struct dhcp_msg), srv_ip, DHCP_SERVER_PORT);
if(len <= 0) {
ERRA("UDPSend fail - ret(%d)", len);
return RET_NOK;
}
}
return RET_OK;
}
static void dhcp_run(void)
{
static bool udp_open_fail = FALSE;
if(di.state == DHCP_STATE_INIT && di.action != DHCP_ACT_START) {
DBG("wrong attempt");
return;
} else if(GetUDPSocketStatus(di.sock) == SOCKSTAT_CLOSED) {
if(udp_open_fail == TRUE && !IS_TIME_PASSED(dhcp_run_tick, DHCP_RETRY_DELAY))
goto RET_ALARM;
ClsNetInfo(NI_IP_ADDR);
ClsNetInfo(NI_SN_MASK);
ClsNetInfo(NI_GW_ADDR);
ClsNetInfo(NI_DNS_ADDR);
if(UDPOpen(di.sock, DHCP_CLIENT_PORT) == RET_OK) {
if(dhcp_async) sockwatch_open(di.sock, dhcp_async_cb);
udp_open_fail = FALSE;
dhcp_run_tick = wizpf_get_systick();
dhcp_run_cnt = 0;
} else {
ERR("UDPOpen fail");
udp_open_fail = TRUE;
dhcp_run_tick = wizpf_get_systick();
goto RET_ALARM;
}
}
switch(di.state) {
case DHCP_STATE_INIT:
if(dhcp_run_cnt==0 && !IS_TIME_PASSED(dhcp_run_tick, DHCP_OPEN_DELAY))
goto RET_ALARM;
if(dhcp_run_cnt < DHCP_SEND_RETRY_COUNT) {
dhcp_run_cnt++;
if(send_discover() == RET_OK) { // Discover ok
if(dhcp_async) {
DBG("DHCP Discovery Send Async");
sockwatch_set(di.sock, WATCH_SOCK_UDP_SEND);
return; // alarm set is not needed
} else {
DBG("DHCP Discovery Sent");
SET_STATE(DHCP_STATE_SEARCHING);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Discovery SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Discovery SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_cnt = 0;
UDPClose(di.sock);
if(dhcp_async) sockwatch_close(di.sock);
dhcp_fail();
return; // alarm set is not needed
}
break;
case DHCP_STATE_SEARCHING:
if(!IS_TIME_PASSED(dhcp_run_tick, DHCP_RETRY_DELAY)) {
int8 ret = recv_handler();
if(ret == DHCP_MSG_OFFER) {
SET_STATE(DHCP_STATE_SELECTING);
dhcp_run_tick = wizpf_get_systick();
dhcp_run_cnt = 0;
} else if(ret != RET_NOK) DBGCRTCA(TRUE, "recv wrong packet(%d)", ret);
} else {
ERRA("DHCP Offer RECV fail - for (%d)msec", DHCP_RETRY_DELAY);
SET_STATE(DHCP_STATE_INIT);
dhcp_run_tick = wizpf_get_systick();
}
break;
case DHCP_STATE_SELECTING:
if(dhcp_run_cnt < DHCP_SEND_RETRY_COUNT) {
dhcp_run_cnt++;
if(send_request() == RET_OK) { // Request ok
if(dhcp_async) {
DBG("DHCP Request Send Async");
sockwatch_set(di.sock, WATCH_SOCK_UDP_SEND);
return; // alarm set is not needed
} else {
DBG("DHCP Request Sent");
SET_STATE(DHCP_STATE_REQUESTING);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Request SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_tick = wizpf_get_systick();
}
} else {
ERRA("DHCP Request SEND fail - (%d)times", dhcp_run_cnt);
dhcp_run_cnt = 0;
UDPClose(di.sock);
if(dhcp_async) sockwatch_close(di.sock);
dhcp_fail();
return; // alarm set is not needed
}
break;
case DHCP_STATE_REQUESTING:
if(!IS_TIME_PASSED(dhcp_run_tick, DHCP_RETRY_DELAY)) {
int8 ret = recv_handler();
if(ret == DHCP_MSG_ACK) { // Recv ACK
LOG("DHCP Success");
SET_STATE(DHCP_STATE_IP_CHECK);
dhcp_run_tick = wizpf_get_systick();
dhcp_run_cnt = 0;
} else if(ret == DHCP_MSG_NAK) { // Recv NAK
if(di.action == DHCP_ACT_START) {
SET_STATE(DHCP_STATE_INIT);
dhcp_run_tick = wizpf_get_systick();
} else {
SET_STATE(DHCP_STATE_BOUND);
}
dhcp_run_cnt = 0;
} else if(ret != RET_NOK) DBGCRTCA(TRUE, "recv wrong packet(%d)", ret);
} else {
ERRA("DHCP ACK RECV fail - for (%d)msec", DHCP_RETRY_DELAY);
if(di.action == DHCP_ACT_START) {
SET_STATE(DHCP_STATE_INIT);
dhcp_run_tick = wizpf_get_systick();
} else {
SET_STATE(DHCP_STATE_BOUND);
}
}
break;
case DHCP_STATE_IP_CHECK:
//if(send_checker() == RET_OK) {
SET_STATE(DHCP_STATE_BOUND);
SetNetInfo(&workinfo);
if(di.ip_update) di.ip_update();
LOGA("DHCP ok - New IP (%d.%d.%d.%d)",
workinfo.ip[0], workinfo.ip[1], workinfo.ip[2], workinfo.ip[3]);
//} else {
// SET_STATE(DHCP_STATE_INIT);
// ERR("IP Addr conflicted - IP(%d.%d.%d.%d)", workinfo.ip[0], workinfo.ip[1], workinfo.ip[2], workinfo.ip[3]);
// send_rel_dec(DHCP_MSG_DECLINE);
// if(di.ip_conflict) (*di.ip_conflict)();
//}
break;
case DHCP_STATE_BOUND:
di.action = DHCP_ACT_NONE;
UDPClose(di.sock);
if(dhcp_async) sockwatch_close(di.sock);
return; // alarm set is not needed
case DHCP_STATE_FAILED:
return; // alarm set is not needed
default:
ERRA("wrong state(%d)", di.state);
return; // alarm set is not needed
}
RET_ALARM:
if(dhcp_alarm) alarm_set(10, dhcp_alarm_cb, 0);
}
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);
}
}
