Diff: C027Interface.cpp

Revision:

14:3d1845f5cd81

Parent:

12:181a9415736b

Child:

15:21d4f56eb172

--- a/C027Interface.cpp	Fri Apr 15 16:08:40 2016 +0000
+++ b/C027Interface.cpp	Thu Apr 21 06:53:31 2016 -0500
@@ -30,7 +30,7 @@
     strcpy(_pin, simpin);
 }
 
-int32_t C027Interface::connect(const char *apn, const char *username, const char *password)
+int C027Interface::connect(const char *apn, const char *username, const char *password)
 {
     // create the modem
     _mdm = new MDMSerial;
@@ -56,122 +56,164 @@
         }
     }
     
-    if (mdmOk)
-    {
+    if (mdmOk) {
         // join the internet connection 
         MDMParser::IP ip = _mdm->join(apn, username, password);
         ipToString(ip, _ip_address);
         mdmOk = (ip != NOIP);
     }
     
-    return mdmOk ? 0 : NS_ERROR_DEVICE_ERROR;
+    return mdmOk ? 0 : NSAPI_ERROR_DEVICE_ERROR;
 }
 
-int32_t C027Interface::disconnect()
+int C027Interface::disconnect()
 {
     if (!_mdm->disconnect()) {
-        return NS_ERROR_DEVICE_ERROR;
+        return NSAPI_ERROR_DEVICE_ERROR;
     }
     
     return 0;
 }
 
-const char *C027Interface::getIPAddress()
+const char *C027Interface::get_ip_address()
 {
     return _ip_address;
 }
 
-const char *C027Interface::getMACAddress()
+const char *C027Interface::get_mac_address()
 {
     return 0;
 }
 
