开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 游戏引擎 > 查看源码
linux_updater.cpp
资源名称：snowglobe-src-viewer-2.0.0-r0.tar.gz　[点击查看]
上传用户：king477883
上传日期：2021-03-01
资源大小：9553k
文件大小：22k
源码类别：

游戏引擎

开发平台：

C++ Builder

linux_updater.cpp：源码内容
  1. /** 
  2.  * @file linux_updater.cpp
  3.  * @author Kyle Ambroff <ambroff@lindenlab.com>, Tofu Linden
  4.  * @brief Viewer update program for unix platforms that support GTK+
  5.  *
  6.  * $LicenseInfo:firstyear=2008&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2008-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #include <unistd.h>
  35. #include <signal.h>
  36. #include <errno.h>
  38. #include "linden_common.h"
  39. #include "llerrorcontrol.h"
  40. #include "llfile.h"
  41. #include "lldir.h"
  42. #include "llxmlnode.h"
  43. #include "lltrans.h"
  45. #include <curl/curl.h>
  47. extern "C" {
  48. #include <gtk/gtk.h>
  49. }
  51. const guint UPDATE_PROGRESS_TIMEOUT = 100;
  52. const guint UPDATE_PROGRESS_TEXT_TIMEOUT = 1000;
  53. const guint ROTATE_IMAGE_TIMEOUT = 8000;
  55. typedef struct _updater_app_state {
  56. std::string app_name;
  57. std::string url;
  58. std::string image_dir;
  59. std::string dest_dir;
  60. std::string strings_dirs;
  61. std::string strings_file;
  63. GtkWidget *window;
  64. GtkWidget *progress_bar;
  65. GtkWidget *image;
  67. double progress_value;
  68. bool activity_mode;
  70. guint image_rotation_timeout_id;
  71. guint progress_update_timeout_id;
  72. guint update_progress_text_timeout_id;
  74. bool failure;
  75. } UpdaterAppState;
  77. // List of entries from strings.xml to always replace
  78. static std::set<std::string> default_trans_args;
  79. void init_default_trans_args()
  80. {
  81.         default_trans_args.insert("SECOND_LIFE"); // World
  82.         default_trans_args.insert("APP_NAME");
  83.         default_trans_args.insert("SECOND_LIFE_GRID");
  84.         default_trans_args.insert("SUPPORT_SITE");
  85. }
  87. bool translate_init(std::string comma_delim_path_list,
  88.     std::string base_xml_name)
  89. {
  90. init_default_trans_args();
  92. // extract paths string vector from comma-delimited flat string
  93. std::vector<std::string> paths;
  94. LLStringUtil::getTokens(comma_delim_path_list, paths, ","); // split over ','
  96. // suck the translation xml files into memory
  97. LLXMLNodePtr root;
  98. bool success = LLXMLNode::getLayeredXMLNode(base_xml_name, root, paths);
  99. if (!success)
  100. {
  101. // couldn't load string table XML
  102. return false;
  103. }
  104. else
  105. {
  106. // get those strings out of the XML
  107. LLTrans::parseStrings(root, default_trans_args);
  108. return true;
  109. }
  110. }
  113. void updater_app_ui_init(void);
  114. void updater_app_quit(UpdaterAppState *app_state);
  115. void parse_args_and_init(int argc, char **argv, UpdaterAppState *app_state);
  116. std::string next_image_filename(std::string& image_path);
  117. void display_error(GtkWidget *parent, std::string title, std::string message);
  118. BOOL install_package(std::string package_file, std::string destination);
  119. BOOL spawn_viewer(UpdaterAppState *app_state);
  121. extern "C" {
  122. void on_window_closed(GtkWidget *sender, gpointer state);
  123. gpointer worker_thread_cb(gpointer *data);
  124. int download_progress_cb(gpointer data, double t, double d, double utotal, double ulnow);
  125. gboolean rotate_image_cb(gpointer data);
  126. gboolean progress_update_timeout(gpointer data);
  127. gboolean update_progress_text_timeout(gpointer data);
  128. }
  130. void updater_app_ui_init(UpdaterAppState *app_state)
  131. {
  132. GtkWidget *vbox;
  133. GtkWidget *summary_label;
  134. GtkWidget *description_label;
  135. GtkWidget *frame;
  137. llassert(app_state != NULL);
  139. // set up window and main container
  140. std::string window_title = LLTrans::getString("UpdaterWindowTitle");
  141. app_state->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  142. gtk_window_set_title(GTK_WINDOW(app_state->window),
  143.      window_title.c_str());
  144. gtk_window_set_resizable(GTK_WINDOW(app_state->window), FALSE);
  145. gtk_window_set_position(GTK_WINDOW(app_state->window),
  146. GTK_WIN_POS_CENTER_ALWAYS);
  148. gtk_container_set_border_width(GTK_CONTAINER(app_state->window), 12);
  149. g_signal_connect(G_OBJECT(app_state->window), "delete-event", 
  150.  G_CALLBACK(on_window_closed), app_state);
  152. vbox = gtk_vbox_new(FALSE, 6);
  153. gtk_container_add(GTK_CONTAINER(app_state->window), vbox);
  155. // set top label
  156. std::ostringstream label_ostr;
  157. label_ostr << "<big><b>"
  158.    << LLTrans::getString("UpdaterNowUpdating")
  159.    << "</b></big>";
  161. summary_label = gtk_label_new(NULL);
  162. gtk_label_set_use_markup(GTK_LABEL(summary_label), TRUE);
  163. gtk_label_set_markup(GTK_LABEL(summary_label), 
  164.      label_ostr.str().c_str());
  165. gtk_misc_set_alignment(GTK_MISC(summary_label), 0, 0.5);
  166. gtk_box_pack_start(GTK_BOX(vbox), summary_label, FALSE, FALSE, 0);
  168. // create the description label
  169. description_label = gtk_label_new(LLTrans::getString("UpdaterUpdatingDescriptive").c_str());
  170. gtk_label_set_line_wrap(GTK_LABEL(description_label), TRUE);
  171. gtk_misc_set_alignment(GTK_MISC(description_label), 0, 0.5);
  172. gtk_box_pack_start(GTK_BOX(vbox), description_label, FALSE, FALSE, 0);
  174. // If an image path has been set, load the background images
  175. if (!app_state->image_dir.empty()) {
  176. frame = gtk_frame_new(NULL);
  177. gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
  178. gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
  180. // load the first image
  181. app_state->image = gtk_image_new_from_file
  182. (next_image_filename(app_state->image_dir).c_str());
  183. gtk_widget_set_size_request(app_state->image, 340, 310);
  184. gtk_container_add(GTK_CONTAINER(frame), app_state->image);
  186. // rotate the images every 5 seconds
  187. app_state->image_rotation_timeout_id = g_timeout_add
  188. (ROTATE_IMAGE_TIMEOUT, rotate_image_cb, app_state);
  189. }
  191. // set up progress bar, and update it roughly every 1/10 of a second
  192. app_state->progress_bar = gtk_progress_bar_new();
  193. gtk_progress_bar_set_text(GTK_PROGRESS_BAR(app_state->progress_bar), 
  194.   LLTrans::getString("UpdaterProgressBarTextWithEllipses").c_str());
  195. gtk_box_pack_start(GTK_BOX(vbox), 
  196.    app_state->progress_bar, FALSE, TRUE, 0);
  197. app_state->progress_update_timeout_id = g_timeout_add
  198. (UPDATE_PROGRESS_TIMEOUT, progress_update_timeout, app_state);
  199. app_state->update_progress_text_timeout_id = g_timeout_add
  200. (UPDATE_PROGRESS_TEXT_TIMEOUT, update_progress_text_timeout, app_state);
  202. gtk_widget_show_all(app_state->window);
  203. }
  205. gboolean rotate_image_cb(gpointer data)
  206. {
  207. UpdaterAppState *app_state;
  208. std::string filename;
  210. llassert(data != NULL);
  211. app_state = (UpdaterAppState *) data;
  213. filename = next_image_filename(app_state->image_dir);
  215. gdk_threads_enter();
  216. gtk_image_set_from_file(GTK_IMAGE(app_state->image), filename.c_str());
  217. gdk_threads_leave();
  219. return TRUE;
  220. }
  222. std::string next_image_filename(std::string& image_path)
  223. {
  224. std::string image_filename;
  225. gDirUtilp->getNextFileInDir(image_path, "/*.jpg", image_filename, true);
  226. return image_path + "/" + image_filename;
  227. }
  229. void on_window_closed(GtkWidget *sender, gpointer data)
  230. {
  231. UpdaterAppState *app_state;
  233. llassert(data != NULL);
  234. app_state = (UpdaterAppState *) data;
  236. updater_app_quit(app_state);
  237. }
  239. void updater_app_quit(UpdaterAppState *app_state)
  240. {
  241. if (app_state != NULL)
  242. {
  243. g_source_remove(app_state->progress_update_timeout_id);
  245. if (!app_state->image_dir.empty())
  246. {
  247. g_source_remove(app_state->image_rotation_timeout_id);
  248. }
  249. }
  251. gtk_main_quit();
  252. }
  254. void display_error(GtkWidget *parent, std::string title, std::string message)
  255. {
  256. GtkWidget *dialog;
  258. dialog = gtk_message_dialog_new(GTK_WINDOW(parent),
  259. GTK_DIALOG_DESTROY_WITH_PARENT,
  260. GTK_MESSAGE_ERROR,
  261. GTK_BUTTONS_OK,
  262. "%s", message.c_str());
  263. gtk_window_set_title(GTK_WINDOW(dialog), title.c_str());
  264. gtk_dialog_run(GTK_DIALOG(dialog));
  265. gtk_widget_destroy(dialog);
  266. }
  268. gpointer worker_thread_cb(gpointer data)
  269. {
  270. UpdaterAppState *app_state;
  271. CURL *curl;
  272. CURLcode result;
  273. FILE *package_file;
  274. GError *error = NULL;
  275. char *tmp_filename = NULL;
  276. int fd;
  278. //g_return_val_if_fail (data != NULL, NULL);
  279. app_state = (UpdaterAppState *) data;
  281. try {
  282. // create temporary file to store the package.
  283. fd = g_file_open_tmp
  284. ("secondlife-update-XXXXXX", &tmp_filename, &error);
  285. if (error != NULL)
  286. {
  287. llerrs << "Unable to create temporary file: "
  288.        << error->message
  289.        << llendl;
  291. g_error_free(error);
  292. throw 0;
  293. }
  295. package_file = fdopen(fd, "wb");
  296. if (package_file == NULL)
  297. {
  298. llerrs << "Failed to create temporary file: "
  299.        << tmp_filename
  300.        << llendl;
  302. gdk_threads_enter();
  303. display_error(app_state->window,
  304.       LLTrans::getString("UpdaterFailDownloadTitle"),
  305.       LLTrans::getString("UpdaterFailUpdateDescriptive"));
  306. gdk_threads_leave();
  307. throw 0;
  308. }
  310. // initialize curl and start downloading the package
  311. llinfos << "Downloading package: " << app_state->url << llendl;
  313. curl = curl_easy_init();
  314. if (curl == NULL)
  315. {
  316. llerrs << "Failed to initialize libcurl" << llendl;
  318. gdk_threads_enter();
  319. display_error(app_state->window,
  320.       LLTrans::getString("UpdaterFailDownloadTitle"),
  321.       LLTrans::getString("UpdaterFailUpdateDescriptive"));
  322. gdk_threads_leave();
  323. throw 0;
  324. }
  326. curl_easy_setopt(curl, CURLOPT_URL, app_state->url.c_str());
  327. curl_easy_setopt(curl, CURLOPT_NOSIGNAL, TRUE);
  328. curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, TRUE);
  329. curl_easy_setopt(curl, CURLOPT_WRITEDATA, package_file);
  330. curl_easy_setopt(curl, CURLOPT_NOPROGRESS, FALSE);
  331. curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, 
  332.  &download_progress_cb);
  333. curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, app_state);
  335. result = curl_easy_perform(curl);
  336. fclose(package_file);
  337. curl_easy_cleanup(curl);
  339. if (result)
  340. {
  341. llerrs << "Failed to download update: " 
  342.        << app_state->url 
  343.        << llendl;
  345. gdk_threads_enter();
  346. display_error(app_state->window,
  347.       LLTrans::getString("UpdaterFailDownloadTitle"),
  348.       LLTrans::getString("UpdaterFailUpdateDescriptive"));
  349. gdk_threads_leave();
  351. throw 0;
  352. }
  354. // now pulse the progres bar back and forth while the package is
  355. // being unpacked
  356. gdk_threads_enter();
  357. std::string installing_msg = LLTrans::getString("UpdaterNowInstalling");
  358. gtk_progress_bar_set_text(
  359. GTK_PROGRESS_BAR(app_state->progress_bar),
  360. installing_msg.c_str());
  361. app_state->activity_mode = TRUE;
  362. gdk_threads_leave();
  364. // *TODO: if the destination is not writable, terminate this
  365. // thread and show file chooser?
  366. if (!install_package(tmp_filename, app_state->dest_dir))
  367. {
  368. llwarns << "Failed to install package to destination: "
  369. << app_state->dest_dir
  370. << llendl;
  372. gdk_threads_enter();
  373. display_error(app_state->window,
  374.       LLTrans::getString("UpdaterFailInstallTitle"),
  375.       LLTrans::getString("UpdaterFailUpdateDescriptive"));
  376. //"Failed to update " + app_state->app_name,
  377. gdk_threads_leave();
  378. throw 0;
  379. }
  381. // try to spawn the new viewer
  382. if (!spawn_viewer(app_state))
  383. {
  384. llwarns << "Viewer was not installed properly in : "
  385. << app_state->dest_dir
  386. << llendl;
  388. gdk_threads_enter();
  389. display_error(app_state->window,
  390.       LLTrans::getString("UpdaterFailStartTitle"),
  391.       LLTrans::getString("UpdaterFailUpdateDescriptive"));
  392. gdk_threads_leave();
  393. throw 0;
  394. }
  395. }
  396. catch (...)
  397. {
  398. app_state->failure = TRUE;
  399. }
  401. // FIXME: delete package file also if delete-event is raised on window
  402. if (tmp_filename != NULL)
  403. {
  404. if (gDirUtilp->fileExists(tmp_filename))
  405. {
  406. LLFile::remove(tmp_filename);
  407. }
  408. }
  410. gdk_threads_enter();
  411. updater_app_quit(app_state);
  412. gdk_threads_leave();
  414. return NULL;
  415. }
  418. gboolean less_anal_gspawnsync(gchar **argv,
  419.       gchar **stderr_output,
  420.       gint *child_exit_status,
  421.       GError **spawn_error)
  422. {
  423. // store current SIGCHLD handler if there is one, replace with default
  424. // handler to make glib happy
  425. struct sigaction sigchld_backup;
  426. struct sigaction sigchld_appease_glib;
  427. sigchld_appease_glib.sa_handler = SIG_DFL;
  428. sigemptyset(&sigchld_appease_glib.sa_mask);
  429. sigchld_appease_glib.sa_flags = 0;
  430. sigaction(SIGCHLD, &sigchld_appease_glib, &sigchld_backup);
  432. gboolean rtn = g_spawn_sync(NULL,
  433.     argv,
  434.     NULL,
  435.     (GSpawnFlags) (G_SPAWN_STDOUT_TO_DEV_NULL),
  436.     NULL,
  437.     NULL,
  438.     NULL,
  439.     stderr_output,
  440.     child_exit_status,
  441.     spawn_error);
  443. // restore SIGCHLD handler
  444. sigaction(SIGCHLD, &sigchld_backup, NULL);
  446. return rtn;
  447. }
  450. // perform a rename, or perform a (prompted) root rename if that fails
  451. int
  452. rename_with_sudo_fallback(const std::string& filename, const std::string& newname)
  453. {
  454. int rtncode = ::rename(filename.c_str(), newname.c_str());
  455. lldebugs << "rename result is: " << rtncode << " / " << errno << llendl;
  456. if (rtncode && (EACCES == errno || EPERM == errno || EXDEV == errno))
  457. {
  458. llinfos << "Permission problem in rename, or moving between different mount points.  Retrying as a mv under a sudo." << llendl;
  459. // failed due to permissions, try again as a gksudo or kdesu mv wrapper hack
  460. char *sudo_cmd = NULL;
  461. sudo_cmd = g_find_program_in_path("gksudo");
  462. if (!sudo_cmd)
  463. {
  464. sudo_cmd = g_find_program_in_path("kdesu");
  465. }
  466. if (sudo_cmd)
  467. {
  468. char *mv_cmd = NULL;
  469. mv_cmd = g_find_program_in_path("mv");
  470. if (mv_cmd)
  471. {
  472. char *src_string_copy = g_strdup(filename.c_str());
  473. char *dst_string_copy = g_strdup(newname.c_str());
  474. char* argv[] = 
  475. {
  476. sudo_cmd,
  477. mv_cmd,
  478. src_string_copy,
  479. dst_string_copy,
  480. NULL
  481. };
  483. gchar *stderr_output = NULL;
  484. gint child_exit_status = 0;
  485. GError *spawn_error = NULL;
  486. if (!less_anal_gspawnsync(argv, &stderr_output,
  487.   &child_exit_status, &spawn_error))
  488. {
  489. llwarns << "Failed to spawn child process: " 
  490. << spawn_error->message 
  491. << llendl;
  492. }
  493. else if (child_exit_status)
  494. {
  495. llwarns << "mv command failed: "
  496. << (stderr_output ? stderr_output : "(no reason given)")
  497. << llendl;
  498. }
  499. else
  500. {
  501. // everything looks good, clear the error code
  502. rtncode = 0;
  503. }
  505. g_free(src_string_copy);
  506. g_free(dst_string_copy);
  507. if (spawn_error) g_error_free(spawn_error);
  508. }
  509. }
  510. }
  511. return rtncode;
  512. }
  514. gboolean install_package(std::string package_file, std::string destination)
  515. {
  516. char *tar_cmd = NULL;
  517. std::ostringstream command;
  519. // Find the absolute path to the 'tar' command.
  520. tar_cmd = g_find_program_in_path("tar");
  521. if (!tar_cmd)
  522. {
  523. llerrs << "`tar' was not found in $PATH" << llendl;
  524. return FALSE;
  525. }
  526. llinfos << "Found tar command: " << tar_cmd << llendl;
  528. // Unpack the tarball in a temporary place first, then move it to 
  529. // its final destination
  530. std::string tmp_dest_dir = gDirUtilp->getTempFilename();
  531. if (LLFile::mkdir(tmp_dest_dir, 0744))
  532. {
  533. llerrs << "Failed to create directory: "
  534.        << destination
  535.        << llendl;
  537. return FALSE;
  538. }
  540. char *package_file_string_copy = g_strdup(package_file.c_str());
  541. char *tmp_dest_dir_string_copy = g_strdup(tmp_dest_dir.c_str());
  542. gchar *argv[8] = {
  543. tar_cmd,
  544. const_cast<gchar*>("--strip"), const_cast<gchar*>("1"),
  545. const_cast<gchar*>("-xjf"),
  546. package_file_string_copy,
  547. const_cast<gchar*>("-C"), tmp_dest_dir_string_copy,
  548. NULL,
  549. };
  551. llinfos << "Untarring package: " << package_file << llendl;
  553. // store current SIGCHLD handler if there is one, replace with default
  554. // handler to make glib happy
  555. struct sigaction sigchld_backup;
  556. struct sigaction sigchld_appease_glib;
  557. sigchld_appease_glib.sa_handler = SIG_DFL;
  558. sigemptyset(&sigchld_appease_glib.sa_mask);
  559. sigchld_appease_glib.sa_flags = 0;
  560. sigaction(SIGCHLD, &sigchld_appease_glib, &sigchld_backup);
  562. gchar *stderr_output = NULL;
  563. gint child_exit_status = 0;
  564. GError *untar_error = NULL;
  565. if (!less_anal_gspawnsync(argv, &stderr_output,
  566.   &child_exit_status, &untar_error))
  567. {
  568. llwarns << "Failed to spawn child process: " 
  569. << untar_error->message 
  570. << llendl;
  571. return FALSE;
  572. }
  574. if (child_exit_status)
  575. {
  576.   llwarns << "Untar command failed: "
  577. << (stderr_output ? stderr_output : "(no reason given)")
  578. << llendl;
  579. return FALSE;
  580. }
  582. g_free(tar_cmd);
  583. g_free(package_file_string_copy);
  584. g_free(tmp_dest_dir_string_copy);
  585. g_free(stderr_output);
  586. if (untar_error) g_error_free(untar_error);
  588. // move the existing package out of the way if it exists
  589. if (gDirUtilp->fileExists(destination))
  590. {
  591. std::string backup_dir = destination + ".backup";
  592. int oldcounter = 1;
  593. while (gDirUtilp->fileExists(backup_dir))
  594. {
  595. // find a foo.backup.N folder name that isn't taken yet
  596. backup_dir = destination + ".backup." + llformat("%d", oldcounter);
  597. ++oldcounter;
  598. }
  600. if (rename_with_sudo_fallback(destination, backup_dir))
  601. {
  602. llwarns << "Failed to move directory: '" 
  603. << destination << "' -> '" << backup_dir 
  604. << llendl;
  605. return FALSE;
  606. }
  607. }
  609. // The package has been unpacked in a staging directory, now we just
  610. // need to move it to its destination.
  611. if (rename_with_sudo_fallback(tmp_dest_dir, destination))
  612. {
  613. llwarns << "Failed to move installation to the destination: "
  614. << destination 
  615. << llendl;
  616. return FALSE;
  617. }
  619. // / Success!
  620. return TRUE;
  621. }
  623. gboolean progress_update_timeout(gpointer data)
  624. {
  625. UpdaterAppState *app_state;
  627. llassert(data != NULL);
  629. app_state = (UpdaterAppState *) data;
  631. gdk_threads_enter();
  632. if (app_state->activity_mode)
  633. {
  634. gtk_progress_bar_pulse
  635. (GTK_PROGRESS_BAR(app_state->progress_bar));
  636. }
  637. else
  638. {
  639. gtk_progress_set_value(GTK_PROGRESS(app_state->progress_bar),
  640.        app_state->progress_value);
  641. }
  642. gdk_threads_leave();
  644. return TRUE;
  645. }
  647. gboolean update_progress_text_timeout(gpointer data)
  648. {
  649. UpdaterAppState *app_state;
  651. llassert(data != NULL);
  652. app_state = (UpdaterAppState *) data;
  654. if (app_state->activity_mode == TRUE)
  655. {
  656. // We no longer need this timeout, it will be removed.
  657. return FALSE;
  658. }
  660. if (!app_state->progress_value)
  661. {
  662. return TRUE;
  663. }
  665. std::string progress_text = llformat((LLTrans::getString("UpdaterProgressBarText")+" (%.0f%%)").c_str(), app_state->progress_value);
  667. gdk_threads_enter();
  668. gtk_progress_bar_set_text(GTK_PROGRESS_BAR(app_state->progress_bar),
  669.   progress_text.c_str());
  670. gdk_threads_leave();
  672. return TRUE;
  673. }
  675. int download_progress_cb(gpointer data,
  676.  double t,
  677.  double d,
  678.  double utotal,
  679.  double ulnow)
  680. {
  681. UpdaterAppState *app_state;
  683. llassert(data != NULL);
  684. app_state = (UpdaterAppState *) data;
  686. if (t <= 0.0)
  687. {
  688. app_state->progress_value = 0;
  689. }
  690. else
  691. {
  692. app_state->progress_value = d * 100.0 / t;
  693. }
  694. return 0;
  695. }
  697. BOOL spawn_viewer(UpdaterAppState *app_state)
  698. {
  699. llassert(app_state != NULL);
  701. std::string cmd = app_state->dest_dir + "/secondlife";
  702. GError *error = NULL;
  704. // We want to spawn the Viewer on the same display as the updater app
  705. gboolean success = gdk_spawn_command_line_on_screen
  706. (gtk_widget_get_screen(app_state->window), cmd.c_str(), &error);
  708. if (!success)
  709. {
  710. llwarns << "Failed to launch viewer: " << error->message 
  711. << llendl;
  712. }
  714. if (error) g_error_free(error);
  716. return success;
  717. }
  719. void show_usage_and_exit()
  720. {
  721. std::cout << "Usage: linux-updater --url URL --name NAME --dest PATH --stringsdir PATH1,PATH2 --stringsfile FILE"
  722.   << "[--image-dir PATH]"
  723.   << std::endl;
  724. exit(1);
  725. }
  727. void parse_args_and_init(int argc, char **argv, UpdaterAppState *app_state)
  728. {
  729. int i;
  731. for (i = 1; i < argc; i++)
  732. {
  733. if ((!strcmp(argv[i], "--url")) && (++i < argc))
  734. {
  735. app_state->url = argv[i];
  736. }
  737. else if ((!strcmp(argv[i], "--name")) && (++i < argc))
  738. {
  739. app_state->app_name = argv[i];
  740. }
  741. else if ((!strcmp(argv[i], "--image-dir")) && (++i < argc))
  742. {
  743. app_state->image_dir = argv[i];
  744. }
  745. else if ((!strcmp(argv[i], "--dest")) && (++i < argc))
  746. {
  747. app_state->dest_dir = argv[i];
  748. }
  749. else if ((!strcmp(argv[i], "--stringsdir")) && (++i < argc))
  750. {
  751. app_state->strings_dirs = argv[i];
  752. }
  753. else if ((!strcmp(argv[i], "--stringsfile")) && (++i < argc))
  754. {
  755. app_state->strings_file = argv[i];
  756. }
  757. else
  758. {
  759. // show usage, an invalid option was given.
  760. show_usage_and_exit();
  761. }
  762. }
  764. if (app_state->app_name.empty() 
  765.     || app_state->url.empty() 
  766.     || app_state->dest_dir.empty())
  767. {
  768. show_usage_and_exit();
  769. }
  771. app_state->progress_value = 0.0;
  772. app_state->activity_mode = FALSE;
  773. app_state->failure = FALSE;
  775. translate_init(app_state->strings_dirs, app_state->strings_file);
  776. }
  778. int main(int argc, char **argv)
  779. {
  780. UpdaterAppState app_state;
  781. GThread *worker_thread;
  783. parse_args_and_init(argc, argv, &app_state);
  785. // Initialize logger, and rename old log file
  786. gDirUtilp->initAppDirs("SecondLife");
  787. LLError::initForApplication
  788. (gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
  789. std::string old_log_file = gDirUtilp->getExpandedFilename
  790. (LL_PATH_LOGS, "updater.log.old");
  791. std::string log_file = 
  792. gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "updater.log");
  793. LLFile::rename(log_file, old_log_file);
  794. LLError::logToFile(log_file);
  796. // initialize gthreads and gtk+
  797. if (!g_thread_supported())
  798. {
  799. g_thread_init(NULL);
  800. gdk_threads_init();
  801. }
  803. gtk_init(&argc, &argv);
  805. // create UI
  806. updater_app_ui_init(&app_state);
  808. //llinfos << "SAMPLE TRANSLATION IS: " << LLTrans::getString("LoginInProgress") << llendl;
  810. // create download thread
  811. worker_thread = g_thread_create
  812. (GThreadFunc(worker_thread_cb), &app_state, FALSE, NULL);
  814. gdk_threads_enter();
  815. gtk_main();
  816. gdk_threads_leave();
  818. return (app_state.failure == FALSE) ? 0 : 1;
  819. }