// --------------------------------------------------------------------------------------------------
// Clean a parameter by removing any embedded \x00 (null) characters from it.
// This would only happen if you have used to web_reg_save_param() and the result contains
// a null-character.
// Any such characters are replaced with ' '. (space)
// Since this changes existing parameters be careful what types of parameters
// you use this on.But when no null-character is found, the result is unaltered.
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// example usage:
// char *test;
// web_reg_save_param("TestParam", "LB=\"name=LastName\" Value=\"", "RB=\"", LAST);
// web_submit_data(...); // will fail, obiously.
// lr_message(lr_eval_string("TestParam: {TestParam}\n"));
// y_cleanse_parameter("TestParam");
// test=y_get_parameter("TestParam");
// lr_message("\nTest: >%s<\n", test);
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void y_cleanse_parameter(const char* paramName)
{
char *result;
unsigned long resultLen;
size_t resultStrlen;
size_t param_size = strlen(paramName) +3; // parameter name + "{}" + '\0' (end of string)
char *tmp = y_mem_alloc( param_size );
//lr_log_message("y_cleanse_parameter(%s)", paramName );
// Get the contents of the parameter using lr_eval_string_ext() - we can't use the
// regular version if we expect to find \x00 in there.
snprintf( tmp, param_size, "{%s}", paramName );
lr_eval_string_ext(tmp, strlen(tmp), &result, &resultLen, 0, 0, -1);
free(tmp);
// replace NULL bytes (\x00) in the input with something else..
for( resultStrlen = strlen(result);
resultStrlen < resultLen;
resultStrlen = strlen(result))
{
result[resultStrlen] = ' ';
}
// Put the result back into the original parameter.
lr_save_string(result, paramName);
lr_eval_string_ext_free(&result);
}
/*!
\brief Get the content of a parameter without embedded null bytes (\0 characters) from the named parameter, if any.
In some cases we want to fetch the content of a parameter but the parameter contains embedded NULL characters which make further processing harder.
This will fetch a parameter but "cleanse" it from such contamination, leaving the rest of the data unaltered before returning it.
\warning The return value of this function needs to be freed using lr_eval_string_ext_free().
\param [in] param_name The parameter to cleanse of nulls.
\param [in] replacement A character that replaces any embedded nulls found.
\returns The resulting parameter content.
\b Example:
\code
{
char buffer[11] = { '\0', 'b', '\0', 'r','o', '\0', 'k', 'e', 'n', '\0', '\0' };
char *tmp;
lr_save_var(buffer, 11, 0, "broken");
tmp = y_get_cleansed_parameter("broken", '!');
lr_log_message("Result: %s", tmp); // Prints "Result: !b!ro!ken!!".
free(tmp);
}
\endcode
*/
char* y_get_cleansed_parameter(const char* param_name, char replacement)
{
char* result;
unsigned long result_size;
size_t param_eval_size = strlen(param_name) +3; // parameter name + "{}" + '\0' (end of string)
char* param_eval_string = y_mem_alloc(param_eval_size);
//lr_log_message("y_cleanse_parameter(%s)", param_name );
// Get the contents of the parameter using lr_eval_string_ext() - we can't use the
// regular version if we expect to find NULL in there.
snprintf( param_eval_string, param_eval_size, "{%s}", param_name );
lr_eval_string_ext(param_eval_string, param_eval_size-1, &result, &result_size, 0, 0, -1);
if( strcmp(param_eval_string, result) == 0 )
{
lr_error_message("y_get_cleansed_parameter: Parameter %s does not exist.", param_name);
lr_abort();
}
free(param_eval_string);
//lr_log_message("Cleansing param %s, result starts with '%-*.*s' and contains %d bytes.", param_name, result_size, result_size, result, result_size);
if (result_size) {
char *ptr;
for(ptr = result; result_size--; ptr++)
if (*ptr == 0) *ptr = replacement;
/*
// Now replace NULL bytes (NULL) in the input with something else..
for( result_strlen = strlen(result); result_strlen < result_size; result_strlen = strlen(result))
{
result[result_strlen] = replacement;
//lr_log_message("Cleansing param %s, result now '%-*.*s' and contains %d bytes.", param_name, result_size, result_size, result, result_size);
}*/
}
return result;
}
/*!
\brief Get the content of a parameter and return it as a char * (lr_eval_string_ext() version)
Like y_get_parameter, but the result will use lr_eval_string_ext() to acquire it's memory,
rather than getting it from lr_eval_string.
This can be useful when you want your data to remain in memory instead of getting freed at the end of each iteration.
An example is the browser emulation code in y_emulate_browser.c, which sets up a linked list that has to stay allocated throughout the duration of the test.
(And therefore never needs to be freed. But I digress.)
\param [in] source_param The name of the parameter to fetch.
\returns A char* buffer containing the contents of the parameter, allocated with lr_eval_string_ext()
\warning Memory allocated in this manner must be freed using lr_eval_string_ext_free() or it will linger.
\b Example:
\code
char *test;
lr_save_string("test123", "TestParam"); // save the string "test123" into parameter {TestParam}
test=y_get_parameter_ext("TestParam");
lr_message("Test: %s", test);
lr_eval_string_ext_free(test);
\endcode
\author Floris Kraak
\sa y_get_parameter(), lr_eval_string_ext()
*/
char* y_get_parameter_ext(const char *source_param)
{
char* buffer;
unsigned long size;
char* source = y_get_parameter_eval_string(source_param); // Puts the parameter name into parameter seperators { }.
lr_eval_string_ext(source, strlen(source), &buffer, &size, 0, 0, -1); // Evaluates the result and copy the data into buffer.
free(source); // Free the intermediate parameter name.
return buffer;
}
// --------------------------------------------------------------------------------------------------
// Semi-efficiënt parameter copy using lr_eval_string_ext() with appropriate freeing of memory.
// @author Floris Kraak
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// example usage:
// lr_save_string("text", "param_a");
// y_copy_param("param_a", "param_b"); // Results in an exact copy of the content of param_a being stored in param_b.
// lr_log_message(lr_eval_string("param_b: {param_b}")); // Prints "param_b: text".
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
void y_copy_param(char* source_param, char* dest_param)
{
unsigned long size;
char* buffer;
char* source = y_get_parameter_eval_string(source_param); // Puts the parameter name into parameter seperators { }. Resulting ptr must be freed.
lr_eval_string_ext(source, strlen(source), &buffer, &size, 0, 0, -1); // Evaluates the result and copies the data into buffer.
free(source); // Free the intermediate parameter name.
lr_save_var(buffer, size, 0, dest_param); // Save the result.
lr_eval_string_ext_free(&buffer); // Free the buffer.
}
get_google_short_url_qrcode(){
int rc=0;
char strFileName[256]; // largest size of file.
char *szBuf;
unsigned long nLength;
if( stricmp("Y",LPCSTR_SaveImageYN ) == FOUND ){ // Run-time Attribute "SaveImageYN" or command line option "-SaveImageYN"
// continue if SaveImageYN was specified with Y
}else{
return LR_PASS;
}
set_pShortHostKey_from_url( lr_eval_string("{pShortURL}") ); // from get_google_short_url()
//wi_startPrintingTrace();
//lr_output_message(">> pShortHostKey=\"%s\"." ,lr_eval_string("{pShortHostKey}") );
//wi_stopPrinting();
// For shortened URL http://goo.gl/AC4IW", details are at http://goo.gl/#analytics/goo.gl/AC4IW/all_time
// {pShortHostKey}=AC4IW in example: URL http://goo.gl/AC4IW.qr redirects to
// The QR code impage at http://chart.googleapis.com/chart?cht=qr&chs=100x100&choe=UTF-8&chld=H|0&chl=http://goo.gl/AC4IW
web_reg_save_param_ex("ParamName=pImage", "LB=\r\n\r\n", "RB=\"", "Notfound=warning", LAST); // The \r\n\r\n is to begin capture after the two blank lines between HTTP header and body.
web_reg_save_param_ex("ParamName=pImage_len", "LB=Content-Length: ", "Notfound=warning", "RB=\r\n", LAST);
sprintf( tempString1, "%s_3image", lr_eval_string("{pTransSequence}") );
lr_save_string(tempString1,"pTransName");
wi_start_transaction();
// This URL was obtained from the DNS-level redirect in the HTML header in response to request for .qr, such as:
// The document has moved <A
// HREF="http://chart.googleapis.com/chart?cht=qr&chs=150x150&choe=UTF-8&chld=H&chl=http://goo.gl/x6wUIS">here</A>.\n
// & needs to be coverted to & character in URLs.
// WARNING: The 150x150 in this URL may change over time as more characters are needed for uniqueness.
// Previously, 100x100 was being returned:
// "URL={pShortURL}.qr",
web_url("imagefile",
"URL=http://chart.googleapis.com/chart?cht=qr&chs=150x150&choe=UTF-8&chld=H&chl={pShortURL}",
"Resource=1",
"RecContentType=image/png",
"Snapshot=t1.inf",
LAST);
// FIXME: File created has black box at bottom.
rc = wi_end_transaction();
// strFileName=wi_define_FileName():
lr_save_datetime("%Y%m%d%H%M%S", DATE_NOW, "pYMDHMS"); // YYMMDDHHMMSS (12 char), no micro seconds
sprintf(strFileName, "%s%s_%d_T%s_%s_%s.png"
,lr_eval_string("{pImageFilePath}")
,global_unique_id
,iActionIterations
,lr_eval_string("{pYMDHMS}")
,lr_eval_string("{pShortHostKey}")
,lr_eval_string("{pImage_len}")
);
lr_eval_string_ext("{pImage}", strlen("{pImage}"), &szBuf, &nLength, 0, 0, -1);
// lr_eval_string_ext( in_str, in_len, pointer out_str, out_len, Reserved for future use.
if( nLength <= 0 ){
lr_error_message(">> No image returned for %s.",strFileName);
}else{
if( wi_WriteDataToFile(strFileName, szBuf, nLength) == LR_PASS ){
wi_startPrintingInfo();
lr_output_message(">> QRcode_image file created at \"%s\".",strFileName);
wi_stopPrinting();
// TODO: 23. Remember after runs to clear out the files to an archive filer.
}else{
wi_startPrintingError();
lr_error_message(">>> QRcode_image file NOT created at \"%s\".",strFileName);
wi_stopPrinting();
}
}
return rc;
} // retrieve_pShortURL_qrcode()
