in iothub_client/src/iothub_client_ll_uploadtoblob.c [1250:1503]
IOTHUB_CLIENT_RESULT IoTHubClient_LL_UploadToBlob_SetOption(IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE handle, const char* optionName, const void* value)
{
IOTHUB_CLIENT_RESULT result;
if (handle == NULL)
{
LogError("invalid argument detected: IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE handle=%p, const char* optionName=%s, const void* value=%p", handle, optionName, value);
result = IOTHUB_CLIENT_ERROR;
}
else
{
IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE_DATA* upload_data = (IOTHUB_CLIENT_LL_UPLOADTOBLOB_HANDLE_DATA*)handle;
if (strcmp(optionName, OPTION_X509_CERT) == 0)
{
if (upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509 && upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509_ECC)
{
LogError("trying to set a x509 certificate while the authentication scheme is not x509");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else
{
/*try to make a copy of the certificate*/
char* temp;
if (mallocAndStrcpy_s(&temp, value) != 0)
{
LogError("unable to mallocAndStrcpy_s");
result = IOTHUB_CLIENT_ERROR;
}
else
{
if (upload_data->credentials.x509_credentials.x509certificate != NULL) /*free any previous values, if any*/
{
free(upload_data->credentials.x509_credentials.x509certificate);
}
upload_data->credentials.x509_credentials.x509certificate = temp;
result = IOTHUB_CLIENT_OK;
}
}
}
else if (strcmp(optionName, OPTION_X509_PRIVATE_KEY) == 0)
{
if (upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509 && upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509_ECC)
{
LogError("trying to set a x509 privatekey while the authentication scheme is not x509");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else
{
/*try to make a copy of the privatekey*/
char* temp;
if (mallocAndStrcpy_s(&temp, value) != 0)
{
LogError("unable to mallocAndStrcpy_s");
result = IOTHUB_CLIENT_ERROR;
}
else
{
if (upload_data->credentials.x509_credentials.x509privatekey != NULL) /*free any previous values, if any*/
{
free(upload_data->credentials.x509_credentials.x509privatekey);
}
upload_data->credentials.x509_credentials.x509privatekey = temp;
result = IOTHUB_CLIENT_OK;
}
}
}
else if (strcmp(OPTION_OPENSSL_PRIVATE_KEY_TYPE, optionName) == 0)
{
if (upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509 && upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509_ECC)
{
LogError("trying to set a x509 private key type while the authentication scheme is not x509");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else if (value == NULL)
{
LogError("NULL is a not a valid value for x509 private key type");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else
{
int* temp = malloc(sizeof(int));
if (temp == NULL)
{
LogError("failure in malloc");
result = IOTHUB_CLIENT_ERROR;
}
else
{
*temp = *(int*)value;
if (upload_data->credentials.x509_credentials.x509privatekeyType != NULL)
{
free(upload_data->credentials.x509_credentials.x509privatekeyType);
}
upload_data->credentials.x509_credentials.x509privatekeyType = temp;
result = IOTHUB_CLIENT_OK;
}
}
}
else if (strcmp(OPTION_OPENSSL_ENGINE, optionName) == 0)
{
if (upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509 && upload_data->cred_type != IOTHUB_CREDENTIAL_TYPE_X509_ECC)
{
LogError("trying to set an openssl engine while the authentication scheme is not x509");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else
{
char* temp;
if (mallocAndStrcpy_s(&temp, value) != 0)
{
LogError("failure in mallocAndStrcpy_s");
result = IOTHUB_CLIENT_ERROR;
}
else
{
if (upload_data->credentials.x509_credentials.engine != NULL)
{
free(upload_data->credentials.x509_credentials.engine);
}
upload_data->credentials.x509_credentials.engine = temp;
result = IOTHUB_CLIENT_OK;
}
}
}
else if (strcmp(OPTION_TRUSTED_CERT, optionName) == 0)
{
if (value == NULL)
{
LogError("NULL is a not a valid value for TrustedCerts");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else
{
char* tempCopy;
if (mallocAndStrcpy_s(&tempCopy, value) != 0)
{
LogError("failure in mallocAndStrcpy_s");
result = IOTHUB_CLIENT_ERROR;
}
else
{
if (upload_data->certificates != NULL)
{
free(upload_data->certificates);
}
upload_data->certificates = tempCopy;
result = IOTHUB_CLIENT_OK;
}
}
}
else if (strcmp(optionName, OPTION_HTTP_PROXY) == 0)
{
HTTP_PROXY_OPTIONS* proxy_options = (HTTP_PROXY_OPTIONS *)value;
if (proxy_options->host_address == NULL)
{
LogError("NULL host_address in proxy options");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else if (((proxy_options->username == NULL) || (proxy_options->password == NULL)) &&
(proxy_options->username != proxy_options->password))
{
LogError("Only one of username and password for proxy settings was NULL");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else
{
if (upload_data->http_proxy_options.host_address != NULL)
{
free((char *)upload_data->http_proxy_options.host_address);
upload_data->http_proxy_options.host_address = NULL;
}
if (upload_data->http_proxy_options.username != NULL)
{
free((char *)upload_data->http_proxy_options.username);
upload_data->http_proxy_options.username = NULL;
}
if (upload_data->http_proxy_options.password != NULL)
{
free((char *)upload_data->http_proxy_options.password);
upload_data->http_proxy_options.password = NULL;
}
upload_data->http_proxy_options.port = proxy_options->port;
if (mallocAndStrcpy_s((char **)(&upload_data->http_proxy_options.host_address), proxy_options->host_address) != 0)
{
LogError("failure in mallocAndStrcpy_s - upload_data->http_proxy_options.host_address");
result = IOTHUB_CLIENT_ERROR;
}
else if (proxy_options->username != NULL && mallocAndStrcpy_s((char **)(&upload_data->http_proxy_options.username), proxy_options->username) != 0)
{
LogError("failure in mallocAndStrcpy_s - upload_data->http_proxy_options.username");
result = IOTHUB_CLIENT_ERROR;
}
else if (proxy_options->password != NULL && mallocAndStrcpy_s((char **)(&upload_data->http_proxy_options.password), proxy_options->password) != 0)
{
LogError("failure in mallocAndStrcpy_s - upload_data->http_proxy_options.password");
result = IOTHUB_CLIENT_ERROR;
}
else
{
result = IOTHUB_CLIENT_OK;
}
}
}
else if (strcmp(optionName, OPTION_CURL_VERBOSE) == 0)
{
upload_data->curl_verbosity_level = ((*(bool*)value) == 0) ? UPLOADTOBLOB_CURL_VERBOSITY_OFF : UPLOADTOBLOB_CURL_VERBOSITY_ON;
result = IOTHUB_CLIENT_OK;
}
else if (strcmp(optionName, OPTION_BLOB_UPLOAD_TIMEOUT_SECS) == 0)
{
upload_data->blob_upload_timeout_millisecs = 1000 * (*(size_t*)value);
result = IOTHUB_CLIENT_OK;
}
else if (strcmp(optionName, OPTION_NETWORK_INTERFACE_UPLOAD_TO_BLOB) == 0)
{
if (value == NULL)
{
LogError("NULL is not a valid value for networkInterface option");
result = IOTHUB_CLIENT_INVALID_ARG;
}
else
{
char* tempCopy;
if (mallocAndStrcpy_s(&tempCopy, value) != 0)
{
LogError("failure in mallocAndStrcpy_s");
result = IOTHUB_CLIENT_ERROR;
}
else
{
if (upload_data->networkInterface != NULL)
{
free((char*)upload_data->networkInterface);
}
upload_data->networkInterface = tempCopy;
result = IOTHUB_CLIENT_OK;
}
}
}
else if (strcmp(optionName, OPTION_BLOB_UPLOAD_TLS_RENEGOTIATION) == 0)
{
upload_data->tls_renegotiation = *((bool*)(value));
result = IOTHUB_CLIENT_OK;
}
else
{
result = IOTHUB_CLIENT_INVALID_ARG;
}
}
return result;
}