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); } }