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

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

游戏引擎

开发平台：

C++ Builder

mac_updater.cpp：源码内容
  1. /** 
  2.  * @file mac_updater.cpp
  3.  * @brief 
  4.  *
  5.  * $LicenseInfo:firstyear=2006&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2006-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. #include "linden_common.h"
  35. #include <sys/types.h>
  36. #include <sys/stat.h>
  37. #include <unistd.h>
  39. #include <curl/curl.h>
  40. #include <pthread.h>
  42. #include "llerror.h"
  43. #include "lltimer.h"
  44. #include "lldir.h"
  45. #include "llfile.h"
  47. #include "llstring.h"
  49. #include <Carbon/Carbon.h>
  51. #include "MoreFilesX.h"
  52. #include "FSCopyObject.h"
  54. #include "llerrorcontrol.h"
  56. enum
  57. {
  58. kEventClassCustom = 'Cust',
  59. kEventCustomProgress = 'Prog',
  60. kEventParamCustomCurValue = 'Cur ',
  61. kEventParamCustomMaxValue = 'Max ',
  62. kEventParamCustomText = 'Text',
  63. kEventCustomDone = 'Done',
  64. };
  66. WindowRef gWindow = NULL;
  67. EventHandlerRef gEventHandler = NULL;
  68. OSStatus gFailure = noErr;
  69. Boolean gCancelled = false;
  71. const char *gUpdateURL;
  72. const char *gProductName;
  74. void *updatethreadproc(void*);
  76. pthread_t updatethread;
  78. OSStatus setProgress(int cur, int max)
  79. {
  80. OSStatus err;
  81. ControlRef progressBar = NULL;
  82. ControlID id;
  84. id.signature = 'prog';
  85. id.id = 0;
  87. err = GetControlByID(gWindow, &id, &progressBar);
  88. if(err == noErr)
  89. {
  90. Boolean indeterminate;
  92. if(max == 0)
  93. {
  94. indeterminate = true;
  95. err = SetControlData(progressBar, kControlEntireControl, kControlProgressBarIndeterminateTag, sizeof(Boolean), (Ptr)&indeterminate);
  96. }
  97. else
  98. {
  99. double percentage = (double)cur / (double)max;
  100. SetControlMinimum(progressBar, 0);
  101. SetControlMaximum(progressBar, 100);
  102. SetControlValue(progressBar, (SInt16)(percentage * 100));
  104. indeterminate = false;
  105. err = SetControlData(progressBar, kControlEntireControl, kControlProgressBarIndeterminateTag, sizeof(Boolean), (Ptr)&indeterminate);
  107. Draw1Control(progressBar);
  108. }
  109. }
  111. return(err);
  112. }
  114. OSStatus setProgressText(CFStringRef text)
  115. {
  116. OSStatus err;
  117. ControlRef progressText = NULL;
  118. ControlID id;
  120. id.signature = 'what';
  121. id.id = 0;
  123. err = GetControlByID(gWindow, &id, &progressText);
  124. if(err == noErr)
  125. {
  126. err = SetControlData(progressText, kControlEntireControl, kControlStaticTextCFStringTag, sizeof(CFStringRef), (Ptr)&text);
  127. Draw1Control(progressText);
  128. }
  130. return(err);
  131. }
  133. OSStatus sendProgress(long cur, long max, CFStringRef text = NULL)
  134. {
  135. OSStatus result;
  136. EventRef evt;
  138. result = CreateEvent( 
  139. NULL,
  140. kEventClassCustom, 
  141. kEventCustomProgress,
  142. 0, 
  143. kEventAttributeNone, 
  144. &evt);
  146. // This event needs to be targeted at the window so it goes to the window's handler.
  147. if(result == noErr)
  148. {
  149. EventTargetRef target = GetWindowEventTarget(gWindow);
  150. result = SetEventParameter (
  151. evt,
  152. kEventParamPostTarget,
  153. typeEventTargetRef,
  154. sizeof(target),
  155. &target);
  156. }
  158. if(result == noErr)
  159. {
  160. result = SetEventParameter (
  161. evt,
  162. kEventParamCustomCurValue,
  163. typeLongInteger,
  164. sizeof(cur),
  165. &cur);
  166. }
  168. if(result == noErr)
  169. {
  170. result = SetEventParameter (
  171. evt,
  172. kEventParamCustomMaxValue,
  173. typeLongInteger,
  174. sizeof(max),
  175. &max);
  176. }
  178. if(result == noErr)
  179. {
  180. if(text != NULL)
  181. {
  182. result = SetEventParameter (
  183. evt,
  184. kEventParamCustomText,
  185. typeCFStringRef,
  186. sizeof(text),
  187. &text);
  188. }
  189. }
  191. if(result == noErr)
  192. {
  193. // Send the event
  194. PostEventToQueue(
  195. GetMainEventQueue(),
  196. evt,
  197. kEventPriorityStandard);
  199. }
  201. return(result);
  202. }
  204. OSStatus sendDone(void)
  205. {
  206. OSStatus result;
  207. EventRef evt;
  209. result = CreateEvent( 
  210. NULL,
  211. kEventClassCustom, 
  212. kEventCustomDone,
  213. 0, 
  214. kEventAttributeNone, 
  215. &evt);
  217. // This event needs to be targeted at the window so it goes to the window's handler.
  218. if(result == noErr)
  219. {
  220. EventTargetRef target = GetWindowEventTarget(gWindow);
  221. result = SetEventParameter (
  222. evt,
  223. kEventParamPostTarget,
  224. typeEventTargetRef,
  225. sizeof(target),
  226. &target);
  227. }
  229. if(result == noErr)
  230. {
  231. // Send the event
  232. PostEventToQueue(
  233. GetMainEventQueue(),
  234. evt,
  235. kEventPriorityStandard);
  237. }
  239. return(result);
  240. }
  242. OSStatus dialogHandler(EventHandlerCallRef handler, EventRef event, void *userdata)
  243. {
  244. OSStatus result = eventNotHandledErr;
  245. OSStatus err;
  246. UInt32 evtClass = GetEventClass(event);
  247. UInt32 evtKind = GetEventKind(event);
  249. if((evtClass == kEventClassCommand) && (evtKind == kEventCommandProcess))
  250. {
  251. HICommand cmd;
  252. err = GetEventParameter(event, kEventParamDirectObject, typeHICommand, NULL, sizeof(cmd), NULL, &cmd);
  254. if(err == noErr)
  255. {
  256. switch(cmd.commandID)
  257. {
  258. case kHICommandCancel:
  259. gCancelled = true;
  260. // QuitAppModalLoopForWindow(gWindow);
  261. result = noErr;
  262. break;
  263. }
  264. }
  265. }
  266. else if((evtClass == kEventClassCustom) && (evtKind == kEventCustomProgress))
  267. {
  268. // Request to update the progress dialog
  269. long cur = 0;
  270. long max = 0;
  271. CFStringRef text = NULL;
  272. (void) GetEventParameter(event, kEventParamCustomCurValue, typeLongInteger, NULL, sizeof(cur), NULL, &cur);
  273. (void) GetEventParameter(event, kEventParamCustomMaxValue, typeLongInteger, NULL, sizeof(max), NULL, &max);
  274. (void) GetEventParameter(event, kEventParamCustomText, typeCFStringRef, NULL, sizeof(text), NULL, &text);
  276. err = setProgress(cur, max);
  277. if(err == noErr)
  278. {
  279. if(text != NULL)
  280. {
  281. setProgressText(text);
  282. }
  283. }
  285. result = noErr;
  286. }
  287. else if((evtClass == kEventClassCustom) && (evtKind == kEventCustomDone))
  288. {
  289. // We're done.  Exit the modal loop.
  290. QuitAppModalLoopForWindow(gWindow);
  291. result = noErr;
  292. }
  294. return(result);
  295. }
  297. #if 0
  298. size_t curl_download_callback(void *data, size_t size, size_t nmemb,
  299.   void *user_data)
  300. {
  301. S32 bytes = size * nmemb;
  302. char *cdata = (char *) data;
  303. for (int i =0; i < bytes; i += 1)
  304. {
  305. gServerResponse.append(cdata[i]);
  306. }
  307. return bytes;
  308. }
  309. #endif
  311. int curl_progress_callback_func(void *clientp,
  312.   double dltotal,
  313.   double dlnow,
  314.   double ultotal,
  315.   double ulnow)
  316. {
  317. int max = (int)(dltotal / 1024.0);
  318. int cur = (int)(dlnow / 1024.0);
  319. sendProgress(cur, max);
  321. if(gCancelled)
  322. return(1);
  324. return(0);
  325. }
  327. int parse_args(int argc, char **argv)
  328. {
  329. int j;
  331. for (j = 1; j < argc; j++) 
  332. {
  333. if ((!strcmp(argv[j], "-url")) && (++j < argc)) 
  334. {
  335. gUpdateURL = argv[j];
  336. }
  337. else if ((!strcmp(argv[j], "-name")) && (++j < argc)) 
  338. {
  339. gProductName = argv[j];
  340. }
  341. }
  343. return 0;
  344. }
  346. int main(int argc, char **argv)
  347. {
  348. // We assume that all the logs we're looking for reside on the current drive
  349. gDirUtilp->initAppDirs("SecondLife");
  351. LLError::initForApplication( gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, ""));
  353. // Rename current log file to ".old"
  354. std::string old_log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "updater.log.old");
  355. std::string log_file = gDirUtilp->getExpandedFilename(LL_PATH_LOGS, "updater.log");
  356. LLFile::rename(log_file.c_str(), old_log_file.c_str());
  358. // Set the log file to updater.log
  359. LLError::logToFile(log_file);
  361. /////////////////////////////////////////
  362. //
  363. // Process command line arguments
  364. //
  365. gUpdateURL  = NULL;
  366. gProductName = NULL;
  367. parse_args(argc, argv);
  368. if (!gUpdateURL)
  369. {
  370. llinfos << "Usage: mac_updater -url <url> [-name <product_name>] [-program <program_name>]" << llendl;
  371. exit(1);
  372. }
  373. else
  374. {
  375. llinfos << "Update url is: " << gUpdateURL << llendl;
  376. if (gProductName)
  377. {
  378. llinfos << "Product name is: " << gProductName << llendl;
  379. }
  380. else
  381. {
  382. gProductName = "Second Life";
  383. }
  384. }
  386. llinfos << "Starting " << gProductName << " Updater" << llendl;
  388. // Real UI...
  389. OSStatus err;
  390. IBNibRef nib = NULL;
  392. err = CreateNibReference(CFSTR("AutoUpdater"), &nib);
  394. char windowTitle[MAX_PATH]; /* Flawfinder: ignore */
  395. snprintf(windowTitle, sizeof(windowTitle), "%s Updater", gProductName);
  396. CFStringRef windowTitleRef = NULL;
  397. windowTitleRef = CFStringCreateWithCString(NULL, windowTitle, kCFStringEncodingUTF8);
  399. if(err == noErr)
  400. {
  401. err = CreateWindowFromNib(nib, CFSTR("Updater"), &gWindow);
  402. }
  404. if (err == noErr)
  405. {
  406. err = SetWindowTitleWithCFString(gWindow, windowTitleRef);
  407. }
  408. CFRelease(windowTitleRef);
  410. if(err == noErr)
  411. {
  412. // Set up an event handler for the window.
  413. EventTypeSpec handlerEvents[] = 
  414. {
  415. { kEventClassCommand, kEventCommandProcess },
  416. { kEventClassCustom, kEventCustomProgress },
  417. { kEventClassCustom, kEventCustomDone }
  418. };
  419. InstallStandardEventHandler(GetWindowEventTarget(gWindow));
  420. InstallWindowEventHandler(
  421. gWindow, 
  422. NewEventHandlerUPP(dialogHandler), 
  423. GetEventTypeCount (handlerEvents), 
  424. handlerEvents, 
  425. 0, 
  426. &gEventHandler);
  427. }
  429. if(err == noErr)
  430. {
  431. ShowWindow(gWindow);
  432. SelectWindow(gWindow);
  433. }
  435. if(err == noErr)
  436. {
  437. pthread_create(&updatethread, 
  438.                          NULL,
  439.                          &updatethreadproc, 
  440.                          NULL);
  441.  
  442. }
  444. if(err == noErr)
  445. {
  446. RunAppModalLoopForWindow(gWindow);
  447. }
  449. void *threadresult;
  451. pthread_join(updatethread, &threadresult);
  453. if(!gCancelled && (gFailure != noErr))
  454. {
  455. // Something went wrong.  Since we always just tell the user to download a new version, we don't really care what.
  456. AlertStdCFStringAlertParamRec params;
  457. SInt16 retval_mac = 1;
  458. DialogRef alert = NULL;
  459. OSStatus err;
  461. params.version = kStdCFStringAlertVersionOne;
  462. params.movable = false;
  463. params.helpButton = false;
  464. params.defaultText = (CFStringRef)kAlertDefaultOKText;
  465. params.cancelText = 0;
  466. params.otherText = 0;
  467. params.defaultButton = 1;
  468. params.cancelButton = 0;
  469. params.position = kWindowDefaultPosition;
  470. params.flags = 0;
  472. err = CreateStandardAlert(
  473. kAlertStopAlert,
  474. CFSTR("Error"),
  475. CFSTR("An error occurred while updating Second Life.  Please download the latest version from www.secondlife.com."),
  476. &params,
  477. &alert);
  479. if(err == noErr)
  480. {
  481. err = RunStandardAlert(
  482. alert,
  483. NULL,
  484. &retval_mac);
  485. }
  487. }
  489. // Don't dispose of things, just exit.  This keeps the update thread from potentially getting hosed.
  490. exit(0);
  492. if(gWindow != NULL)
  493. {
  494. DisposeWindow(gWindow);
  495. }
  497. if(nib != NULL)
  498. {
  499. DisposeNibReference(nib);
  500. }
  502. return 0;
  503. }
  505. bool isDirWritable(FSRef &dir)
  506. {
  507. bool result = false;
  509. // Test for a writable directory by creating a directory, then deleting it again.
  510. // This is kinda lame, but will pretty much always give the right answer.
  512. OSStatus err = noErr;
  513. char temp[PATH_MAX] = ""; /* Flawfinder: ignore */
  515. err = FSRefMakePath(&dir, (UInt8*)temp, sizeof(temp));
  517. if(err == noErr)
  518. {
  519. strncat(temp, "/.test_XXXXXX", (sizeof(temp) - strlen(temp)) - 1);
  521. if(mkdtemp(temp) != NULL)
  522. {
  523. // We were able to make the directory.  This means the directory is writable.
  524. result = true;
  526. // Clean up.
  527. rmdir(temp);
  528. }
  529. }
  531. #if 0
  532. // This seemed like a good idea, but won't tell us if we're on a volume mounted read-only.
  533. UInt8 perm;
  534. err = FSGetUserPrivilegesPermissions(&targetParentRef, &perm, NULL);
  535. if(err == noErr)
  536. {
  537. if(perm & kioACUserNoMakeChangesMask)
  538. {
  539. // Parent directory isn't writable.
  540. llinfos << "Target parent directory not writable." << llendl;
  541. err = -1;
  542. replacingTarget = false;
  543. }
  544. }
  545. #endif
  547. return result;
  548. }
  550. static void utf8str_to_HFSUniStr255(HFSUniStr255 *dest, const char* src)
  551. {
  552. llutf16string utf16str = utf8str_to_utf16str(src);
  554. dest->length = utf16str.size();
  555. if(dest->length > 255)
  556. {
  557. // There's onl room for 255 chars in a HFSUniStr25..
  558. // Truncate to avoid stack smaching or other badness.
  559. dest->length = 255;
  560. }
  561. memcpy(dest->unicode, utf16str.data(), sizeof(UniChar)* dest->length); /* Flawfinder: ignore */
  562. }
  564. static std::string HFSUniStr255_to_utf8str(const HFSUniStr255* src)
  565. {
  566. llutf16string string16((U16*)&(src->unicode), src->length);
  567. std::string result = utf16str_to_utf8str(string16);
  568. return result;
  569. }
  571. int restoreObject(const char* aside, const char* target, const char* path, const char* object)
  572. {
  573. char source[PATH_MAX] = ""; /* Flawfinder: ignore */
  574. char dest[PATH_MAX] = ""; /* Flawfinder: ignore */
  575. snprintf(source, sizeof(source), "%s/%s/%s", aside, path, object);
  576. snprintf(dest, sizeof(dest), "%s/%s", target, path);
  577. FSRef sourceRef;
  578. FSRef destRef;
  579. OSStatus err;
  580. err = FSPathMakeRef((UInt8 *)source, &sourceRef, NULL);
  581. if(err != noErr) return false;
  582. err = FSPathMakeRef((UInt8 *)dest, &destRef, NULL);
  583. if(err != noErr) return false;
  585. llinfos << "Copying " << source << " to " << dest << llendl;
  587. err = FSCopyObject(
  588. &sourceRef,
  589. &destRef,
  590. 0,
  591. kFSCatInfoNone,
  592. kDupeActionReplace,
  593. NULL,
  594. false,
  595. false,
  596. NULL,
  597. NULL,
  598. NULL,
  599. NULL);
  601. if(err != noErr) return false;
  602. return true;
  603. }
  605. // Replace any mention of "Second Life" with the product name.
  606. void filterFile(const char* filename)
  607. {
  608. char temp[PATH_MAX] = ""; /* Flawfinder: ignore */
  609. // First copy the target's version, so we can run it through sed.
  610. snprintf(temp, sizeof(temp), "cp '%s' '%s.tmp'", filename, filename);
  611. system(temp); /* Flawfinder: ignore */
  613. // Now run it through sed.
  614. snprintf(temp, sizeof(temp), 
  615. "sed 's/Second Life/%s/g' '%s.tmp' > '%s'", gProductName, filename, filename);
  616. system(temp); /* Flawfinder: ignore */
  617. }
  619. static bool isFSRefViewerBundle(FSRef *targetRef)
  620. {
  621. bool result = false;
  622. CFURLRef targetURL = NULL;
  623. CFBundleRef targetBundle = NULL;
  624. CFStringRef targetBundleID = NULL;
  626. targetURL = CFURLCreateFromFSRef(NULL, targetRef);
  628. if(targetURL == NULL)
  629. {
  630. llinfos << "Error creating target URL." << llendl;
  631. }
  632. else
  633. {
  634. targetBundle = CFBundleCreate(NULL, targetURL);
  635. }
  637. if(targetBundle == NULL)
  638. {
  639. llinfos << "Failed to create target bundle." << llendl;
  640. }
  641. else
  642. {
  643. targetBundleID = CFBundleGetIdentifier(targetBundle);
  644. }
  646. if(targetBundleID == NULL)
  647. {
  648. llinfos << "Couldn't retrieve target bundle ID." << llendl;
  649. }
  650. else
  651. {
  652. if(CFStringCompare(targetBundleID, CFSTR("com.secondlife.indra.viewer"), 0) == kCFCompareEqualTo)
  653. {
  654. // This is the bundle we're looking for.
  655. result = true;
  656. }
  657. else
  658. {
  659. llinfos << "Target bundle ID mismatch." << llendl;
  660. }
  661. }
  663. // Don't release targetBundleID -- since we don't retain it, it's released when targetBundle is released.
  664. if(targetURL != NULL)
  665. CFRelease(targetURL);
  666. if(targetBundle != NULL)
  667. CFRelease(targetBundle);
  669. return result;
  670. }
  672. // Search through the directory specified by 'parent' for an item that appears to be a Second Life viewer.
  673. static OSErr findAppBundleOnDiskImage(FSRef *parent, FSRef *app)
  674. {
  675. FSIterator iterator;
  676. bool found = false;
  678. OSErr err = FSOpenIterator( parent, kFSIterateFlat, &iterator );
  679. if(!err)
  680. {
  681. do
  682. {
  683. ItemCount actualObjects = 0;
  684. Boolean containerChanged = false;
  685. FSCatalogInfo info;
  686. FSRef ref;
  687. HFSUniStr255 unicodeName;
  688. err = FSGetCatalogInfoBulk( 
  689. iterator, 
  690. 1, 
  691. &actualObjects, 
  692. &containerChanged,
  693. kFSCatInfoNodeFlags, 
  694. &info, 
  695. &ref,
  696. NULL, 
  697. &unicodeName );
  699. if(actualObjects == 0)
  700. break;
  702. if(!err)
  703. {
  704. // Call succeeded and not done with the iteration.
  705. std::string name = HFSUniStr255_to_utf8str(&unicodeName);
  707. llinfos << "Considering "" << name << """ << llendl;
  709. if(info.nodeFlags & kFSNodeIsDirectoryMask)
  710. {
  711. // This is a directory.  See if it's a .app
  712. if(name.find(".app") != std::string::npos)
  713. {
  714. // Looks promising.  Check to see if it has the right bundle identifier.
  715. if(isFSRefViewerBundle(&ref))
  716. {
  717. // This is the one.  Return it.
  718. *app = ref;
  719. found = true;
  720. }
  721. }
  722. }
  723. }
  724. }
  725. while(!err && !found);
  727. FSCloseIterator(iterator);
  728. }
  730. if(!err && !found)
  731. err = fnfErr;
  733. return err;
  734. }
  736. void *updatethreadproc(void*)
  737. {
  738. char tempDir[PATH_MAX] = ""; /* Flawfinder: ignore */
  739. FSRef tempDirRef;
  740. char temp[PATH_MAX] = ""; /* Flawfinder: ignore */
  741. // *NOTE: This buffer length is used in a scanf() below.
  742. char deviceNode[1024] = ""; /* Flawfinder: ignore */
  743. LLFILE *downloadFile = NULL;
  744. OSStatus err;
  745. ProcessSerialNumber psn;
  746. char target[PATH_MAX] = ""; /* Flawfinder: ignore */
  747. FSRef targetRef;
  748. FSRef targetParentRef;
  749. FSVolumeRefNum targetVol;
  750. FSRef trashFolderRef;
  751. Boolean replacingTarget = false;
  753. memset(&tempDirRef, 0, sizeof(tempDirRef));
  754. memset(&targetRef, 0, sizeof(targetRef));
  755. memset(&targetParentRef, 0, sizeof(targetParentRef));
  757. try
  758. {
  759. // Attempt to get a reference to the Second Life application bundle containing this updater.
  760. // Any failures during this process will cause us to default to updating /Applications/Second Life.app
  761. {
  762. FSRef myBundle;
  764. err = GetCurrentProcess(&psn);
  765. if(err == noErr)
  766. {
  767. err = GetProcessBundleLocation(&psn, &myBundle);
  768. }
  770. if(err == noErr)
  771. {
  772. // Sanity check:  Make sure the name of the item referenced by targetRef is "Second Life.app".
  773. FSRefMakePath(&myBundle, (UInt8*)target, sizeof(target));
  775. llinfos << "Updater bundle location: " << target << llendl;
  776. }
  778. // Our bundle should be in Second Life.app/Contents/Resources/AutoUpdater.app
  779. // so we need to go up 3 levels to get the path to the main application bundle.
  780. if(err == noErr)
  781. {
  782. err = FSGetParentRef(&myBundle, &targetRef);
  783. }
  784. if(err == noErr)
  785. {
  786. err = FSGetParentRef(&targetRef, &targetRef);
  787. }
  788. if(err == noErr)
  789. {
  790. err = FSGetParentRef(&targetRef, &targetRef);
  791. }
  793. // And once more to get the parent of the target
  794. if(err == noErr)
  795. {
  796. err = FSGetParentRef(&targetRef, &targetParentRef);
  797. }
  799. if(err == noErr)
  800. {
  801. FSRefMakePath(&targetRef, (UInt8*)target, sizeof(target));
  802. llinfos << "Path to target: " << target << llendl;
  803. }
  805. // Sanity check: make sure the target is a bundle with the right identifier
  806. if(err == noErr)
  807. {
  808. // Assume the worst...
  809. err = -1;
  811. if(isFSRefViewerBundle(&targetRef))
  812. {
  813. // This is the bundle we're looking for.
  814. err = noErr;
  815. replacingTarget = true;
  816. }
  817. }
  819. // Make sure the target's parent directory is writable.
  820. if(err == noErr)
  821. {
  822. if(!isDirWritable(targetParentRef))
  823. {
  824. // Parent directory isn't writable.
  825. llinfos << "Target parent directory not writable." << llendl;
  826. err = -1;
  827. replacingTarget = false;
  828. }
  829. }
  831. if(err != noErr)
  832. {
  833. Boolean isDirectory;
  834. llinfos << "Target search failed, defaulting to /Applications/" << gProductName << ".app." << llendl;
  836. // Set up the parent directory
  837. err = FSPathMakeRef((UInt8*)"/Applications", &targetParentRef, &isDirectory);
  838. if((err != noErr) || (!isDirectory))
  839. {
  840. // We're so hosed.
  841. llinfos << "Applications directory not found, giving up." << llendl;
  842. throw 0;
  843. }
  845. snprintf(target, sizeof(target), "/Applications/%s.app", gProductName);
  847. memset(&targetRef, 0, sizeof(targetRef));
  848. err = FSPathMakeRef((UInt8*)target, &targetRef, NULL);
  849. if(err == fnfErr)
  850. {
  851. // This is fine, just means we're not replacing anything.
  852. err = noErr;
  853. replacingTarget = false;
  854. }
  855. else
  856. {
  857. replacingTarget = true;
  858. }
  860. // Make sure the target's parent directory is writable.
  861. if(err == noErr)
  862. {
  863. if(!isDirWritable(targetParentRef))
  864. {
  865. // Parent directory isn't writable.
  866. llinfos << "Target parent directory not writable." << llendl;
  867. err = -1;
  868. replacingTarget = false;
  869. }
  870. }
  872. }
  874. // If we haven't fixed all problems by this point, just bail.
  875. if(err != noErr)
  876. {
  877. llinfos << "Unable to pick a target, giving up." << llendl;
  878. throw 0;
  879. }
  880. }
  882. // Find the volID of the volume the target resides on
  883. {
  884. FSCatalogInfo info;
  885. err = FSGetCatalogInfo(
  886. &targetParentRef,
  887. kFSCatInfoVolume,
  888. &info,
  889. NULL, 
  890. NULL,  
  891. NULL);
  893. if(err != noErr)
  894. throw 0;
  896. targetVol = info.volume;
  897. }
  899. // Find the temporary items and trash folders on that volume.
  900. err = FSFindFolder(
  901. targetVol,
  902. kTrashFolderType,
  903. true,
  904. &trashFolderRef);
  906. if(err != noErr)
  907. throw 0;
  909. #if 0 // *HACK for DEV-11935 see below for details.
  911. FSRef tempFolderRef;
  913. err = FSFindFolder(
  914. targetVol,
  915. kTemporaryFolderType,
  916. true,
  917. &tempFolderRef);
  919. if(err != noErr)
  920. throw 0;
  922. err = FSRefMakePath(&tempFolderRef, (UInt8*)temp, sizeof(temp));
  924. if(err != noErr)
  925. throw 0;
  927. #else
  929. // *HACK for DEV-11935  the above kTemporaryFolderType query was giving
  930. // back results with path names that seem to be too long to be used as
  931. // mount points.  I suspect this incompatibility was introduced in the
  932. // Leopard 10.5.2 update, but I have not verified this. 
  933. char const HARDCODED_TMP[] = "/tmp";
  934. strncpy(temp, HARDCODED_TMP, sizeof(HARDCODED_TMP));
  936. #endif // 0 *HACK for DEV-11935
  938. strncat(temp, "/SecondLifeUpdate_XXXXXX", (sizeof(temp) - strlen(temp)) - 1);
  939. if(mkdtemp(temp) == NULL)
  940. {
  941. throw 0;
  942. }
  944. strncpy(tempDir, temp, sizeof(tempDir));
  945. temp[sizeof(tempDir) - 1] = '';
  947. llinfos << "tempDir is " << tempDir << llendl;
  949. err = FSPathMakeRef((UInt8*)tempDir, &tempDirRef, NULL);
  951. if(err != noErr)
  952. throw 0;
  954. chdir(tempDir);
  956. snprintf(temp, sizeof(temp), "SecondLife.dmg");
  958. downloadFile = LLFile::fopen(temp, "wb"); /* Flawfinder: ignore */
  959. if(downloadFile == NULL)
  960. {
  961. throw 0;
  962. }
  964. {
  965. CURL *curl = curl_easy_init();
  967. curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1);
  968. // curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, &curl_download_callback);
  969. curl_easy_setopt(curl, CURLOPT_FILE, downloadFile);
  970. curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
  971. curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, &curl_progress_callback_func);
  972. curl_easy_setopt(curl, CURLOPT_URL, gUpdateURL);
  973. curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
  975. sendProgress(0, 1, CFSTR("Downloading..."));
  977. CURLcode result = curl_easy_perform(curl);
  979. curl_easy_cleanup(curl);
  981. if(gCancelled)
  982. {
  983. llinfos << "User cancel, bailing out."<< llendl;
  984. throw 0;
  985. }
  987. if(result != CURLE_OK)
  988. {
  989. llinfos << "Error " << result << " while downloading disk image."<< llendl;
  990. throw 0;
  991. }
  993. fclose(downloadFile);
  994. downloadFile = NULL;
  995. }
  997. sendProgress(0, 0, CFSTR("Mounting image..."));
  998. LLFile::mkdir("mnt", 0700);
  1000. // NOTE: we could add -private at the end of this command line to keep the image from showing up in the Finder,
  1001. // but if our cleanup fails, this makes it much harder for the user to unmount the image.
  1002. std::string mountOutput;
  1003. FILE* mounter = popen("hdiutil attach SecondLife.dmg -mountpoint mnt", "r"); /* Flawfinder: ignore */
  1005. if(mounter == NULL)
  1006. {
  1007. llinfos << "Failed to mount disk image, exiting."<< llendl;
  1008. throw 0;
  1009. }
  1011. // We need to scan the output from hdiutil to find the device node it uses to attach the disk image.
  1012. // If we don't have this information, we can't detach it later.
  1013. while(mounter != NULL)
  1014. {
  1015. size_t len = fread(temp, 1, sizeof(temp)-1, mounter);
  1016. temp[len] = 0;
  1017. mountOutput.append(temp);
  1018. if(len < sizeof(temp)-1)
  1019. {
  1020. // End of file or error.
  1021. int result = pclose(mounter);
  1022. if(result != 0)
  1023. {
  1024. // NOTE: We used to abort here, but pclose() started returning 
  1025. // -1, possibly when the size of the DMG passed a certain point 
  1026. llinfos << "Unexpected result closing pipe: " << result << llendl; 
  1027. }
  1028. mounter = NULL;
  1029. }
  1030. }
  1032. if(!mountOutput.empty())
  1033. {
  1034. const char *s = mountOutput.c_str();
  1035. const char *prefix = "/dev/";
  1036. char *sub = strstr(s, prefix);
  1038. if(sub != NULL)
  1039. {
  1040. sub += strlen(prefix); /* Flawfinder: ignore */
  1041. sscanf(sub, "%1023s", deviceNode); /* Flawfinder: ignore */
  1042. }
  1043. }
  1045. if(deviceNode[0] != 0)
  1046. {
  1047. llinfos << "Disk image attached on /dev/" << deviceNode << llendl;
  1048. }
  1049. else
  1050. {
  1051. llinfos << "Disk image device node not found!" << llendl;
  1052. throw 0; 
  1053. }
  1055. // Get an FSRef to the new application on the disk image
  1056. FSRef sourceRef;
  1057. FSRef mountRef;
  1058. snprintf(temp, sizeof(temp), "%s/mnt", tempDir);
  1060. llinfos << "Disk image mount point is: " << temp << llendl;
  1062. err = FSPathMakeRef((UInt8 *)temp, &mountRef, NULL);
  1063. if(err != noErr)
  1064. {
  1065. llinfos << "Couldn't make FSRef to disk image mount point." << llendl;
  1066. throw 0;
  1067. }
  1069. err = findAppBundleOnDiskImage(&mountRef, &sourceRef);
  1070. if(err != noErr)
  1071. {
  1072. llinfos << "Couldn't find application bundle on mounted disk image." << llendl;
  1073. throw 0;
  1074. }
  1076. FSRef asideRef;
  1077. char aside[MAX_PATH]; /* Flawfinder: ignore */
  1079. // this will hold the name of the destination target
  1080. HFSUniStr255 appNameUniStr;
  1082. if(replacingTarget)
  1083. {
  1084. // Get the name of the target we're replacing
  1085. err = FSGetCatalogInfo(&targetRef, 0, NULL, &appNameUniStr, NULL, NULL);
  1086. if(err != noErr)
  1087. throw 0;
  1089. // Move aside old version (into work directory)
  1090. err = FSMoveObject(&targetRef, &tempDirRef, &asideRef);
  1091. if(err != noErr)
  1092. throw 0;
  1094. // Grab the path for later use.
  1095. err = FSRefMakePath(&asideRef, (UInt8*)aside, sizeof(aside));
  1096. }
  1097. else
  1098. {
  1099. // Construct the name of the target based on the product name
  1100. char appName[MAX_PATH]; /* Flawfinder: ignore */
  1101. snprintf(appName, sizeof(appName), "%s.app", gProductName);
  1102. utf8str_to_HFSUniStr255( &appNameUniStr, appName );
  1103. }
  1105. sendProgress(0, 0, CFSTR("Copying files..."));
  1107. llinfos << "Starting copy..." << llendl;
  1109. // Copy the new version from the disk image to the target location.
  1110. err = FSCopyObject(
  1111. &sourceRef,
  1112. &targetParentRef,
  1113. 0,
  1114. kFSCatInfoNone,
  1115. kDupeActionStandard,
  1116. &appNameUniStr,
  1117. false,
  1118. false,
  1119. NULL,
  1120. NULL,
  1121. &targetRef,
  1122. NULL);
  1124. // Grab the path for later use.
  1125. err = FSRefMakePath(&targetRef, (UInt8*)target, sizeof(target));
  1126. if(err != noErr)
  1127. throw 0;
  1129. llinfos << "Copy complete. Target = " << target << llendl;
  1131. if(err != noErr)
  1132. {
  1133. // Something went wrong during the copy.  Attempt to put the old version back and bail.
  1134. (void)FSDeleteObjects(&targetRef);
  1135. if(replacingTarget)
  1136. {
  1137. (void)FSMoveObject(&asideRef, &targetParentRef, NULL);
  1138. }
  1139. throw 0;
  1140. }
  1141. else
  1142. {
  1143. // The update has succeeded.  Clear the cache directory.
  1145. sendProgress(0, 0, CFSTR("Clearing cache..."));
  1147. llinfos << "Clearing cache..." << llendl;
  1149. char mask[LL_MAX_PATH]; /* Flawfinder: ignore */
  1150. snprintf(mask, LL_MAX_PATH, "%s*.*", gDirUtilp->getDirDelimiter().c_str());
  1151. gDirUtilp->deleteFilesInDir(gDirUtilp->getExpandedFilename(LL_PATH_CACHE,""),mask);
  1153. llinfos << "Clear complete." << llendl;
  1155. }
  1156. }
  1157. catch(...)
  1158. {
  1159. if(!gCancelled)
  1160. if(gFailure == noErr)
  1161. gFailure = -1;
  1162. }
  1164. // Failures from here on out are all non-fatal and not reported.
  1165. sendProgress(0, 3, CFSTR("Cleaning up..."));
  1167. // Close disk image file if necessary
  1168. if(downloadFile != NULL)
  1169. {
  1170. llinfos << "Closing download file." << llendl;
  1172. fclose(downloadFile);
  1173. downloadFile = NULL;
  1174. }
  1176. sendProgress(1, 3);
  1177. // Unmount image
  1178. if(deviceNode[0] != 0)
  1179. {
  1180. llinfos << "Detaching disk image." << llendl;
  1182. snprintf(temp, sizeof(temp), "hdiutil detach '%s'", deviceNode);
  1183. system(temp); /* Flawfinder: ignore */
  1184. }
  1186. sendProgress(2, 3);
  1188. // Move work directory to the trash
  1189. if(tempDir[0] != 0)
  1190. {
  1191. // chdir("/");
  1192. // FSDeleteObjects(tempDirRef);
  1194. llinfos << "Moving work directory to the trash." << llendl;
  1196. err = FSMoveObject(&tempDirRef, &trashFolderRef, NULL);
  1198. // snprintf(temp, sizeof(temp), "rm -rf '%s'", tempDir);
  1199. // printf("%sn", temp);
  1200. // system(temp);
  1201. }
  1203. if(!gCancelled  && !gFailure && (target[0] != 0))
  1204. {
  1205. llinfos << "Touching application bundle." << llendl;
  1207. snprintf(temp, sizeof(temp), "touch '%s'", target);
  1208. system(temp); /* Flawfinder: ignore */
  1210. llinfos << "Launching updated application." << llendl;
  1212. snprintf(temp, sizeof(temp), "open '%s'", target);
  1213. system(temp); /* Flawfinder: ignore */
  1214. }
  1216. sendDone();
  1218. return(NULL);
  1219. }