Initial: start moving WiFi generic classes into a standalone library

Author: facchinm

libraries/SocketWrapper/library.properties

@@ -0,0 +1,9 @@
+name=SocketWrapper
+version=1.0
+author=Arduino
+maintainer=Arduino <info@arduino.cc>
+sentence=Wrapper for mbed Socket classes
+paragraph=
+category=Other
+url=http://www.arduino.cc/en/Reference/WiFi
+architectures=mbed,ArduinoCore-mbed,mbed_portenta

libraries/SocketWrapper/src/MbedClient.cpp

@@ -0,0 +1,280 @@
+#include "MbedClient.h"
+
+
+#ifndef SOCKET_TIMEOUT
+#define SOCKET_TIMEOUT 1500
+#endif
+
+arduino::MbedClient::MbedClient():
+ _status(false)
+{
+}
+
+uint8_t arduino::MbedClient::status() {
+return _status;
+}
+
+void arduino::MbedClient::readSocket() {
+while (1) {
+event->wait_any(0xFF, 100);
+ uint8_t data[SOCKET_BUFFER_SIZE];
+ int ret = NSAPI_ERROR_WOULD_BLOCK;
+ do {
+	mutex->lock();
+ if (rxBuffer.availableForStore() == 0) {
+ yield();
+	}
+ if (sock == nullptr || (closing && borrowed_socket)) {
+ goto cleanup;
+}
+ ret = sock->recv(data, rxBuffer.availableForStore());
+ if (ret < 0 && ret != NSAPI_ERROR_WOULD_BLOCK) {
+ goto cleanup;
+ }
+ for (int i = 0; i < ret; i++) {
+ rxBuffer.store_char(data[i]);
+ }
+	_status = true;
+ mutex->unlock();
+} while (ret == NSAPI_ERROR_WOULD_BLOCK || ret > 0);
+}
+cleanup:
+_status = false;
+mutex->unlock();
+return;
+}
+
+void arduino::MbedClient::getStatus() {
+event->set(1);
+}
+
+void arduino::MbedClient::setSocket(Socket* _sock) {
+ sock = _sock;
+ configureSocket(sock);
+}
+
+void arduino::MbedClient::configureSocket(Socket* _s) {
+_s->set_timeout(0);
+_s->set_blocking(false);
+
+if (event == nullptr) {
+event = new rtos::EventFlags;
+}
+if (mutex == nullptr) {
+mutex = new rtos::Mutex;
+}
+mutex->lock();
+if (reader_th == nullptr) {
+reader_th = new rtos::Thread;
+reader_th->start(mbed::callback(this, &MbedClient::readSocket));
+}
+mutex->unlock();
+_s->sigio(mbed::callback(this, &MbedClient::getStatus));
+_status = true;
+}
+
+int arduino::MbedClient::connect(SocketAddress socketAddress) {
+if (sock == nullptr) {
+sock = new TCPSocket();
+_own_socket = true;
+}
+if (sock == nullptr) {
+return 0;
+}
+
+if(static_cast<TCPSocket*>(sock)->open(getNetwork()) != NSAPI_ERROR_OK){
+return 0;
+}
+
+address = socketAddress;
+nsapi_error_t returnCode = static_cast<TCPSocket*>(sock)->connect(socketAddress);
+int ret = 0;
+
+switch (returnCode) {
+case NSAPI_ERROR_IS_CONNECTED:
+case NSAPI_ERROR_OK: {
+ret = 1;
+break;
+}
+}
+
+if (ret == 1) {
+configureSocket(sock);
+_status = true;
+} else {
+_status = false;
+}
+
+return ret;
+}
+
+int arduino::MbedClient::connect(IPAddress ip, uint16_t port) {
+return connect(SocketHelpers::socketAddressFromIpAddress(ip, port));
+}
+
+int arduino::MbedClient::connect(const char *host, uint16_t port) {
+SocketAddress socketAddress = SocketAddress();
+socketAddress.set_port(port);
+getNetwork()->gethostbyname(host, &socketAddress);
+return connect(socketAddress);
+}
+
+int arduino::MbedClient::connectSSL(SocketAddress socketAddress) {
+if (sock == nullptr) {
+sock = new TLSSocket();
+_own_socket = true;
+}
+if (sock == nullptr) {
+return 0;
+}
+
+if (beforeConnect) {
+beforeConnect();
+}
+
+if(static_cast<TLSSocket*>(sock)->open(getNetwork()) != NSAPI_ERROR_OK){
+return 0;
+}
+
+address = socketAddress;
+
+restart_connect:
+nsapi_error_t returnCode = static_cast<TLSSocket*>(sock)->connect(socketAddress);
+int ret = 0;
+
+switch (returnCode) {
+case NSAPI_ERROR_IS_CONNECTED:
+case NSAPI_ERROR_OK: {
+ret = 1;
+break;
+}
+case NSAPI_ERROR_IN_PROGRESS:
+case NSAPI_ERROR_ALREADY: {
+delay(100);
+goto restart_connect;
+}
+}
+
+if (ret == 1) {
+configureSocket(sock);
+_status = true;
+} else {
+_status = false;
+}
+
+return ret;
+}
+
+int arduino::MbedClient::connectSSL(IPAddress ip, uint16_t port) {
+return connectSSL(SocketHelpers::socketAddressFromIpAddress(ip, port));
+}
+
+int arduino::MbedClient::connectSSL(const char *host, uint16_t port) {
+SocketAddress socketAddress = SocketAddress();
+socketAddress.set_port(port);
+getNetwork()->gethostbyname(host, &socketAddress);
+return connectSSL(socketAddress);
+}
+
+size_t arduino::MbedClient::write(uint8_t c) {
+return write(&c, 1);
+}
+
+size_t arduino::MbedClient::write(const uint8_t *buf, size_t size) {
+if (sock == nullptr)
+return 0;
+
+sock->set_blocking(true);
+sock->set_timeout(SOCKET_TIMEOUT);
+sock->send(buf, size);
+configureSocket(sock);
+return size;
+}
+
+int arduino::MbedClient::available() {
+int ret = rxBuffer.available();
+ return ret;
+}
+
+int arduino::MbedClient::read() {
+mutex->lock();
+if (!available()) {
+ return -1;
+}
+
+int ret = rxBuffer.read_char();
+mutex->unlock();
+return ret;
+}
+
+int arduino::MbedClient::read(uint8_t *data, size_t len) {
+mutex->lock();
+int avail = available();
+
+if (!avail) {
+return -1;
+}
+
+if ((int)len > avail) {
+len = avail;
+}
+
+for (size_t i = 0; i < len; i++) {
+data[i] = rxBuffer.read_char();
+}
+mutex->unlock();
+
+return len;
+}
+
+int arduino::MbedClient::peek() {
+return rxBuffer.peek();
+}
+
+void arduino::MbedClient::flush() {
+
+}
+
+void arduino::MbedClient::stop() {
+if (mutex != nullptr) {
+mutex->lock();
+}
+if (sock != nullptr && borrowed_socket == false) {
+if (_own_socket) {
+delete sock;
+} else {
+sock->close();
+}
+sock = nullptr;
+}
+closing = true;
+if (mutex != nullptr) {
+mutex->unlock();
+}
+if (reader_th != nullptr) {
+reader_th->join();
+delete reader_th;
+reader_th = nullptr;
+}
+if (event != nullptr) {
+delete event;
+event = nullptr;
+}
+if (mutex != nullptr) {
+delete mutex;
+mutex = nullptr;
+}
+_status = false;
+}
+
+uint8_t arduino::MbedClient::connected() {
+return _status;
+}
+
+IPAddress arduino::MbedClient::remoteIP() {
+return SocketHelpers::ipAddressFromSocketAddress(address);
+}
+
+uint16_t arduino::MbedClient::remotePort() {
+return 0;
+}