File content as of revision 4:df1e7ada3ef2:

#define __DEBUG__ 4 //Maximum verbosity
#ifndef __MODULE__
#define __MODULE__ "main.cpp"
#endif

#define DEBUG_CYASSL 1
#include "bsd_socket.h"
#include "mbed.h"
#include "rtos.h"
#include "dbg.h"
#include "cyassl/ssl.h"
#include "EthernetInterface.h"
#include "NTPClient.h"

#include "logging.h"

#include "certs/device_certificate.h"
#include "certs/device_private_key.h"
#include "certs/root_certificate.h"

/* 
// this is how you would setup a client PSK
static INLINE unsigned int my_psk_client_cb(CYASSL* ssl, const char* hint,
        char* identity, unsigned int id_max_len, unsigned char* key,
        unsigned int key_max_len)
{
    (void)ssl;
    (void)hint;
    (void)key_max_len;
    
    DBG("PSK client callback callled.");
    
    // identity is OpenSSL testing default for openssl s_client, keep same
    strncpy(identity, "Client_identity", id_max_len);


    // test key in hex is 0x1a2b3c4d , in decimal 439,041,101 , we're using
    //   unsigned binary
    key[0] = 26;
    key[1] = 43;
    key[2] = 60;
    key[3] = 77;

    return 4;   // length of key in octets or 0 for error
}
*/

sockaddr_in bindAddr,serverAddress;

bool connectToSocketUDP(char *ipAddress, int port, int *sockfd) {
  *sockfd = -1;
  // create the socket
  if((*sockfd=socket(AF_INET,SOCK_DGRAM,0))<0) {
     DBG("Error opening socket");
     return false;
  }
  socklen_t sockAddrInLen = sizeof(struct sockaddr_in);
   
  // bind socket to 11111
  memset(&bindAddr,  0x00, sockAddrInLen);
  bindAddr.sin_family = AF_INET; // IP family
  bindAddr.sin_port = htons(11111);
  bindAddr.sin_addr.s_addr = IPADDR_ANY; // 32 bit IP representation
  // call bind
  if(bind(*sockfd,(const struct sockaddr *)&bindAddr,sockAddrInLen)!=0) {
     DBG("Error binding socket");
     perror(NULL);
  }

  INFO("UDP socket created and bound to: %s:%d",inet_ntoa(bindAddr.sin_addr),ntohs(bindAddr.sin_port));
         
  // create the socket address

  memset(&serverAddress, 0x00, sizeof(struct sockaddr_in));
  serverAddress.sin_addr.s_addr = inet_addr(ipAddress);
  serverAddress.sin_family = AF_INET;
  serverAddress.sin_port = htons(port);

  // do socket connect
  //LOG("Connecting socket to %s:%d", inet_ntoa(serverAddress.sin_addr), ntohs(serverAddress.sin_port));
  if(connect(*sockfd, (const struct sockaddr *)&serverAddress, sizeof(serverAddress))<0) {
     shutdown(*sockfd,SHUT_RDWR);
     close(*sockfd);
     DBG("Could not connect");
     return false;
  }
  return true;
}

DigitalOut myled(LED1);
#define INTERFACE EthernetInterface

void printError(CYASSL *ssl, int resultCode) {
   int err = CyaSSL_get_error(ssl, resultCode);
   char errorString[80];
   CyaSSL_ERR_error_string(err, errorString);
   DBG("Error: CyaSSL_write %s", errorString);
}

void debugCallback(const int logLevel,const char *const logMessage) {
   DBG(logMessage);
}


