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;
}
}
static void hdl_nrecv(void)
{
int8 num = VAL_NONE;
int32 maxlen;
if(atci.poll == POLL_MODE_NONE) RESP_CR(RET_DISABLED);
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_EQUAL;
if(atci.tcmd.sign == CMD_SIGN_QUEST) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, ATC_SOCK_NUM_START, ATC_SOCK_NUM_END))
RESP_CDR(RET_RANGE_OUT, 1);
}
if(atci.tcmd.arg2[0] == 0) maxlen = WORK_BUF_SIZE; // 사이즈 지정안되면 최대값으로 지정
else if(str_check(isdigit, atci.tcmd.arg2) != RET_OK) RESP_CDR(RET_WRONG_ARG, 2);
else if((maxlen = atoi((char*)atci.tcmd.arg2)) < 1 || maxlen > WORK_BUF_SIZE)
RESP_CDR(RET_RANGE_OUT, 2);
CMD_CLEAR();
act_nrecv(num, maxlen);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void hdl_mset(void)
{
int8 echo, poll, num = -1; //, mode, country
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_QUEST; // [?] 구현
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 4)) RESP_CDR(RET_RANGE_OUT, 1);
}
CMD_CLEAR();
act_mset_q(num);
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 4)) RESP_CDR(RET_RANGE_OUT, 1);
if(num == 1) {
if(CMP_CHAR_2(atci.tcmd.arg2, 'E', 'D')) RESP_CDR(RET_WRONG_ARG, 2);
echo = atci.tcmd.arg2[0];
CMD_CLEAR();
act_mset_a(echo, 0, 0, 0);
} else if(num == 2) {
RESP_CDR(RET_NOT_ALLOWED, 2); // 아직 정해진 것 없음
} else if(num == 3) {
if(CMP_CHAR_3(atci.tcmd.arg2, 'F', 'S', 'D')) RESP_CDR(RET_WRONG_ARG, 2);
poll = atci.tcmd.arg2[0];
CMD_CLEAR();
act_mset_a(0, 0, poll, 0);
} else RESP_CDR(RET_NOT_ALLOWED, 2); // 국가 설정 아직 구현안함
} else RESP_CDR(RET_WRONG_ARG, 1);
}
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
num = 0;
if(atci.tcmd.arg1[0] != 0) {
num++;
if(CMP_CHAR_2(atci.tcmd.arg1, 'E', 'D')) RESP_CDR(RET_WRONG_ARG, 1);
}
if(atci.tcmd.arg3[0] != 0) {
num++;
if(CMP_CHAR_3(atci.tcmd.arg3, 'F', 'S', 'D')) RESP_CDR(RET_WRONG_ARG, 3);
}
// arg 2, 4 는 일단 무시
if(num == 0) RESP_CR(RET_NOT_ALLOWED);
echo = atci.tcmd.arg1[0];
poll = atci.tcmd.arg3[0];
CMD_CLEAR();
act_mset_a(echo, 0, poll, 0);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void hdl_mstat(void)
{
int8 num = -1;
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_QUEST;
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 1)) RESP_CDR(RET_RANGE_OUT, 1);
}
CMD_CLEAR();
act_mstat();
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL) RESP_CR(RET_WRONG_SIGN);
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void hdl_nopen(void)
{
int8 type=0;
uint8 DstIP[4], *dip = NULL;
uint16 SrcPort, DstPort = 0;
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_QUEST;
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
CMD_CLEAR();
act_nopen_q();
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
if(CMP_CHAR_3(atci.tcmd.arg1, 'S', 'C', 'U')) RESP_CDR(RET_WRONG_ARG, 1);
if(port_check(atci.tcmd.arg2, &SrcPort) != RET_OK) RESP_CDR(RET_WRONG_ARG, 2);
if(atci.tcmd.arg1[0] == 'C') {
if(ip_check(atci.tcmd.arg3, DstIP) != RET_OK) RESP_CDR(RET_WRONG_ARG, 3);
if(port_check(atci.tcmd.arg4, &DstPort) != RET_OK) RESP_CDR(RET_WRONG_ARG, 4);
dip = DstIP;
} else if(atci.tcmd.arg1[0] == 'U') {
if(atci.tcmd.arg3[0] != 0 && atci.tcmd.arg4[0] != 0) {
if(ip_check(atci.tcmd.arg3, DstIP) != RET_OK) RESP_CDR(RET_WRONG_ARG, 3);
if(port_check(atci.tcmd.arg4, &DstPort) != RET_OK) RESP_CDR(RET_WRONG_ARG, 4);
dip = DstIP;
} else {
CHK_ARG_LEN(atci.tcmd.arg3, 0, 3);
CHK_ARG_LEN(atci.tcmd.arg4, 0, 4);
}
} else { // 'S' 무시정책이냐 아니면 전부 확인 정책이냐
CHK_ARG_LEN(atci.tcmd.arg3, 0, 3);
CHK_ARG_LEN(atci.tcmd.arg4, 0, 4);
}
CHK_ARG_LEN(atci.tcmd.arg5, 0, 5);
type = atci.tcmd.arg1[0];
CMD_CLEAR();
act_nopen_a(type, SrcPort, dip, DstPort);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void hdl_nsend(void)
{
int8 num = -1;
int32 ret;
uint8 *dip = NULL;
uint16 *dport = NULL;
if(atci.tcmd.sign == CMD_SIGN_NONE) RESP_CR(RET_WRONG_SIGN);
if(atci.tcmd.sign == CMD_SIGN_QUEST) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, ATC_SOCK_NUM_START, ATC_SOCK_NUM_END))
RESP_CDR(RET_RANGE_OUT, 1);
}
if(str_check(isdigit, atci.tcmd.arg2) != RET_OK ||
(atci.sendlen = atoi((char*)atci.tcmd.arg2)) < 1 ||
atci.sendlen > WORK_BUF_SIZE) RESP_CDR(RET_RANGE_OUT, 2);
if(atci.tcmd.arg3[0]) {
if(ip_check(atci.tcmd.arg3, atci.sendip) == RET_OK) dip = atci.sendip;
else RESP_CDR(RET_WRONG_ARG, 3);
}
if(atci.tcmd.arg4[0]) {
if(port_check(atci.tcmd.arg4, &atci.sendport)==RET_OK) dport = &atci.sendport;
else RESP_CDR(RET_WRONG_ARG, 4);
}
CHK_ARG_LEN(atci.tcmd.arg5, 0, 5);
CHK_ARG_LEN(atci.tcmd.arg6, 0, 6);
CMD_CLEAR();
ret = act_nsend_chk(num, &atci.sendlen, dip, dport);
if(ret != RET_OK) return;
atci.sendsock = num; // 유효성 검사가 완료되면 SEND모드로 전환
atci.worklen = 0;
cmd_resp(RET_ASYNC, num);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void hdl_mevt(void)
{
int8 num = -1;
if(atci.poll != POLL_MODE_FULL) RESP_CR(RET_DISABLED);
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_EQUAL;
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
CMD_CLEAR();
act_mevt_q();
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV) RESP_CR(RET_WRONG_SIGN);
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, ATC_SOCK_NUM_START, ATC_SOCK_NUM_END))
RESP_CDR(RET_RANGE_OUT, 1);
}
CMD_CLEAR();
act_mevt_a(num);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
static void hdl_nset(void)
{
int8 mode, num = -1;
uint8 ip[4];
if(atci.tcmd.sign == CMD_SIGN_NONE) atci.tcmd.sign = CMD_SIGN_QUEST; // x는 ?로 치환
if(atci.tcmd.sign == CMD_SIGN_QUEST)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 6)) RESP_CDR(RET_RANGE_OUT, 1);
}
CMD_CLEAR();
act_nset_q(num);
}
else if(atci.tcmd.sign == CMD_SIGN_INDIV)
{
if(atci.tcmd.arg1[0] != 0) {
if(str_check(isdigit, atci.tcmd.arg1) != RET_OK) RESP_CDR(RET_WRONG_ARG, 1);
if(CHK_DGT_RANGE(atci.tcmd.arg1, num, 1, 6)) RESP_CDR(RET_RANGE_OUT, 1);
if(num == 1) {
if(CMP_CHAR_2(atci.tcmd.arg2, 'D', 'S')) RESP_CDR(RET_WRONG_ARG, 2);
mode = atci.tcmd.arg2[0];
CMD_CLEAR();
act_nset_a(mode, NULL, NULL, NULL, NULL, NULL);
} else {
if(ip_check(atci.tcmd.arg2, ip) != RET_OK) RESP_CDR(RET_WRONG_ARG, 2);
CMD_CLEAR();
switch(num) {
case 2: act_nset_a(0, ip, NULL, NULL, NULL, NULL); return;
case 3: act_nset_a(0, NULL, ip, NULL, NULL, NULL); return;
case 4: act_nset_a(0, NULL, NULL, ip, NULL, NULL); return;
case 5: act_nset_a(0, NULL, NULL, NULL, ip, NULL); return;
case 6: act_nset_a(0, NULL, NULL, NULL, NULL, ip); return;
default: CRITICAL_ERR("nset wrong num");
}
}
} else RESP_CDR(RET_WRONG_ARG, 1);
}
else if(atci.tcmd.sign == CMD_SIGN_EQUAL)
{
uint8 sn[4], gw[4], dns1[4], dns2[4], *ptr[5];
num = 0;
if(atci.tcmd.arg1[0] != 0) {
if(CMP_CHAR_2(atci.tcmd.arg1, 'D', 'S')) RESP_CDR(RET_WRONG_ARG, 1);
else num++;
}
#define NSET_ARG_SET(arg_p, addr_p, idx_v, ret_v) \
if(arg_p[0] != 0) { \
num++; \
if(ip_check(arg_p, addr_p) != RET_OK) RESP_CDR(RET_WRONG_ARG, ret_v); \
ptr[idx_v] = addr_p; \
} else ptr[idx_v] = NULL
NSET_ARG_SET(atci.tcmd.arg2, ip, 0, 2);
NSET_ARG_SET(atci.tcmd.arg3, sn, 1, 3);
NSET_ARG_SET(atci.tcmd.arg4, gw, 2, 4);
NSET_ARG_SET(atci.tcmd.arg5, dns1, 3, 5);
NSET_ARG_SET(atci.tcmd.arg6, dns2, 4, 6);
if(num == 0) RESP_CR(RET_NOT_ALLOWED);
mode = atci.tcmd.arg1[0];
CMD_CLEAR();
act_nset_a(mode, ptr[0], ptr[1], ptr[2], ptr[3], ptr[4]);
}
else CRITICAL_ERRA("wrong sign(%d)", atci.tcmd.sign);
}
void cmd_resp(int8 retval, int8 idval)
{
uint8 cnt, len, idx = 0;
DBGA("ret(%d), id(%d)", retval, idval);
cnt = (atci.tcmd.arg1[0] != 0) + (atci.tcmd.arg2[0] != 0) + (atci.tcmd.arg3[0] != 0) +
(atci.tcmd.arg4[0] != 0) + (atci.tcmd.arg5[0] != 0) + (atci.tcmd.arg6[0] != 0);
#define MAKE_RESP(item_v, size_v) \
{ \
if(item_v[0] != 0) { \
termbuf[idx++] = ','; \
len = strlen((char*)item_v); \
if(len > size_v-1) CRITICAL_ERR("resp buf overflow"); \
memcpy((char*)&termbuf[idx], (char*)item_v, len); \
idx += len; \
cnt--; \
} else if(cnt) { \
termbuf[idx++] = ','; \
} \
}//printf("MakeResp-(%s)(%d)", item_v, len);
termbuf[idx++] = '[';
if(retval >= RET_OK) {
if(retval == RET_OK) termbuf[idx++] = 'S';
else if(retval == RET_OK_DUMP) CRITICAL_ERR("use cmd_resp_dump for dump");
else if(retval == RET_ASYNC) termbuf[idx++] = 'W';
else if(retval == RET_RECV) termbuf[idx++] = 'R';
else CRITICAL_ERRA("undefined return value (%d)", retval);
if(idval != VAL_NONE) {
termbuf[idx++] = ',';
//snprintf((char*)tbuf, TBUF_SIZE, "%d", idval);
//len = strlen((char*)tbuf);
//strcpy((char*)&termbuf[idx], (char*)tbuf);
sprintf((char*)&termbuf[idx], "%d", idval);
len = digit_length(idval, 10);
idx += len;
} else if(cnt) termbuf[idx++] = ',';
} else {
termbuf[idx++] = 'F';
termbuf[idx++] = ',';
if(idval != VAL_NONE) {
//snprintf((char*)tbuf, TBUF_SIZE, "%d", idval);
//len = strlen((char*)tbuf);
//strcpy((char*)&termbuf[idx], (char*)tbuf);
sprintf((char*)&termbuf[idx], "%d", idval);
len = digit_length(idval, 10);
idx += len;
}
termbuf[idx++] = ',';
#define CMD_SWT_DEF(errval_v) termbuf[idx++] = errval_v; break;
#define CMD_SWT_EXT(base_v, errval_v) termbuf[idx++]=base_v;termbuf[idx++] = errval_v; break;
switch(retval) {
case RET_UNSPECIFIED: CMD_SWT_DEF(ERRVAL_UNSPECIFIED);
case RET_WRONG_OP: CMD_SWT_DEF(ERRVAL_WRONG_OP);
case RET_WRONG_SIGN: CMD_SWT_DEF(ERRVAL_WRONG_SIGN);
case RET_WRONG_ARG: CMD_SWT_DEF(ERRVAL_WRONG_ARG);
case RET_RANGE_OUT: CMD_SWT_DEF(ERRVAL_RANGE_OUT);
case RET_DISABLED: CMD_SWT_DEF(ERRVAL_DISABLED);
case RET_NOT_ALLOWED: CMD_SWT_DEF(ERRVAL_NOT_ALLOWED);
case RET_BUSY: CMD_SWT_DEF(ERRVAL_BUSY);
case RET_TIMEOUT: CMD_SWT_DEF(ERRVAL_TIMEOUT);
case RET_NO_SOCK: CMD_SWT_EXT('1', ERRVAL_NO_SOCK);
case RET_SOCK_CLS: CMD_SWT_EXT('1', ERRVAL_SOCK_CLS);
case RET_USING_PORT: CMD_SWT_EXT('1', ERRVAL_USING_PORT);
case RET_NOT_CONN: CMD_SWT_EXT('1', ERRVAL_NOT_CONN);
case RET_WRONG_ADDR: CMD_SWT_EXT('1', ERRVAL_WRONG_ADDR);
case RET_NO_DATA: CMD_SWT_EXT('1', ERRVAL_NO_DATA);
case RET_NO_FREEMEM: CMD_SWT_EXT('2', ERRVAL_NO_FREEMEM);
default:termbuf[idx++] = '0';break;
}
}
MAKE_RESP(atci.tcmd.arg1, ARG_1_SIZE);
MAKE_RESP(atci.tcmd.arg2, ARG_2_SIZE);
MAKE_RESP(atci.tcmd.arg3, ARG_3_SIZE);
MAKE_RESP(atci.tcmd.arg4, ARG_4_SIZE);
MAKE_RESP(atci.tcmd.arg5, ARG_5_SIZE);
MAKE_RESP(atci.tcmd.arg6, ARG_6_SIZE);
termbuf[idx++] = ']';
termbuf[idx++] = 0;
printf("%s\r\n", termbuf); // print basic response
}
void act_nsock(int8 sock)
{
uint8 tip[4];
uint16 tport;
if(sock < ATC_SOCK_NUM_START)
{
int8 *dump, i, type, cnt_con=0, cnt_notcon=0;
DBG("NSOCK-start");
for(i=ATC_SOCK_NUM_START; i<=ATC_SOCK_NUM_END; i++) {
if(sockstat[i] != SOCK_STAT_IDLE) {
if(sockstat[i] & SOCK_STAT_CONNECTED) cnt_con++;
else cnt_notcon++;
}
}
DBGA("NSOCK-con(%d),not(%d)", cnt_con, cnt_notcon);
if(cnt_con+cnt_notcon == 0) {
cmd_resp_dump(VAL_NONE, NULL);
return;
}
dump = malloc((34*cnt_con)+(12*cnt_notcon)+1);
if(dump == NULL) CMD_RESP_RET(RET_NO_FREEMEM, VAL_NONE);
cnt_con = 0;
for(i=ATC_SOCK_NUM_START; i<=ATC_SOCK_NUM_END; i++) {
if(sockstat[i] == SOCK_STAT_IDLE) continue;
if(cnt_con != 0) {
dump[cnt_con++] = '\r';
dump[cnt_con++] = '\n';
}
if((sockstat[i]&SOCK_STAT_PROTMASK)==SOCK_STAT_TCP_SRV) type = 'S';
else if((sockstat[i]&SOCK_STAT_PROTMASK)==SOCK_STAT_TCP_CLT) type='C';
else type = 'U';
if(sockstat[i] & SOCK_STAT_CONNECTED) {
GetDstInfo((uint8)i, tip, &tport);
sprintf((char*)&dump[cnt_con], "%d,%c,%d,%d.%d.%d.%d,%d", i, type,
sockport[i], tip[0], tip[1], tip[2], tip[3], tport);
} else {
sprintf((char*)&dump[cnt_con], "%d,%c,%d", i, type, sockport[i]);
}
cnt_con += strlen((char*)&dump[cnt_con]);
}
cmd_resp_dump(VAL_NONE, dump);
}
else if(sock <= ATC_SOCK_NUM_END)
{
if(sockstat[sock] == SOCK_STAT_IDLE)
sprintf((char*)atci.tcmd.arg1, "%c", 'I');
else if((sockstat[sock] & SOCK_STAT_PROTMASK) == SOCK_STAT_TCP_SRV)
sprintf((char*)atci.tcmd.arg1, "%c", 'S');
else if((sockstat[sock] & SOCK_STAT_PROTMASK) == SOCK_STAT_TCP_CLT)
sprintf((char*)atci.tcmd.arg1, "%c", 'C');
else if((sockstat[sock] & SOCK_STAT_PROTMASK) == SOCK_STAT_UDP)
sprintf((char*)atci.tcmd.arg1, "%c", 'U');
else CRITICAL_ERRA("wrong sock state(0x%d)", sockstat[sock]);
sprintf((char*)atci.tcmd.arg2, "%d", sockport[sock]);
if(sockstat[sock] & SOCK_STAT_CONNECTED) {
GetDstInfo((uint8)sock, tip, &tport);
sprintf((char*)atci.tcmd.arg3, "%d.%d.%d.%d", tip[0], tip[1], tip[2], tip[3]);
sprintf((char*)atci.tcmd.arg4, "%d", tport);
}
CMD_RESP_RET(RET_OK, VAL_NONE);
}
else CMD_RESP_RET(RET_WRONG_ARG, VAL_NONE);
}
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);
}
}
