int32_t S3_HLS_Client_Set_Credential()

in S3_HLS_S3_Put_Client.c [362:523]

• 122 lines of code
• 31 McCabe index (conditional complexity)

int32_t S3_HLS_Client_Set_Credential(S3_HLS_CLIENT_CTX* ctx, char* ak, char* sk, char* token) {
    PUT_DEBUG("Setting Credential!\n");

    if(NULL == ctx || NULL == ak || NULL == sk)
        return S3_HLS_INVALID_PARAMETER;
        
    int32_t ret = S3_HLS_OK;
    
    uint32_t secret_access_key_length = snprintf(NULL, 0, S3_HLS_SECRET_ACCESS_KEY_FORMAT, sk);
    if(0 >= secret_access_key_length) {
        PUT_DEBUG("Setting Access Key Failed\n");
        return S3_HLS_UNKNOWN_INTERNAL_ERROR;
    }

    uint32_t token_header_length = 0;
    if(NULL != token) {
        token_header_length = snprintf(NULL, 0, S3_HLS_TOKEN_HEADER_FORMAT, token);
        if(0 >= token_header_length) {
            PUT_DEBUG("Setting Token Failed\n");
            return S3_HLS_UNKNOWN_INTERNAL_ERROR;
        }
    }

    // lock credential lock
    if(0 != pthread_mutex_lock(&ctx->credential_lock))
        return S3_HLS_LOCK_FAILED;

    uint32_t auth_header_length = snprintf(
                                                NULL, 
                                                0, 
                                                S3_HLS_AUTHENTICATION_HEADER_FORMAT, 
                                                ak, 
                                                S3_HLS_DUMMY_DATE, 
                                                ctx->region, 
                                                S3_HLS_TOKEN_HEADER_IN_CANONICAL_REQUEST, 
                                                S3_HLS_TAG_HEADER_IN_CANONICAL_REQUEST,
                                                S3_HLS_EMPTY_STRING
                                            );
    if(0 >= auth_header_length) {
        PUT_DEBUG("Setting Authorization Header Failed\n");
        return S3_HLS_UNKNOWN_INTERNAL_ERROR;
    }

    // add additional length for hash
    auth_header_length += S3_HLS_HEX_HASH_STIRNG_LENGTH;

    secret_access_key_length++;
    auth_header_length++;
    
    if(token_header_length > 0)
        token_header_length++;


    PUT_DEBUG("Buffer Length: Token Header: %d, SK: %d, Auth Header %d!\n", token_header_length, secret_access_key_length, auth_header_length);

    // start allocate memory if necessary
    char* temp_secret_access_key = NULL;
    char* temp_token_header = NULL;
    char* temp_auth_header = NULL;
    
    if(secret_access_key_length > ctx->secret_access_key_length) {
        temp_secret_access_key = (char*)malloc(secret_access_key_length);
        if(NULL == temp_secret_access_key) {
            ret = S3_HLS_OUT_OF_MEMORY;
            goto l_unlock;
        }
    }
    
    if(NULL != token) {
        if(token_header_length > ctx->token_header_length) {
            temp_token_header = (char*)malloc(token_header_length);
            if(NULL == temp_token_header) {
                ret = S3_HLS_OUT_OF_MEMORY;
                
                if(NULL != temp_secret_access_key)
                    free(temp_secret_access_key);
                    
                goto l_unlock;
            }
        }
    }

    if(auth_header_length > ctx->auth_header_length) {
        temp_auth_header = (char*)malloc(auth_header_length);
        if(NULL == temp_auth_header) {
            ret = S3_HLS_OUT_OF_MEMORY;
            
            if(NULL != temp_secret_access_key)
                free(temp_secret_access_key);
                
            if(NULL != temp_token_header)
                free(temp_token_header);
                
            goto l_unlock;
        }
    }

    // update pointer and length marks
    if(NULL != temp_secret_access_key) {
        if(NULL != ctx->secret_access_key) {
            free(ctx->secret_access_key);
        }
        
        ctx->secret_access_key = temp_secret_access_key;
        ctx->secret_access_key_length = secret_access_key_length;
    }
    
    if(NULL != temp_token_header) {
        if(NULL != ctx->token_header) {
            free(ctx->token_header);
        }

        ctx->token_header = temp_token_header;
        ctx->token_header_length = token_header_length;
    }
    
    if(NULL != temp_auth_header) {
        if(NULL != ctx->auth_header) {
            free(ctx->auth_header);
        }

        ctx->auth_header = temp_auth_header;
        ctx->auth_header_length = auth_header_length;
    }
    
    // Start writing to variables
    uint32_t length = sprintf(ctx->secret_access_key, S3_HLS_SECRET_ACCESS_KEY_FORMAT, sk);
    if(0 >= length) {
        PUT_DEBUG("Print SK Failed\n");
        ret = S3_HLS_UNKNOWN_INTERNAL_ERROR;
        goto l_unlock;
    }
    
    if(NULL != token) {
        length = sprintf(ctx->token_header, S3_HLS_TOKEN_HEADER_FORMAT, token);
        if(0 >= length) {
            PUT_DEBUG("Print Token Header Failed\n");
            ret = S3_HLS_UNKNOWN_INTERNAL_ERROR;
            goto l_unlock;
        }
    } else if(NULL != ctx->token_header) { // in case of last token is not null and new one is null
        free(ctx->token_header);
        ctx->token_header = NULL;
        ctx->token_header_length = 0;
    }
    
    // auth header only need to allocate space
    
    ctx->access_key = ak;

    PUT_DEBUG("AK: %s\n", ctx->access_key);
    PUT_DEBUG("SK: %s\n", ctx->secret_access_key);
    
    if(NULL != ctx->token_header) {
        PUT_DEBUG("Token: %s\n", ctx->token_header);
    }

l_unlock:
    pthread_mutex_unlock(&ctx->credential_lock);
    
    return ret;
}