NetworkStack.cpp

00001 /* Socket
00002  * Copyright (c) 2015 ARM Limited
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *     http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #include "NetworkStack.h"
00018 #include "nsapi_dns.h"
00019 #include "mbed.h"
00020 #include "stddef.h"
00021 #include <new>
00022 
00023 
00024 // Default NetworkStack operations
00025 int NetworkStack::gethostbyname(SocketAddress *address, const char *name)
00026 {
00027     return nsapi_dns_query(this, address, name);
00028 }
00029 
00030 int NetworkStack::setstackopt(int level, int optname, const void *optval, unsigned optlen)
00031 {
00032     return NSAPI_ERROR_UNSUPPORTED;
00033 }
00034 
00035 int NetworkStack::getstackopt(int level, int optname, void *optval, unsigned *optlen)
00036 {
00037     return NSAPI_ERROR_UNSUPPORTED;
00038 }
00039 
00040 int NetworkStack::setsockopt(void *handle, int level, int optname, const void *optval, unsigned optlen)
00041 {
00042     return NSAPI_ERROR_UNSUPPORTED;
00043 }
00044 
00045 int NetworkStack::getsockopt(void *handle, int level, int optname, void *optval, unsigned *optlen)
00046 {
00047     return NSAPI_ERROR_UNSUPPORTED;
00048 }
00049 
00050 
00051 // NetworkStackWrapper class for encapsulating the raw nsapi_stack structure
00052 class NetworkStackWrapper : public NetworkStack
00053 {
00054 private:
00055     inline nsapi_stack_t *_stack()
00056     {
00057         return reinterpret_cast<nsapi_stack_t *>(
00058                 reinterpret_cast<uint8_t *>(this)
00059                 - offsetof(nsapi_stack_t, _stack_buffer));
00060     }
00061 
00062     inline const nsapi_stack_api_t *_stack_api()
00063     {
00064         return _stack()->stack_api;
00065     }
00066 
00067 public:
00068     virtual const char *get_ip_address()
00069     {
00070         if (!_stack_api()->get_ip_address) {
00071             return 0;
00072         }
00073 
00074         static uint8_t buffer[sizeof(SocketAddress)];
00075         SocketAddress *address = new (buffer) SocketAddress(_stack_api()->get_ip_address(_stack()));
00076         return address->get_ip_address();
00077     }
00078 
00079     virtual int gethostbyname(SocketAddress *address, const char *name)
00080     {
00081         if (!_stack_api()->gethostbyname) {
00082             return NetworkStack::gethostbyname(address, name);
00083         }
00084 
00085         nsapi_addr_t addr = {NSAPI_IPv4, 0};
00086         int err = _stack_api()->gethostbyname(_stack(), &addr, name);
00087         address->set_addr(addr);
00088         return err;
00089     }
00090 
00091     virtual int setstackopt(int level, int optname, const void *optval, unsigned optlen)
00092     {
00093         if (!_stack_api()->setstackopt) {
00094             return NSAPI_ERROR_UNSUPPORTED;
00095         }
00096 
00097         return _stack_api()->setstackopt(_stack(), level, optname, optval, optlen);
00098     }
00099 
00100     virtual int getstackopt(int level, int optname, void *optval, unsigned *optlen)
00101     {
00102         if (!_stack_api()->getstackopt) {
00103             return NSAPI_ERROR_UNSUPPORTED;
00104         }
00105 
00106         return _stack_api()->getstackopt(_stack(), level, optname, optval, optlen);
00107     }
00108 
00109 protected:
00110     virtual int socket_open(nsapi_socket_t *socket, nsapi_protocol_t proto)
00111     {
00112         if (!_stack_api()->socket_open) {
00113             return NSAPI_ERROR_UNSUPPORTED;
00114         }
00115 
00116         return _stack_api()->socket_open(_stack(), socket, proto);
00117     }
00118 
00119     virtual int socket_close(nsapi_socket_t socket)
00120     {
00121         if (!_stack_api()->socket_close) {
00122             return NSAPI_ERROR_UNSUPPORTED;
00123         }
00124 
00125         return _stack_api()->socket_close(_stack(), socket);
00126     }
00127 
00128     virtual int socket_bind(nsapi_socket_t socket, const SocketAddress &address)
00129     {
00130         if (!_stack_api()->socket_bind) {
00131             return NSAPI_ERROR_UNSUPPORTED;
00132         }
00133 
00134         return _stack_api()->socket_bind(_stack(), socket, address.get_addr(), address.get_port());
00135     }
00136 
00137     virtual int socket_listen(nsapi_socket_t socket, int backlog)
00138     {
00139         if (!_stack_api()->socket_listen) {
00140             return NSAPI_ERROR_UNSUPPORTED;
00141         }
00142 
00143         return _stack_api()->socket_listen(_stack(), socket, backlog);
00144     }
00145 
00146     virtual int socket_connect(nsapi_socket_t socket, const SocketAddress &address)
00147     {
00148         if (!_stack_api()->socket_connect) {
00149             return NSAPI_ERROR_UNSUPPORTED;
00150         }
00151 
00152         return _stack_api()->socket_connect(_stack(), socket, address.get_addr(), address.get_port());
00153     }
00154 
00155     virtual int socket_accept(nsapi_socket_t server, nsapi_socket_t *socket, SocketAddress *address)
00156     {
00157         if (!_stack_api()->socket_accept) {
00158             return NSAPI_ERROR_UNSUPPORTED;
00159         }
00160 
00161         nsapi_addr_t addr = {NSAPI_IPv4, 0};
00162         uint16_t port = 0;
00163 
00164         int err = _stack_api()->socket_accept(_stack(), server, socket, &addr, &port);
00165 
00166         if (address) {
00167             address->set_addr(addr);
00168             address->set_port(port);
00169         }
00170 
00171         return err;
00172     }
00173 
00174     virtual int socket_send(nsapi_socket_t socket, const void *data, unsigned size)
00175     {
00176         if (!_stack_api()->socket_send) {
00177             return NSAPI_ERROR_UNSUPPORTED;
00178         }
00179 
00180         return _stack_api()->socket_send(_stack(), socket, data, size);
00181     }
00182 
00183     virtual int socket_recv(nsapi_socket_t socket, void *data, unsigned size)
00184     {
00185         if (!_stack_api()->socket_recv) {
00186             return NSAPI_ERROR_UNSUPPORTED;
00187         }
00188 
00189         return _stack_api()->socket_recv(_stack(), socket, data, size);
00190     }
00191 
00192     virtual int socket_sendto(nsapi_socket_t socket, const SocketAddress &address, const void *data, unsigned size)
00193     {
00194         if (!_stack_api()->socket_sendto) {
00195             return NSAPI_ERROR_UNSUPPORTED;
00196         }
00197 
00198         return _stack_api()->socket_sendto(_stack(), socket, address.get_addr(), address.get_port(), data, size);
00199     }
00200 
00201     virtual int socket_recvfrom(nsapi_socket_t socket, SocketAddress *address, void *data, unsigned size)
00202     {
00203         if (!_stack_api()->socket_recvfrom) {
00204             return NSAPI_ERROR_UNSUPPORTED;
00205         }
00206 
00207         nsapi_addr_t addr = {NSAPI_IPv4, 0};
00208         uint16_t port = 0;
00209 
00210         int err = _stack_api()->socket_recvfrom(_stack(), socket, &addr, &port, data, size);
00211 
00212         if (address) {
00213             address->set_addr(addr);
00214             address->set_port(port);
00215         }
00216 
00217         return err;
00218     }
00219 
00220     virtual void socket_attach(nsapi_socket_t socket, void (*callback)(void *), void *data)
00221     {
00222         if (!_stack_api()->socket_attach) {
00223             return;
00224         }
00225 
00226         return _stack_api()->socket_attach(_stack(), socket, callback, data);
00227     }
00228 
00229     virtual int setsockopt(nsapi_socket_t socket, int level, int optname, const void *optval, unsigned optlen)
00230     {
00231         if (!_stack_api()->setsockopt) {
00232             return NSAPI_ERROR_UNSUPPORTED;
00233         }
00234 
00235         return _stack_api()->setsockopt(_stack(), socket, level, optname, optval, optlen);
00236     }
00237 
00238     virtual int getsockopt(nsapi_socket_t socket, int level, int optname, void *optval, unsigned *optlen)
00239     {
00240         if (!_stack_api()->getsockopt) {
00241             return NSAPI_ERROR_UNSUPPORTED;
00242         }
00243 
00244         return _stack_api()->getsockopt(_stack(), socket, level, optname, optval, optlen);
00245     }
00246 };
00247 
00248 
00249 // Conversion function for network stacks
00250 NetworkStack *nsapi_create_stack(nsapi_stack_t *stack)
00251 {
00252     MBED_ASSERT(sizeof stack->_stack_buffer >= sizeof(NetworkStackWrapper));
00253     return new (stack->_stack_buffer) NetworkStackWrapper;
00254 }
00255 
00256 NetworkStack *nsapi_create_stack(NetworkStack *stack)
00257 {
00258     return stack;
00259 }
00260