sys_result comm_receive(modem_socket_t * socket)
{
sys_result result;
if(socket->state_handle.state == COMM_RECEIVE_RX) {
if(socket->state_handle.substate == COMM_RECEIVE_INVOKE) {
#ifdef LOG_COMMRECEIVE
printf("socket(%d) receive...\r\n", socket->socket_id);
#endif
// prepare the socket receive buffer
memset(socket->rx_buffer, '\0', SOCKET_BUFFER_LEN+1);
socket->bytes_received = 0;
socket_entersubstate(socket, COMM_RECEIVE_WAITREPLY);
socket_settimeout(socket, DEFAULT_COMM_SOCKETRECEIVE_TIMEOUT);
result = SYS_OK;
} else if(socket->state_handle.substate == COMM_RECEIVE_WAITREPLY) {
// if we receive bytes we need to copy the data and signal the
// function to return
// if(socket->bytes_received > 0) {
// socket->event_handler->on_datareceive(socket->rx_buffer, socket->bytes_received);
// memset(socket->rx_buffer, '\0', SOCKET_BUFFER_LEN+1);
// xSemaphoreGive(tcp_receive_signal);
// }
// wait up to n seconds.
if(socket_timeout(socket)) {
socket->socket_error = SCK_ERR_TIMEOUT;
#ifdef LOG_COMMRECEIVE
printf("socket(%d) receive timeout\r\n", socket->socket_id);
#endif
// TODO: review for proper transition after receive
comm_enterstate(socket, COMM_IDLE);
socket_exitstate(socket);
xSemaphoreGive(tcp_receive_signal);
result = SYS_OK;
}
// // if we receive bytes we need to copy the data and signal the
// // function to return
if(socket->bytes_received > 0) {
socket->event_handler->on_datareceive(socket->rx_buffer, socket->bytes_received);
memset(socket->rx_buffer, '\0', SOCKET_BUFFER_LEN+1);
xSemaphoreGive(tcp_receive_signal);
}
result = SYS_OK;
}
}
return result;
}
sys_result comm_close(modem_socket_t * socket)
{
sys_result result;
if(socket->state_handle.state == COMM_CLOSE_CONNECTION) {
if(socket->state_handle.substate == COMM_CLOSE_INVOKE) {
printf("socket(%d) close...\r\n", socket->socket_id);
modem_socketclose(socket);
socket_entersubstate(socket, COMM_CLOSE_WAITREPLY);
socket_settimeout(socket, DEFAULT_COMM_SOCKETCLOSE_TIMEOUT);
result = SYS_OK;
} else if(socket->state_handle.substate == COMM_CLOSE_WAITREPLY) {
if(socket_timeout(socket)) {
printf("socket(%d) close timeout.\r\n", socket->socket_id);
comm_enterstate(socket, COMM_IDLE);
socket_exitstate(socket);
xSemaphoreGive(tcp_close_signal);
}
result = modem_handle_socketclose(socket);
if(result == SYS_AT_OK) {
socket->socket_status = SCK_CLOSED;
comm_enterstate(socket, COMM_IDLE);
socket_exitstate(socket);
xSemaphoreGive(tcp_close_signal);
} else if (result == SYS_ERR_AT_NOCARRIER) {
comm_enterstate(socket, COMM_IDLE);
socket_exitstate(socket);
xSemaphoreGive(tcp_close_signal);
}else if (result == SYS_ERR_AT_TIMEOUT) {
comm_enterstate(socket, COMM_IDLE);
socket_exitstate(socket);
xSemaphoreGive(tcp_close_signal);
}
}
return result;
}
return result;
}
sys_result comm_idle(modem_socket_t * socket)
{
sys_result result;
if(socket->state_handle.state == COMM_IDLE_SETTIMEOUT) {
printf("socket(%d) idle.\r\n", socket->socket_id);
printf("wait %d sec.\r\n", DEFAULT_COMM_IDLE_TIMEOUT/1000);
socket_enterstate(socket, COMM_IDLE_WAITTIMEOUT);
socket_settimeout(socket, DEFAULT_COMM_IDLE_TIMEOUT);
result = SYS_OK;
} else if(socket->state_handle.state == COMM_IDLE_WAITTIMEOUT) {
if(socket_timeout(socket)) {
socket_enterstate(socket, COMM_IDLE_SETTIMEOUT);
result = SYS_OK;
}
}
return result;
}
//OpenID
int CInputAuth::auth_OpenID(const char *authKey, const char *ipAddr, char *rID)
{
//return value
//0 : normal execution
//1 : cannot connect to openid auth server
//2 : socket_write failed
//3 : openid auth server not reply
//4 : Reply Error
//5 : Incorrect auth key.
extern char openid_host[256];
extern char openid_uri[256];
int port = 80;
socket_t fd = socket_connect(openid_host, port);
if (fd < 0)
{
sys_err("[auth_OpenID] : could not connect to OpenID server(%s)", openid_host);
return 1;
}
socket_block(fd);
socket_timeout(fd, 3, 0);
// send request
{
char request[512];
int len = snprintf(request, sizeof(request),
//"GET /kyw/gameauth.php?auth_key=%s&ip=%s HTTP/1.1\r\n"
"GET %s?auth_key=%s&ip=%s HTTP/1.1\r\n"
"Host: %s\r\n"
"Connection: Close\r\n\r\n",
//openid_uri, authKey,ipAddr);//"aaaaa", "202.31.212.73");
//authKey,ipAddr);
//"/kyw/gameauth.php", authKey, ipAddr);
openid_uri, authKey, ipAddr, openid_host);
//#ifndef __WIN32__
// if (write(fd, request, len) < 0)
//#else
if (socket_write(fd, request, len) < 0)
//#endif
{
sys_err("[auth_OpenID] : could not send auth-request (%s)", authKey);
socket_close(fd);
return 2;
}
}
// read reply
char reply[1024] = {0};
int len;
//#ifndef __WIN32__
// len = read(fd, reply, sizeof(reply));
//#else
len = socket_read(fd, reply, sizeof(reply));
//#endif
socket_close(fd);
if (len <= 0)
{
sys_err("[auth_OpenID] : could not recv auth-reply (%s)", authKey);
return 3;
}
//결과값 파싱
char buffer[1024];
strcpy(buffer, reply);
const char *delim = "\r\n";
char *last = 0;
char *v = strtok(buffer, delim);
char *result = 0;
while (v)
{
result = v;
v = strtok(NULL, delim);
}
char *id = strtok(result, "%");
char *success = strtok(NULL, "%");
if (!*id || !*success)
{
sys_err("[auth_OpenID] : OpenID AuthServer Reply Error (%s)", reply);
return 4;
}
if (0 != strcmp("OK", success)) //에러 처리
{
int returnNumber = 0;
str_to_number(returnNumber, id);
switch (returnNumber)
{
case 1:
sys_err("[auth_OpenID] : AuthKey incorrect");
break;
case 2:
sys_err("[auth_OpenID] : ip incorrect");
break;
case 3:
sys_err("[auth_OpenID] : used AuthKey");
break;
case 4:
sys_err("[auth_OpenID] : AuthKey not delivered");
break;
case 5:
sys_err("[auth_OpenID] : ip not delivered");
break;
case 6:
sys_err("[auth_OpenID] : AuthKey time over");
break;
default:
break;
return 5;
}
}
strcpy(rID, id);
return 0;
}
socket_t socket_connect(const char* host, WORD port)
{
socket_t s = 0;
struct sockaddr_in server_addr;
int rslt;
/* 소켓주소 구조체 초기화 */
memset(&server_addr, 0, sizeof(server_addr));
if (isdigit(*host))
server_addr.sin_addr.s_addr = inet_addr(host);
else
{
struct hostent *hp;
if ((hp = gethostbyname(host)) == NULL)
{
sys_err("socket_connect(): can not connect to %s:%d", host, port);
return -1;
}
thecore_memcpy((char* ) &server_addr.sin_addr, hp->h_addr, sizeof(server_addr.sin_addr));
}
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(port);
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("socket");
return -1;
}
socket_keepalive(s);
socket_sndbuf(s, 233016);
socket_rcvbuf(s, 233016);
socket_timeout(s, 10, 0);
socket_lingeron(s);
/* 연결요청 */
if ((rslt = connect(s, (struct sockaddr *) &server_addr, sizeof(server_addr))) < 0)
{
socket_close(s);
#ifdef __WIN32__
switch (WSAGetLastError())
#else
switch (rslt)
#endif
{
#ifdef __WIN32__
case WSAETIMEDOUT:
#else
case EINTR:
#endif
sys_err("HOST %s:%d connection timeout.", host, port);
break;
#ifdef __WIN32__
case WSAECONNREFUSED:
#else
case ECONNREFUSED:
#endif
sys_err("HOST %s:%d port is not opened. connection refused.", host, port);
break;
#ifdef __WIN32__
case WSAENETUNREACH:
#else
case ENETUNREACH:
#endif
sys_err("HOST %s:%d is not reachable from this host.", host, port);
break;
default:
sys_err("HOST %s:%d, could not connect.", host, port);
break;
}
perror("connect");
return (-1);
}
return (s);
}
