Diff: MQTTSocket.h

Revision:

48:4e7679e7ff94

Parent:

47:a696ce982cde

Child:

49:8a88045f2b79

--- a/MQTTSocket.h	Tue Jan 31 09:37:15 2017 +0000
+++ b/MQTTSocket.h	Fri May 19 05:32:26 2017 +0000
@@ -5,93 +5,176 @@
 
 #include "MQTTmbed.h"
 #include "TCPSocketConnection.h"
-#include "wolfssl/ssl.h"
-#include "wolfssl/wolfcrypt/error-crypt.h"
+#include "ssl.h"
+// #include "Cyassl/Cyacrypt/error-crypt.h"
+
+#define MAX_URL_HOSTNAME_LENGTH 128
+#define MAX_URL_PATH_LENGTH     128
+
+//Debug is disabled by default
+#if 0
+//Enable debug
+#include <cstdio>
+#define DBG(x, ...) std::printf("[HTTPClient : DBG]"x"\r\n", ##__VA_ARGS__);
+#define WARN(x, ...) std::printf("[HTTPClient : WARN]"x"\r\n", ##__VA_ARGS__);
+#define ERR(x, ...) std::printf("[HTTPClient : ERR]"x"\r\n", ##__VA_ARGS__);
+
+#else
+//Disable debug
+#define DBG(x, ...)
+#define WARN(x, ...)
+#define ERR(x, ...)
 
-static int SocketReceive(WOLFSSL* ssl, char *buf, int sz, void *sock)
+#endif
+
+static  TCPSocketConnection* m_sock;
+#define CHUNK_SIZE    256
+#define SEND_BUF_SIZE 1024
+static char send_buf[SEND_BUF_SIZE] ;
+static char *send_buf_p = NULL;
+
+static int SocketReceive(CYASSL* ssl, char *buf, int sz, void *ctx)
 {
-    return ((TCPSocketConnection *)sock)->receive(buf, sz) ;
+    int n ;
+    int i ;
+#define RECV_RETRY 3
+
+    for(i=0; i<RECV_RETRY; i++) {
+        n = m_sock->receive(buf, sz) ;
+        if(n >= 0)return n  ;
+        wait(0.2) ;
+    }
+    ERR("SocketReceive:%d/%d\n", n, sz)  ;
+    return n ;
 }
 
