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 // Default NetworkStack operations
00024 const char *NetworkStack::get_ip_address()
00025 {
00026     return 0;
00027 
00028 }
00029 nsapi_error_t NetworkStack::gethostbyname(const char *name, SocketAddress *address, nsapi_version_t version)
00030 {
00031     if (name[0] == '\0') {
00032         return NSAPI_ERROR_PARAMETER ;
00033     }
00034 
00035     // check for simple ip addresses
00036     if (address->set_ip_address(name)) {
00037         if (version != NSAPI_UNSPEC  && address->get_ip_version() != version) {
00038             return NSAPI_ERROR_DNS_FAILURE ;
00039         }
00040 
00041         return NSAPI_ERROR_OK ;
00042     }
00043 
00044     // if the version is unspecified, try to guess the version from the
00045     // ip address of the underlying stack
00046     if (version == NSAPI_UNSPEC ) {
00047         SocketAddress testaddress;
00048         if (testaddress.set_ip_address(this->get_ip_address())) {
00049             version = testaddress.get_ip_version();
00050         }
00051     }
00052 
00053     return nsapi_dns_query(this, name, address, version);
00054 }
00055 
00056 nsapi_value_or_error_t NetworkStack::gethostbyname_async(const char *name, hostbyname_cb_t callback, nsapi_version_t version)
00057 {
00058     SocketAddress address;
00059 
00060     if (name[0] == '\0') {
00061         return NSAPI_ERROR_PARAMETER ;
00062     }
00063 
00064     // check for simple ip addresses
00065     if (address.set_ip_address(name)) {
00066         if (version != NSAPI_UNSPEC  && address.get_ip_version() != version) {
00067             return NSAPI_ERROR_DNS_FAILURE ;
00068         }
00069 
00070         callback(NSAPI_ERROR_OK , &address);
00071         return NSAPI_ERROR_OK ;
00072     }
00073 
00074     // if the version is unspecified, try to guess the version from the
00075     // ip address of the underlying stack
00076     if (version == NSAPI_UNSPEC ) {
00077         SocketAddress testaddress;
00078         if (testaddress.set_ip_address(this->get_ip_address())) {
00079             version = testaddress.get_ip_version();
00080         }
00081     }
00082 
00083     call_in_callback_cb_t call_in_cb = get_call_in_callback();
00084 
00085     return nsapi_dns_query_async(this, name, callback, call_in_cb, version);
00086 }
00087 
00088 nsapi_error_t NetworkStack::gethostbyname_async_cancel(int id)
00089 {
00090     return nsapi_dns_query_async_cancel(id);
00091 }
00092 
00093 nsapi_error_t NetworkStack::add_dns_server(const SocketAddress &address)
00094 {
00095     return nsapi_dns_add_server(address);
00096 }
00097 
00098 nsapi_error_t NetworkStack::get_dns_server(int index, SocketAddress *address)
00099 {
00100     return NSAPI_ERROR_UNSUPPORTED ;
00101 }
00102 
00103 nsapi_error_t NetworkStack::setstackopt(int level, int optname, const void *optval, unsigned optlen)
00104 {
00105     return NSAPI_ERROR_UNSUPPORTED ;
00106 }
00107 
00108 nsapi_error_t NetworkStack::getstackopt(int level, int optname, void *optval, unsigned *optlen)
00109 {
00110     return NSAPI_ERROR_UNSUPPORTED ;
00111 }
00112 
00113 nsapi_error_t NetworkStack::setsockopt(void *handle, int level, int optname, const void *optval, unsigned optlen)
00114 {
00115     return NSAPI_ERROR_UNSUPPORTED ;
00116 }
00117 
00118 nsapi_error_t NetworkStack::getsockopt(void *handle, int level, int optname, void *optval, unsigned *optlen)
00119 {
00120     return NSAPI_ERROR_UNSUPPORTED ;
00121 }
00122 
00123 nsapi_error_t NetworkStack::call_in(int delay, mbed::Callback<void()> func)
00124 {
00125     static events::EventQueue *event_queue = mbed::mbed_event_queue();
00126 
00127     if (!event_queue) {
00128         return NSAPI_ERROR_NO_MEMORY ;
00129     }
00130 
00131     if (delay > 0) {
00132         if (event_queue->call_in(delay, func) == 0) {
00133             return NSAPI_ERROR_NO_MEMORY ;
00134         }
00135     } else {
00136         if (event_queue->call(func) == 0) {
00137             return NSAPI_ERROR_NO_MEMORY ;
00138         }
00139     }
00140 
00141     return NSAPI_ERROR_OK ;
00142 }
00143 
00144 call_in_callback_cb_t NetworkStack::get_call_in_callback()
00145 {
00146     call_in_callback_cb_t cb(this, &NetworkStack::call_in);
00147     return cb;
00148 }
00149 
00150 // NetworkStackWrapper class for encapsulating the raw nsapi_stack structure
00151 class NetworkStackWrapper : public NetworkStack {
00152 private:
00153     inline nsapi_stack_t *_stack()
00154     {
00155         return reinterpret_cast<nsapi_stack_t *>(
00156                    reinterpret_cast<uint8_t *>(this)
00157                    - offsetof(nsapi_stack_t, _stack_buffer));
00158     }
00159 
00160     inline const nsapi_stack_api_t *_stack_api()
00161     {
00162         return _stack()->stack_api;
00163     }
00164 
00165 public:
00166     virtual const char *get_ip_address()
00167     {
00168         if (!_stack_api()->get_ip_address) {
00169             return 0;
00170         }
00171 
00172         static uint8_t buffer[sizeof(SocketAddress)];
00173         SocketAddress *address = new (buffer) SocketAddress(_stack_api()->get_ip_address(_stack()));
00174         return address->get_ip_address();
00175     }
00176 
00177     virtual nsapi_error_t gethostbyname(const char *name, SocketAddress *address, nsapi_version_t version)
00178     {
00179         if (!_stack_api()->gethostbyname) {
00180             return NetworkStack::gethostbyname(name, address, version);
00181         }
00182 
00183         nsapi_addr_t addr = {NSAPI_UNSPEC , 0};
00184         nsapi_error_t err = _stack_api()->gethostbyname(_stack(), name, &addr, version);
00185         address->set_addr(addr);
00186         return err;
00187     }
00188 
00189     virtual nsapi_error_t add_dns_server(const SocketAddress &address)
00190     {
00191         if (!_stack_api()->add_dns_server) {
00192             return NetworkStack::add_dns_server(address);
00193         }
00194 
00195         return _stack_api()->add_dns_server(_stack(), address.get_addr());
00196     }
00197 
00198     virtual nsapi_error_t setstackopt(int level, int optname, const void *optval, unsigned optlen)
00199     {
00200         if (!_stack_api()->setstackopt) {
00201             return NSAPI_ERROR_UNSUPPORTED ;
00202         }
00203 
00204         return _stack_api()->setstackopt(_stack(), level, optname, optval, optlen);
00205     }
00206 
00207     virtual nsapi_error_t getstackopt(int level, int optname, void *optval, unsigned *optlen)
00208     {
00209         if (!_stack_api()->getstackopt) {
00210             return NSAPI_ERROR_UNSUPPORTED ;
00211         }
00212 
00213         return _stack_api()->getstackopt(_stack(), level, optname, optval, optlen);
00214     }
00215 
00216 protected:
00217     virtual nsapi_error_t socket_open(nsapi_socket_t *socket, nsapi_protocol_t proto)
00218     {
00219         if (!_stack_api()->socket_open) {
00220             return NSAPI_ERROR_UNSUPPORTED ;
00221         }
00222 
00223         return _stack_api()->socket_open(_stack(), socket, proto);
00224     }
00225 
00226     virtual nsapi_error_t socket_close(nsapi_socket_t socket)
00227     {
00228         if (!_stack_api()->socket_close) {
00229             return NSAPI_ERROR_UNSUPPORTED ;
00230         }
00231 
00232         return _stack_api()->socket_close(_stack(), socket);
00233     }
00234 
00235     virtual nsapi_error_t socket_bind(nsapi_socket_t socket, const SocketAddress &address)
00236     {
00237         if (!_stack_api()->socket_bind) {
00238             return NSAPI_ERROR_UNSUPPORTED ;
00239         }
00240 
00241         return _stack_api()->socket_bind(_stack(), socket, address.get_addr(), address.get_port());
00242     }
00243 
00244     virtual nsapi_error_t socket_listen(nsapi_socket_t socket, int backlog)
00245     {
00246         if (!_stack_api()->socket_listen) {
00247             return NSAPI_ERROR_UNSUPPORTED ;
00248         }
00249 
00250         return _stack_api()->socket_listen(_stack(), socket, backlog);
00251     }
00252 
00253     virtual nsapi_error_t socket_connect(nsapi_socket_t socket, const SocketAddress &address)
00254     {
00255         if (!_stack_api()->socket_connect) {
00256             return NSAPI_ERROR_UNSUPPORTED ;
00257         }
00258 
00259         return _stack_api()->socket_connect(_stack(), socket, address.get_addr(), address.get_port());
00260     }
00261 
00262     virtual nsapi_error_t socket_accept(nsapi_socket_t server, nsapi_socket_t *socket, SocketAddress *address)
00263     {
00264         if (!_stack_api()->socket_accept) {
00265             return NSAPI_ERROR_UNSUPPORTED ;
00266         }
00267 
00268         nsapi_addr_t addr = {NSAPI_IPv4 , 0};
00269         uint16_t port = 0;
00270 
00271         nsapi_error_t err = _stack_api()->socket_accept(_stack(), server, socket, &addr, &port);
00272 
00273         if (address) {
00274             address->set_addr(addr);
00275             address->set_port(port);
00276         }
00277 
00278         return err;
00279     }
00280 
00281     virtual nsapi_size_or_error_t socket_send(nsapi_socket_t socket, const void *data, nsapi_size_t size)
00282     {
00283         if (!_stack_api()->socket_send) {
00284             return NSAPI_ERROR_UNSUPPORTED ;
00285         }
00286 
00287         return _stack_api()->socket_send(_stack(), socket, data, size);
00288     }
00289 
00290     virtual nsapi_size_or_error_t socket_recv(nsapi_socket_t socket, void *data, nsapi_size_t size)
00291     {
00292         if (!_stack_api()->socket_recv) {
00293             return NSAPI_ERROR_UNSUPPORTED ;
00294         }
00295 
00296         return _stack_api()->socket_recv(_stack(), socket, data, size);
00297     }
00298 
00299     virtual nsapi_size_or_error_t socket_sendto(nsapi_socket_t socket, const SocketAddress &address, const void *data, nsapi_size_t size)
00300     {
00301         if (!_stack_api()->socket_sendto) {
00302             return NSAPI_ERROR_UNSUPPORTED ;
00303         }
00304 
00305         return _stack_api()->socket_sendto(_stack(), socket, address.get_addr(), address.get_port(), data, size);
00306     }
00307 
00308     virtual nsapi_size_or_error_t socket_recvfrom(nsapi_socket_t socket, SocketAddress *address, void *data, nsapi_size_t size)
00309     {
00310         if (!_stack_api()->socket_recvfrom) {
00311             return NSAPI_ERROR_UNSUPPORTED ;
00312         }
00313 
00314         nsapi_addr_t addr = {NSAPI_IPv4 , 0};
00315         uint16_t port = 0;
00316 
00317         nsapi_size_or_error_t err = _stack_api()->socket_recvfrom(_stack(), socket, &addr, &port, data, size);
00318 
00319         if (address) {
00320             address->set_addr(addr);
00321             address->set_port(port);
00322         }
00323 
00324         return err;
00325     }
00326 
00327     virtual void socket_attach(nsapi_socket_t socket, void (*callback)(void *), void *data)
00328     {
00329         if (!_stack_api()->socket_attach) {
00330             return;
00331         }
00332 
00333         return _stack_api()->socket_attach(_stack(), socket, callback, data);
00334     }
00335 
00336     virtual nsapi_error_t setsockopt(nsapi_socket_t socket, int level, int optname, const void *optval, unsigned optlen)
00337     {
00338         if (!_stack_api()->setsockopt) {
00339             return NSAPI_ERROR_UNSUPPORTED ;
00340         }
00341 
00342         return _stack_api()->setsockopt(_stack(), socket, level, optname, optval, optlen);
00343     }
00344 
00345     virtual nsapi_error_t getsockopt(nsapi_socket_t socket, int level, int optname, void *optval, unsigned *optlen)
00346     {
00347         if (!_stack_api()->getsockopt) {
00348             return NSAPI_ERROR_UNSUPPORTED ;
00349         }
00350 
00351         return _stack_api()->getsockopt(_stack(), socket, level, optname, optval, optlen);
00352     }
00353 };
00354 
00355 
00356 // Conversion function for network stacks
00357 NetworkStack *nsapi_create_stack(nsapi_stack_t *stack)
00358 {
00359     MBED_STATIC_ASSERT(sizeof stack->_stack_buffer >= sizeof(NetworkStackWrapper),
00360                        "The nsapi_stack_t stack buffer must fit a NetworkStackWrapper");
00361     return new (stack->_stack_buffer) NetworkStackWrapper;
00362 }
00363 
00364 NetworkStack *nsapi_create_stack(NetworkStack *stack)
00365 {
00366     return stack;
00367 }
00368