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