Guest User

Untitled

a guest
Jan 15th, 2021
158
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 9.86 KB | None | 0 0
  1. /*
  2.  * nce_onboarding.c
  3.  *
  4.  *  Created on: Sep 7, 2020
  5.  *  Authors: Mohammed Abdelmaksoud & Hatim Jamali
  6.  *  1NCE GmbH
  7.  */
  8.  
  9. #include <stdbool.h>
  10. #include "demo_config.h"
  11. #include "nce_onboarding.h"
  12. #include "trace_interface.h"
  13.  
  14. /* Trace Define */
  15. #define PRINT_INFO(format, args...) \
  16.   TRACE_PRINT(DBG_CHAN_MQTTDEMO, DBL_LVL_P0, "1NCE_Demo: " format "\n\r", ## args)
  17. #define PRINT_ERR(format, args...)  \
  18.   TRACE_PRINT(DBG_CHAN_ATCMD, DBL_LVL_ERR, "1NCE_Demo ERROR: " format "\n\r", ## args)
  19.  
  20. /* Onboarding Defines */
  21. uint8_t PART[1800];
  22. int offset = &PART[0];
  23. char find[] = "\\n";
  24. char replace_with[] = "\n";
  25. char end_key[] = "-----END RSA PRIVATE KEY-----";
  26. int end_key_len = sizeof(end_key);
  27. char end_cert[] = "-----END CERTIFICATE-----";
  28. int end_cert_len = sizeof(end_cert);
  29. char end_identifier[] = "\"";
  30. char *location;
  31. int client_cert_size = 0;
  32. int client_cert_cmd_size = 0;
  33. int client_key_size = 0;
  34. int client_key_cmd_size = 0;
  35. int root_size = 0;
  36. int root_cmd_size = 0;
  37. char amazonRootCaUrl[80];
  38. char sim_iccid[30];
  39.  
  40. /* MQTT Defines */
  41. char IOT_DEMO_MQTT_TOPIC_PREFIX[19];
  42. char WILL_TOPIC_NAME[35];
  43. char ACKNOWLEDGEMENT_TOPIC_NAME[40];
  44. const char *pTopics[TOPIC_FILTER_COUNT];
  45. uint16_t WILL_TOPIC_NAME_LENGTH = 0;
  46. uint16_t TOPIC_FILTER_LENGTH = 0;
  47.  
  48. /* Modem Defines */
  49. CS_Status_t cs_status;
  50.  
  51. at_status_t retval = ATSTATUS_OK;
  52.  
  53. static void CST_cellular_direct_cmd_callback(CS_direct_cmd_rx_t direct_cmd_rx) {
  54.     UNUSED(direct_cmd_rx);
  55. }
  56.  
  57. Onboarding_Status_t nce_onboard_device(void) {
  58.  
  59.     Onboarding_Status_t onboarding_status = ONBOARDING_ERROR;
  60.     cs_status = nce_reset_modem_fs();
  61.  
  62.     if (cs_status != CELLULAR_OK) {
  63.         PRINT_ERR("Onboarding Error : Modem Reset ");
  64.         return (onboarding_status);
  65.     } else {
  66.         PRINT_INFO(" ************** Modem Reset Done ************** \n");
  67.     }
  68.  
  69.     cs_status = nce_configure_onboarding_socket();
  70.  
  71.     if (cs_status != CELLULAR_OK) {
  72.         PRINT_ERR("Onboarding Error : Onboarding Socket Configuration ");
  73.         return (onboarding_status);
  74.     } else {
  75.         PRINT_INFO(
  76.                 " ************** Onboarding Socket Configuration Done ************** \n");
  77.     }
  78.     /* Connect to onboarding endpoint */
  79.  
  80.     Socket_t cert_socket = SOCKETS_Socket( SOCKETS_AF_INET,
  81.     SOCKETS_SOCK_STREAM, SOCKETS_IPPROTO_TCP);
  82.     uint32_t ROOT_IP = SOCKETS_GetHostByName(&ONBOARDING_ENDPOINT);
  83.     SocketsSockaddr_t root_address = { .ucLength = sizeof(SocketsSockaddr_t),
  84.             .ucSocketDomain = SOCKETS_AF_INET, .usPort = SOCKETS_htons(443),
  85.             .ulAddress = ROOT_IP };
  86.     uint32_t timeout = 30000;
  87.  
  88.     int32_t set_timeout = SOCKETS_SetSockOpt(cert_socket,
  89.     COM_SOL_SOCKET, SOCKETS_SO_RCVTIMEO, &timeout, (int32_t) sizeof(timeout));
  90.     int32_t lRetVal = SOCKETS_Connect(cert_socket, &root_address,
  91.             sizeof(SocketsSockaddr_t));
  92.     char send_packet[100];
  93.  
  94.     sprintf(send_packet, "GET /device-api/onboarding HTTP/1.1\r\n"
  95.             "Host: %s\r\n"
  96.             "Accept: text/csv\r\n\r\n", ONBOARDING_ENDPOINT);
  97.     int32_t SendVal = SOCKETS_Send(cert_socket, &send_packet,
  98.             strlen(send_packet), NULL);
  99.     HAL_Delay(1000);
  100.  
  101.     expected_bytes = sizeof(PART) - 500;
  102.  
  103.     /* receive the onboarding data */
  104.  
  105.     uint8_t *complete_response = (uint8_t*) pvPortMalloc(
  106.             5000 * sizeof(uint8_t));
  107.  
  108.     (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  109.  
  110.     waitforprocessing(30);
  111.  
  112.     int32_t rec = SOCKETS_Recv(cert_socket, (com_char_t*) &PART[0],
  113.             (int32_t) sizeof(PART),
  114.             COM_MSG_WAIT);
  115.     HAL_Delay(1000);
  116.  
  117.     PRINT_INFO(" ************** Raw Response (1) **************   %d bytes \n",
  118.             strlen(PART))
  119.     strcat(complete_response,
  120.             strstr(PART, "Express\r\n\r\n\"") + strlen("Express\r\n\r\n\""));
  121.     (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  122.  
  123.     rec = SOCKETS_Recv(cert_socket, (com_char_t*) &PART[0],
  124.             (int32_t) sizeof(PART),
  125.             COM_MSG_WAIT);
  126.  
  127.     PRINT_INFO(" ************** Raw Response (2) **************   %d bytes \n",
  128.             strlen(PART))
  129.  
  130.     strncat(complete_response, PART, strlen(PART));
  131.     (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  132.  
  133.     rec = SOCKETS_Recv(cert_socket, (com_char_t*) &PART[0],
  134.             (int32_t) sizeof(PART),
  135.             COM_MSG_WAIT);
  136.  
  137.     PRINT_INFO(" ************** Raw Response (3) **************   %d bytes \n",
  138.             strlen(PART))
  139.  
  140.     strncat(complete_response, PART, strlen(PART));
  141.     (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  142.  
  143.     rec = SOCKETS_Recv(cert_socket, (com_char_t*) &PART[0],
  144.             (int32_t) sizeof(PART),
  145.             COM_MSG_WAIT);
  146.  
  147.     PRINT_INFO(" ************** Raw Response (4) **************   %d bytes \n",
  148.             strlen(PART))
  149.  
  150.     strncat(complete_response, PART, strlen(PART));
  151.     (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  152.  
  153.     PRINT_INFO(" ************** Response Received ************** \n");
  154.  
  155.     nce_prepare_and_upload_certificates(complete_response);
  156.  
  157.     onboarding_status = ONBOARDING_OK;
  158.  
  159.     return (onboarding_status);
  160. }
  161.  
  162. char* str_replace(char *orig, char *rep, char *with) {
  163.  
  164.     char *result;
  165.     char *ins;
  166.     char *tmp;
  167.     int len_rep;
  168.     int len_with;
  169.     int len_front;
  170.     int count;
  171.     if (!orig || !rep)
  172.         return NULL;
  173.     len_rep = strlen(rep);
  174.     if (len_rep == 0)
  175.         return NULL;
  176.     if (!with)
  177.         with = "";
  178.     len_with = strlen(with);
  179.     ins = orig;
  180.     for (count = 0; tmp = strstr(ins, rep); ++count) {
  181.         ins = tmp + len_rep;
  182.     }
  183.     tmp = result = malloc(strlen(orig) + (len_with - len_rep) * count + 1);
  184.     if (!result)
  185.         return NULL;
  186.     while (count--) {
  187.         ins = strstr(orig, rep);
  188.         len_front = ins - orig;
  189.         tmp = strncpy(tmp, orig, len_front) + len_front;
  190.         tmp = strcpy(tmp, with) + len_with;
  191.         orig += len_front + len_rep;
  192.     }
  193.     strcpy(tmp, orig);
  194.     return result;
  195. }
  196.  
  197. void waitforprocessing(int n) {
  198.     CS_Status_t result;
  199.     for (int i = 0; i < n; i++) {
  200.         result = nce_send_modem_command("AT");
  201.     }
  202.     HAL_Delay(500);
  203.  
  204. }
  205.  
  206. static void nce_prepare_and_upload_certificates(uint8_t *complete_response) {
  207.  
  208.     /* get the first token */
  209.     char *token = strtok(complete_response, ",");
  210.     memcpy(sim_iccid, token, strlen(token));
  211.     int i = 0;
  212.     offset = &sim_iccid[0];
  213.     location = strstr(sim_iccid, end_identifier);
  214.     int identifier_size = location - offset;
  215.     memcpy(identifier, sim_iccid, identifier_size);
  216.     memcpy(IOT_DEMO_MQTT_TOPIC_PREFIX, sim_iccid, identifier_size);
  217.  
  218.     /* walk through other tokens */
  219.     while (token != NULL) {
  220.  
  221.         token = strtok(NULL, ",");
  222.         if (i == 0) {
  223.             (void) memset(&iotCoreEndpointUrl, (int8_t) '\0',
  224.                     sizeof(iotCoreEndpointUrl));
  225.             memcpy(iotCoreEndpointUrl, token + 1, strlen(token) - 2);
  226.         }
  227.         if (i == 1) {
  228.             memcpy(amazonRootCaUrl, token, strlen(token));
  229.         }
  230.         if (i == 2) {
  231.             /*Process root.pem*/
  232.             memcpy(PART, token + 1, strlen(token) - 1);
  233.             memcpy(PART, str_replace(PART, find, replace_with), strlen(PART));
  234.             offset = &PART[0];
  235.             location = strstr(PART, end_cert);
  236.             root_size = location + end_cert_len - offset;
  237.             PART[root_size] = '\n';
  238.             char root_cmd[30] = "AT+QFUPL=\"root.pem\",";
  239.             sprintf(root_cmd, "%s%d,60", root_cmd, root_size);
  240.             root_cmd_size = strlen(root_cmd);
  241.             /*Upload root.pem*/
  242.             CS_direct_cmd_tx_t crt_command_root = { .cmd_str = root_cmd,
  243.                     .cmd_size = root_cmd_size, .cmd_timeout = 10 };
  244.             memcpy(crt_command_root.cmd_str, root_cmd, root_cmd_size);
  245.             cs_status = osCDS_direct_cmd(&crt_command_root,
  246.                     CST_cellular_direct_cmd_callback);
  247.  
  248.             (void) osMutexWait(CellularServiceMutexHandle, RTOS_WAIT_FOREVER);
  249.             retval = sendToIPC(0, (uint8_t*) &PART[0], root_size);
  250.             (void) osMutexRelease(CellularServiceMutexHandle);
  251.  
  252.             (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  253.             waitforprocessing(10);
  254.         }
  255.         if (i == 3) {
  256.             /* Process client_cert.pem */
  257.             memcpy(PART, token + 1, strlen(token) - 1);
  258.             memcpy(PART, str_replace(PART, find, replace_with), strlen(PART));
  259.             offset = &PART[0];
  260.             location = strstr(PART, end_cert);
  261.             client_cert_size = location + end_cert_len - offset;
  262.             PART[client_cert_size] = '\n';
  263.             char client_cert_cmd[40] = "AT+QFUPL=\"clientcert.pem\",";
  264.             sprintf(client_cert_cmd, "%s%d,60", client_cert_cmd,
  265.                     client_cert_size);
  266.             client_cert_cmd_size = strlen(client_cert_cmd);
  267.             /* Upload client_cert.pem */
  268.             CS_direct_cmd_tx_t crt_command_client_cert = { .cmd_str =
  269.                     client_cert_cmd, .cmd_size = client_cert_cmd_size,
  270.                     .cmd_timeout = 30 };
  271.             memcpy(crt_command_client_cert.cmd_str, client_cert_cmd,
  272.                     client_cert_cmd_size);
  273.             cs_status = osCDS_direct_cmd(&crt_command_client_cert,
  274.                     CST_cellular_direct_cmd_callback);
  275.  
  276.             (void) osMutexWait(CellularServiceMutexHandle, RTOS_WAIT_FOREVER);
  277.             retval = sendToIPC(0, (uint8_t*) &PART[0], client_cert_size);
  278.             (void) osMutexRelease(CellularServiceMutexHandle);
  279.             (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  280.         }
  281.         if (i == 4) {
  282.             /* Process client_key.pem */
  283.             memcpy(PART, token + 1, strlen(token) - 1);
  284.             memcpy(PART, str_replace(PART, find, replace_with), strlen(PART));
  285.             offset = &PART[0];
  286.             location = strstr(PART, end_key);
  287.             client_key_size = location + end_key_len - offset;
  288.             PART[client_key_size] = '\n';
  289.             char client_key_cmd[40] = "AT+QFUPL=\"clientkey.pem\",";
  290.             sprintf(client_key_cmd, "%s%d,60", client_key_cmd, client_key_size);
  291.             waitforprocessing(10);
  292.             client_key_cmd_size = strlen(client_key_cmd);
  293.             /* Upload client_key.pem */
  294.             CS_direct_cmd_tx_t crt_command_client_key = { .cmd_str =
  295.                     client_key_cmd, .cmd_size = client_key_cmd_size,
  296.                     .cmd_timeout = 30 };
  297.             memcpy(crt_command_client_key.cmd_str, client_key_cmd,
  298.                     client_key_cmd_size);
  299.             cs_status = osCDS_direct_cmd(&crt_command_client_key,
  300.                     CST_cellular_direct_cmd_callback);
  301.  
  302.             (void) osMutexWait(CellularServiceMutexHandle, RTOS_WAIT_FOREVER);
  303.             retval = sendToIPC(0, (uint8_t*) &PART[0], client_key_size);
  304.             retval = sendToIPC(0, (uint8_t*) &PART[0], client_key_size);
  305.             (void) osMutexRelease(CellularServiceMutexHandle);
  306.             HAL_Delay(10000);
  307.             (void) memset(&PART, (int8_t) '\0', sizeof(PART));
  308.             vPortFree(complete_response);
  309.         }
  310.         i++;
  311.     }
  312.     waitforprocessing(10);
  313.     PRINT_INFO(
  314.             " ************** Certificates Uploaded Successfully  ************** \n");
  315. }
  316.  
  317.  
Advertisement
Add Comment
Please, Sign In to add comment