Updated on 2022-02-21 GMT+08:00

C++

Scenarios

To use C++ to call an API through App authentication, obtain the C++ SDK, and then call the API by referring to the API calling example.

Preparing the Environment

  1. Obtain the domain name, request URL, and request method of the API to be called, and the AppKey and AppSecret of the app for calling the API. For more information, see Preparation.
  2. Install the OpenSSL library.
    apt-get install libssl-dev
  3. Install the curl library.
    apt-get install libcurl4-openssl-dev

Obtaining the SDK

Log in to the API Gateway console, and download the SDK on the SDKs page by referring to section "SDKs" in the User Guide.

The following table shows the files decompressed from the package.

Name

Description

hasher.cpp

SDK code

hasher.h

header.h

RequestParams.cpp

RequestParams.h

signer.cpp

signer.h

Makefile

Makefile file

main.cpp

Sample code

API Calling Example

  1. Add the following references to main.cpp:

    1
    2
    3
    4
    5
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <curl/curl.h>
    #include "signer.h"
    

  2. Generate a new signer and enter the AppKey and AppSecret.

    1
    Signer signer("4f5f626b-073f-402f-a1e0-e52171c6100c", "******");
    

  3. Generate a new RequestParams request, and specify the method, domain name, request URI, query strings, and request body.

    1
    2
     RequestParams* request = new RequestParams("POST", "c967a237-cd6c-470e-906f-a8655461897e.apigw.exampleRegion.com", "/app1",
            "Action=ListUsers&Version=2010-05-08", "demo");
    

  4. Add the x-stage header to the request to specify an environment name. Add other headers to be signed as necessary.

    1
    request->addHeader("x-stage", "RELEASE");
    

  5. Execute the following function to add the generated headers to the request variable.

    1
    signer.createSignature(request);
    

  6. Use the curl library to access the API and view the access result.

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    static size_t
    WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp)
    {
        size_t realsize = size * nmemb;
        struct MemoryStruct *mem = (struct MemoryStruct *)userp;
    
        mem->memory = (char*)realloc(mem->memory, mem->size + realsize + 1);
        if (mem->memory == NULL) {
            /* out of memory! */
            printf("not enough memory (realloc returned NULL)\n");
            return 0;
        }
    
        memcpy(&(mem->memory[mem->size]), contents, realsize);
        mem->size += realsize;
        mem->memory[mem->size] = 0;
    
        return realsize;
    }
    
    //send http request using curl library
    int perform_request(RequestParams* request)
    {
        CURL *curl;
        CURLcode res;
        struct MemoryStruct resp_header;
        resp_header.memory = (char*)malloc(1);
        resp_header.size = 0;
        struct MemoryStruct resp_body;
        resp_body.memory = (char*)malloc(1);
        resp_body.size = 0;
    
        curl_global_init(CURL_GLOBAL_ALL);
        curl = curl_easy_init();
    
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, request->getMethod().c_str());
        std::string url = "http://" + request->getHost() + request->getUri() + "?" + request->getQueryParams();
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        struct curl_slist *chunk = NULL;
        std::set<Header>::iterator it;
        for (auto header : *request->getHeaders()) {
            std::string headerEntry = header.getKey() + ": " + header.getValue();
            printf("%s\n", headerEntry.c_str());
            chunk = curl_slist_append(chunk, headerEntry.c_str());
        }
        printf("-------------\n");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
        curl_easy_setopt(curl, CURLOPT_COPYPOSTFIELDS, request->getPayload().c_str());
        curl_easy_setopt(curl, CURLOPT_NOBODY, 0L);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
        curl_easy_setopt(curl, CURLOPT_HEADERDATA, (void *)&resp_header);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&resp_body);
        //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
        res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
        }
        else {
            long status;
            curl_easy_getinfo(curl, CURLINFO_HTTP_CODE, &status);
            printf("status %d\n", status);
            printf(resp_header.memory);
            printf(resp_body.memory);
        }
        free(resp_header.memory);
        free(resp_body.memory);
        curl_easy_cleanup(curl);
    
        curl_global_cleanup();
    
        return 0;
    }
    

  7. Run the make command to obtain a main executable file, execute the file, and then view the execution result.