File content as of revision 6:e7a3fca2df10:

/* SpwfSAInterface implementation of NetworkInterfaceAPI
 * Copyright (c) 2015 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "SPWFInterface.h"
 
// Various timeouts for different SPWF operations
#define SPWF_CONNECT_TIMEOUT 20000
#define SPWF_SEND_TIMEOUT    500
#define SPWF_RECV_TIMEOUT    2000
#define SPWF_MISC_TIMEOUT    15000

// Handle structure for socket
struct spwf_socket {
    int id;
    int server_port;
    nsapi_protocol_t proto;
    bool connected;
};

// SpwfSAInterface implementation
SpwfSAInterface::SpwfSAInterface(PinName tx, PinName rx, PinName rst, PinName wkup, PinName rts, bool debug)
    : _spwf(tx, rx, rst, wkup, rts)
{
    memset(_ids, 0, sizeof(_ids));
    isInitialized = false;
    isListening = false;
}
 
SpwfSAInterface::~SpwfSAInterface()
{
}

int SpwfSAInterface::init(void) 
{
    _spwf.setTimeout(SPWF_MISC_TIMEOUT);
    return (_spwf.init());
}

int SpwfSAInterface::connect(
    const char *ap, 
    const char *pass_phrase, 
    nsapi_security_t security)
{
    //initialize the device before connecting
    if(!isInitialized)
    {
        if(init()==0)
            isInitialized=true;
        else return NSAPI_ERROR_DEVICE_ERROR;
    }
    
    _spwf.setTimeout(SPWF_CONNECT_TIMEOUT);
    
    if(security == NSAPI_SECURITY_WPA2) return NSAPI_ERROR_DEVICE_ERROR;
    
    WiFi_Priv_Mode mode = (WiFi_Priv_Mode)security;
  
    return (_spwf.connect((char*)ap, (char*)pass_phrase, mode));//0 on success
}
 
int SpwfSAInterface::disconnect()
{    
    return (_spwf.disconnect());
}
 
const char *SpwfSAInterface::get_ip_address()
{
    return _spwf.getIPAddress();
}
 
const char *SpwfSAInterface::get_mac_address()
{
    return _spwf.getMACAddress();
}


int SpwfSAInterface::socket_open(void **handle, nsapi_protocol_t proto)
{
    // Look for an unused socket
    int id = -1;    

    struct spwf_socket *socket = new struct spwf_socket;
    if (!socket) {
        return NSAPI_ERROR_NO_SOCKET;
    }

    socket->id = id;
    socket->server_port = id;
    socket->proto = proto;
    socket->connected = false;
    *handle = socket;
    return 0;
}

int SpwfSAInterface::socket_connect(void *handle, const SocketAddress &addr)
{
    uint8_t sock_id = 99;
    struct spwf_socket *socket = (struct spwf_socket *)handle;
    
    const char *proto = (socket->proto == NSAPI_UDP) ? "u" : "t";//"s" for secure socket?
 
    _spwf.socket_client_open((uint8_t*)addr.get_ip_address(), (uint32_t)addr.get_port(), (uint8_t *)proto, &sock_id);//sock ID is allocated NOW
    
    //TODO: Maintain a socket table to map socket ID to host & port
    //TODO: lookup on client table to see if already socket is allocated to same host/port
    //multimap <char *, vector <uint16_t> > ::iterator i = c_table.find((char*)ip);
      
    if(sock_id <= SPWFSA_SOCKET_COUNT)
    {
        //_ids[socket->id] = false;
        socket->id = sock_id;//the socket ID of this Socket instance
        _ids[socket->id] = true;
        socket->connected = true;
    }
    else 
        return NSAPI_ERROR_NO_SOCKET;
    
    return 0;//0 means SUCCESS
}

int SpwfSAInterface::socket_bind(void *handle, const SocketAddress &address)
{
    struct spwf_socket *socket = (struct spwf_socket *)handle;
    socket->id = SERVER_SOCKET_NO;//Special socket ID number for Server Socket
    socket->server_port = address.get_port();
    return 0;
}

int SpwfSAInterface::socket_listen(void *handle, int backlog)
{
    struct spwf_socket *socket = (struct spwf_socket *)handle;
    int err;
    
    if(socket->server_port==-1 || isListening) 
        return NSAPI_ERROR_NO_SOCKET; //server socket not bound or already listening
    
    const char *proto = (socket->proto == NSAPI_UDP) ? "u" : "t";
    
    err = _spwf.socket_server_open((uint32_t)socket->server_port, (uint8_t *)proto);
    
    if(err==0)
    {
        isListening = true;
    }
    else 
        return NSAPI_ERROR_DEVICE_ERROR;
        
    return err;
}

/** Accepts a connection on a TCP socket
     *
     *  The server socket must be bound and set to listen for connections.
     *  On a new connection, creates a network socket using the specified
     *  socket instance.
     *
     *  By default, accept blocks until data is sent. If socket is set to
     *  non-blocking or times out, NSAPI_ERROR_WOULD_BLOCK is returned
     *  immediately.
     *
     *  @param socket   TCPSocket instance that will handle the incoming connection.
     *  @return         0 on success, negative error code on failure
     */