int main() {
   DBG_INIT();
   DBG_SET_SPEED(115200);
   DBG_SET_NEWLINE("\r\n");
   DBG("\r\n\r\n\r\n\r\n");
   
   int ret = 0;
   
   // init ethernet
   EthernetInterface ethernet;
   // connnect ethernet
   DBG("Cnnecting to network interface");
   ethernet.init();
   if(ethernet.connect(10000)) {
      DBG("Error initialising ethernet interface");
   }
   DBG("Connected to network interface");
   
   DBG("IP: %s",ethernet.getIPAddress());
    
   // need to set the time before doing anything else
   NTPClient ntp;
   time_t currentTime = time(NULL);
   int obtainedTimeSuccessfully = false;
   // try 100 times and then just force a watchdog reboot
   for(int i=0; i<100; i++) {
      obtainedTimeSuccessfully = false;
   
      if(ntp.setTime("0.pool.ntp.org")==0) {
         // there is a bug from somewhere which results in a negative timestamp
         currentTime = time(NULL);
         if(currentTime>0) {
            obtainedTimeSuccessfully = true;
            INFO("Time set successfully, time is now (UTC): %s", ctime(&currentTime));
         }
      }
      if(obtainedTimeSuccessfully) {
         break;
      }
   }
        
   CyaSSL_Init();// Initialize CyaSSL
   if(CyaSSL_Debugging_ON()==0) {
      DBG("CyaSSL debugging enabled");
   } else {
      DBG("CyaSSL debugging not compiled in");
   }
   
   // use our own debugging system for CyaSSL debugging
   CyaSSL_SetLoggingCb(&debugCallback);

   // set client method
   
   // DTLS
   CYASSL_METHOD* method = CyaDTLSv1_2_client_method();
   if(method == NULL) {
      // unable to get method
   }
   CYASSL_CTX* ctx;
   ctx = CyaSSL_CTX_new(method);
   if(ctx == NULL){
      DBG("CyaSSL_CTX_new error.\n");
      exit(EXIT_FAILURE);
   }
   
   DBG("Setup SSL context");
   
   // use pre-shared keys
   //CyaSSL_CTX_set_psk_client_callback(ctx,my_psk_client_cb);
   
   // load certificates for CA and us
   // load CA cert
   ret = CyaSSL_CTX_load_verify_buffer(ctx,rootCertificate, rootCertificateLength,SSL_FILETYPE_ASN1);
   // load device cert
   ret = CyaSSL_CTX_use_certificate_buffer(ctx, deviceCertificate, deviceCertificateLength, SSL_FILETYPE_ASN1);
   // load device private key
   ret = CyaSSL_CTX_use_PrivateKey_buffer(ctx, devicePrivateKey, devicePrivateKeyLength, SSL_FILETYPE_ASN1);
   
   // setup UDP socket
   int sockfd = NULL;
   if(!connectToSocketUDP("192.168.1.99", 11111, &sockfd)) {
      DBG("Error connecting to socket");
   }
   
   DBG("Connected to non-SSL socket");
   
   // hook into SSL
   // Create CYASSL object
   CYASSL* ssl;
   ssl = CyaSSL_new(ctx);
   if(ssl == NULL) {
      DBG("CyaSSL_new error.");
      exit(EXIT_FAILURE);
   }
   DBG("CyaSSL_new OK");
   
   // this is where you set the peer name for the server
   // CyaSSL_connect() will return an error which resolves to
   // DOMAIN_NAME_MISMATCH via CyaSSL_get_error()
   // this is how you ensure that the peer is who you think it is
   CyaSSL_check_domain_name(ssl, "DMServer");
   
   // attach to socket
   DBG("Attaching CyaSSL to socket");
   CyaSSL_set_fd(ssl, sockfd);
   DBG("Attached CyaSSL to socket");
   
   // DTLS stuff
   ret = CyaSSL_dtls_set_peer(ssl, &serverAddress, sizeof(serverAddress));
   if(ret != SSL_SUCCESS) {
      // failed to set DTLS peer
      DBG("Failed to set DTLS peer");
   }
   
   ret = CyaSSL_dtls(ssl);
   if(ret) {
      // SSL session has been configured to use DTLS
      DBG("DTLS configured");
   } else {
      DBG("DTLS not configured");
   }
   
   DBG("Issuing CyaSSL_connect");
   int result = CyaSSL_connect(ssl);
   if(result!=SSL_SUCCESS) {
      DBG("CyaSSL_connect failed");
      printError(ssl,result);
   }
   DBG("CyaSSL_connect OK");
   
   result = CyaSSL_write(ssl,"onion",5);
   DBG("Wrote %d things",result);
   if(result<0) {
      printError(ssl,result);
   }
   
    char buffer[200];
    int d =0;
    if((d=CyaSSL_read(ssl, &buffer, 200))>0) {
       DBG("Received %d bytes: %s",d,buffer);
    }
   
   // clean up
   CyaSSL_CTX_free(ctx);
   CyaSSL_Cleanup();  
   
}