iot_tests_https_common.h

Go to the documentation of this file.

/*
 * FreeRTOS HTTPS Client V1.1.3
 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * http://aws.amazon.com/freertos
 * http://www.FreeRTOS.org
 */
 
#ifndef IOT_TESTS_HTTPS_COMMON_H_
#define IOT_TESTS_HTTPS_COMMON_H_
 
/* The config header is always included first. */
#include "iot_config.h"
 
/* C standard includes. */
#include <string.h>
 
/* SDK initialization include. */
#include "iot_init.h"
 
/* HTTPS Client internal include. */
#include "private/iot_https_internal.h"
 
/* Test access include. */
#include "iot_test_access_https.h"
 
/* Credential includes. */
#include "aws_clientcredential.h"
#include "aws_clientcredential_keys.h"
 
/* Test framework includes. */
#include "unity_fixture.h"
 
/*-----------------------------------------------------------*/
 
#define HTTPS_TEST_PORT             ( ( uint16_t ) 443 )
 
#define HTTPS_TEST_ADDRESS          "www.amazon.com "
 
#define HTTPS_TEST_PATH             "/path.txt"
 
#define HTTPS_TEST_ALPN_PROTOCOL    "http/1.1"
 
#define HTTPS_TEST_ROOT_CA                                               \
    "-----BEGIN CERTIFICATE-----\n"                                      \
    "MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ\n" \
    "RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD\n" \
    "VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX\n" \
    "DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y\n" \
    "ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy\n" \
    "VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr\n" \
    "mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr\n" \
    "IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK\n" \
    "mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu\n" \
    "XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy\n" \
    "dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye\n" \
    "jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1\n" \
    "BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3\n" \
    "DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92\n" \
    "9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx\n" \
    "jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0\n" \
    "Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz\n" \
    "ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS\n" \
    "R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp\n"                             \
    "-----END CERTIFICATE-----\n"
 
 
#define HTTPS_TEST_CONN_USER_BUFFER_SIZE        ( sizeof( _httpsConnection_t ) )
 
#define HTTPS_TEST_REQ_USER_BUFFER_SIZE         ( 512 )
 
#define HTTPS_TEST_RESP_USER_BUFFER_SIZE        ( sizeof( _httpsResponse_t ) + 128 )
 
#define HTTPS_TEST_RESP_BODY_BUFFER_SIZE        ( 256 )
 
#define HTTPS_TEST_RESPONSE_MESSAGE_LENGTH      ( 1024 )
 
#define HTTPS_TEST_RESP_HEADER_BUFFER_LENGTH    ( HTTPS_TEST_RESP_USER_BUFFER_SIZE - sizeof( _httpsResponse_t ) )
 
#define HTTPS_TEST_REQUEST_BODY                                                                                      \
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore " \
    "magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo" \
    " consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla paria" \
    "tur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est lab" \
    "orum."
#define HTTPS_TEST_REQUEST_BODY_LENGTH    ( sizeof( HTTPS_TEST_REQUEST_BODY ) - 1 ) 
#define HTTPS_TEST_SMALL_RESPONSE                               \
    "HTTP/1.1 200 OK\r\nheader0: value0\r\nheader1: value1\r\n" \
    "header2: value2 value2a\r\nContent-Length: 26\r\n\r\nabcdefghijklmnopqrstuvwxyz"
#define HTTPS_TEST_SMALL_RESPONSE_LENGTH    ( sizeof( HTTPS_TEST_SMALL_RESPONSE ) - 1 ) 
#define HTTPS_TEST_CHUNKED_RESPONSE  \
    "HTTP/1.1 403 Forbidden\r\n"     \
    "header0: value0\r\n"            \
    "header1: value1\r\n"            \
    "Transfer-Encoding: chunked\r\n" \
    "\r\n"                           \
    "b\r\n"                          \
    "abcdefghijk\r\n"                \
    "c\r\n"                          \
    "lmnopqrstuvw\r\n"               \
    "3\r\n"                          \
    "xyz\r\n"                        \
    "0\r\n"                          \
    "\r\n"
#define HTTPS_TEST_CHUNKED_RESPONSE_BODY_LENGTH    ( 0xB + 0xC + 3 ) 
/*-----------------------------------------------------------*/
 
extern uint8_t _pConnUserBuffer[ HTTPS_TEST_CONN_USER_BUFFER_SIZE ];
 
extern uint8_t _pRespBodyBuffer[ HTTPS_TEST_RESP_BODY_BUFFER_SIZE ];
 
extern uint8_t _pRespMessageBuffer[ HTTPS_TEST_RESPONSE_MESSAGE_LENGTH ];
 
extern uint8_t _pReqUserBuffer[ HTTPS_TEST_REQ_USER_BUFFER_SIZE ];
 
extern uint8_t _pRespUserBuffer[ HTTPS_TEST_RESP_USER_BUFFER_SIZE ];
 
static uint32_t _nextRespMessageBufferByteToReceive = 0;
 
static IotNetworkInterface_t _networkInterface = { 0 };
 
