Updated on 2025-03-26 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. You have obtained the domain name, request URL, and request method of the API as well as the key and secret (or AppKey and AppSecret of the client) of the integration application. For details, see Preparations.
  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 ROMA Connect console, choose API Connect > API Calling, and download the SDK. The following shows the directory structure after the decompression.

Name

Description

signer_common.c

SDK code

signer_common.h

signer.c

signer.h

Makefile

Makefile file

main.c

Sample code

API Calling Example

  1. Add the following references to main.c:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <curl/curl.h>
    #include "signer.h"

  2. Generate a sig_params_t variable, and enter the AppKey and AppSecret.

    1. In this example, the AK and SK stored in the environment variables are used. Specify the environment variables CLOUD_SDK_AK and CLOUD_SDK_SK in the local environment first. The following uses Linux as an example to describe how to set the obtained AK/SK as environment variables.
      1. Open the terminal and run the following command to open the environment variable configuration file:

        vi ~/.bashrc

      2. Set environment variables, save the file, and exit the editor.
        export CLOUD_SDK_AK="Obtained AK"
        export CLOUD_SDK_SK="Obtained SK"
      3. Run the following command to apply the modification:

        source ~/.bashrc

    2. Generate a sig_params_t variable, and enter the configured environment variables.
      sig_params_t params;
      sig_params_init(&params);
      sig_str_t app_key = sig_str(getenv("CLOUD_SDK_AK"));
      sig_str_t app_secret = sig_str(getenv("CLOUD_SDK_SK"));
      params.key = app_key;
      params.secret = app_secret;

  3. Specify the method, domain name, request URI, query strings, and request body.

    sig_str_t host = sig_str("c967a237-cd6c-470e-906f-a8655461897e.apigw.exampleRegion.com");
    sig_str_t method = sig_str("GET");
    sig_str_t uri = sig_str("/app1");
    sig_str_t query_str = sig_str("a=1&b=2");
    sig_str_t payload = sig_str("");
    params.host = host;
    params.method = method;
    params.uri = uri;
    params.query_str = query_str;
    params.payload = payload;

  4. Add the x-stage header to the request to specify the environment. Add other headers to sign as required.

    sig_headers_add(&params.headers, "x-stage", "RELEASE");

  5. Execute the following function to add the generated headers as request variables.

    sig_sign(&params);

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

    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 = malloc(1);
        resp_header.size = 0;
        struct MemoryStruct resp_body;
        resp_body.memory = malloc(1);
        resp_body.size = 0;
    
        curl_global_init(CURL_GLOBAL_ALL);
        curl = curl_easy_init();
    
        curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, params.method.data);
        char url[1024];
        sig_snprintf(url, 1024, "http://%V%V?%V", &params.host, &params.uri, &params.query_str);
        curl_easy_setopt(curl, CURLOPT_URL, url);
        struct curl_slist *chunk = NULL;
        for (int i = 0; i < params.headers.len; i++) {
            char header[1024];
            sig_snprintf(header, 1024, "%V: %V", &params.headers.data[i].name, &params.headers.data[i].value);
            printf("%s\n", header);
            chunk = curl_slist_append(chunk, header);
        }
        printf("-------------\n");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, params.payload.data);
        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();
    
        //free signature params
        sig_params_free(&params);
        return 0;
    }

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