int SpwfSAInterface::socket_accept(void **handle, void *server)
{
    char debug_str[10];
    struct spwf_socket *server_socket = (struct spwf_socket *)server;
    int id = -1;
    
    if(server_socket->server_port==-1 || !isListening) 
        return NSAPI_ERROR_NO_SOCKET; //server socket not bound or not listening
    
    while(true)
    {        
        if(_spwf.get_wait_for_incoming_client())
        {
            server_socket->connected = true;

            //struct spwf_socket *temp_socket;// = new struct spwf_socket;//create new network socket
            struct spwf_socket *socket = new struct spwf_socket;//create new network socket
            if (!socket) {
                return NSAPI_ERROR_NO_SOCKET;
            }
            
            memset(socket, 0, sizeof (struct spwf_socket));
            /*
            if(get_network_socket(&temp_socket)!=0)
            {
                return NSAPI_ERROR_NO_SOCKET;
            }*/
            
            socket->id = server_socket->id;
            socket->server_port = server_socket->server_port;
            socket->proto = server_socket->proto;
            socket->connected = true;
            
            *handle = socket; 
            socket = 0;
            _spwf.set_wait_for_incoming_client(false);//reset
            wait_ms(50);//CHECK:TODO:Why do we need this?
            break;
        }
    }
    
    return 0;
}

/*
int SpwfSAInterface::get_network_socket(struct spwf_socket **handle)
{
    struct spwf_socket *__socket = new struct spwf_socket;//create new network socket
    __socket = new struct spwf_socket;//create new network socket
    if (!__socket) {
        return NSAPI_ERROR_NO_SOCKET;
    }
    
    memset(__socket, 0, sizeof (struct spwf_socket));
    *handle = __socket;
    return 0;
}
*/

int SpwfSAInterface::socket_close(void *handle)
{
    struct spwf_socket *socket = (struct spwf_socket *)handle;
    int err = 0;
    //_spwf.setTimeout(SPWF_MISC_TIMEOUT);
    
    if(socket->id!=-1)
    {
        if(socket->id==SERVER_SOCKET_NO)
        {
            if (_spwf.socket_server_close()==-1) {
                err = NSAPI_ERROR_DEVICE_ERROR;
            }
            isListening = false;
        }
        else
        {
            if (_spwf.socket_client_close(socket->id)==-1) {
                err = NSAPI_ERROR_DEVICE_ERROR;
            }
            _ids[socket->id] = false;
        }
    }

    delete socket;
    return err;
}

int SpwfSAInterface::socket_send(void *handle, const void *data, unsigned size)
{    
    struct spwf_socket *socket = (struct spwf_socket *)handle;
    int err;
    
    if(socket->id==SERVER_SOCKET_NO)
        {
            err = _spwf.socket_server_write((uint16_t)size, (char*)data);
        }
    else
        {
            err = _spwf.socket_client_write((uint8_t)socket->id, (uint16_t)size, (char*)data);
        }
    
    return err;
}

//return no of bytes read
int SpwfSAInterface::socket_recv(void *handle, void *data, unsigned size)
{
    struct spwf_socket *socket = (struct spwf_socket *)handle;
    int32_t recv;
    
    _spwf.setTimeout(SPWF_RECV_TIMEOUT);
    
    //CHECK:Receive for both Client and Server Sockets same?
    recv = _spwf.socket_client_recv((uint8_t)socket->id, (uint16_t)size, (char*)data);    
    if (recv < 0) {
        return NSAPI_ERROR_WOULD_BLOCK;
    }
    return recv;
    
}

int SpwfSAInterface::socket_sendto(void *handle, const SocketAddress &addr, const void *data, unsigned size)
{
    struct spwf_socket *socket = (struct spwf_socket *)handle;
    if (!socket->connected) {
        int err = socket_connect(socket, addr);
        if (err < 0) {
            return err;
        }
    }
    
    return socket_send(socket, data, size);
}

int SpwfSAInterface::socket_recvfrom(void *handle, SocketAddress *addr, void *data, unsigned size)
{
    struct spwf_socket *socket = (struct spwf_socket *)handle;    
    return socket_recv(socket, data, size);
}

void SpwfSAInterface::socket_attach(void *handle, void (*callback)(void *), void *data)
{
    //No implementation yet
}

void SpwfSAInterface::debug(const char * string)
{
    _spwf.debug_print(string);
}