xiao sun / SNICInterface

debug version

Dependents:   HTTPClient_WiFi_HelloWorld_src

Fork of SNICInterface by muRata

Socket/TCPSocketConnection.cpp@48:ee7e07fb401f, 2015-03-31 (annotated)

Committer:
MACRUM
Date:
Tue Mar 31 02:48:32 2015 +0000
Revision:
48:ee7e07fb401f
Parent:
43:d80bbb12ffe6 
Fixed: HTTPClient library compatibility. https://developer.mbed.org/users/ban4jp/code/SNICInterface_PullReq/rev/c50e7332afcc

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kishino 20:dd736d328de6 1 /* Copyright (C) 2012 mbed.org, MIT License
kishino 20:dd736d328de6 2 *
kishino 20:dd736d328de6 3 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
kishino 20:dd736d328de6 4 * and associated documentation files (the "Software"), to deal in the Software without restriction,
kishino 20:dd736d328de6 5 * including without limitation the rights to use, copy, modify, merge, publish, distribute,
kishino 20:dd736d328de6 6 * sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
kishino 20:dd736d328de6 7 * furnished to do so, subject to the following conditions:
kishino 20:dd736d328de6 8 *
kishino 20:dd736d328de6 9 * The above copyright notice and this permission notice shall be included in all copies or
kishino 20:dd736d328de6 10 * substantial portions of the Software.
kishino 20:dd736d328de6 11 *
kishino 20:dd736d328de6 12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
kishino 20:dd736d328de6 13 * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
kishino 20:dd736d328de6 14 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
kishino 20:dd736d328de6 15 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
kishino 20:dd736d328de6 16 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
kishino 20:dd736d328de6 17 */
kishino 39:a1233ca02edf 18 /* Copyright (C) 2014 Murata Manufacturing Co.,Ltd., MIT License
kishino 41:1c1b5ad4d491 19 * port to the muRata, SWITCH SCIENCE Wi-FI module TypeYD SNIC-UART.
kishino 39:a1233ca02edf 20 */
kishino 20:dd736d328de6 21 #include "TCPSocketConnection.h"
kishino 20:dd736d328de6 22 #include <cstring>
kishino 20:dd736d328de6 23
kishino 20:dd736d328de6 24 TCPSocketConnection::TCPSocketConnection()
kishino 20:dd736d328de6 25 {
kishino 20:dd736d328de6 26 }
kishino 20:dd736d328de6 27
kishino 26:f2e1030964e4 28 TCPSocketConnection::~TCPSocketConnection()
kishino 26:f2e1030964e4 29 {
kishino 26:f2e1030964e4 30 }
kishino 26:f2e1030964e4 31
kishino 29:6a0ba999597d 32 int TCPSocketConnection::connect( const char *host_p, unsigned short port)
kishino 20:dd736d328de6 33 {
kishino 20:dd736d328de6 34 int ret;
kishino 24:987e412ae879 35 C_SNIC_Core *snic_core_p = C_SNIC_Core::getInstance();
kishino 24:987e412ae879 36 C_SNIC_UartCommandManager *uartCmdMgr_p = snic_core_p->getUartCommand();
kishino 29:6a0ba999597d 37
kishino 43:d80bbb12ffe6 38 FUNC_IN();
kishino 20:dd736d328de6 39 // Socket create
kishino 20:dd736d328de6 40 ret = createSocket();
kishino 20:dd736d328de6 41 if( ret != 0 )
kishino 20:dd736d328de6 42 {
kishino 40:b6b10c22a121 43 DEBUG_PRINT("createSocket error : %d\r\n", ret);
kishino 43:d80bbb12ffe6 44 FUNC_OUT();
kishino 20:dd736d328de6 45 return -1;
kishino 20:dd736d328de6 46 }
kishino 20:dd736d328de6 47
kishino 29:6a0ba999597d 48 int ip_addr = resolveHostName( host_p );
kishino 30:944b8c04b5ff 49 //lcd_printf("connect to [%s](%08x)\r\n", host_p, ip_addr);
kishino 29:6a0ba999597d 50 if( ( ip_addr == 0) || (ip_addr == -1) )
kishino 29:6a0ba999597d 51 {
kishino 43:d80bbb12ffe6 52 DEBUG_PRINT("connect resolveHostName failed\r\n");
kishino 43:d80bbb12ffe6 53 FUNC_OUT();
kishino 29:6a0ba999597d 54 return -1;
kishino 29:6a0ba999597d 55 }
kishino 29:6a0ba999597d 56
kishino 20:dd736d328de6 57 // Get buffer for response payload from MemoryPool
kishino 38:f13e4e563d65 58 tagMEMPOOL_BLOCK_T *payload_buf_p = snic_core_p->allocCmdBuf();
kishino 38:f13e4e563d65 59 if( payload_buf_p == NULL )
kishino 20:dd736d328de6 60 {
kishino 40:b6b10c22a121 61 DEBUG_PRINT("connect payload_buf_p NULL\r\n");
kishino 43:d80bbb12ffe6 62 FUNC_OUT();
kishino 20:dd736d328de6 63 return -1;
kishino 20:dd736d328de6 64 }
kishino 29:6a0ba999597d 65
kishino 27:dcc4f34448f0 66 // IP address convert to number from strings.
kishino 29:6a0ba999597d 67 // unsigned int ip_addr = addrToInteger(ip_addr_p);
kishino 27:dcc4f34448f0 68
kishino 29:6a0ba999597d 69 //
kishino 22:a9ec0cad4f84 70 C_SNIC_Core::tagSNIC_TCP_CONNECT_TO_SERVER_REQ_T req;
kishino 20:dd736d328de6 71 // Make request
kishino 20:dd736d328de6 72 req.cmd_sid = UART_CMD_SID_SNIC_TCP_CONNECT_TO_SERVER_REQ;
kishino 20:dd736d328de6 73 req.seq = mUartRequestSeq++;
kishino 20:dd736d328de6 74 req.socket_id = mSocketID;
kishino 20:dd736d328de6 75
kishino 20:dd736d328de6 76 // set ip addr ( byte order )
kishino 34:8c3527b8f44e 77 C_SNIC_UartMsgUtil::convertIntToByteAdday( ip_addr, (char *)req.remote_addr );
kishino 20:dd736d328de6 78 req.remote_port[0] = ( (port & 0xFF00) >> 8 );
kishino 20:dd736d328de6 79 req.remote_port[1] = (port & 0xFF);
kishino 20:dd736d328de6 80 req.recv_bufsize[0] = ( (SNIC_UART_RECVBUF_SIZE & 0xFF00) >> 8 );
kishino 20:dd736d328de6 81 req.recv_bufsize[1] = (SNIC_UART_RECVBUF_SIZE & 0xFF);
kishino 20:dd736d328de6 82 req.timeout = 60;
kishino 20:dd736d328de6 83
kishino 38:f13e4e563d65 84 unsigned char *command_array_p = snic_core_p->getCommandBuf();
kishino 20:dd736d328de6 85 unsigned int command_len;
kishino 20:dd736d328de6 86 // Preparation of command
kishino 24:987e412ae879 87 command_len = snic_core_p->preparationSendCommand( UART_CMD_ID_SNIC, req.cmd_sid, (unsigned char *)&req
kishino 38:f13e4e563d65 88 , sizeof(C_SNIC_Core::tagSNIC_TCP_CONNECT_TO_SERVER_REQ_T), payload_buf_p->buf, command_array_p );
kishino 20:dd736d328de6 89
kishino 29:6a0ba999597d 90 uartCmdMgr_p->setCommandSID( UART_CMD_SID_SNIC_TCP_CONNECTION_STATUS_IND );
kishino 29:6a0ba999597d 91
kishino 20:dd736d328de6 92 // Send uart command request
kishino 38:f13e4e563d65 93 snic_core_p->sendUart( command_len, command_array_p );
kishino 20:dd736d328de6 94
kishino 20:dd736d328de6 95 // Wait UART response
kishino 20:dd736d328de6 96 ret = uartCmdMgr_p->wait();
kishino 20:dd736d328de6 97 if( ret != 0 )
kishino 20:dd736d328de6 98 {
kishino 40:b6b10c22a121 99 DEBUG_PRINT( "connect failed\r\n" );
kishino 38:f13e4e563d65 100 snic_core_p->freeCmdBuf( payload_buf_p );
kishino 43:d80bbb12ffe6 101 FUNC_OUT();
kishino 20:dd736d328de6 102 return -1;
kishino 20:dd736d328de6 103 }
kishino 20:dd736d328de6 104
kishino 20:dd736d328de6 105 if( uartCmdMgr_p->getCommandStatus() != UART_CMD_RES_SNIC_CONNECTION_UP )
kishino 20:dd736d328de6 106 {
kishino 40:b6b10c22a121 107 DEBUG_PRINT("connect status:%02x\r\n", uartCmdMgr_p->getCommandStatus());
kishino 38:f13e4e563d65 108 snic_core_p->freeCmdBuf( payload_buf_p );
kishino 43:d80bbb12ffe6 109 FUNC_OUT();
kishino 20:dd736d328de6 110 return -1;
kishino 20:dd736d328de6 111 }
kishino 29:6a0ba999597d 112
kishino 38:f13e4e563d65 113 snic_core_p->freeCmdBuf( payload_buf_p );
kishino 20:dd736d328de6 114
kishino 20:dd736d328de6 115 // Initialize connection information
kishino 24:987e412ae879 116 C_SNIC_Core::tagCONNECT_INFO_T *con_info_p = snic_core_p->getConnectInfo( mSocketID );
kishino 20:dd736d328de6 117 if( con_info_p->recvbuf_p == NULL )
kishino 20:dd736d328de6 118 {
kishino 40:b6b10c22a121 119 DEBUG_PRINT( "create recv buffer[socket:%d]\r\n", mSocketID);
kishino 29:6a0ba999597d 120 con_info_p->recvbuf_p = new CircBuffer<char>(SNIC_UART_RECVBUF_SIZE);
kishino 20:dd736d328de6 121 }
kishino 20:dd736d328de6 122 con_info_p->is_connected = true;
kishino 20:dd736d328de6 123 con_info_p->is_received = false;
kishino 43:d80bbb12ffe6 124 FUNC_OUT();
kishino 20:dd736d328de6 125 return 0;
kishino 20:dd736d328de6 126 }
kishino 20:dd736d328de6 127
kishino 20:dd736d328de6 128 bool TCPSocketConnection::is_connected(void)
kishino 20:dd736d328de6 129 {
kishino 24:987e412ae879 130 C_SNIC_Core *snic_core_p = C_SNIC_Core::getInstance();
kishino 24:987e412ae879 131 C_SNIC_Core::tagCONNECT_INFO_T *con_info_p = snic_core_p->getConnectInfo( mSocketID );
kishino 20:dd736d328de6 132 return con_info_p->is_connected;
kishino 20:dd736d328de6 133 }
kishino 20:dd736d328de6 134
kishino 29:6a0ba999597d 135 int TCPSocketConnection::send(char* data_p, int length)
kishino 20:dd736d328de6 136 {
kishino 24:987e412ae879 137 C_SNIC_Core *snic_core_p = C_SNIC_Core::getInstance();
kishino 24:987e412ae879 138 C_SNIC_UartCommandManager *uartCmdMgr_p = snic_core_p->getUartCommand();
kishino 20:dd736d328de6 139
kishino 43:d80bbb12ffe6 140 FUNC_IN();
kishino 20:dd736d328de6 141 // Get buffer for response payload from MemoryPool
kishino 38:f13e4e563d65 142 tagMEMPOOL_BLOCK_T *payload_buf_p = snic_core_p->allocCmdBuf();
kishino 38:f13e4e563d65 143 if( payload_buf_p == NULL )
kishino 20:dd736d328de6 144 {
kishino 40:b6b10c22a121 145 DEBUG_PRINT("connect payload_buf_p NULL\r\n");
kishino 43:d80bbb12ffe6 146 FUNC_OUT();
kishino 20:dd736d328de6 147 return -1;
kishino 20:dd736d328de6 148 }
kishino 29:6a0ba999597d 149
kishino 22:a9ec0cad4f84 150 C_SNIC_Core::tagSNIC_TCP_SEND_FROM_SOCKET_REQ_T req;
kishino 20:dd736d328de6 151 // Make request
kishino 20:dd736d328de6 152 req.cmd_sid = UART_CMD_SID_SNIC_SEND_FROM_SOCKET_REQ;
kishino 20:dd736d328de6 153 req.seq = mUartRequestSeq++;
kishino 20:dd736d328de6 154 req.socket_id = mSocketID;
kishino 20:dd736d328de6 155 req.option = 0;
kishino 20:dd736d328de6 156 req.payload_len[0]= ( (length & 0xFF00) >> 8 );
kishino 20:dd736d328de6 157 req.payload_len[1]= (length & 0xFF);
kishino 20:dd736d328de6 158
kishino 34:8c3527b8f44e 159 int req_size = sizeof(C_SNIC_Core::tagSNIC_TCP_SEND_FROM_SOCKET_REQ_T);
kishino 34:8c3527b8f44e 160 char *send_buf_p = getSocketSendBuf();
kishino 34:8c3527b8f44e 161 memcpy( send_buf_p, &req, req_size );
kishino 34:8c3527b8f44e 162 memcpy( &send_buf_p[req_size], data_p, length );
kishino 20:dd736d328de6 163
kishino 38:f13e4e563d65 164 unsigned char *command_array_p = snic_core_p->getCommandBuf();
kishino 29:6a0ba999597d 165 unsigned int command_len;
kishino 20:dd736d328de6 166 // Preparation of command
kishino 34:8c3527b8f44e 167 command_len = snic_core_p->preparationSendCommand( UART_CMD_ID_SNIC, req.cmd_sid, (unsigned char *)send_buf_p
kishino 38:f13e4e563d65 168 , req_size + length, payload_buf_p->buf, command_array_p );
kishino 20:dd736d328de6 169
kishino 20:dd736d328de6 170 // Send uart command request
kishino 38:f13e4e563d65 171 snic_core_p->sendUart( command_len, command_array_p );
kishino 20:dd736d328de6 172
kishino 20:dd736d328de6 173 // Wait UART response
kishino 20:dd736d328de6 174 int ret = uartCmdMgr_p->wait();
kishino 20:dd736d328de6 175 if( ret != 0 )
kishino 20:dd736d328de6 176 {
kishino 40:b6b10c22a121 177 DEBUG_PRINT( "send failed\r\n" );
kishino 38:f13e4e563d65 178 snic_core_p->freeCmdBuf( payload_buf_p );
kishino 43:d80bbb12ffe6 179 FUNC_OUT();
kishino 20:dd736d328de6 180 return -1;
kishino 20:dd736d328de6 181 }
kishino 20:dd736d328de6 182
kishino 20:dd736d328de6 183 if( uartCmdMgr_p->getCommandStatus() != UART_CMD_RES_SNIC_SUCCESS )
kishino 20:dd736d328de6 184 {
kishino 40:b6b10c22a121 185 DEBUG_PRINT("send status:%02x\r\n", uartCmdMgr_p->getCommandStatus());
kishino 38:f13e4e563d65 186 snic_core_p->freeCmdBuf( payload_buf_p );
kishino 43:d80bbb12ffe6 187 FUNC_OUT();
kishino 20:dd736d328de6 188 return -1;
kishino 20:dd736d328de6 189 }
kishino 38:f13e4e563d65 190 snic_core_p->freeCmdBuf( payload_buf_p );
kishino 20:dd736d328de6 191
kishino 20:dd736d328de6 192 // SNIC_SEND_FROM_SOCKET_REQ
kishino 43:d80bbb12ffe6 193 FUNC_OUT();
MACRUM 48:ee7e07fb401f 194 return length;
kishino 20:dd736d328de6 195 }
kishino 20:dd736d328de6 196
kishino 29:6a0ba999597d 197 int TCPSocketConnection::send_all(char *data_p, int length)
kishino 29:6a0ba999597d 198 {
kishino 29:6a0ba999597d 199 return send( data_p, length );
kishino 29:6a0ba999597d 200 }
kishino 29:6a0ba999597d 201
kishino 29:6a0ba999597d 202 int TCPSocketConnection::receive(char* data_p, int length)
kishino 20:dd736d328de6 203 {
kishino 20:dd736d328de6 204 int i = 0;
kishino 20:dd736d328de6 205
kishino 43:d80bbb12ffe6 206 FUNC_IN();
kishino 20:dd736d328de6 207 if( (data_p == NULL) || (length < 1) )
kishino 20:dd736d328de6 208 {
kishino 40:b6b10c22a121 209 DEBUG_PRINT("TCPSocketConnection::receive parameter error\r\n");
kishino 43:d80bbb12ffe6 210 FUNC_OUT();
kishino 20:dd736d328de6 211 return -1;
kishino 20:dd736d328de6 212 }
kishino 20:dd736d328de6 213
kishino 24:987e412ae879 214 C_SNIC_Core *snic_core_p = C_SNIC_Core::getInstance();
kishino 20:dd736d328de6 215 // Initialize connection information
kishino 24:987e412ae879 216 C_SNIC_Core::tagCONNECT_INFO_T *con_info_p = snic_core_p->getConnectInfo( mSocketID );
kishino 20:dd736d328de6 217 if( con_info_p->recvbuf_p == NULL )
kishino 20:dd736d328de6 218 {
kishino 40:b6b10c22a121 219 DEBUG_PRINT("TCPSocketConnection::receive Conncection info error\r\n");
kishino 43:d80bbb12ffe6 220 FUNC_OUT();
kishino 20:dd736d328de6 221 return -1;
kishino 20:dd736d328de6 222 }
kishino 20:dd736d328de6 223
kishino 20:dd736d328de6 224 // Check connection
kishino 20:dd736d328de6 225 if( con_info_p->is_connected == false )
kishino 20:dd736d328de6 226 {
kishino 40:b6b10c22a121 227 DEBUG_PRINT(" Socket id \"%d\" is not connected\r\n", mSocketID);
kishino 43:d80bbb12ffe6 228 FUNC_OUT();
kishino 20:dd736d328de6 229 return -1;
kishino 20:dd736d328de6 230 }
kishino 43:d80bbb12ffe6 231 con_info_p->is_receive_complete = true;
MACRUM 48:ee7e07fb401f 232 if( con_info_p->is_received == false )
kishino 20:dd736d328de6 233 {
MACRUM 48:ee7e07fb401f 234 // Try receive
kishino 43:d80bbb12ffe6 235 Thread::yield();
MACRUM 48:ee7e07fb401f 236
MACRUM 48:ee7e07fb401f 237 if( con_info_p->is_received == false )
MACRUM 48:ee7e07fb401f 238 {
MACRUM 48:ee7e07fb401f 239 // No data received.
MACRUM 48:ee7e07fb401f 240 FUNC_OUT();
MACRUM 48:ee7e07fb401f 241 return 0;
MACRUM 48:ee7e07fb401f 242 }
kishino 20:dd736d328de6 243 }
kishino 20:dd736d328de6 244 // Get packet data from buffer for receive.
kishino 20:dd736d328de6 245 for (i = 0; i < length; i ++)
kishino 20:dd736d328de6 246 {
kishino 20:dd736d328de6 247 if (con_info_p->recvbuf_p->dequeue(&data_p[i]) == false)
kishino 20:dd736d328de6 248 {
kishino 20:dd736d328de6 249 break;
kishino 20:dd736d328de6 250 }
kishino 20:dd736d328de6 251 }
kishino 20:dd736d328de6 252
kishino 20:dd736d328de6 253 if( con_info_p->recvbuf_p->isEmpty() )
kishino 20:dd736d328de6 254 {
kishino 39:a1233ca02edf 255 con_info_p->mutex.lock();
kishino 20:dd736d328de6 256 con_info_p->is_received = false;
kishino 39:a1233ca02edf 257 con_info_p->mutex.unlock();
kishino 20:dd736d328de6 258 }
kishino 20:dd736d328de6 259
kishino 43:d80bbb12ffe6 260 FUNC_OUT();
kishino 20:dd736d328de6 261 return i;
kishino 20:dd736d328de6 262 }
kishino 32:ae95309643aa 263
MACRUM 48:ee7e07fb401f 264 int TCPSocketConnection::receive_all(char* data_p, int length)
MACRUM 48:ee7e07fb401f 265 {
MACRUM 48:ee7e07fb401f 266 return receive( data_p, length );
MACRUM 48:ee7e07fb401f 267 }
MACRUM 48:ee7e07fb401f 268
kishino 32:ae95309643aa 269 void TCPSocketConnection::setAcceptSocket( int socket_id )
kishino 32:ae95309643aa 270 {
kishino 43:d80bbb12ffe6 271 FUNC_IN();
kishino 32:ae95309643aa 272 mSocketID = socket_id;
kishino 32:ae95309643aa 273 }