-SocketInterface *C027Interface::createSocket(ns_protocol_t proto)
+struct c027_socket {
+    int socket;
+    MDMParser::IpProtocol proto;
+    MDMParser::IP ip;
+    int port;
+};
+
+int C027Interface::socket_open(void **handle, nsapi_protocol_t proto)
 {
-    MDMParser::IpProtocol mdmproto = (proto == NS_UDP) ? MDMParser::IPPROTO_UDP : MDMParser::IPPROTO_TCP;
-    int socket = _mdm->socketSocket(mdmproto);
-    if (socket < 0) {
-        return 0;
+    MDMParser::IpProtocol mdmproto = (proto == NSAPI_UDP) ? MDMParser::IPPROTO_UDP : MDMParser::IPPROTO_TCP;
+    int fd = _mdm->socketSocket(mdmproto);
+    if (fd < 0) {
+        return NSAPI_ERROR_NO_SOCKET;
     }
     
-    _mdm->socketSetBlocking(socket, 10000);
+    _mdm->socketSetBlocking(fd, 10000);
+    struct c027_socket *socket = new struct c027_socket;
+    if (!socket) {
+        return NSAPI_ERROR_NO_SOCKET;
+    }
 
-    return new C027Socket(_mdm, socket, mdmproto);
+    socket->socket = fd;
+    socket->proto = mdmproto;
+    *handle = socket;
+    return 0;
 }
 
-void C027Interface::destroySocket(SocketInterface *siface)
+int C027Interface::socket_close(void *handle)
 {
-    C027Socket *socket = (C027Socket *)siface;
-    _mdm->socketFree(socket->_socket);
+    struct c027_socket *socket = (struct c027_socket *)handle;
+    _mdm->socketFree(socket->socket);
 
     delete socket;
+    return 0;
 }
 
+int C027Interface::socket_bind(void *handle, const SocketAddress &address)
+{
+    return NSAPI_ERROR_UNSUPPORTED;
+}
 
-// TCP SocketInterface implementation
-int32_t C027Interface::C027Socket::open(const char *ip, uint16_t port)
+int C027Interface::socket_listen(void *handle, int backlog)
 {
-    _ip = _mdm->gethostbyname(ip);
-    _port = port;
+    return NSAPI_ERROR_UNSUPPORTED;
+}
+
+int C027Interface::socket_connect(void *handle, const SocketAddress &addr)
+{
+    struct c027_socket *socket = (struct c027_socket *)handle;
     
-    if (_proto == MDMParser::IPPROTO_TCP) {
-        if (!_mdm->socketConnect(_socket, ip, port)) {
-            return NS_ERROR_DEVICE_ERROR;
-        }
+    if (!_mdm->socketConnect(socket->socket, addr.get_ip_address(), addr.get_port())) {
+        return NSAPI_ERROR_DEVICE_ERROR;
     }
     
     return 0;
 }
 
-int32_t C027Interface::C027Socket::close()
+int C027Interface::socket_accept(void **handle, void *server)
 {
-    if (_proto == MDMParser::IPPROTO_TCP) {
-        if (!_mdm->socketClose(_socket)) {
-            return NS_ERROR_DEVICE_ERROR;
-        }
-    }
-    
-    return 0;
+    return NSAPI_ERROR_UNSUPPORTED;
 }
 
-int32_t C027Interface::C027Socket::send(const void *data, uint32_t size)
+int C027Interface::socket_send(void *handle, const void *data, unsigned size)
 {
-    int sent;
-    
-    if (_proto == MDMParser::IPPROTO_TCP) {
-        sent = _mdm->socketSend(_socket, (const char *)data, size);
-    } else {
-        sent = _mdm->socketSendTo(_socket, _ip, _port, (const char *)data, size);
-    }   
-        
-    if (sent != size) {
-        return NS_ERROR_DEVICE_ERROR;
+    struct c027_socket *socket = (struct c027_socket *)handle;
+
+    int sent = _mdm->socketSend(socket->socket, (const char *)data, size);
+    if (sent == SOCKET_ERROR) {
+        return NSAPI_ERROR_DEVICE_ERROR;
     }
     
-    return 0;
+    return sent;
 }
 
-int32_t C027Interface::C027Socket::recv(void *data, uint32_t size)
+int C027Interface::socket_recv(void *handle, void *data, unsigned size)
 {
-    if (!_mdm->socketReadable(_socket)) {
-        return NS_ERROR_WOULD_BLOCK;
+    struct c027_socket *socket = (struct c027_socket *)handle;
+    if (!_mdm->socketReadable(socket->socket)) {
+        return NSAPI_ERROR_WOULD_BLOCK;
     }
     
-    int recv;
-    
-    if (_proto == MDMParser::IPPROTO_TCP) {
-        recv = _mdm->socketRecv(_socket, (char *)data, size);
-    } else {
-        MDMParser::IP ip;
-        int port;
-        recv = _mdm->socketRecvFrom(_socket, &ip, &port, (char *)data, size);
-    }
-    
+    int recv = _mdm->socketRecv(socket->socket, (char *)data, size);
     if (recv == SOCKET_ERROR) {
-        return NS_ERROR_DEVICE_ERROR;
+        return NSAPI_ERROR_DEVICE_ERROR;
     }
     
     return recv;
 }
 
+int C027Interface::socket_sendto(void *handle, const SocketAddress &addr, const void *data, unsigned size)
+{
+    struct c027_socket *socket = (struct c027_socket *)handle;
 
+    MDMParser::IP ip = _mdm->gethostbyname(addr.get_ip_address());
+    uint16_t port = addr.get_port();
+
+    int sent = _mdm->socketSendTo(socket->socket, ip, port, (const char *)data, size);
+    if (sent == SOCKET_ERROR) {
+        return NSAPI_ERROR_DEVICE_ERROR;
+    }
+    
+    return sent;
+}
+
+int C027Interface::socket_recvfrom(void *handle, SocketAddress *addr, void *data, unsigned size)
+{
+    struct c027_socket *socket = (struct c027_socket *)handle;
+    if (!_mdm->socketReadable(socket->socket)) {
+        return NSAPI_ERROR_WOULD_BLOCK;
+    }
+    
+    MDMParser::IP ip;
+    int port;
+
+    int recv = _mdm->socketRecvFrom(socket->socket, &ip, &port, (char *)data, size);
+    if (recv == SOCKET_ERROR) {
+        return NSAPI_ERROR_DEVICE_ERROR;
+    }
+
+    if (addr) {
+        char buffer[NSAPI_IP_SIZE];
+        ipToString(ip, buffer);
+        addr->set_ip_address(buffer);
+        addr->set_port(port);
+    }
+    
+    return recv;
+}
+
+void C027Interface::socket_attach(void *handle, void (*callback)(void *), void *data)
+{
+}