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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 加密解密 > CA认证 > 查看源码
install.c
资源名称：nss-3.1.1.tar.gz　[点击查看]
上传用户：lyxiangda
上传日期：2007-01-12
资源大小：3042k
文件大小：24k
源码类别：

CA认证

开发平台：

WINDOWS

install.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is the Netscape security libraries.
  13.  * 
  14.  * The Initial Developer of the Original Code is Netscape
  15.  * Communications Corporation.  Portions created by Netscape are 
  16.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  17.  * Rights Reserved.
  18.  * 
  19.  * Contributor(s):
  20.  * 
  21.  * Alternatively, the contents of this file may be used under the
  22.  * terms of the GNU General Public License Version 2 or later (the
  23.  * "GPL"), in which case the provisions of the GPL are applicable 
  24.  * instead of those above.  If you wish to allow use of your 
  25.  * version of this file only under the terms of the GPL and not to
  26.  * allow others to use your version of this file under the MPL,
  27.  * indicate your decision by deleting the provisions above and
  28.  * replace them with the notice and other provisions required by
  29.  * the GPL.  If you do not delete the provisions above, a recipient
  30.  * may use your version of this file under either the MPL or the
  31.  * GPL.
  32.  */
  34. #include "install.h"
  35. #include "install-ds.h"
  36. #include <prlock.h>
  37. #include <prio.h>
  38. #include <prmem.h>
  39. #include <prprf.h>
  40. #include <prsystem.h>
  41. #include <prproces.h>
  43. /*extern "C" {*/
  44. #include <jar.h>
  45. /*}*/
  47. extern /*"C"*/
  48. int Pk11Install_AddNewModule(char* moduleName, char* dllPath,
  49.                               unsigned long defaultMechanismFlags,
  50.                               unsigned long cipherEnableFlags);
  51. extern /*"C"*/
  52. short Pk11Install_UserVerifyJar(JAR *jar, PRFileDesc *out,
  53. PRBool query);
  54. extern /*"C"*/
  55. char* mySECU_ErrorString(int16);
  56. extern 
  57. int Pk11Install_yyparse();
  59. #define INSTALL_METAINFO_TAG "Pkcs11_install_script"
  60. #define SCRIPT_TEMP_FILE "pkcs11inst.tmp"
  61. #define ROOT_MARKER "%root%"
  62. #define TEMP_MARKER "%temp%"
  63. #define PRINTF_ROOT_MARKER "%%root%%"
  64. #define TEMPORARY_DIRECTORY_NAME "pk11inst.dir"
  65. #define JAR_BASE_END (JAR_BASE+100)
  67. static PRLock* errorHandlerLock=NULL;
  68. static Pk11Install_ErrorHandler errorHandler=NULL;
  69. static char* PR_Strdup(const char* str);
  70. static int rm_dash_r (char *path);
  71. static int make_dirs(char *path, int file_perms);
  72. static int dir_perms(int perms);
  74. static Pk11Install_Error DoInstall(JAR *jar, const char *installDir,
  75. const char* tempDir, Pk11Install_Platform *platform, 
  76. PRFileDesc *feedback, PRBool noverify);
  78. static char *errorString[]= {
  79. "Operation was successful", /* PK11_INSTALL_NO_ERROR */
  80. "Directory "%s" does not exist", /* PK11_INSTALL_DIR_DOESNT_EXIST */
  81. "File "%s" does not exist", /* PK11_INSTALL_FILE_DOESNT_EXIST */
  82. "File "%s" is not readable", /* PK11_INSTALL_FILE_NOT_READABLE */
  83. "%s", /* PK11_INSTALL_ERROR_STRING */
  84. "Error in JAR file %s: %s",  /* PK11_INSTALL_JAR_ERROR */
  85. "No Pkcs11_install_script specified in JAR metainfo file",
  86. /* PK11_INSTALL_NO_INSTALLER_SCRIPT */
  87. "Could not delete temporary file "%s"",
  88. /*PK11_INSTALL_DELETE_TEMP_FILE */
  89. "Could not open temporary file "%s"", /*PK11_INSTALL_OPEN_SCRIPT_FILE*/
  90. "%s: %s", /* PK11_INSTALL_SCRIPT_PARSE */
  91. "Error in script: %s",
  92. "Unable to obtain system platform information",
  93. "Installer script has no information about the current platform (%s)",
  94. "Relative directory "%s" does not contain "PRINTF_ROOT_MARKER,
  95. "Module File "%s" not found",
  96. "Error occurred installing module "%s" into database",
  97. "Error extracting "%s" from JAR file: %s",
  98. "Directory "%s" is not writeable",
  99. "Could not create directory "%s"",
  100. "Could not remove directory "%s"",
  101. "Unable to execute "%s"",
  102. "Unable to wait for process "%s"",
  103. ""%s" returned error code %d",
  104. "User aborted operation",
  105. "Unspecified error"
  106. };
  108. enum {
  109. INSTALLED_FILE_MSG=0,
  110. INSTALLED_MODULE_MSG,
  111. INSTALLER_SCRIPT_NAME,
  112. MY_PLATFORM_IS,
  113. USING_PLATFORM,
  114. PARSED_INSTALL_SCRIPT,
  115. EXEC_FILE_MSG,
  116. EXEC_SUCCESS,
  117. INSTALLATION_COMPLETE_MSG,
  118. USER_ABORT
  119. };
  121. static char *msgStrings[] = {
  122. "Installed file %s to %sn",
  123. "Installed module "%s" into module databasen",
  124. "Using installer script "%s"n",
  125. "Current platform is %sn",
  126. "Using installation parameters for platform %sn",
  127. "Successfully parsed installation scriptn",
  128. "Executing "%s"...n",
  129. ""%s" executed successfullyn",
  130. "nInstallation completed successfullyn",
  131. "nAborting...n"
  132. };
  134. /**************************************************************************
  135.  * S t r i n g N o d e
  136.  */
  137. typedef struct StringNode_str {
  138.     char *str;
  139.     struct StringNode_str* next;
  140. } StringNode;
  142. StringNode* StringNode_new()
  143. {
  144. StringNode* new_this;
  145. new_this = (StringNode*)malloc(sizeof(StringNode));
  146.   new_this->str=NULL;
  147.   new_this->next=NULL;
  148. return new_this;
  149. }
  151. void StringNode_delete(StringNode* s) 
  152. {
  153. if(s->str) {
  154. PR_Free(s->str);
  155. s->str=NULL;
  156. }
  157. }
  159. /*************************************************************************
  160.  * S t r i n g L i s t
  161.  */
  162. typedef struct StringList_str {
  163.   StringNode* head;
  164. StringNode* tail;
  165. } StringList;
  167. void StringList_new(StringList* list)
  168. {
  169.   list->head=NULL;
  170.   list->tail=NULL;
  171. }
  173. void StringList_delete(StringList* list)
  174. {
  175. StringNode *tmp;
  176. while(list->head) {
  177. tmp = list->head;
  178. list->head = list->head->next;
  179. StringNode_delete(tmp);
  180. }
  181. }
  183. void
  184. StringList_Append(StringList* list, char* str)
  185. {
  186. if(!str) {
  187. return;
  188. }
  190. if(!list->tail) {
  191. /* This is the first element */
  192.   list->head = list->tail = StringNode_new();
  193. } else {
  194. list->tail->next = StringNode_new();
  195. list->tail = list->tail->next;
  196. }
  198. list->tail->str = PR_Strdup(str);
  199. list->tail->next = NULL; /* just to be sure */
  200. }
  202. /**************************************************************************
  203.  *
  204.  * P k 1 1 I n s t a l l _ S e t E r r o r H a n d l e r
  205.  *
  206.  * Sets the error handler to be used by the library.  Returns the current
  207.  * error handler function.
  208.  */
  209. Pk11Install_ErrorHandler
  210. Pk11Install_SetErrorHandler(Pk11Install_ErrorHandler handler)
  211. {
  212. Pk11Install_ErrorHandler old;
  214. if(!errorHandlerLock) {
  215. errorHandlerLock = PR_NewLock();
  216. }
  218. PR_Lock(errorHandlerLock);
  220. old = errorHandler;
  221. errorHandler = handler;
  223. PR_Unlock(errorHandlerLock);
  225. return old;
  226. }
  228. /**************************************************************************
  229.  *
  230.  * P k 1 1 I n s t a l l _ I n i t
  231.  *
  232.  * Does initialization that otherwise would be done on the fly.  Only
  233.  * needs to be called by multithreaded apps, before they make any calls
  234.  * to this library.
  235.  */
  236. void
  237. Pk11Install_Init()
  238. {
  239. if(!errorHandlerLock) {
  240. errorHandlerLock = PR_NewLock();
  241. }
  242. }
  244. /**************************************************************************
  245.  *
  246.  * P k 1 1 I n s t a l l _ R e l e a s e
  247.  *
  248.  * Releases static data structures used by the library.  Don't use the
  249.  * library after calling this, unless you call Pk11Install_Init()
  250.  * first.  This function doesn't have to be called at all unless you're
  251.  * really anal about freeing memory before your program exits.
  252.  */
  253. void
  254. Pk11Install_Release()
  255. {
  256. if(errorHandlerLock) {
  257. PR_Free(errorHandlerLock);
  258. errorHandlerLock = NULL;
  259. }
  260. }
  262. /*************************************************************************
  263.  *
  264.  * e r r o r
  265.  *
  266.  * Takes an error code and its arguments, creates the error string,
  267.  * and sends the string to the handler function if it exists.
  268.  */
  270. #ifdef OSF1
  271. /* stdarg has already been pulled in from NSPR */
  272. #undef va_start
  273. #undef va_end
  274. #undef va_arg
  275. #include <varargs.h>
  276. #else
  277. #include <stdarg.h>
  278. #endif
  280. #ifdef OSF1
  281. static void
  282. error(long va_alist, ...)
  283. #else
  284. static void
  285. error(Pk11Install_Error errcode, ...)
  286. #endif
  287. {
  289. va_list ap;
  290. char *errstr;
  291. Pk11Install_ErrorHandler handler;
  293. if(!errorHandlerLock) {
  294. errorHandlerLock = PR_NewLock();
  295. }
  297. PR_Lock(errorHandlerLock);
  299. handler = errorHandler;
  301. PR_Unlock(errorHandlerLock);
  303. if(handler) {
  304. #ifdef OSF1
  305. va_start(ap);
  306. errstr = PR_vsmprintf(errorString[va_arg(ap, Pk11Install_Error)], ap);
  307. #else
  308. va_start(ap, errcode);
  309. errstr = PR_vsmprintf(errorString[errcode], ap);
  310. #endif
  311. handler(errstr);
  312. PR_smprintf_free(errstr);
  313. va_end(ap);
  314. }
  315. }
  317. /*************************************************************************
  318.  *
  319.  * j a r _ c a l l b a c k
  320.  */
  321. static int
  322. jar_callback(int status, JAR *foo, const char *bar, char *pathname,
  323. char *errortext) {
  324. char *string;
  326. string = PR_smprintf("JAR error %d: %s in file %sn", status, errortext,
  327. pathname);
  328. error(PK11_INSTALL_ERROR_STRING, string);
  329. PR_smprintf_free(string);
  330. return 0;
  331. }
  333. /*************************************************************************
  334.  *
  335.  * P k 1 1 I n s t a l l _ D o I n s t a l l
  336.  *
  337.  * jarFile is the path of a JAR in the PKCS #11 module JAR format.
  338.  * installDir is the directory relative to which files will be
  339.  *   installed.
  340.  */
  341. Pk11Install_Error
  342. Pk11Install_DoInstall(char *jarFile, const char *installDir,
  343. const char *tempDir, PRFileDesc *feedback, short force, PRBool noverify)
  344. {
  345. JAR *jar;
  346. char *installer;
  347. unsigned long installer_len;
  348. int status;
  349. Pk11Install_Error ret;
  350. PRBool made_temp_file;
  351. Pk11Install_Info installInfo;
  352. Pk11Install_Platform *platform;
  353. char* errMsg;
  354. char sysname[SYS_INFO_BUFFER_LENGTH], release[SYS_INFO_BUFFER_LENGTH],
  355.        arch[SYS_INFO_BUFFER_LENGTH];
  356. char *myPlatform;
  358. jar=NULL;
  359. ret = PK11_INSTALL_UNSPECIFIED;
  360. made_temp_file=PR_FALSE;
  361. errMsg=NULL;
  362. Pk11Install_Info_init(&installInfo);
  364. /*
  365. printf("Inside DoInstall, jarFile=%s, installDir=%s, tempDir=%sn",
  366. jarFile, installDir, tempDir);
  367. */
  369. /*
  370.  * Check out jarFile and installDir for validity
  371.  */
  372. if( PR_Access(installDir, PR_ACCESS_EXISTS) != PR_SUCCESS ) {
  373. error(PK11_INSTALL_DIR_DOESNT_EXIST, installDir);
  374. return PK11_INSTALL_DIR_DOESNT_EXIST;
  375. }
  376. if(!tempDir) {
  377. tempDir = ".";
  378. }
  379. if( PR_Access(tempDir, PR_ACCESS_EXISTS) != PR_SUCCESS ) {
  380. error(PK11_INSTALL_DIR_DOESNT_EXIST, tempDir);
  381. return PK11_INSTALL_DIR_DOESNT_EXIST;
  382. }
  383. if( PR_Access(tempDir, PR_ACCESS_WRITE_OK) != PR_SUCCESS ) {
  384. error(PK11_INSTALL_DIR_NOT_WRITEABLE, tempDir);
  385. return PK11_INSTALL_DIR_NOT_WRITEABLE;
  386. }
  387. if( (PR_Access(jarFile, PR_ACCESS_EXISTS) != PR_SUCCESS) ) {
  388. error(PK11_INSTALL_FILE_DOESNT_EXIST, jarFile);
  389. return PK11_INSTALL_FILE_DOESNT_EXIST;
  390. }
  391. if( PR_Access(jarFile, PR_ACCESS_READ_OK) != PR_SUCCESS ) {
  392. error(PK11_INSTALL_FILE_NOT_READABLE, jarFile);
  393. return PK11_INSTALL_FILE_NOT_READABLE;
  394. }
  396. /*
  397.  * Extract the JAR file
  398.  */
  399. jar = JAR_new();
  400. JAR_set_callback(JAR_CB_SIGNAL, jar, jar_callback);
  402. if(noverify) {
  403. status = JAR_pass_archive_unverified(jar, jarArchGuess, jarFile, "url");
  404. } else {
  405. status = JAR_pass_archive(jar, jarArchGuess, jarFile, "url");
  406. }
  407. if( (status < 0) || (jar->valid < 0) ) {
  408. if (status >= JAR_BASE && status <= JAR_BASE_END) {
  409. error(PK11_INSTALL_JAR_ERROR, jarFile, JAR_get_error(status));
  410. } else {
  411. error(PK11_INSTALL_JAR_ERROR, jarFile,
  412.   mySECU_ErrorString((int16) PORT_GetError()) );
  413. }
  414. ret=PK11_INSTALL_JAR_ERROR;
  415. goto loser;
  416. }
  417. /*printf("passed the archiven");*/
  419. /*
  420.  * Show the user security information, allow them to abort or continue
  421.  */
  422. if( Pk11Install_UserVerifyJar(jar, PR_STDOUT,
  423. force?PR_FALSE:PR_TRUE) && !force) {
  424. if(feedback) {
  425. PR_fprintf(feedback, msgStrings[USER_ABORT]);
  426. }
  427. ret=PK11_INSTALL_USER_ABORT;
  428. goto loser;
  429. }
  431. /*
  432.  * Get the name of the installation file
  433.  */
  434. if( JAR_get_metainfo(jar, NULL, INSTALL_METAINFO_TAG, (void**)&installer,
  435. (unsigned long*)&installer_len) ) {
  436. error(PK11_INSTALL_NO_INSTALLER_SCRIPT);
  437. ret=PK11_INSTALL_NO_INSTALLER_SCRIPT;
  438. goto loser;
  439. }
  440. if(feedback) {
  441. PR_fprintf(feedback, msgStrings[INSTALLER_SCRIPT_NAME], installer);
  442. }
  444. /*
  445.  * Extract the installation file
  446.  */
  447. if( PR_Access(SCRIPT_TEMP_FILE, PR_ACCESS_EXISTS) == PR_SUCCESS) {
  448. if( PR_Delete(SCRIPT_TEMP_FILE) != PR_SUCCESS) {
  449. error(PK11_INSTALL_DELETE_TEMP_FILE, SCRIPT_TEMP_FILE);
  450. ret=PK11_INSTALL_DELETE_TEMP_FILE;
  451. goto loser;
  452. }
  453. }
  454. if(noverify) {
  455. status = JAR_extract(jar, installer, SCRIPT_TEMP_FILE);
  456. } else {
  457. status = JAR_verified_extract(jar, installer, SCRIPT_TEMP_FILE);
  458. }
  459. if(status) {
  460. if (status >= JAR_BASE && status <= JAR_BASE_END) {
  461. error(PK11_INSTALL_JAR_EXTRACT, installer, JAR_get_error(status));
  462. } else {
  463. error(PK11_INSTALL_JAR_EXTRACT, installer,
  464.   mySECU_ErrorString((int16) PORT_GetError()) );
  465. }
  466. ret = PK11_INSTALL_JAR_EXTRACT;
  467. goto loser;
  468. } else {
  469. made_temp_file = PR_TRUE;
  470. }
  472. /*
  473.  * Parse the installation file into a syntax tree
  474.  */
  475. Pk11Install_FD = PR_Open(SCRIPT_TEMP_FILE, PR_RDONLY, 0);
  476. if(!Pk11Install_FD) {
  477. error(PK11_INSTALL_OPEN_SCRIPT_FILE, SCRIPT_TEMP_FILE);
  478. ret=PK11_INSTALL_OPEN_SCRIPT_FILE;
  479. goto loser;
  480. }
  481. if(Pk11Install_yyparse()) {
  482. error(PK11_INSTALL_SCRIPT_PARSE, installer,
  483. Pk11Install_yyerrstr ? Pk11Install_yyerrstr : "");
  484. ret=PK11_INSTALL_SCRIPT_PARSE;
  485. goto loser;
  486. }
  488. #if 0
  489. /* for debugging */
  490. Pk11Install_valueList->Print(0);
  491. #endif
  493. /*
  494.  * From the syntax tree, build a semantic structure
  495.  */
  496. errMsg = Pk11Install_Info_Generate(&installInfo,Pk11Install_valueList);
  497. if(errMsg) {
  498. error(PK11_INSTALL_SEMANTIC, errMsg);
  499. ret=PK11_INSTALL_SEMANTIC;
  500. goto loser;
  501. }
  502. #if 0
  503. installInfo.Print(0);
  504. #endif
  506. if(feedback) {
  507. PR_fprintf(feedback, msgStrings[PARSED_INSTALL_SCRIPT]);
  508. }
  510. /*
  511.  * Figure out which platform to use
  512.  */
  513. {
  514. sysname[0] = release[0] = arch[0] = '';
  516. if( (PR_GetSystemInfo(PR_SI_SYSNAME, sysname, SYS_INFO_BUFFER_LENGTH)
  517. != PR_SUCCESS) ||
  518.     (PR_GetSystemInfo(PR_SI_RELEASE, release, SYS_INFO_BUFFER_LENGTH)
  519. != PR_SUCCESS) ||
  520.     (PR_GetSystemInfo(PR_SI_ARCHITECTURE, arch, SYS_INFO_BUFFER_LENGTH)
  521. != PR_SUCCESS) ) {
  522. error(PK11_INSTALL_SYSINFO);
  523. ret=PK11_INSTALL_SYSINFO;
  524. goto loser;
  525. }
  526. myPlatform = PR_smprintf("%s:%s:%s", sysname, release, arch);
  527. platform = Pk11Install_Info_GetBestPlatform(&installInfo,myPlatform);
  528. if(!platform) {
  529. error(PK11_INSTALL_NO_PLATFORM, myPlatform);
  530. PR_smprintf_free(myPlatform);
  531. ret=PK11_INSTALL_NO_PLATFORM;
  532. goto loser;
  533. }
  534. if(feedback) {
  535. PR_fprintf(feedback, msgStrings[MY_PLATFORM_IS], myPlatform);
  536. PR_fprintf(feedback, msgStrings[USING_PLATFORM],
  537.                     Pk11Install_PlatformName_GetString(&platform->name));
  538. }
  539. PR_smprintf_free(myPlatform);
  540. }
  542. /* Run the install for that platform */
  543. ret = DoInstall(jar, installDir, tempDir, platform, feedback, noverify);
  544. if(ret) {
  545. goto loser;
  546. }
  548. ret = PK11_INSTALL_SUCCESS;
  549. loser:
  550. if(Pk11Install_valueList) {
  551. Pk11Install_ValueList_delete(Pk11Install_valueList);
  552. PR_Free(Pk11Install_valueList);
  553. Pk11Install_valueList = NULL;
  554. }
  555. if(jar) {
  556. JAR_destroy(jar);
  557. }
  558. if(made_temp_file) {
  559. PR_Delete(SCRIPT_TEMP_FILE);
  560. }
  561. if(errMsg) {
  562. PR_smprintf_free(errMsg);
  563. }
  564. return ret;
  565. }
  567. /*
  568. /////////////////////////////////////////////////////////////////////////
  569. // actually run the installation, copying files to and fro
  570. */
  571. static Pk11Install_Error
  572. DoInstall(JAR *jar, const char *installDir, const char *tempDir,
  573. Pk11Install_Platform *platform, PRFileDesc *feedback, PRBool noverify)
  574. {
  575. Pk11Install_File *file;
  576. Pk11Install_Error ret;
  577. char *reldir;
  578. char *dest;
  579. char *modDest;
  580. char *cp;
  581. int i;
  582. int status;
  583. char *tempname, *temp;
  584. StringList executables;
  585. StringNode *execNode;
  586. PRProcessAttr *attr;
  587. PRProcess *proc;
  588. char *argv[2];
  589. char *envp[1];
  590. int errcode;
  592. ret=PK11_INSTALL_UNSPECIFIED;
  593. reldir=NULL;
  594. dest=NULL;
  595. modDest=NULL;
  596. tempname=NULL;
  598. StringList_new(&executables);
  599. /*
  600. // Create Temporary directory
  601. */
  602. tempname = PR_smprintf("%s/%s", tempDir, TEMPORARY_DIRECTORY_NAME);
  603. if( PR_Access(tempname, PR_ACCESS_EXISTS)==PR_SUCCESS ) {
  604. /* Left over from previous run?  Delete it. */
  605. rm_dash_r(tempname);
  606. }
  607. if(PR_MkDir(tempname, 0700) != PR_SUCCESS) {
  608. error(PK11_INSTALL_CREATE_DIR, tempname);
  609. ret = PK11_INSTALL_CREATE_DIR;
  610. goto loser;
  611. }
  613. /*
  614. // Install all the files
  615. */
  616. for(i=0; i < platform->numFiles; i++) {
  617. file = &platform->files[i];
  619. if(file->relativePath) {
  620. PRBool foundMarker = PR_FALSE;
  621. reldir = PR_Strdup(file->relativePath);
  623. /* Replace all the markers with the directories for which they stand */
  624. while(1) {
  625. if( (cp=PL_strcasestr(reldir, ROOT_MARKER)) ) {
  626. /* Has a %root% marker  */
  627. *cp = '';
  628. temp = PR_smprintf("%s%s%s", reldir, installDir,
  629. cp+strlen(ROOT_MARKER));
  630. PR_Free(reldir);
  631. reldir = temp;
  632. foundMarker = PR_TRUE;
  633. } else if( (cp = PL_strcasestr(reldir, TEMP_MARKER)) ) {
  634. /* Has a %temp% marker */
  635. *cp = '';
  636. temp = PR_smprintf("%s%s%s", reldir, tempname, 
  637. cp+strlen(TEMP_MARKER));
  638. PR_Free(reldir);
  639. reldir = temp;
  640. foundMarker = PR_TRUE;
  641. } else {
  642. break;
  643. }
  644. }
  645. if(!foundMarker) {
  646. /* Has no markers...this isn't really a relative directory */
  647. error(PK11_INSTALL_BOGUS_REL_DIR, file->relativePath);
  648. ret = PK11_INSTALL_BOGUS_REL_DIR;
  649. goto loser;
  650. }
  651. dest = reldir;
  652. reldir = NULL;
  653. } else if(file->absolutePath) {
  654. dest = PR_Strdup(file->absolutePath);
  655. }
  657. /* Remember if this is the module file, we'll need to add it later */
  658. if(i == platform->modFile) {
  659. modDest = PR_Strdup(dest);
  660. }
  662. /* Remember is this is an executable, we'll need to run it later */
  663. if(file->executable) {
  664. StringList_Append(&executables,dest);
  665. /*executables.Append(dest);*/
  666. }
  668. /* Make sure the directory we are targetting exists */
  669. if( make_dirs(dest, file->permissions) ) {
  670. ret=PK11_INSTALL_CREATE_DIR;
  671. goto loser;
  672. }
  674. /* Actually extract the file onto the filesystem */
  675. if(noverify) {
  676. status = JAR_extract(jar, (char*)file->jarPath, dest);
  677. } else {
  678. status = JAR_verified_extract(jar, (char*)file->jarPath, dest);
  679. }
  680. if(status) {
  681. if (status >= JAR_BASE && status <= JAR_BASE_END) {
  682. error(PK11_INSTALL_JAR_EXTRACT, file->jarPath,
  683.                   JAR_get_error(status));
  684. } else {
  685. error(PK11_INSTALL_JAR_EXTRACT, file->jarPath,
  686.   mySECU_ErrorString((int16) PORT_GetError()) );
  687. }
  688. ret=PK11_INSTALL_JAR_EXTRACT;
  689. goto loser;
  690. }
  691. if(feedback) {
  692. PR_fprintf(feedback, msgStrings[INSTALLED_FILE_MSG],
  693. file->jarPath, dest);
  694. }
  696. /* no NSPR command to change permissions? */
  697. #ifdef XP_UNIX
  698. chmod(dest, file->permissions);
  699. #endif
  701. /* Memory clean-up tasks */
  702. if(reldir) {
  703. PR_Free(reldir);
  704. reldir = NULL;
  705. }
  706. if(dest) {
  707. PR_Free(dest);
  708. dest = NULL;
  709. }
  710. }
  711. /* Make sure we found the module file */
  712. if(!modDest) {
  713. /* Internal problem here, since every platform is supposed to have
  714.    a module file */
  715. error(PK11_INSTALL_NO_MOD_FILE, platform->moduleName);
  716. ret=PK11_INSTALL_NO_MOD_FILE;
  717. goto loser;
  718. }
  720. /*
  721. // Execute any executable files
  722. */
  723. {
  724. argv[1] = NULL;
  725. envp[0] = NULL;
  726. for(execNode = executables.head; execNode; execNode = execNode->next) {
  727. attr = PR_NewProcessAttr();
  728. argv[0] = PR_Strdup(execNode->str);
  730. /* Announce our intentions */
  731. if(feedback) {
  732. PR_fprintf(feedback, msgStrings[EXEC_FILE_MSG], execNode->str);
  733. }
  735. /* start the process */
  736. if( !(proc=PR_CreateProcess(execNode->str, argv, envp, attr)) ) {
  737. PR_Free(argv[0]);
  738. PR_DestroyProcessAttr(attr);
  739. error(PK11_INSTALL_EXEC_FILE, execNode->str);
  740. ret=PK11_INSTALL_EXEC_FILE;
  741. goto loser;
  742. }
  744. /* wait for it to finish */
  745. if( PR_WaitProcess(proc, &errcode) != PR_SUCCESS) {
  746. PR_Free(argv[0]);
  747. PR_DestroyProcessAttr(attr);
  748. error(PK11_INSTALL_WAIT_PROCESS, execNode->str);
  749. ret=PK11_INSTALL_WAIT_PROCESS;
  750. goto loser;
  751. }
  753. /* What happened? */
  754. if(errcode) {
  755. /* process returned an error */
  756. error(PK11_INSTALL_PROC_ERROR, execNode->str, errcode);
  757. } else if(feedback) {
  758. /* process ran successfully */
  759. PR_fprintf(feedback, msgStrings[EXEC_SUCCESS], execNode->str);
  760. }
  762. PR_Free(argv[0]);
  763. PR_DestroyProcessAttr(attr);
  764. }
  765. }
  767. /*
  768. // Add the module
  769. */
  770. status = Pk11Install_AddNewModule((char*)platform->moduleName,
  771. (char*)modDest, platform->mechFlags, platform->cipherFlags );
  773. if(status != SECSuccess) {
  774. error(PK11_INSTALL_ADD_MODULE, platform->moduleName);
  775. ret=PK11_INSTALL_ADD_MODULE;
  776. goto loser;
  777. }
  778. if(feedback) {
  779. PR_fprintf(feedback, msgStrings[INSTALLED_MODULE_MSG],
  780. platform->moduleName);
  781. }
  783. if(feedback) {
  784. PR_fprintf(feedback, msgStrings[INSTALLATION_COMPLETE_MSG]);
  785. }
  787. ret = PK11_INSTALL_SUCCESS;
  789. loser:
  790. if(reldir) {
  791. PR_Free(reldir);
  792. }
  793. if(dest) {
  794. PR_Free(dest);
  795. }
  796. if(modDest) {
  797. PR_Free(modDest);
  798. }
  799. if(tempname) {
  800. PRFileInfo info;
  801. if(PR_GetFileInfo(tempname, &info) == PR_SUCCESS) {
  802. if((info.type == PR_FILE_DIRECTORY)) {
  803. /* Recursively remove temporary directory */
  804. if(rm_dash_r(tempname)) {
  805. error(PK11_INSTALL_REMOVE_DIR,
  806. tempname);
  807. ret=PK11_INSTALL_REMOVE_DIR;
  808. }
  810. }
  811. }
  812. PR_Free(tempname);
  813. }
  814. StringList_delete(&executables);
  815. return ret;
  816. }
  818. /*
  819. //////////////////////////////////////////////////////////////////////////
  820. */
  821. static char*
  822. PR_Strdup(const char* str)
  823. {
  824. char *tmp = (char*) PR_Malloc(strlen(str)+1);
  825. strcpy(tmp, str);
  826. return tmp;
  827. }
  829. /*
  830.  *  r m _ d a s h _ r
  831.  *
  832.  *  Remove a file, or a directory recursively.
  833.  *
  834.  */
  835. static int
  836. rm_dash_r (char *path)
  837. {
  838.     PRDir   *dir;
  839.     PRDirEntry *entry;
  840.     PRFileInfo fileinfo;
  841.     char filename[240];
  843.     if(PR_GetFileInfo(path, &fileinfo) != PR_SUCCESS) {
  844.         /*fprintf(stderr, "Error: Unable to access %sn", filename);*/
  845.         return -1;
  846.     }
  847.     if(fileinfo.type == PR_FILE_DIRECTORY) {
  849.         dir = PR_OpenDir(path);
  850.         if(!dir) {
  851.             return -1;
  852.         }
  854.         /* Recursively delete all entries in the directory */
  855.         while((entry = PR_ReadDir(dir, PR_SKIP_BOTH)) != NULL) {
  856.             sprintf(filename, "%s/%s", path, entry->name);
  857.             if(rm_dash_r(filename)) return -1;
  858.         }
  860.         if(PR_CloseDir(dir) != PR_SUCCESS) {
  861.             return -1;
  862.         }
  864.         /* Delete the directory itself */
  865.         if(PR_RmDir(path) != PR_SUCCESS) {
  866.             return -1;
  867.         }
  868.     } else {
  869.         if(PR_Delete(path) != PR_SUCCESS) {
  870.             return -1;
  871.         }
  872.     }
  873.     return 0;
  874. }
  876. /***************************************************************************
  877.  *
  878.  * m a k e _ d i r s
  879.  *
  880.  * Ensure that the directory portion of the path exists.  This may require
  881.  * making the directory, and its parent, and its parent's parent, etc.
  882.  */
  883. static int
  884. make_dirs(char *path, int file_perms)
  885. {
  886. char *Path;
  887. char *start;
  888. char *sep;
  889. int ret = 0;
  890. PRFileInfo info;
  892. if(!path) {
  893. return 0;
  894. }
  896. Path = PR_Strdup(path);
  897. start = strpbrk(Path, "/\");
  898. if(!start) {
  899. return 0;
  900. }
  901. start++; /* start right after first slash */
  903. /* Each time through the loop add one more directory. */
  904. while( (sep=strpbrk(start, "/\")) ) {
  905. *sep = '';
  907. if( PR_GetFileInfo(Path, &info) != PR_SUCCESS) {
  908. /* No such dir, we have to create it */
  909. if( PR_MkDir(Path, dir_perms(file_perms)) != PR_SUCCESS) {
  910. error(PK11_INSTALL_CREATE_DIR, Path);
  911. ret = PK11_INSTALL_CREATE_DIR;
  912. goto loser;
  913. }
  914. } else {
  915. /* something exists by this name, make sure it's a directory */
  916. if( info.type != PR_FILE_DIRECTORY ) {
  917. error(PK11_INSTALL_CREATE_DIR, Path);
  918. ret = PK11_INSTALL_CREATE_DIR;
  919. goto loser;
  920. }
  921. }
  923. /* If this is the lowest directory level, make sure it is writeable */
  924. if(!strpbrk(sep+1, "/\")) {
  925. if( PR_Access(Path, PR_ACCESS_WRITE_OK)!=PR_SUCCESS) {
  926. error(PK11_INSTALL_DIR_NOT_WRITEABLE, Path);
  927. ret = PK11_INSTALL_DIR_NOT_WRITEABLE;
  928. goto loser;
  929. }
  930. }
  932. start = sep+1; /* start after the next slash */
  933. *sep = '/';
  934. }
  936. loser:
  937. PR_Free(Path);
  938. return ret;
  939. }
  941. /*************************************************************************
  942.  * d i r _ p e r m s
  943.  * 
  944.  * Guesses the desired permissions on a directory based on the permissions
  945.  * of a file that will be stored in it. Give read, write, and
  946.  * execute to the owner (so we can create the file), read and 
  947.  * execute to anyone who has read permissions on the file, and write
  948.  * to anyone who has write permissions on the file.
  949.  */
  950. static int
  951. dir_perms(int perms)
  952. {
  953. int ret = 0;
  955. /* owner */
  956. ret |= 0700;
  958. /* group */
  959. if(perms & 0040) {
  960. /* read on the file -> read and execute on the directory */
  961. ret |= 0050;
  962. }
  963. if(perms & 0020) {
  964. /* write on the file -> write on the directory */
  965. ret |= 0020;
  966. }
  968. /* others */
  969. if(perms & 0004) {
  970. /* read on the file -> read and execute on the directory */
  971. ret |= 0005;
  972. }
  973. if(perms & 0002) {
  974. /* write on the file -> write on the directory */
  975. ret |= 0002;
  976. }
  978. return ret;
  979. }