static IotHttpsConnectionInfo_t _connInfo = {
    .pAddress             = HTTPS_TEST_ADDRESS,
    .addressLen           = sizeof( HTTPS_TEST_ADDRESS ) - 1,
    .port                 = HTTPS_TEST_PORT,
    .flags                = 0,
    .pCaCert              = HTTPS_TEST_ROOT_CA,
    .caCertLen            = sizeof( HTTPS_TEST_ROOT_CA ),
    .userBuffer.pBuffer   = _pConnUserBuffer,
    .userBuffer.bufferLen = sizeof( _pConnUserBuffer ),
    .pClientCert          = keyCLIENT_CERTIFICATE_PEM,
    .clientCertLen        = sizeof( keyCLIENT_CERTIFICATE_PEM ),
    .pPrivateKey          = keyCLIENT_PRIVATE_KEY_PEM,
    .privateKeyLen        = sizeof( keyCLIENT_PRIVATE_KEY_PEM ),
    .pAlpnProtocols       = HTTPS_TEST_ALPN_PROTOCOL,
    .alpnProtocolsLen     = sizeof( HTTPS_TEST_ALPN_PROTOCOL ),
    .pNetworkInterface    = &_networkInterface
};
 
/*-----------------------------------------------------------*/
 
static inline IotNetworkError_t _networkCreateSuccess( void * pConnectionInfo,
                                                       void * pCredentialInfo,
                                                       void ** pConnection )
{
    ( void ) pConnectionInfo;
    ( void ) pCredentialInfo;
    ( void ) pConnection;
    return IOT_NETWORK_SUCCESS;
}
 
/*-----------------------------------------------------------*/
 
static inline IotNetworkError_t _setReceiveCallbackSuccess( void * pConnection,
                                                            IotNetworkReceiveCallback_t receiveCallback,
                                                            void * pContext )
{
    ( void ) pConnection;
    ( void ) receiveCallback;
    ( void ) pContext;
    return IOT_NETWORK_SUCCESS;
}
 
/*-----------------------------------------------------------*/
 
static inline IotHttpsConnectionHandle_t _getConnHandle( void )
{
    IotHttpsConnectionHandle_t connHandle = IOT_HTTPS_CONNECTION_HANDLE_INITIALIZER;
 
    _networkInterface.create = _networkCreateSuccess;
    _networkInterface.setReceiveCallback = _setReceiveCallbackSuccess;
    IotHttpsClient_Connect( &connHandle, &_connInfo );
    return connHandle;
}
 
/*-----------------------------------------------------------*/
 
static inline IotHttpsRequestHandle_t _getReqHandle( IotHttpsRequestInfo_t * pReqInfo )
{
    IotHttpsRequestHandle_t reqHandle = IOT_HTTPS_REQUEST_HANDLE_INITIALIZER;
 
    IotHttpsClient_InitializeRequest( &reqHandle, pReqInfo );
    return reqHandle;
}
 
/*-----------------------------------------------------------*/
 
static inline IotHttpsResponseHandle_t _getRespHandle( IotHttpsResponseInfo_t * pRespInfo,
                                                       IotHttpsRequestHandle_t reqHandle )
{
    IotHttpsResponseHandle_t respHandle = IOT_HTTPS_RESPONSE_HANDLE_INITIALIZER;
 
    IotTestHttps_initializeResponse( &respHandle, pRespInfo, reqHandle );
    return respHandle;
}
 
/*-----------------------------------------------------------*/
 
static inline IotNetworkError_t _networkCloseSuccess( void * pConnection )
{
    ( void ) pConnection;
    /* When the network closes there should be no data on the socket. */
    _nextRespMessageBufferByteToReceive = 0;
    ( void ) memset( _pRespMessageBuffer, 0x00, sizeof( _pRespMessageBuffer ) );
    return IOT_NETWORK_SUCCESS;
}
 
/*-----------------------------------------------------------*/
 
static inline IotNetworkError_t _networkDestroySuccess( void * pConnection )
{
    ( void ) pConnection;
    return IOT_NETWORK_SUCCESS;
}
 
 
 
/*-----------------------------------------------------------*/
 
static inline size_t _networkReceiveSuccess( void * pConnection,
                                             uint8_t * pBuffer,
                                             size_t bytesRequested )
{
    size_t responseMessageLengthLeft = strlen( ( char * ) _pRespMessageBuffer ) - _nextRespMessageBufferByteToReceive;
    size_t copyLen = 0;
 
    ( void ) pConnection;
    ( void ) pBuffer;
    ( void ) bytesRequested;
 
    if( responseMessageLengthLeft < bytesRequested )
    {
        copyLen = responseMessageLengthLeft;
    }
    else
    {
        copyLen = bytesRequested;
    }
 
    memcpy( pBuffer, &( _pRespMessageBuffer[ _nextRespMessageBufferByteToReceive ] ), copyLen );
    _nextRespMessageBufferByteToReceive += copyLen;
 
    return copyLen;
}
 
/*-----------------------------------------------------------*/
 
void _generateHttpResponseMessage( int headerLength,
                                   int bodyLength );
 
void _verifyHttpResponseBody( int bodyLength,
                              uint8_t * pBody,
                              int startIndex );
 
#endif /* IOT_TESTS_HTTPS_COMMON_H_ */