int set_result_type(AGENT_RESULT *result, int value_type, int data_type, char *c)
{
int ret = FAIL;
zbx_uint64_t value_uint64;
double value_double;
assert(result);
switch (value_type)
{
case ITEM_VALUE_TYPE_UINT64:
zbx_rtrim(c, " \"");
zbx_ltrim(c, " \"+");
del_zeroes(c);
switch (data_type)
{
case ITEM_DATA_TYPE_BOOLEAN:
if (SUCCEED == is_boolean(c, &value_uint64))
{
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
case ITEM_DATA_TYPE_OCTAL:
if (SUCCEED == is_uoct(c))
{
ZBX_OCT2UINT64(value_uint64, c);
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
case ITEM_DATA_TYPE_DECIMAL:
if (SUCCEED == is_uint64(c, &value_uint64))
{
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
case ITEM_DATA_TYPE_HEXADECIMAL:
if (SUCCEED == is_uhex(c))
{
ZBX_HEX2UINT64(value_uint64, c);
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
else if (SUCCEED == is_hex_string(c))
{
zbx_remove_whitespace(c);
ZBX_HEX2UINT64(value_uint64, c);
SET_UI64_RESULT(result, value_uint64);
ret = SUCCEED;
}
break;
default:
THIS_SHOULD_NEVER_HAPPEN;
break;
}
break;
case ITEM_VALUE_TYPE_FLOAT:
zbx_rtrim(c, " \"");
zbx_ltrim(c, " \"+");
if (SUCCEED != is_double(c))
break;
value_double = atof(c);
SET_DBL_RESULT(result, value_double);
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_STR:
zbx_replace_invalid_utf8(c);
SET_STR_RESULT(result, zbx_strdup(NULL, c));
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_TEXT:
zbx_replace_invalid_utf8(c);
SET_TEXT_RESULT(result, zbx_strdup(NULL, c));
ret = SUCCEED;
break;
case ITEM_VALUE_TYPE_LOG:
zbx_replace_invalid_utf8(c);
add_log_result(result, c);
ret = SUCCEED;
break;
}
if (SUCCEED != ret)
{
char *error = NULL;
zbx_remove_chars(c, "\r\n");
zbx_replace_invalid_utf8(c);
if (ITEM_VALUE_TYPE_UINT64 == value_type)
error = zbx_dsprintf(error,
"Received value [%s] is not suitable for value type [%s] and data type [%s]",
c, zbx_item_value_type_string(value_type),
zbx_item_data_type_string(data_type));
else
error = zbx_dsprintf(error,
"Received value [%s] is not suitable for value type [%s]",
c, zbx_item_value_type_string(value_type));
SET_MSG_RESULT(result, error);
}
return ret;
}
/******************************************************************************
* *
* Function: send_ez_texting *
* *
* Purpose: send SMS using Ez Texting API *
* *
* Parameters: *
* *
* Return value: SUCCEED if message has been sent successfully *
* FAIL otherwise *
* *
* Author: Aleksandrs Saveljevs *
* *
* Comments: *
* *
******************************************************************************/
int send_ez_texting(const char *username, const char *password, const char *sendto,
const char *message, const char *limit, char *error, int max_error_len)
{
#ifdef HAVE_LIBCURL
const char *__function_name = "send_ez_texting";
int ret = FAIL;
int max_message_len;
int i, len, opt, err;
char *sendto_digits = NULL, *message_ascii = NULL;
char *username_esc = NULL, *password_esc = NULL, *sendto_esc = NULL, *message_esc = NULL;
char postfields[MAX_STRING_LEN];
CURL *easy_handle = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() sendto:'%s' message:'%s'", __function_name, sendto, message);
assert(error);
*error = '\0';
memset(&page, 0, sizeof(page));
/* replace UTF-8 and invalid ASCII characters, and make sure the message is not too long */
switch (atoi(limit))
{
case EZ_TEXTING_LIMIT_USA:
max_message_len = EZ_TEXTING_LENGTH_USA;
break;
case EZ_TEXTING_LIMIT_CANADA:
max_message_len = EZ_TEXTING_LENGTH_CANADA;
break;
default:
THIS_SHOULD_NEVER_HAPPEN;
zbx_snprintf(error, max_error_len, "Could not determine proper length limit: [%s]", limit);
goto clean;
}
if (NULL == (message_ascii = zbx_replace_utf8(message)))
{
zbx_snprintf(error, max_error_len, "Could not replace UTF-8 characters: [%s]", message);
goto clean;
}
for (i = 0, len = 0; '\0' != message_ascii[i] && len < max_message_len; i++, len++)
{
if (' ' == message_ascii[i])
continue;
if ('a' <= message_ascii[i] && message_ascii[i] <= 'z')
continue;
if ('A' <= message_ascii[i] && message_ascii[i] <= 'Z')
continue;
if ('0' <= message_ascii[i] && message_ascii[i] <= '9')
continue;
if ('\t' == message_ascii[i]) /* \t is not part of GSM character set */
{
message_ascii[i] = ' ';
continue;
}
if ('\r' == message_ascii[i]) /* line end counts as two, regardless of... */
{
if ('\n' != message_ascii[i + 1])
len++;
continue;
}
if ('\n' == message_ascii[i]) /* ... how it is specified: \r, \n, or \r\n */
{
if (0 < i && '\r' != message_ascii[i - 1])
len++;
continue;
}
if (NULL == (strchr(EZ_TEXTING_VALID_CHARS, message_ascii[i])))
{
message_ascii[i] = '?';
continue;
}
if (NULL != (strchr(EZ_TEXTING_DOUBLE_CHARS, message_ascii[i])))
{
len++;
continue;
}
}
if (len > max_message_len)
i--;
message_ascii[i] = '\0';
/* prepare and make cURL request to Ez Texting API */
if (NULL == (easy_handle = curl_easy_init()))
{
zbx_snprintf(error, max_error_len, "Could not initialize cURL");
goto clean;
}
sendto_digits = strdup(sendto);
zbx_remove_chars(sendto_digits, "() -"); /* allow phone numbers to be specified like "(123) 456-7890" */
if (NULL == (username_esc = curl_easy_escape(easy_handle, username, strlen(username))) ||
NULL == (password_esc = curl_easy_escape(easy_handle, password, strlen(password))) ||
NULL == (sendto_esc = curl_easy_escape(easy_handle, sendto_digits, strlen(sendto_digits))) ||
NULL == (message_esc = curl_easy_escape(easy_handle, message_ascii, strlen(message_ascii))))
{
zbx_snprintf(error, max_error_len, "Could not URL encode POST fields");
goto clean;
}
zbx_snprintf(postfields, sizeof(postfields), "user=%s&pass=%s&phonenumber=%s&subject=&message=%s",
username_esc, password_esc, sendto_esc, message_esc);
if (CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_USERAGENT, "Zabbix " ZABBIX_VERSION)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_FOLLOWLOCATION, 1L)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_WRITEFUNCTION, WRITEFUNCTION2)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_HEADERFUNCTION, HEADERFUNCTION2)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_SSL_VERIFYPEER, 1L)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_SSL_VERIFYHOST, 2L)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_POSTFIELDS, postfields)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_POST, 1L)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_URL, EZ_TEXTING_API_URL)) ||
CURLE_OK != (err = curl_easy_setopt(easy_handle, opt = CURLOPT_TIMEOUT, (long)EZ_TEXTING_TIMEOUT)))
{
zbx_snprintf(error, max_error_len, "Could not set cURL option %d: [%s]", opt, curl_easy_strerror(err));
goto clean;
}
if (CURLE_OK != (err = curl_easy_perform(easy_handle)))
{
zbx_snprintf(error, max_error_len, "Error doing curl_easy_perform(): [%s]", curl_easy_strerror(err));
goto clean;
}
/* parse the response */
if (NULL == page.data || FAIL == is_int_prefix(page.data))
{
zbx_snprintf(error, max_error_len, "Did not receive a proper response: [%s]",
NULL == page.data ? "(null)" : page.data);
goto clean;
}
switch (atoi(page.data))
{
case 1:
ret = SUCCEED;
break;
case -1:
zbx_snprintf(error, max_error_len, "Invalid user and/or password or API is not allowed");
break;
case -2:
zbx_snprintf(error, max_error_len, "Credit limit reached");
break;
case -5:
zbx_snprintf(error, max_error_len, "Locally opted out phone number");
break;
case -7:
zbx_snprintf(error, max_error_len, "Message too long or contains invalid characters");
break;
case -104:
zbx_snprintf(error, max_error_len, "Globally opted out phone number");
break;
case -106:
zbx_snprintf(error, max_error_len, "Incorrectly formatted phone number");
break;
case -10:
zbx_snprintf(error, max_error_len, "Unknown error (please contact Ez Texting)");
break;
default:
zbx_snprintf(error, max_error_len, "Unknown return value: [%s]", page.data);
break;
}
clean:
if (NULL != message_ascii)
zbx_free(message_ascii);
if (NULL != sendto_digits)
zbx_free(sendto_digits);
if (NULL != username_esc)
zbx_free(username_esc);
if (NULL != password_esc)
zbx_free(password_esc);
if (NULL != sendto_esc)
zbx_free(sendto_esc);
if (NULL != message_esc)
zbx_free(message_esc);
if (NULL != page.data)
zbx_free(page.data);
if (NULL != easy_handle)
curl_easy_cleanup(easy_handle);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
#else
zbx_snprintf(error, max_error_len, "cURL library is required for Ez Texting support");
return FAIL;
#endif /* HAVE_LIBCURL */
}
