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(const char *name, SocketAddress *address)
00026 {
00027     // check for simple ip addresses
00028     if (address->set_ip_address(name)) {
00029         return 0;
00030     }
00031 
00032     return nsapi_dns_query(this, name, address);
00033 }
00034 
00035 int NetworkStack::gethostbyname(const char *name, SocketAddress *address, nsapi_version_t version)
00036 {
00037     // check for simple ip addresses
00038     if (address->set_ip_address(name)) {
00039         if (address->get_ip_version() != version) {
00040             return NSAPI_ERROR_DNS_FAILURE ;
00041         }
00042 
00043         return 0;
00044     }
00045 
00046     return nsapi_dns_query(this, name, address, version);
00047 }
00048 
00049 int NetworkStack::add_dns_server(const SocketAddress &address)
00050 {
00051     return nsapi_dns_add_server(address);
00052 }
00053 
00054 int NetworkStack::setstackopt(int level, int optname, const void *optval, unsigned optlen)
00055 {
00056     return NSAPI_ERROR_UNSUPPORTED ;
00057 }
00058 
00059 int NetworkStack::getstackopt(int level, int optname, void *optval, unsigned *optlen)
00060 {
00061     return NSAPI_ERROR_UNSUPPORTED ;
00062 }
00063 
00064 int NetworkStack::setsockopt(void *handle, int level, int optname, const void *optval, unsigned optlen)
00065 {
00066     return NSAPI_ERROR_UNSUPPORTED ;
00067 }
00068 
00069 int NetworkStack::getsockopt(void *handle, int level, int optname, void *optval, unsigned *optlen)
00070 {
00071     return NSAPI_ERROR_UNSUPPORTED ;
00072 }
00073 
00074 
00075 // NetworkStackWrapper class for encapsulating the raw nsapi_stack structure
00076 class NetworkStackWrapper : public NetworkStack
00077 {
00078 private:
00079     inline nsapi_stack_t *_stack()
00080     {
00081         return reinterpret_cast<nsapi_stack_t *>(
00082                 reinterpret_cast<uint8_t *>(this)
00083                 - offsetof(nsapi_stack_t, _stack_buffer));
00084     }
00085 
00086     inline const nsapi_stack_api_t *_stack_api()
00087     {
00088         return _stack()->stack_api;
00089     }
00090 
00091 public:
00092     virtual const char *get_ip_address()
00093     {
00094         if (!_stack_api()->get_ip_address) {
00095             return 0;
00096         }
00097 
00098         static uint8_t buffer[sizeof(SocketAddress)];
00099         SocketAddress *address = new (buffer) SocketAddress(_stack_api()->get_ip_address(_stack()));
00100         return address->get_ip_address();
00101     }
00102 
00103     virtual int gethostbyname(const char *name, SocketAddress *address)
00104     {
00105         if (!_stack_api()->gethostbyname) {
00106             return NetworkStack::gethostbyname(name, address);
00107         }
00108 
00109         nsapi_addr_t addr = {NSAPI_IPv4 , 0};
00110         int err = _stack_api()->gethostbyname(_stack(), name, &addr, NSAPI_UNSPEC );
00111         address->set_addr(addr);
00112         return err;
00113     }
00114 
00115     virtual int gethostbyname(const char *name, SocketAddress *address, nsapi_version_t version)
00116     {
00117         if (!_stack_api()->gethostbyname) {
00118             return NetworkStack::gethostbyname(name, address, version);
00119         }
00120 
00121         nsapi_addr_t addr = {NSAPI_IPv4 , 0};
00122         int err = _stack_api()->gethostbyname(_stack(), name, &addr, version);
00123         address->set_addr(addr);
00124         return err;
00125     }
00126 
00127     virtual int add_dns_server(const SocketAddress &address)
00128     {
00129         if (!_stack_api()->add_dns_server) {
00130             return NetworkStack::add_dns_server(address);
00131         }
00132 
00133         return _stack_api()->add_dns_server(_stack(), address.get_addr());
00134     }
00135 
00136     virtual int setstackopt(int level, int optname, const void *optval, unsigned optlen)
00137     {
00138         if (!_stack_api()->setstackopt) {
00139             return NSAPI_ERROR_UNSUPPORTED ;
00140         }
00141 
00142         return _stack_api()->setstackopt(_stack(), level, optname, optval, optlen);
00143     }
00144 
00145     virtual int getstackopt(int level, int optname, void *optval, unsigned *optlen)
00146     {
00147         if (!_stack_api()->getstackopt) {
00148             return NSAPI_ERROR_UNSUPPORTED ;
00149         }
00150 
00151         return _stack_api()->getstackopt(_stack(), level, optname, optval, optlen);
00152     }
00153 
00154 protected:
00155     virtual int socket_open(nsapi_socket_t *socket, nsapi_protocol_t proto)
00156     {
00157         if (!_stack_api()->socket_open) {
00158             return NSAPI_ERROR_UNSUPPORTED ;
00159         }
00160 
00161         return _stack_api()->socket_open(_stack(), socket, proto);
00162     }
00163 
00164     virtual int socket_close(nsapi_socket_t socket)
00165     {
00166         if (!_stack_api()->socket_close) {
00167             return NSAPI_ERROR_UNSUPPORTED ;
00168         }
00169 
00170         return _stack_api()->socket_close(_stack(), socket);
00171     }
00172 
00173     virtual int socket_bind(nsapi_socket_t socket, const SocketAddress &address)
00174     {
00175         if (!_stack_api()->socket_bind) {
00176             return NSAPI_ERROR_UNSUPPORTED ;
00177         }
00178 
00179         return _stack_api()->socket_bind(_stack(), socket, address.get_addr(), address.get_port());
00180     }
00181 
00182     virtual int socket_listen(nsapi_socket_t socket, int backlog)
00183     {
00184         if (!_stack_api()->socket_listen) {
00185             return NSAPI_ERROR_UNSUPPORTED ;
00186         }
00187 
00188         return _stack_api()->socket_listen(_stack(), socket, backlog);
00189     }
00190 
00191     virtual int socket_connect(nsapi_socket_t socket, const SocketAddress &address)
00192     {
00193         if (!_stack_api()->socket_connect) {
00194             return NSAPI_ERROR_UNSUPPORTED ;
00195         }
00196 
00197         return _stack_api()->socket_connect(_stack(), socket, address.get_addr(), address.get_port());
00198     }
00199 
00200     virtual int socket_accept(nsapi_socket_t server, nsapi_socket_t *socket, SocketAddress *address)
00201     {
00202         if (!_stack_api()->socket_accept) {
00203             return NSAPI_ERROR_UNSUPPORTED ;
00204         }
00205 
00206         nsapi_addr_t addr = {NSAPI_IPv4 , 0};
00207         uint16_t port = 0;
00208 
00209         int err = _stack_api()->socket_accept(_stack(), server, socket, &addr, &port);
00210 
00211         if (address) {
00212             address->set_addr(addr);
00213             address->set_port(port);
00214         }
00215 
00216         return err;
00217     }
00218 
00219     virtual int socket_send(nsapi_socket_t socket, const void *data, unsigned size)
00220     {
00221         if (!_stack_api()->socket_send) {
00222             return NSAPI_ERROR_UNSUPPORTED ;
00223         }
00224 
00225         return _stack_api()->socket_send(_stack(), socket, data, size);
00226     }
00227 
00228     virtual int socket_recv(nsapi_socket_t socket, void *data, unsigned size)
00229     {
00230         if (!_stack_api()->socket_recv) {
00231             return NSAPI_ERROR_UNSUPPORTED ;
00232         }
00233 
00234         return _stack_api()->socket_recv(_stack(), socket, data, size);
00235     }
00236 
00237     virtual int socket_sendto(nsapi_socket_t socket, const SocketAddress &address, const void *data, unsigned size)
00238     {
00239         if (!_stack_api()->socket_sendto) {
00240             return NSAPI_ERROR_UNSUPPORTED ;
00241         }
00242 
00243         return _stack_api()->socket_sendto(_stack(), socket, address.get_addr(), address.get_port(), data, size);
00244     }
00245 
00246     virtual int socket_recvfrom(nsapi_socket_t socket, SocketAddress *address, void *data, unsigned size)
00247     {
00248         if (!_stack_api()->socket_recvfrom) {
00249             return NSAPI_ERROR_UNSUPPORTED ;
00250         }
00251 
00252         nsapi_addr_t addr = {NSAPI_IPv4 , 0};
00253         uint16_t port = 0;
00254 
00255         int err = _stack_api()->socket_recvfrom(_stack(), socket, &addr, &port, data, size);
00256 
00257         if (address) {
00258             address->set_addr(addr);
00259             address->set_port(port);
00260         }
00261 
00262         return err;
00263     }
00264 
00265     virtual void socket_attach(nsapi_socket_t socket, void (*callback)(void *), void *data)
00266     {
00267         if (!_stack_api()->socket_attach) {
00268             return;
00269         }
00270 
00271         return _stack_api()->socket_attach(_stack(), socket, callback, data);
00272     }
00273 
00274     virtual int setsockopt(nsapi_socket_t socket, int level, int optname, const void *optval, unsigned optlen)
00275     {
00276         if (!_stack_api()->setsockopt) {
00277             return NSAPI_ERROR_UNSUPPORTED ;
00278         }
00279 
00280         return _stack_api()->setsockopt(_stack(), socket, level, optname, optval, optlen);
00281     }
00282 
00283     virtual int getsockopt(nsapi_socket_t socket, int level, int optname, void *optval, unsigned *optlen)
00284     {
00285         if (!_stack_api()->getsockopt) {
00286             return NSAPI_ERROR_UNSUPPORTED ;
00287         }
00288 
00289         return _stack_api()->getsockopt(_stack(), socket, level, optname, optval, optlen);
00290     }
00291 };
00292 
00293 
00294 // Conversion function for network stacks
00295 NetworkStack *nsapi_create_stack(nsapi_stack_t *stack)
00296 {
00297     MBED_ASSERT(sizeof stack->_stack_buffer >= sizeof(NetworkStackWrapper));
00298     return new (stack->_stack_buffer) NetworkStackWrapper;
00299 }
00300 
00301 NetworkStack *nsapi_create_stack(NetworkStack *stack)
00302 {
00303     return stack;
00304 }
00305