Firebase.h

00001 #ifndef _FIREBASE_H_
00002 #define _FIREBASE_H_
00003 
00004 #include "mbed.h"
00005 #include "NetworkInterface.h"
00006 #include "https_request.h"
00007 
00008 /* List of trusted root CA certificates
00009  * currently two: Amazon, the CA for os.mbed.com and Let's Encrypt,
00010  * the CA for httpbin.org
00011  * To add more root certificates, just concatenate them.
00012  */
00013 const char SSL_CA_PEM[] =  
00014     "-----BEGIN CERTIFICATE-----\n"
00015     "MIIESjCCAzKgAwIBAgINAeO0mqGNiqmBJWlQuDANBgkqhkiG9w0BAQsFADBMMSAw\n"
00016     "HgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEGA1UEChMKR2xvYmFs\n"
00017     "U2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjAeFw0xNzA2MTUwMDAwNDJaFw0yMTEy\n"
00018     "MTUwMDAwNDJaMEIxCzAJBgNVBAYTAlVTMR4wHAYDVQQKExVHb29nbGUgVHJ1c3Qg\n"
00019     "U2VydmljZXMxEzARBgNVBAMTCkdUUyBDQSAxTzEwggEiMA0GCSqGSIb3DQEBAQUA\n"
00020     "A4IBDwAwggEKAoIBAQDQGM9F1IvN05zkQO9+tN1pIRvJzzyOTHW5DzEZhD2ePCnv\n"
00021     "UA0Qk28FgICfKqC9EksC4T2fWBYk/jCfC3R3VZMdS/dN4ZKCEPZRrAzDsiKUDzRr\n"
00022     "mBBJ5wudgzndIMYcLe/RGGFl5yODIKgjEv/SJH/UL+dEaltN11BmsK+eQmMF++Ac\n"
00023     "xGNhr59qM/9il71I2dN8FGfcddwuaej4bXhp0LcQBbjxMcI7JP0aM3T4I+DsaxmK\n"
00024     "FsbjzaTNC9uzpFlgOIg7rR25xoynUxv8vNmkq7zdPGHXkxWY7oG9j+JkRyBABk7X\n"
00025     "rJfoucBZEqFJJSPk7XA0LKW0Y3z5oz2D0c1tJKwHAgMBAAGjggEzMIIBLzAOBgNV\n"
00026     "HQ8BAf8EBAMCAYYwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMCMBIGA1Ud\n"
00027     "EwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFJjR+G4Q68+b7GCfGJAboOt9Cf0rMB8G\n"
00028     "A1UdIwQYMBaAFJviB1dnHB7AagbeWbSaLd/cGYYuMDUGCCsGAQUFBwEBBCkwJzAl\n"
00029     "BggrBgEFBQcwAYYZaHR0cDovL29jc3AucGtpLmdvb2cvZ3NyMjAyBgNVHR8EKzAp\n"
00030     "MCegJaAjhiFodHRwOi8vY3JsLnBraS5nb29nL2dzcjIvZ3NyMi5jcmwwPwYDVR0g\n"
00031     "BDgwNjA0BgZngQwBAgIwKjAoBggrBgEFBQcCARYcaHR0cHM6Ly9wa2kuZ29vZy9y\n"
00032     "ZXBvc2l0b3J5LzANBgkqhkiG9w0BAQsFAAOCAQEAGoA+Nnn78y6pRjd9XlQWNa7H\n"
00033     "TgiZ/r3RNGkmUmYHPQq6Scti9PEajvwRT2iWTHQr02fesqOqBY2ETUwgZQ+lltoN\n"
00034     "FvhsO9tvBCOIazpswWC9aJ9xju4tWDQH8NVU6YZZ/XteDSGU9YzJqPjY8q3MDxrz\n"
00035     "mqepBCf5o8mw/wJ4a2G6xzUr6Fb6T8McDO22PLRL6u3M4Tzs3A2M1j6bykJYi8wW\n"
00036     "IRdAvKLWZu/axBVbzYmqmwkm5zLSDW5nIAJbELCQCZwMH56t2Dvqofxs6BBcCFIZ\n"
00037     "USpxu6x6td0V7SvJCCosirSmIatj/9dSSVDQibet8q/7UK4v4ZUN80atnZz1yg==\n"
00038     "-----END CERTIFICATE-----\n";
00039 
00040 /*
00041     // how to build the Firebase connection FirebaseUrl string for 'method overide'
00042     
00043     strcpy(FirebaseUrl, FirebaseID);                // Firebase account ID
00044     
00045     // this bit in the middle to send .json data structure and authority
00046     // for any REST api functions e.g. GET, PUT, POST, PATCH, DELETE
00047     // replace the PUT with required function
00048     
00049     strcat(FirebaseUrl, "/Parent/Child/.json?x-http-method-override=PUT&auth=");
00050     strcat(FirebaseUrl, FirebaseAuth);              // Firebase account authorisation key
00051 */
00052 
00053 
00054 // set Firebase project information..
00055 char    FirebaseUrl[300];   // dimension to suit required character space
00056 const char FirebaseID[100]  = "https://projectID.firebaseio.com";   // project ID 
00057 const char FirebaseAuth[100]= "Web API key";                        // web API key
00058 
00059 
00060 
00061 char*   getData;
00062 int     TLSfailText,httpfail;
00063 /* Port number used to connect to the server */
00064 const int server_port = 443;
00065 
00066 #define IP         "192.168.1.180"
00067 #define GATEWAY    "192.168.1.1"
00068 #define NETMASK    "255.255.255.0" 
00069 
00070 /*
00071   Connects to the network using the mbed_app.json ESP8266 WIFI networking interface,
00072   you can also swap this out with a driver for a different networking interface or
00073   if you use ETHERNET: change mbed_app.json "target.network-default-interface-type" : "ETHERNET",
00074 */
00075  
00076 NetworkInterface*   net;
00077 TLSSocket* socket = new TLSSocket();
00078 SocketAddress Fbase;
00079 nsapi_error_t result;
00080  
00081 NetworkInterface *connect_to_default_network_interface() {
00082     printf("Connecting to network...\n\n");
00083 
00084     NetworkInterface* net = NetworkInterface::get_default_instance();
00085     
00086     // set static IP, not working on WIFI at the moment 
00087     //net->set_network((SocketAddress)IP,(SocketAddress)NETMASK,(SocketAddress)GATEWAY);
00088     
00089     if (!net) {
00090         printf("No network interface found, select an interface in 'mbed_app.json'\n");
00091         return NULL;
00092     }
00093     nsapi_error_t connect_status = net->connect();
00094     if (connect_status != NSAPI_ERROR_OK) {
00095         printf("Failed to connect to network (%d)\n", connect_status);
00096         return NULL;
00097     }
00098     SocketAddress net_addr;   
00099     net->get_ip_address(&net_addr);
00100     printf("IP address: %s\n", net_addr.get_ip_address() ? net_addr.get_ip_address() : "None");
00101     net->get_netmask(&net_addr);
00102     printf("Netmask:    %s\n", net_addr.get_ip_address() ? net_addr.get_ip_address() : "None");
00103     net->get_gateway(&net_addr);
00104     printf("Gateway:    %s\n", net_addr.get_ip_address() ? net_addr.get_ip_address() : "None");    
00105     printf("MAC:        %s\n", net->get_mac_address());  
00106     return net;
00107 }
00108    
00109 void startTLSreusesocket(char *FirebaseID) { 
00110           
00111     if ((result = socket->open(net)) != NSAPI_ERROR_OK) {
00112         printf("TLS socket open failed (%d)\n", result);
00113     }
00114     if ((result = socket->set_root_ca_cert(SSL_CA_PEM)) != NSAPI_ERROR_OK) {
00115         printf("TLS socket set_root_ca_cert failed (%d)\n", result);
00116     }   
00117     net->gethostbyname(FirebaseID, &Fbase);
00118     Fbase.set_port(server_port);
00119     if ((result = socket->connect(Fbase)) != NSAPI_ERROR_OK) {
00120         printf("Connect failure:\n%d\n", result);
00121         return;
00122     }
00123     printf("Successfully connected to:\n%s \nat port: %u\n",
00124                    FirebaseID, server_port);
00125 }
00126 
00127 void dump_response(HttpResponse* res) {
00128     mbedtls_printf("Status: %d - %s\n", res->get_status_code(), res->get_status_message().c_str()); 
00129     mbedtls_printf("Headers:\n");
00130     for (size_t ix = 0; ix < res->get_headers_length(); ix++) {
00131         mbedtls_printf("\t%s: %s\n", res->get_headers_fields()[ix]->c_str(), res->get_headers_values()[ix]->c_str());
00132     }
00133     mbedtls_printf("\nBody (%d bytes):\n\n%s\n", res->get_body_length(), res->get_body_as_string().c_str());
00134 }
00135 
00136 char *getFirebase(char* FirebaseUrl)
00137 {       
00138     //HttpsRequest* get_req = new HttpsRequest(net, SSL_CA_PEM, HTTP_GET, FirebaseUrl);  // non socket reuse function
00139     HttpsRequest* get_req = new HttpsRequest(socket, HTTP_GET, FirebaseUrl);    // socket reuse function 
00140     HttpResponse* get_res = get_req->send();    
00141     if (!get_res) {       
00142         time_t seconds = time(NULL);                                        
00143         printf("Https GET failed (error code %d), %s", get_req->get_error(), ctime(&seconds));        
00144         socket->close();
00145         delete socket;  
00146         delete get_req;
00147         TLSSocket* socket = new TLSSocket();
00148         startTLSreusesocket((char*)FirebaseID); // restart TLS reuse socket if failure 
00149         return 0;}
00150         else{
00151             //dump_response(get_res);
00152             delete get_req;
00153             getData = (char*)get_res->get_body_as_string().c_str();                
00154             return getData;
00155             }
00156 } 
00157 
00158 bool patchFirebase(char* FirebaseUrl, char *stringToProcess)
00159 {
00160     //HttpsRequest* patch_req = new HttpsRequest(net, SSL_CA_PEM, HTTP_PATCH, FirebaseUrl);    // non socket reuse function
00161     HttpsRequest* patch_req = new HttpsRequest(socket, HTTP_PATCH, FirebaseUrl);    // socket reuse function   
00162     patch_req->set_header("Content-Type", "application/json");
00163     HttpResponse* patch_res = patch_req->send(stringToProcess, strlen(stringToProcess));    
00164     if (!patch_res) {
00165         time_t seconds = time(NULL);                                        
00166         printf("Https PATCH failed (error code %d), %s", patch_req->get_error(), ctime(&seconds));
00167         socket->close();
00168         delete socket;   
00169         delete patch_req;
00170         TLSSocket* socket = new TLSSocket();                            
00171         startTLSreusesocket((char*)FirebaseID); // restart TLS reuse socket if failure 
00172         TLSfailText++;
00173         httpfail=1;
00174         return 0;                
00175         }
00176         else{
00177             // dump_response(put_res);   
00178             delete patch_req;     
00179             return patch_res; 
00180             } 
00181 }
00182 
00183 bool putFirebase(char* FirebaseUrl, char *stringToProcess)
00184 {
00185     //HttpsRequest* put_req = new HttpsRequest(net, SSL_CA_PEM, HTTP_PUT, FirebaseUrl);    // non socket reuse function
00186     HttpsRequest* put_req = new HttpsRequest(socket, HTTP_PUT, FirebaseUrl);    // socket reuse function   
00187     put_req->set_header("Content-Type", "application/json");
00188     HttpResponse* put_res = put_req->send(stringToProcess, strlen(stringToProcess));    
00189     if (!put_res) {
00190         time_t seconds = time(NULL);                                        
00191         printf("Https PUT failed (error code %d), %s", put_req->get_error(), ctime(&seconds));
00192         socket->close();
00193         delete socket;   
00194         delete put_req;
00195         TLSSocket* socket = new TLSSocket();                            
00196         startTLSreusesocket((char*)FirebaseID); // restart TLS reuse socket if failure 
00197         return 0;                
00198         }
00199         else{
00200             //dump_response(put_res);   
00201             delete put_req;     
00202             return put_res; 
00203             } 
00204 }
00205 
00206 bool postFirebase(char* FirebaseUrl, char *stringToProcess)
00207 {  
00208    // HttpsRequest* post_req = new HttpsRequest(net, SSL_CA_PEM, HTTP_POST, FirebaseUrl);   // non socket reuse function
00209     HttpsRequest* post_req = new HttpsRequest(socket, HTTP_POST, FirebaseUrl);  // socket reuse function   
00210     post_req->set_header("Content-Type", "application/json");
00211     HttpResponse* post_res = post_req->send(stringToProcess, strlen(stringToProcess));    
00212     if (!post_res) {
00213         time_t seconds = time(NULL);                                        
00214         printf("Https POST failed (error code %d), %s", post_req->get_error(), ctime(&seconds));
00215         socket->close();
00216         delete socket;
00217         delete post_req;
00218         TLSSocket* socket = new TLSSocket();
00219         startTLSreusesocket((char*)FirebaseID); // restart TLS reuse socket if failure 
00220         return 0;
00221         }
00222         else{
00223             //dump_response(post_res);    
00224             delete post_req;     
00225             return post_res;
00226             }           
00227 }
00228 
00229 bool deleteFirebase(char* FirebaseUrl, char *stringToProcess)
00230 {
00231     // HttpsRequest* delete_req = new HttpsRequest(net, SSL_CA_PEM, HTTP_DELETE, FirebaseUrl);   // non socket reuse function
00232     HttpsRequest* delete_req = new HttpsRequest(socket, HTTP_DELETE, FirebaseUrl);  // socket reuse function   
00233     delete_req->set_header("Content-Type", "application/json");
00234     HttpResponse* delete_res = delete_req->send(stringToProcess, strlen(stringToProcess));    
00235     if (!delete_res) {
00236         time_t seconds = time(NULL);                                        
00237         printf("Https DELETE failed (error code %d), %s", delete_req->get_error(), ctime(&seconds));
00238         socket->close();
00239         delete socket;
00240         delete delete_req;
00241         TLSSocket* socket = new TLSSocket();
00242         startTLSreusesocket((char*)FirebaseID); // restart TLS socket reuse if failure 
00243         return 0;
00244         }
00245         else{
00246             //dump_response(delete_res);    
00247             delete delete_req;     
00248             return delete_res;
00249             }    
00250 }
00251 
00252 #endif // _FIREBASE_H_