FB::variant BracExtenssionProviderAPI::cleanup(const FB::variant& msg) {
std::string command;
#if defined _WIN32
command = "rmdir /S /Q \"" + escape_path(m_screenshot_dir) + "\"";
#elif defined __APPLE__
command = "rm -Rf " + escape_path(m_screenshot_dir);
#endif
systemCall(command);
return "done!";
}
void onReturn(const std::string& path) {
BracExtenssionProviderAPI * api_ptr = brac_extenssion_provider_api;
if (!api_ptr) {
return;
}
if (path.empty()) {
api_ptr->log("No brac file selected, the path is empty ");
return;
} else {
api_ptr->log("brac file selected: " + path);
}
std::string root_dir = api_ptr->getExtensionPath();
#if defined _WIN32
std::string command = "cd /d \"" + root_dir + "\" & bin\\7za.exe e -y \"" + path + "\" brac.xml";
#elif defined __APPLE__
std::string escaped_root_dir = escape_path(root_dir);
api_ptr->log("brac extension root dir (escaped): " + escaped_root_dir);
std::string escaped_path = escape_path(path);
api_ptr->log("selected brac dir (escaped): " + escaped_path);
std::string command = "cd " + escaped_root_dir + "; bin/7za e -y " + escaped_path + " brac.xml";
#endif
api_ptr->systemCall(command);
std::string content;
std::string brac_path = root_dir + "/brac.xml";
pugi::xml_document brac_xml;
std::stringstream out_stream(std::stringstream::out);
pugi::xml_parse_result res = brac_xml.load_file(brac_path.c_str());
if (!res) {
api_ptr->log("Couldn't load the brac.xml at " + brac_path + ": " + res.description());
return;
}
brac_xml.save(out_stream);
content = out_stream.str();
#if defined _WIN32
command = "del /F /Q \"" + root_dir + "\\brac.xml\"";
#elif defined __APPLE__
command = "rm -f " + escaped_root_dir + "/brac.xml";
#endif
api_ptr->systemCall(command);
brac_extenssion_provider_api->fire_bracfileselect(path, content);
return;
}
FB::variant BracExtenssionProviderAPI::setExtensionPath(const FB::variant& msg) {
m_extension_path = msg.cast<std::string>();
size_t index = 0;
#if defined _WIN32
std::string env_var = "LOCALAPPDATA";
#elif defined __APPLE__
std::string env_var = "USER";
#endif
std::string signedvar = '%' + std::string(env_var) + '%';
index = m_extension_path.find(signedvar, index);
if (std::string::npos != index) {
m_extension_path.replace(index, signedvar.length(), get_env(env_var.c_str()));
log("Extension path is set to ('" + std::string(get_env(env_var.c_str())) + "'): " + m_extension_path);
} else {
log("No environment variable was found: " + m_extension_path);
}
#if defined __APPLE__
std::string esc_ext_path = escape_path(m_extension_path);
systemCall("chmod 700 " + esc_ext_path + "/bin/7za");
systemCall("chmod 700 " + esc_ext_path + "/bin/clg-crop.app");
systemCall("chmod 700 " + esc_ext_path + "/bin/clg-snapshot.app");
#endif
return m_extension_path;
}
static void
fr_command_tar_extract (FRCommand *comm,
GList *file_list,
char *dest_dir,
gboolean overwrite,
gboolean skip_older,
gboolean junk_paths)
{
GList *scan;
fr_process_begin_command (comm->process, "tar");
fr_process_add_arg (comm->process, "-xf");
fr_process_add_arg (comm->process, comm->filename);
add_compress_arg (comm);
if (dest_dir != NULL) {
fr_process_add_arg (comm->process, "-C");
fr_process_add_arg (comm->process, dest_dir);
}
/*
if (! overwrite)
fr_process_add_arg (comm->process, "-k");
*/
for (scan = file_list; scan; scan = scan->next) {
gchar *escaped = escape_path(scan->data);
if (escaped) {
fr_process_add_arg (comm->process, escaped);
g_free(escaped);
}
}
fr_process_end_command (comm->process);
}
/* Send args to the OOo instance (using the 'fd' file descriptor) */
static sal_Bool
send_args( int fd, rtl_uString *pCwdPath )
{
rtl_uString *pBuffer = NULL, *pTmp = NULL;
sal_Int32 nCapacity = 1000;
rtl_String *pOut = NULL;
sal_Bool bResult;
size_t nLen;
rtl_uString *pEscapedCwdPath = escape_path( pCwdPath );
sal_uInt32 nArg = 0;
sal_uInt32 nArgCount = rtl_getAppCommandArgCount();
rtl_uString_new_WithLength( &pBuffer, nCapacity );
rtl_uString_new( &pTmp );
rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
rtl_uString_getLength( pBuffer ),
RTL_CONSTASCII_STRINGPARAM( "InternalIPC::Arguments" ) );
if ( rtl_uString_getLength( pEscapedCwdPath ) )
{
rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
rtl_uString_getLength( pBuffer ),
RTL_CONSTASCII_STRINGPARAM( "1" ) );
rtl_uStringbuffer_insert( &pBuffer, &nCapacity,
rtl_uString_getLength( pBuffer ),
rtl_uString_getStr( pEscapedCwdPath ),
rtl_uString_getLength( pEscapedCwdPath ) );
}
else
{
rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
rtl_uString_getLength( pBuffer ),
RTL_CONSTASCII_STRINGPARAM( "0" ) );
}
for ( nArg = 0; nArg < nArgCount; ++nArg )
{
rtl_uString *pEscapedTmp = NULL;
rtl_uStringbuffer_insert_ascii( &pBuffer, &nCapacity,
rtl_uString_getLength( pBuffer ),
",", 1 );
rtl_getAppCommandArg( nArg, &pTmp );
pEscapedTmp = escape_path( pTmp );
rtl_uStringbuffer_insert( &pBuffer, &nCapacity,
rtl_uString_getLength( pBuffer ),
rtl_uString_getStr( pEscapedTmp ),
rtl_uString_getLength( pEscapedTmp ) );
rtl_uString_release( pEscapedTmp );
}
if ( !rtl_convertUStringToString(
&pOut, rtl_uString_getStr( pBuffer ),
rtl_uString_getLength( pBuffer ), RTL_TEXTENCODING_UTF8,
( RTL_UNICODETOTEXT_FLAGS_UNDEFINED_ERROR
| RTL_UNICODETOTEXT_FLAGS_INVALID_ERROR ) ) )
{
fprintf( stderr, "ERROR: cannot convert arguments to UTF-8\n" );
exit( 1 );
}
nLen = rtl_string_getLength( pOut ) + 1;
bResult = ( write( fd, rtl_string_getStr( pOut ), nLen ) == (ssize_t) nLen );
if ( bResult )
{
char resp[ strlen( "InternalIPC::ProcessingDone" ) ];
ssize_t n = read( fd, resp, SAL_N_ELEMENTS( resp ) );
bResult = n == (ssize_t) SAL_N_ELEMENTS( resp )
&& (memcmp(
resp, "InternalIPC::ProcessingDone",
SAL_N_ELEMENTS( resp ) )
== 0);
}
/* cleanup */
rtl_uString_release( pEscapedCwdPath );
rtl_uString_release( pBuffer );
rtl_uString_release( pTmp );
rtl_string_release( pOut );
return bResult;
}
FB::variant BracExtenssionProviderAPI::saveToBracFile(const FB::variant& msg) {
std::string command = "";
if (msg.empty())
log("Received message is empty.");
std::string msg_str = msg.cast<std::string>();
std::istringstream input(msg_str);
jsonxx::Object o;
if(!jsonxx::Object::parse(input, o)) {
log("Couldn't parse the JSON message.");
return "error";
}
if(!o.has<jsonxx::Object>("brac")) {
log("Couldn't find the brac JSON object.");
return "error";
}
jsonxx::Object & brac_info = o.get<jsonxx::Object>("brac");
jsonxx::Object & bric_info = o.get<jsonxx::Object>("bric");
std::string path = brac_info.get<std::string>("filepath");
std::string path_orig = path;
path += ".zip";
#if defined _WIN32
char drive[_MAX_DRIVE];
char dir[_MAX_DIR];
char fname[_MAX_FNAME];
char ext[_MAX_EXT];
_splitpath(path.c_str(), drive, dir, fname, ext);
command = "rename \"" + path_orig + "\" \"" + fname + ext + "\"";
#elif defined __APPLE__
std::string escaped_path = escape_path(path);
std::string escaped_path_orig = escape_path(path_orig);
command = "mv " + escaped_path_orig + " " + escaped_path;
#endif
systemCall(command);
#if defined _WIN32
command = "cd /d \"" + m_extension_path + "\" & bin\\7za.exe e -y \"" + path + "\" brac.xml";
#elif defined __APPLE__
std::string escaped_extension_path = escape_path(m_extension_path);
command = "cd " + escaped_extension_path + "; bin/7za e -y " + escaped_path + " brac.xml";
#endif
systemCall(command);
std::string in_file = m_extension_path + "/brac.xml";
pugi::xml_document brac_xml;
pugi::xml_parse_result result = brac_xml.load_file(in_file.c_str());
if (!result)
log(result.description());
pugi::xml_node brac_node = brac_xml.child("brac");
if (brac_node.empty()) {
log("brac node could not be found");
return "error";
}
pugi::xml_node layers_node = brac_node.child("layers");
if (layers_node.empty()) {
log("layers node could not be found");
return "error";
}
pugi::xml_object_range<pugi::xml_node_iterator> layers = layers_node.children();
int max_id = -1;
if (layers.begin() != layers.end())
for (pugi::xml_node_iterator itr = layers.begin(); itr != layers.end(); ++itr)
if (max_id < itr->attribute("id").as_int())
max_id = itr->attribute("id").as_int();
int new_brac_num = max_id + 1;
pugi::xml_node bric_node = layers_node.append_child("bric");
time_t t = time(0); // get current time
struct tm * now = localtime( &t );
char time_now[50];
sprintf(time_now, "%d-%02d-%02d %02d:%02d:%02d",
now->tm_year + 1900,
now->tm_mon + 1,
now->tm_mday,
now->tm_hour,
now->tm_min,
now->tm_sec
);
bric_node.append_attribute("revision" ).set_value(1);
bric_node.append_attribute("lastupdate" ).set_value(time_now);
bric_node.append_attribute("id" ).set_value(new_brac_num);
bric_node.append_attribute("alpha" ).set_value(bric_info.get<std::string>("alpha" ).c_str());
bric_node.append_attribute("order" ).set_value(bric_info.get<std::string>("order" ).c_str());
bric_node.append_attribute("resolution" ).set_value(bric_info.get<std::string>("resolution" ).c_str());
bric_node.append_attribute("position" ).set_value(bric_info.get<std::string>("position" ).c_str());
bric_node.append_attribute("maskposition").set_value(bric_info.get<std::string>("maskposition").c_str());
bric_node.append_attribute("rotate" ).set_value(bric_info.get<std::string>("rotation" ).c_str());
bric_node.append_attribute("scale" ).set_value(bric_info.get<std::string>("scale" ).c_str());
bric_node.append_attribute("timeinterval").set_value(bric_info.get<std::string>("timeInterval").c_str());
bric_node.append_child(pugi::node_pcdata).set_value(bric_info.get<std::string>("comment").c_str());
brac_node.attribute("name") .set_value(brac_info.get<std::string>("name").c_str());
brac_node.attribute("artist").set_value(brac_info.get<std::string>("artist").c_str());
brac_node.attribute("tags") .set_value(brac_info.get<std::string>("tags").c_str());
pugi::xml_object_range<pugi::xml_node_iterator> children = brac_node.children();
for (pugi::xml_node_iterator itr = children.begin(); itr != children.end(); ++itr)
if (itr->type() == pugi::node_pcdata) {
brac_node.remove_child(*itr);
itr = children.begin();
}
brac_node.append_child(pugi::node_pcdata).set_value(brac_info.get<std::string>("comment").c_str());
std::string out_file = m_extension_path + "/brac.xml";
if (!brac_xml.save_file(out_file.c_str()))
log("Error occurred while creating the new brac file: " + out_file);
#if defined _WIN32
command = "cd /d \"" + m_extension_path + "\" & bin\\7za.exe u \"" + path + "\" brac.xml & del /F /Q brac.xml";
#elif defined __APPLE__
command = "cd " + escaped_extension_path + "; bin/7za u " + escaped_path + " brac.xml; rm -f brac.xml";
#endif
systemCall(command);
std::stringstream stm;
stm << new_brac_num;
std::string new_bric_path = m_extension_path + "/temp/bric." + stm.str();
#if defined _WIN32
command = "mkdir \"" + new_bric_path + "\"";
#elif defined __APPLE__
std::string escaped_new_bric_path = escape_path(new_bric_path);
command = "mkdir -p " + escaped_new_bric_path;
#endif
systemCall(command);
pugi::xml_document bric_xml;
pugi::xml_node root_node = bric_xml.append_child("bric");
root_node.append_attribute("version" ).set_value("1.0");
root_node.append_attribute("title" ).set_value(bric_info.get<std::string>("title" ).c_str());
root_node.append_attribute("timeinterval").set_value(bric_info.get<std::string>("timeInterval").c_str());
root_node.append_attribute("startdate" ).set_value(bric_info.get<std::string>("startDate" ).c_str());
root_node.append_attribute("url" ).set_value(bric_info.get<std::string>("url" ).c_str());
root_node.append_attribute("region" ).set_value(bric_info.get<std::string>("region" ).c_str());
root_node.append_attribute("tags" ).set_value(bric_info.get<std::string>("tags" ).c_str());
pugi::xml_node snapshot_node = root_node.append_child("snapshot");
snapshot_node.append_attribute("revision").set_value("1");
snapshot_node.append_attribute("date").set_value(time_now);
std::string new_bric_filepath = new_bric_path + "/bric.xml";
std::string bric_screenshot_filename = "1.png";
std::string bric_screenshot = new_bric_path + "/" + bric_screenshot_filename;
std::string bric_thumbnail = "thumb.png";
std::string bric_thumbnail_path = new_bric_path + "/" + bric_thumbnail;
if (!bric_xml.save_file(new_bric_filepath.c_str()))
log("Error occurred while creating the new bric file: " + new_bric_filepath);
std::vector<std::string> brac_resolution = split(brac_info.get<std::string>("resolution"), ' ');
if (brac_resolution.size() != 2)
log("Brac resolution should be a pair of integer numbers, separated by space character.");
std::vector<std::string> bric_region = split(bric_info.get<std::string>("local_region"), ' ');
if (bric_region.size() != 4)
log("Bric region should be four integer numbers, separated by space character.");
std::string mask_layer_b64 = bric_info.get<std::string>("mask_b64").c_str();
bool mask_created = false;
std::string mask_filename = new_bric_path + "/mask.png";
if (!mask_layer_b64.empty()) {
std::string decoded = base64_decode(mask_layer_b64);
mask_created = saveBinaryFile(mask_filename.c_str(), decoded.c_str(), decoded.size());
}
#if defined _WIN32
command = "cd /d \"" + m_extension_path + "\" & move \"" + m_screenshot_dir + "\\" + m_screenshot_filename + "\" \"" + bric_screenshot + "\"";
systemCall(command);
//*/
command = "cd /d \"" + m_extension_path + "\" & bin\\clg-crop.exe"
+ " \"" + bric_screenshot + "\" "
+ bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
/*/
command = "cd /d \"" + m_extension_path + "\" & python bin\\crop.py"
+ " \"" + bric_screenshot + "\" "
+ bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
//*/
systemCall(command);
command = "cd /d \"" + new_bric_path + "\" & copy " + bric_screenshot_filename + " " + bric_thumbnail;
systemCall(command);
command = "cd /d \"" + m_extension_path + "\" & bin\\7za.exe a \"" + path + "\" \"" + new_bric_path + "\"";
systemCall(command);
command = "rmdir /S /Q \"" + m_extension_path + "\\temp\"";
systemCall(command);
_splitpath(path_orig.c_str(), drive, dir, fname, ext);
command = "rename \"" + path + "\" \"" + fname + ext + "\"";
systemCall(command);
#elif defined __APPLE__
std::string escaped_bric_screenshot = escape_path(bric_screenshot);
std::string escaped_screenshot_dir = escape_path(m_screenshot_dir);
command = "mv " + escaped_screenshot_dir + "/" + m_screenshot_filename + " " + escaped_bric_screenshot;
systemCall(command);
//*/
command = "cd " + escaped_extension_path + "; open -gW bin/clg-crop.app --args "
+ " " + escaped_bric_screenshot + " "
+ bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
/*/
command = "cd " + escaped_extension_path + "; bin/crop.py"
+ " " + escaped_bric_screenshot + " "
+ bric_region[0] + " " + bric_region[1] + " " + bric_region[2] + " " + bric_region[3];
//*/
systemCall(command);
std::string escaped_bric_thumbnail = escape_path(bric_thumbnail_path);
command = "cp \"" + escaped_bric_screenshot + "\" \"" + escaped_bric_thumbnail + "\"";
systemCall(command);
command = "cd " + escaped_extension_path + "; bin/7za a " + escaped_path + " " + escaped_new_bric_path;
systemCall(command);
command = "rm -Rf " + escaped_extension_path + "/temp";
systemCall(command);
command = "mv " + escaped_path + " " + escaped_path_orig;
systemCall(command);
#endif
fire_cleanup();
return "done!";
}
FB::variant BracExtenssionProviderAPI::takeSnapShot(const FB::variant& msg) {
if (msg.empty()) {
log("Received message is empty.");
return false;
}
std::string msg_str = msg.cast<std::string>();
std::istringstream input(msg_str);
jsonxx::Object o;
if(!jsonxx::Object::parse(input, o))
log("Couldn't parse the JSON message.");
std::string url = o.get<std::string>("url");
std::string width = o.get<std::string>("width");
std::string height = o.get<std::string>("height");
std::string scrollLeft = o.get<std::string>("scrollLeft");
std::string scrollTop = o.get<std::string>("scrollTop");
m_screenshot_dir = m_extension_path + "/img/screenshot";
m_screenshot_filename = o.get<std::string>("filename");
std::string command = "";
#if defined _WIN32
command = "mkdir \"" + escape_path(m_screenshot_dir) + "\"";
systemCall(command);
std::string filepath = m_screenshot_dir + "/" + m_screenshot_filename;
//*/
command = "cd /d \"" + m_extension_path + "\" & bin\\clg-snapshot.exe "
+ "\"" + url + "\" " // target url
+ "\"" + filepath + "\" " // target filepath
+ width + " " // window width
+ height + " " // window height
+ scrollLeft + " " // scrollLeft
+ scrollTop // scrollTop
;// using default timeout
/*/
command = "cd /d \"" + m_extension_path + "\" & python bin\\snapshot.py "
+ "\"" + url + "\" " // target url
+ "\"" + filepath + "\" " // target filepath
+ width + " " // window width
+ height + " " // window height
+ scrollLeft + " " // scrollLeft
+ scrollTop // scrollTop
;// using default timeout
//*/
systemCall(command);
#elif defined __APPLE__
std::string escaped_extension_path = escape_path(m_extension_path);
std::string escaped_dir = escape_path(m_screenshot_dir);
command = "mkdir -p " + escaped_dir;
systemCall(command);
std::string filepath = escaped_dir + "/" + m_screenshot_filename;
//*/
command = "cd " + escaped_extension_path + "; "
+ "open -gW bin/clg-snapshot.app --args "
+ "'" + url + "' " // target url
+ "'" + filepath + "' " // target filepath
+ width + " " // window width
+ height + " " // window height
+ scrollLeft + " " // scrollLeft
+ scrollTop // scrollTop
;// using default timeout
/*/
command = "cd " + escaped_extension_path + "; "
+ "bin/snapshot.py "
+ "'" + url + "' " // target url
+ "'" + filepath + "' " // target filepath
+ width + " " // window width
+ height + " " // window height
+ scrollLeft + " " // scrollLeft
+ scrollTop // scrollTop
;// using default timeout
//*/
systemCall(command);
#endif
return "done!";
}
// Actually starts a download by adding it to the curl multi handle.
static void start_download(dlqueue_t *entry, dlhandle_t *dl)
{
size_t len;
char temp[MAX_QPATH];
char escaped[MAX_QPATH * 4];
CURLMcode ret;
qerror_t err;
//yet another hack to accomodate filelists, how i wish i could push :(
//NULL file handle indicates filelist.
if (entry->type == DL_LIST) {
dl->file = NULL;
dl->path[0] = 0;
//filelist paths are absolute
escape_path(entry->path, escaped);
} else {
len = Q_snprintf(dl->path, sizeof(dl->path), "%s/%s.tmp", fs_gamedir, entry->path);
if (len >= sizeof(dl->path)) {
Com_EPrintf("[HTTP] Refusing oversize temporary file path.\n");
goto fail;
}
//prepend quake path with gamedir
len = Q_snprintf(temp, sizeof(temp), "%s/%s", http_gamedir(), entry->path);
if (len >= sizeof(temp)) {
Com_EPrintf("[HTTP] Refusing oversize server file path.\n");
goto fail;
}
escape_path(temp, escaped);
err = FS_CreatePath(dl->path);
if (err < 0) {
Com_EPrintf("[HTTP] Couldn't create path to '%s': %s\n", dl->path, Q_ErrorString(err));
goto fail;
}
//don't bother with http resume... too annoying if server doesn't support it.
dl->file = fopen(dl->path, "wb");
if (!dl->file) {
Com_EPrintf("[HTTP] Couldn't open '%s' for writing: %s\n", dl->path, strerror(errno));
goto fail;
}
}
len = Q_snprintf(dl->url, sizeof(dl->url), "%s%s", download_server, escaped);
if (len >= sizeof(dl->url)) {
Com_EPrintf("[HTTP] Refusing oversize download URL.\n");
goto fail;
}
dl->buffer = NULL;
dl->size = 0;
dl->position = 0;
dl->queue = entry;
if (!dl->curl)
dl->curl = curl_easy_init();
curl_easy_setopt(dl->curl, CURLOPT_ENCODING, "");
#ifdef _DEBUG
if (cl_http_debug->integer) {
curl_easy_setopt(dl->curl, CURLOPT_DEBUGFUNCTION, debug_func);
curl_easy_setopt(dl->curl, CURLOPT_VERBOSE, 1);
}
#endif
curl_easy_setopt(dl->curl, CURLOPT_NOPROGRESS, 0);
if (dl->file) {
curl_easy_setopt(dl->curl, CURLOPT_WRITEDATA, dl->file);
curl_easy_setopt(dl->curl, CURLOPT_WRITEFUNCTION, NULL);
} else {
curl_easy_setopt(dl->curl, CURLOPT_WRITEDATA, dl);
curl_easy_setopt(dl->curl, CURLOPT_WRITEFUNCTION, recv_func);
}
curl_easy_setopt(dl->curl, CURLOPT_FAILONERROR, 1);
curl_easy_setopt(dl->curl, CURLOPT_PROXY, cl_http_proxy->string);
curl_easy_setopt(dl->curl, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(dl->curl, CURLOPT_MAXREDIRS, 5);
curl_easy_setopt(dl->curl, CURLOPT_PROGRESSFUNCTION, progress_func);
curl_easy_setopt(dl->curl, CURLOPT_PROGRESSDATA, dl);
curl_easy_setopt(dl->curl, CURLOPT_USERAGENT, com_version->string);
curl_easy_setopt(dl->curl, CURLOPT_REFERER, download_referer);
curl_easy_setopt(dl->curl, CURLOPT_URL, dl->url);
ret = curl_multi_add_handle(curl_multi, dl->curl);
if (ret != CURLM_OK) {
Com_EPrintf("[HTTP] Failed to add download handle: %s\n",
curl_multi_strerror(ret));
fail:
CL_FinishDownload(entry);
// see if we have more to dl
CL_RequestNextDownload();
return;
}
Com_DPrintf("[HTTP] Fetching %s...\n", dl->url);
entry->state = DL_RUNNING;
curl_handles++;
}