-static int SocketSend(WOLFSSL* ssl, char *buf, int sz, void *sock)
+static int SocketSend(CYASSL* ssl, char *buf, int sz, void *ctx)
 {
-    return ((TCPSocketConnection *)sock)->send(buf, sz);
+    int n ;
+
+    wait(0.1);
+    n = m_sock->send(buf, sz);
+    if(n > 0) {
+        wait(0.3);
+        return n;
+    } else {
+    ERR("SocketSend:%d/%d\n", n, sz);
+    }
+    return n;
 }
 
 class MQTTSocket
 {
 public:
+    MQTTSocket()
+    {
+        m_sock = &_m_sock;
+        //CyaSSL_Debugging_ON() ;   //Turn on if the CyaSSL library isn't working, turns on debug printf's
+
+        peerMethod = VERIFY_NONE;
+        ctx = 0 ;
+        ssl = 0 ;
+        SSLver = 3 ;
+        certificates = NULL;
+        redirect_url = NULL ;
+        redirect = 0 ;
+        header = NULL ;
+    }
+
     int connect(char* hostname, int port,  const char *certName = NULL, int timeout=1000)
     {
 
-        mysock.set_blocking(false, timeout);    // 1 second Timeout
+        m_sock->set_blocking(false, timeout);    // 1 second Timeout
         isTLS = certName == NULL ? false : true ;
-        int ret = mysock.connect(hostname, port);
+        int ret = m_sock->connect(hostname, port);
         if((ret == 0) && isTLS) {
-            return tls_connect(&mysock, certName) ;
+            return tls_connect(certName) ;
         } else return ret ;
     }
-    
+
     int read(unsigned char* buffer, int len, int timeout)
     {
-        mysock.set_blocking(false, timeout);
+        m_sock->set_blocking(false, timeout);
         return isTLS ?
-               wolfSSL_read(ssl, (char*)buffer, len) :
-               mysock.receive((char *)buffer, len) ;
+               CyaSSL_read(ssl, (char*)buffer, len) :
+               m_sock->receive((char *)buffer, len) ;
     }
-    
+
     int write(unsigned char* buffer, int len, int timeout)
     {
-        mysock.set_blocking(false, timeout);
+        m_sock->set_blocking(false, timeout);
         return isTLS ?
-               wolfSSL_write(ssl, (char*)buffer, len) :
-               mysock.send((char *)buffer, len) ;
+               CyaSSL_write(ssl, (char*)buffer, len) :
+               m_sock->send((char *)buffer, len) ;
     }
-    
+
     int disconnect()
     {
         if(isTLS) {
-            wolfSSL_free(ssl);
-            wolfSSL_CTX_free(ctx);
-            wolfSSL_Cleanup();
+            CyaSSL_free(ssl);
+            CyaSSL_CTX_free(ctx);
+            CyaSSL_Cleanup();
         }
-        return mysock.close();
+        return m_sock->close();
     }
 
 private:
 
-    TCPSocketConnection mysock;
+    // TCPSocketConnection m_sock;
     bool  isTLS ;
-    WOLFSSL_CTX* ctx;
-    WOLFSSL*     ssl;
-    
-    int tls_connect(TCPSocketConnection *sock, const char *certName)
+    // WOLFSSL_CTX* ctx;
+    // WOLFSSL*     ssl;
+
+    //Parameters
+    TCPSocketConnection _m_sock;
+
+    int m_timeout;
+
+    const char* m_basicAuthUser;
+    const char* m_basicAuthPassword;
+    int m_httpResponseCode;
+
+    const char * header ;
+    char * redirect_url ;
+    int    redirect_url_size ;
+    int    redirect ;
+
+    /* for CyaSSL */
+    const char* certificates; //CA certificates
+    SSLMethod peerMethod;
+    int    SSLver ;
+    uint16_t port;
+    struct CYASSL_CTX* ctx ;
+    struct CYASSL    * ssl ;
+
+    int tls_connect(const char *certName)
     {
         /* create and initiLize WOLFSSL_CTX structure */
-        if ((ctx = wolfSSL_CTX_new(wolfTLSv1_2_client_method())) == NULL) {
+        if ((ctx = CyaSSL_CTX_new(CyaTLSv1_2_client_method())) == NULL) {
             printf("SSL_CTX_new error.\n");
             return EXIT_FAILURE;
         }
         if(*certName == '\0'){
-            wolfSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
+            CyaSSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, 0);
         } else {
-            if (wolfSSL_CTX_load_verify_buffer(ctx, (const unsigned char*)certName, strlen(certName), SSL_FILETYPE_PEM) != SSL_SUCCESS)
+            if (CyaSSL_CTX_load_verify_buffer(ctx, (const unsigned char*)certName, strlen(certName), SSL_FILETYPE_PEM) != SSL_SUCCESS)
                 printf("can't load ca file\n");
         }
-        
-        wolfSSL_SetIORecv(ctx, SocketReceive) ;
-        wolfSSL_SetIOSend(ctx, SocketSend) ;
 
-        if ((ssl = wolfSSL_new(ctx)) == NULL) {
-            printf("wolfSSL_new error.\n");
+        CyaSSL_SetIORecv(ctx, SocketReceive) ;
+        CyaSSL_SetIOSend(ctx, SocketSend) ;
+
+        if ((ssl = CyaSSL_new(ctx)) == NULL) {
+            printf("CyaSSL_new error.\n");
             return EXIT_FAILURE;
         }
 
-        wolfSSL_SetIOReadCtx(ssl, (void *)sock) ;
-        wolfSSL_SetIOWriteCtx(ssl, (void *)sock) ;
+        CyaSSL_SetIOReadCtx(ssl, (void *)m_sock) ;
+        CyaSSL_SetIOWriteCtx(ssl, (void *)m_sock) ;
 
-        if (wolfSSL_connect(ssl) != SSL_SUCCESS) {
-            printf("TLS Connect error, %s\n", wc_GetErrorString(wolfSSL_get_error(ssl, 0)));
+        if (CyaSSL_connect(ssl) != SSL_SUCCESS) {
+            char data[32];
+            printf("TLS Connect error, %s\n", CyaSSL_ERR_error_string(CyaSSL_get_error(ssl, 0), data));
             return EXIT_FAILURE;
         } else {
             logInfo("SSL Successs.");