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

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

CA认证

开发平台：

WINDOWS

prefs.c：源码内容
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /*
  3.  * The contents of this file are subject to the Mozilla Public
  4.  * License Version 1.1 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of
  6.  * the License at http://www.mozilla.org/MPL/
  7.  * 
  8.  * Software distributed under the License is distributed on an "AS
  9.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10.  * implied. See the License for the specific language governing
  11.  * rights and limitations under the License.
  12.  * 
  13.  * The Original Code is the Netscape security libraries.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation.  Portions created by Netscape are 
  17.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  18.  * Rights Reserved.
  19.  * 
  20.  * Contributor(s):
  21.  * 
  22.  * Alternatively, the contents of this file may be used under the
  23.  * terms of the GNU General Public License Version 2 or later (the
  24.  * "GPL"), in which case the provisions of the GPL are applicable 
  25.  * instead of those above.  If you wish to allow use of your 
  26.  * version of this file only under the terms of the GPL and not to
  27.  * allow others to use your version of this file under the MPL,
  28.  * indicate your decision by deleting the provisions above and
  29.  * replace them with the notice and other provisions required by
  30.  * the GPL.  If you do not delete the provisions above, a recipient
  31.  * may use your version of this file under either the MPL or the
  32.  * GPL.
  33.  */
  34. #if 0
  35. #include "prtypes.h"
  36. #include "prlock.h"
  37. #include "prmem.h"
  38. #include "prio.h"
  39. #include "prlog.h"
  40. #include "prerror.h"
  41. #include "prclist.h"
  42. #include "plstr.h"
  44. #include "prefs.h"
  46. /* Number of hash buckets.  As we add prefs, we should raise this. */
  47. #define NUM_BUCKETS 64
  49. static struct {
  50.     PRLock *lock;
  51.     PRCList list;
  52. } pref_file_list = { NULL };
  54. struct PrefFileStr {
  55.     PRCList link;
  56.     PRLock *lock;
  57.     int ref_cnt;
  58.     PrefFile *next;
  59.     char *filename;
  60.     PRBool modified;
  61.     PLHashTable *hash;
  62. };
  64. typedef struct DefaultPrefs {
  65.     char *key;
  66.     char *value;
  67. } DefaultPrefs;
  69. DefaultPrefs pref_defaults[] = {
  70.     { "enable_ssl2", "true" },
  71.     { "enable_ssl3", "true" },
  72.     { NULL, NULL }
  73. };
  75. static PLHashNumber
  76. pref_HashString(const void *key)
  77. {
  78.     PLHashNumber result;
  79.     char *string;
  81.     result = 0;
  82.     string = (char *)key;
  83.     while(*string != '') {
  84. result = (result << 4) + (result >> 28);
  85. result += *string;
  86. string++;
  87.     }
  88.     return result;
  89. }
  91. static PRIntn
  92. pref_HashCompareKey(const void *v1, const void *v2)
  93. {
  94.     if (strcmp(v1, v2) == 0)
  95. return 1;
  96.     else
  97. return 0;
  98. }
  100. static PRIntn
  101. pref_HashCompareValue(const void *v1, const void *v2)
  102. {
  103.     if (v1 == v2)
  104. return 1;
  105.     else
  106. return 0;
  107. }
  109. static void *
  110. pref_allocTable(void *pool, PRSize size)
  111. {
  112.     return PR_Malloc(size);
  113. }
  115. static void
  116. pref_freeTable(void *pool, void *item)
  117. {
  118.     PR_Free(item);
  119. }
  121. static PLHashEntry *
  122. pref_allocEntry(void *pool, const void *key)
  123. {
  124.     return PR_NEW(PLHashEntry);
  125. }
  127. static void
  128. pref_freeEntry(void *pool, PLHashEntry *he, PRUintn flag)
  129. {
  130.     PR_Free(he->value);
  132.     if (flag == HT_FREE_ENTRY)
  133.         PR_DELETE(he);
  134. }
  136. static PLHashAllocOps pref_HashAllocOps = {
  137.     pref_allocTable, pref_freeTable, pref_allocEntry, pref_freeEntry
  138. };
  140. struct StringBufStr {
  141.     char *str;
  142.     int len;
  143.     int space;
  144. };
  146. typedef struct StringBufStr StringBuf;
  148. static StringBuf *
  149. str_create(int space)
  150. {
  151.     StringBuf *buf;
  153.     buf = PR_NEW(StringBuf);
  154.     if (buf == NULL)
  155. goto loser;
  157.     buf->str = PR_Malloc(space + 1);
  158.     if (buf->str == NULL)
  159. goto loser;
  161.     buf->str[0] = '';
  162.     buf->len = 0;
  163.     buf->space = space;
  164.     return buf;
  166. loser:
  167.     if (buf != NULL) {
  168. if (buf->str != NULL)
  169.     PR_Free(buf->str);
  170. PR_DELETE(buf);
  171.     }
  172.     return NULL;
  173. }
  175. static SSMStatus
  176. str_addchar(StringBuf *buf, char c)
  177. {
  178.     int len, space;
  180.     PR_ASSERT(buf->len <= buf->space);
  182.     /* If we had a previous allocation failure, fail immediately. */
  183.     if (buf->space == 0)
  184. goto loser;
  186.     if (buf->len == buf->space) {
  187. buf->space *= 2;
  188. buf->str = PR_Realloc(buf->str, buf->space + 1);
  189. if (buf->str == NULL)
  190.     goto loser;
  191.     }
  193.     buf->str[len] = c;
  194.     len++;
  195.     buf->str[len] = '';
  196.     return PR_SUCCESS;
  198. loser:
  199.     buf->space = 0;
  200.     buf->len = 0;
  201.     return PR_FAILURE;
  202. }
  204. static void
  205. str_clear(StringBuf *buf)
  206. {
  207.     buf->len = 0;
  208.     buf->str[0] = '';
  209. }
  211. static char *
  212. str_dup(StringBuf *buf)
  213. {
  214.     return PL_strdup(buf->str);
  215. }
  217. static void
  218. str_destroy(StringBuf *buf)
  219. {
  220.     if (buf != NULL) {
  221. if (buf->str != NULL)
  222.     PR_Free(buf->str);
  223. PR_DELETE(buf);
  224.     }
  225. }
  227. typedef enum ParseState { parse_key, parse_value } ParseState;
  229. static SSMStatus
  230. pref_ReadPrefs(PrefFile *prefs)
  231. {
  232.     PRFileDesc *fd;
  233.     StringBuf *keybuf, *valbuf;
  234.     char *readbuf;
  235.     int i, readlen;
  236.     SSMStatus rv;
  237.     char c;
  238.     ParseState parse_state;
  240.     fd = PR_Open(prefs->filename, PR_RDONLY, 0);
  241.     if (fd == NULL) {
  242. /* No prefs file is okay.  Just don't do anything. */
  243. if (PR_GetError() == PR_FILE_NOT_FOUND_ERROR)
  244.     return PR_SUCCESS;
  245. else
  246.     return PR_FAILURE;
  247.     }
  249.     keybuf = str_create(128);
  250.     if (keybuf == NULL)
  251. goto loser;
  252.     valbuf = str_create(128);
  253.     if (valbuf == NULL)
  254. goto loser;
  255.     readbuf = PR_Malloc(1024);
  256.     if (readbuf == NULL)
  257. goto loser;
  259.     readlen = PR_Read(fd, readbuf, 1024);
  260.     i = 0;
  261.     while(readlen != 0) {
  262. c = readbuf[i];
  263. switch(parse_state) {
  264.   case parse_key:
  265.     if (c == ':') {
  266. parse_state = parse_value;
  267.     } else { 
  268. str_addchar(keybuf, c);
  269.     }
  270.     break;
  271.   case parse_value:
  272.     if (c == 'n') {
  273. PLHashEntry *entry;
  274. char *key, *val;
  276. key = str_dup(keybuf);
  277. val = str_dup(valbuf);
  278. entry = PL_HashTableAdd(prefs->hash, key, val);
  279. if (entry == NULL) {
  280.     PR_Free(key);
  281.     PR_Free(val);
  282. }
  283. parse_state = parse_key;
  284.     } else {
  285. str_addchar(valbuf, c);
  286.     }
  287.     break;
  288. }
  289. i++;
  291. if (i == readlen) {
  292.     readlen = PR_Read(fd, readbuf, 1024);
  293.     i = 0;
  294. }
  295.     }
  296.     rv = PR_SUCCESS;
  298. done:
  299.     if (fd != NULL)
  300. PR_Close(fd);
  301.     if (keybuf != NULL)
  302. str_destroy(keybuf);
  303.     if (valbuf != NULL)
  304. str_destroy(valbuf);
  305.     if (readbuf != NULL)
  306. PR_Free(readbuf);
  307.     return rv;
  308. loser:
  309.     rv = PR_FAILURE;
  310.     goto done;
  311. }
  313. static PrefFile *
  314. pref_OpenNewPrefFile(char *filename)
  315. {
  316.     PrefFile *prefs;
  317.     PRFileDesc *fd;
  318.     SSMStatus status;
  320.     prefs = PR_NEW(PrefFile);
  321.     if (prefs == NULL)
  322. goto loser;
  324.     prefs->lock = PR_NewLock();
  325.     if (prefs->lock == NULL)
  326. goto loser;
  328.     prefs->filename = PL_strdup(filename);
  329.     if (prefs->filename == NULL)
  330. goto loser;
  332.     prefs->hash = PL_NewHashTable(NUM_BUCKETS, pref_HashString,
  333.   pref_HashCompareKey, pref_HashCompareValue,
  334.   NULL, NULL);
  335.     if (prefs->hash == NULL)
  336. goto loser;
  338.     status = pref_ReadPrefs(prefs);
  339.     if (status != PR_SUCCESS)
  340. goto loser;
  342.     prefs->ref_cnt = 1;
  344.     return prefs;
  345. loser:
  346.     if (prefs != NULL) {
  347. if (prefs->lock != NULL)
  348.     PR_DestroyLock(prefs->lock);
  349. if (prefs->filename != NULL)
  350.     PR_Free(prefs->filename);
  351. if (prefs->hash != NULL) {
  352.     PL_HashTableDestroy(prefs->hash);
  353. }
  355. PR_DELETE(prefs);
  356.     }
  357.     return NULL;
  358. }
  360. PrefFile *
  361. PREF_OpenPrefs(char *filename)
  362. {
  363.     PrefFile *prefs;
  364.     PRCList *link, *list;
  366.     /* Init the global file list if this is the first time. */
  367.     if (pref_file_list.lock == NULL) {
  368. pref_file_list.lock = PR_NewLock();
  369. if (pref_file_list.lock == NULL)
  370.     return NULL;
  371. PR_INIT_CLIST(&pref_file_list.list);
  372.     }
  374.     /* First, check to see if we've already got this file open. */
  375.     PR_Lock(pref_file_list.lock);
  376.     list = &pref_file_list.list;
  377.     for (link = PR_LIST_HEAD(list); link != list; link = PR_NEXT_LINK(link)) {
  378. prefs = (PrefFile *)link;
  379. if (PL_strcmp(filename, prefs->filename) == 0) {
  380.     PR_Lock(prefs->lock);
  381.     prefs->ref_cnt++;
  382.     PR_Unlock(prefs->lock);
  383.     PR_Unlock(pref_file_list.lock);
  384.     return prefs;
  385. }
  386.     }
  388.     /* We don't already have this prefs file open, so open it. */
  389.     prefs = pref_OpenNewPrefFile(filename);
  390.     if (prefs == NULL)
  391. goto loser;
  392.     PR_INSERT_BEFORE(&prefs->link, list);
  393.     PR_Unlock(pref_file_list.lock);
  394.     return prefs;
  396. loser:
  397.     PR_Unlock(pref_file_list.lock);
  398.     return NULL;
  399. }
  401. static PRIntn
  402. pref_writeEnumerator(PLHashEntry *he, PRIntn i, void *arg)
  403. {
  404.     PRFileDesc *fd = (PRFileDesc *)arg;
  406.     PR_Write(fd, he->key, PL_strlen(he->key));
  407.     PR_Write(fd, ":", 1);
  408.     PR_Write(fd, he->value, PL_strlen(he->value));
  409.     PR_Write(fd, "n", 1);
  411.     return HT_ENUMERATE_NEXT;
  412. }
  414. SSMStatus
  415. PREF_WritePrefs(PrefFile *prefs)
  416. {
  417.     PRFileDesc *fd;
  418.     SSMStatus status = PR_SUCCESS;
  420.     PR_Lock(prefs->lock);
  421.     if (prefs->modified == PR_FALSE)
  422. goto done;
  424.     fd = PR_Open(prefs->filename, PR_RDWR | PR_CREATE_FILE | PR_TRUNCATE, 0600);
  425.     if (fd == NULL) {
  426. status = PR_FAILURE;
  427. goto done;
  428.     }
  430.     PL_HashTableEnumerateEntries(prefs->hash, pref_writeEnumerator, fd);
  431. done:
  432.     PR_Unlock(prefs->lock);
  433.     PR_Close(fd);
  434.     return status;
  435. }
  437. SSMStatus
  438. PREF_ClosePrefs(PrefFile *prefs)
  439. {
  440.     SSMStatus status;
  442.     PR_Lock(pref_file_list.lock);
  443.     PR_Lock(prefs->lock);
  445.     PR_ASSERT(prefs->ref_cnt >= 1);
  446.     prefs->ref_cnt--;
  448.     if (prefs->ref_cnt > 0) {
  449. PR_Unlock(prefs->lock);
  450. PR_Unlock(pref_file_list.lock);
  451. return PR_SUCCESS;
  452.     }
  454.     PR_REMOVE_LINK(&prefs->link);
  455.     PR_Unlock(pref_file_list.lock);
  457.     status = PREF_WritePrefs(prefs);
  458.     PR_DestroyLock(prefs->lock);
  459.     PR_Free(prefs->filename);
  460.     PL_HashTableDestroy(prefs->hash);
  461.     PR_Free(prefs);
  463.     return status;
  464. }
  466. static SSMStatus
  467. pref_SetStringPref_unlocked(PrefFile *prefs, char *name, char *value)
  468. {
  469.     PLHashEntry *entry;
  470.     char *key, *val;
  472.     key = PL_strdup(key);
  473.     if (key == NULL)
  474. goto loser;
  475.     val = PL_strdup(value);
  476.     if (val == NULL)
  477. goto loser;
  479.     entry = PL_HashTableAdd(prefs->hash, key, val);
  480.     if (entry == NULL)
  481. goto loser;
  483.     return PR_SUCCESS;
  485. loser:
  486.     if (key != NULL)
  487. PR_Free(key);
  488.     if (val != NULL)
  489. PR_Free(val);
  491.     return PR_FAILURE;
  492. }
  494. SSMStatus
  495. PREF_SetStringPref(PrefFile *prefs, char *name, char *value)
  496. {
  497.     SSMStatus status;
  499.     PR_Lock(prefs->lock);
  500.     status = pref_SetStringPref_unlocked(prefs, name, value);
  501.     prefs->modified = PR_TRUE;
  502.     PR_Unlock(prefs->lock);
  503.     return status;
  504. }
  506. char *
  507. PREF_GetStringPref(PrefFile *prefs, char *name)
  508. {
  509.     char *val;
  511.     PR_Lock(prefs->lock);
  512.     val = PL_HashTableLookup(prefs->hash, name);
  513.     if (val != NULL)
  514. val = PL_strdup(val);
  515.     PR_Unlock(prefs->lock);
  516.     return val;
  517. }
  519. static SSMStatus
  520. pref_SetDefaultPrefs(PrefFile *prefs)
  521. {
  522.     DefaultPrefs *dp;
  523.     SSMStatus status = PR_SUCCESS;
  525.     PR_Lock(prefs->lock);
  526.     dp = pref_defaults;
  527.     while(dp->key != NULL) {
  528. status = pref_SetStringPref_unlocked(prefs, dp->key, dp->value);
  529. if (status != PR_SUCCESS)
  530.     goto loser;
  531. dp++;
  532.     }
  533. loser:
  534.     PR_Unlock(prefs->lock);
  535.     return status;
  536. }
  538. #else    /* PREFS LITE (tm) */
  539. /*------------------------------------------------------*/
  540. #include "nspr.h"
  541. #include "prtypes.h"
  542. #include "prclist.h"
  543. #include "prlock.h"
  544. #include "prmem.h"
  545. #include "prlog.h"
  546. #include "plstr.h"
  548. #include "prefs.h"
  551. struct PrefSetStr {
  552.     PRCList list;
  553.     PRLock* lock;
  554.     PRBool modified;
  555. };
  557. typedef struct PrefItemStr {
  558.     char* key;
  559.     char* value;
  560. } PrefItem;
  562. typedef struct PrefItemNodeStr {
  563.     PRCList link;
  564.     PrefItem* item;
  565. } PrefItemNode;
  568. /* Default values with which a PrefSet is initialized
  569.  */ 
  570. PrefItem pref_defaults[] = {
  571.     {"security.enable_ssl2", "true"},
  572.     {"security.enable_ssl3", "true"},
  573.     {"security.default_personal_cert", "Ask Every Time"},
  574.     {"security.default_mail_cert", NULL},
  575.     {"security.ask_for_password", "0"},
  576.     {"security.password_lifetime", "30"},
  577.     {"security.OCSP.enabled", "false"},
  578.     {"security.warn_entering_secure", "true"},
  579.     {"security.warn_leaving_secure", "true"},
  580.     {"security.warn_viewing_mixed", "true"},
  581.     {"security.warn_submit_insecure", "true"},
  582.     {"mail.encrypt_outgoing_mail", "false"},
  583.     {"mail.crypto_sign_outgoing_mail", "false"},
  584.     {"mail.crypto_sign_outgoing_news", "false"},
  585.     {NULL, NULL}
  586. };
  589. char* STRING_TRUE = "true";
  590. char* STRING_FALSE = "false";
  593. static void pref_free_pref_item(PrefItem* pref)
  594. {
  595.     if (pref != NULL) {
  596.         if (pref->key != NULL) {
  597.             PR_Free(pref->key);
  598.         }
  599.         if (pref->value != NULL) {
  600.             PR_Free(pref->value);
  601.         }
  602.         PR_Free(pref);
  603.     }
  604. }
  606. static PrefItem* pref_new_pref_item(char* key, char* value)
  607. {
  608.     PrefItem* tmp = NULL;
  610.     PR_ASSERT(key != NULL);
  611.     tmp = (PrefItem*)PR_NEWZAP(PrefItem);
  612.     if (tmp == NULL) {
  613.         return tmp;
  614.     }
  615.     
  616.     tmp->key = PL_strdup(key);
  617.     if (tmp->key == NULL) {
  618.         goto loser;
  619.     }
  620.     if (value != NULL) {
  621.         tmp->value = PL_strdup(value);
  622.         if (tmp->value == NULL) {
  623.             goto loser;
  624.         }
  625.     }
  626.     else {
  627.         tmp->value = NULL;
  628.     }
  630.     return tmp;
  631. loser:
  632.     pref_free_pref_item(tmp);
  633.     return NULL;
  634. }
  636. static PrefItemNode* pref_new_pref_item_node(PrefItem* item)
  637. {
  638.     PrefItemNode* node = NULL;
  640.     PR_ASSERT(item != NULL);
  642.     node = (PrefItemNode*)PR_NEWZAP(PrefItemNode);
  643.     if (node == NULL) {
  644.         /* failed: bail out */
  645.         return node;
  646.     }
  648.     /* initialize elements to the right values */
  649.     PR_INIT_CLIST(&node->link);
  650.     node->item = item;
  652.     return node;
  653. }
  656. /* Append a PrefItem to the list */
  657. static SSMStatus pref_append_item_unlocked(PrefItem* pref, PRCList* list)
  658. {
  659.     PrefItemNode* node = NULL;
  661.     PR_ASSERT((pref != NULL) && (list != NULL));
  663.     node = pref_new_pref_item_node(pref);
  664.     if (node == NULL) {
  665.         return PR_FAILURE;
  666.     }
  668.     /* append the link */
  669.     PR_APPEND_LINK(&node->link, list);
  670.     return PR_SUCCESS;
  671. }
  674. /* Append a PrefItem made from (key, value) into the list */
  675. static SSMStatus pref_append_pref_unlocked(PrefSet* prefs, char* key, 
  676.                                           char* value)
  677. {
  678.     PrefItem* pref = NULL;
  680.     pref = pref_new_pref_item(key, value);
  681.     if (pref == NULL) {
  682.         return PR_FAILURE;
  683.     }
  685.     return pref_append_item_unlocked(pref, &prefs->list);
  686. }
  689. /* Modify (old) by comparing with (new)
  690.  * - returns PR_SUCCESS if everything went right; PR_FAILURE if PL_strdup()
  691.  *   failed
  692.  */
  693. static SSMStatus pref_reset_value(char** oldStr, char* newStr)
  694. {
  695.     PR_ASSERT(oldStr != NULL);
  697.     if (newStr == NULL) {
  698.         if (*oldStr != NULL) {
  699.             PR_Free(*oldStr);
  700.             *oldStr = newStr;
  701.         }
  702.         return PR_SUCCESS;
  703.     }
  705.     if (*oldStr != NULL) {
  706.         if (PL_strcmp(*oldStr, newStr) != 0) {
  707.             /* different: reset it */
  708.             PR_Free(*oldStr);
  709.             *oldStr = PL_strdup(newStr);
  710.             if (*oldStr == NULL) {
  711.                 return PR_FAILURE;
  712.             }
  713.         }
  714.     }
  715.     else {
  716.         *oldStr = PL_strdup(newStr);
  717.         if (*oldStr == NULL) {
  718.             return PR_FAILURE;
  719.         }
  720.     }
  721.     return PR_SUCCESS;
  722. }
  725. /* Retrieve (value) that belongs to (key) in (prefs)
  726.  * - return PR_SUCCESS if key exists; PR_FAILURE otherwise
  727.  * - (value) may be NULL
  728.  * - returned (value) is a pointer to an existing string, not a new string
  729.  */
  731. static SSMStatus pref_get_pref_unlocked(PrefSet* prefs, char* key, char** value)
  732. {
  733.     PRCList* link = NULL;
  735.     PR_ASSERT((prefs != NULL) && (key != NULL) && (value != NULL));
  737.     /* in case of failure */
  738.     *value = NULL;
  740.     /* first make sure the list is not empty */
  741.     if (PR_CLIST_IS_EMPTY(&prefs->list)) {
  742.         return PR_FAILURE;
  743.     }
  745.     /* walk the list to find the key */
  746.     for (link = PR_LIST_HEAD(&prefs->list); link != &prefs->list;
  747.          link = PR_NEXT_LINK(link)) {
  748.         PrefItemNode* node = (PrefItemNode*)link;
  749.         if (PL_strcmp(node->item->key, key) == 0) {
  750.             /* found the key: return the value whatever it is */
  751.             *value = node->item->value;
  752.             return PR_SUCCESS;
  753.         }
  754.     }
  756.     /* we couldn't find the key: return NULL */
  757.     return PR_FAILURE;
  758. }
  760. /* Set (value) for (key) in (prefs)
  761.  * - if (key) exists, reset (value) (if necessary)
  762.  * - if (key) does not exist, insert this item into (prefs)
  763.  * - we do not care if (value) is NULL
  764.  * - when new elements are created, they are allocated on the heap
  765.  */
  766. static SSMStatus pref_set_pref_unlocked(PrefSet* prefs, char* key, char* value)
  767. {
  768.     PRCList* link = NULL;
  770.     PR_ASSERT((prefs != NULL) && (key != NULL));
  772.     if (!PR_CLIST_IS_EMPTY(&prefs->list)) {
  773.         for (link = PR_LIST_HEAD(&prefs->list); link != &prefs->list;
  774.              link = PR_NEXT_LINK(link)) {
  775.             PrefItemNode* node = (PrefItemNode*)link;
  776.             if (PL_strcmp(node->item->key, key) == 0) {
  777.                 /* found the key */
  778.                 return pref_reset_value(&node->item->value, value);
  779.             }
  780.         }
  781.     }
  783.     /* either the list was empty or the key was not found */
  784.     return pref_append_pref_unlocked(prefs, key, value);
  785. }
  787. /* Compare (value) with the stored value under (key)
  788.  * - returns PR_TRUE if the key does not exist or the values do not match
  789.  * - returns PR_FALSE only if the key exists and the values match
  790.  */
  791. static PRBool pref_pref_changed_unlocked(PrefSet* prefs, char* key, 
  792.                                          char* value)
  793. {
  794.     PRCList* link = NULL;
  795.     PRBool rv = PR_TRUE;
  797.     PR_ASSERT((prefs != NULL) && (key != NULL));
  799.     if (!PR_CLIST_IS_EMPTY(&prefs->list)) {
  800.         for (link = PR_LIST_HEAD(&prefs->list); link != &prefs->list;
  801.              link = PR_NEXT_LINK(link)) {
  802.             PrefItemNode* node = (PrefItemNode*)link;
  803.             if (PL_strcmp(node->item->key, key) == 0) {
  804.                 /* found the key */
  806.                 if (((value == NULL) && (node->item->value == NULL)) ||
  807.                     (value != NULL) && (node->item->value != NULL) &&
  808.                     (PL_strcmp(node->item->value, value) == 0)) {
  809.                     rv = PR_FALSE;
  810.                 }
  811.                 goto done;
  812.             }
  813.         }
  814.         /* exhausted the list but could not find the key */
  815.     }
  816. done:
  817.     return rv;
  818. }
  820. static void pref_clean_out_list(PRCList* list)
  821. {
  822.     PRCList* link = NULL;
  824.     PR_ASSERT(list != NULL);
  826.     if (PR_CLIST_IS_EMPTY(list)) {
  827.         /* we're already done */
  828.         return;
  829.     }
  831.     link = PR_LIST_HEAD(list); 
  832.     while (link != list) {
  833.         PrefItemNode* node = (PrefItemNode*)link;
  834.         pref_free_pref_item(node->item);
  835.         link = PR_NEXT_LINK(link);
  836.         if (node != NULL) {
  837.             PR_Free(node);
  838.         }
  839.     }
  840.     return;
  841. }
  844. PrefSet* PREF_NewPrefs(void)
  845. {
  846.     SSMStatus status;
  847.     PrefSet* prefs = NULL;
  848.     int i;
  850.     /* initialize the structure */
  851.     prefs = (PrefSet*)PR_NEWZAP(PrefSet);
  852.     if (prefs == NULL) {
  853.         goto loser;
  854.     }
  856.     prefs->lock = PR_NewLock();
  857.     if (prefs->lock == NULL) {
  858.         goto loser;
  859.     }
  861.     PR_INIT_CLIST(&prefs->list);
  863.     /* fill the list with default data */
  864.     for (i = 0; pref_defaults[i].key != NULL; i++) {
  865.         PR_Lock(prefs->lock);
  866.         status = pref_append_pref_unlocked(prefs, pref_defaults[i].key,
  867.                                            pref_defaults[i].value);
  868.         PR_Unlock(prefs->lock);
  869.         if (status != PR_SUCCESS) {
  870.             goto loser;
  871.         }
  872.     }
  874.     return prefs;
  875. loser:
  876.     if (prefs != NULL) {
  877.         if (prefs->lock != NULL) {
  878.             PR_DestroyLock(prefs->lock);
  879.         }
  880.         PR_Free(prefs);
  881.     }
  882.     return NULL;
  883. }
  885. SSMStatus PREF_ClosePrefs(PrefSet* prefs)
  886. {
  887.     if (prefs == NULL) {
  888.         goto loser;
  889.     }
  890.     if (prefs->lock == NULL) {
  891.         goto loser;
  892.     }
  894.     /* clean out the list */
  895.     PR_Lock(prefs->lock);
  896.     pref_clean_out_list(&prefs->list);
  897.     PR_Unlock(prefs->lock);
  899.     PR_DestroyLock(prefs->lock);
  901.     PR_Free(prefs);
  903.     return PR_SUCCESS;
  904. loser:
  905.     return PR_FAILURE;
  906. }
  909. SSMStatus PREF_GetStringPref(PrefSet* prefs, char* key, char** value)
  910. {
  911.     SSMStatus rv;
  913.     /* in case of failure */
  914.     *value = NULL;
  916.     if ((prefs == NULL) || (key == NULL) || (value == NULL)) {
  917.         return PR_FAILURE;
  918.     }
  920.     PR_Lock(prefs->lock);
  921.     rv = pref_get_pref_unlocked(prefs, key, value);
  922.     PR_Unlock(prefs->lock);
  924.     return rv;
  925. }
  927. SSMStatus PREF_CopyStringPref(PrefSet* prefs, char* key, char** value)
  928. {
  929.     SSMStatus rv;
  930.     char* tmp = NULL;
  932.     *value = NULL;
  933.     rv = PREF_GetStringPref(prefs, key, &tmp);
  934.     if (tmp != NULL) {
  935.         *value = PL_strdup(tmp);
  936.         if (*value == NULL && rv == PR_SUCCESS) {
  937.             rv = PR_FAILURE;
  938.         }
  939.     }
  941.     return rv;
  942. }
  944. SSMStatus PREF_SetStringPref(PrefSet* prefs, char* key, char* value)
  945. {
  946.     SSMStatus rv;
  948.     if ((prefs == NULL) || (key == NULL)) {
  949.         return PR_FAILURE;
  950.     }
  952.     PR_Lock(prefs->lock);
  953.     rv = pref_set_pref_unlocked(prefs, key, value);
  954.     PR_Unlock(prefs->lock);
  956.     return rv;
  957. }
  959. PRBool PREF_StringPrefChanged(PrefSet* prefs, char* key, char* value)
  960. {
  961.     PRBool rv;
  963.     PR_ASSERT((prefs != NULL) && (key != NULL));
  964.     if ((prefs == NULL) || (key == NULL)) {
  965.         return PR_TRUE; /* this really is an error */
  966.     }
  968.     PR_Lock(prefs->lock);
  969.     rv = pref_pref_changed_unlocked(prefs, key, value);
  970.     PR_Unlock(prefs->lock);
  972.     return rv;
  973. }
  976. SSMStatus PREF_GetBoolPref(PrefSet* prefs, char* key, PRBool* value)
  977. {
  978.     SSMStatus rv;
  979.     char* tmp = NULL;
  981.     if ((prefs == NULL) || (key == NULL) || (value == NULL)) {
  982.         return PR_FAILURE;
  983.     }
  985.     PR_Lock(prefs->lock);
  986.     rv = pref_get_pref_unlocked(prefs, key, &tmp);
  987.     PR_Unlock(prefs->lock);
  989.     if (rv != PR_SUCCESS) {
  990.         /* pref item was not found */
  991.         return rv;
  992.     }
  994.     if (PL_strcmp(tmp, STRING_TRUE) == 0) {
  995.         *value = PR_TRUE;
  996.     }
  997.     else if (PL_strcmp(tmp, STRING_FALSE) == 0) {
  998.         *value = PR_FALSE;
  999.     }
  1000.     else {
  1001.         return PR_FAILURE;
  1002.     }
  1004.     return PR_SUCCESS;
  1005. }
  1008. SSMStatus PREF_SetBoolPref(PrefSet* prefs, char* key, PRBool value)
  1009. {
  1010.     SSMStatus rv;
  1011.     char* tmp = NULL;
  1013.     if ((prefs == NULL) || (key == NULL)) {
  1014.         return PR_FAILURE;
  1015.     }
  1017.     if (value == PR_FALSE) {
  1018.         tmp = STRING_FALSE;
  1019.     }
  1020.     else if (value == PR_TRUE) {
  1021.         tmp = STRING_TRUE;
  1022.     }
  1023.     else {
  1024.         PR_ASSERT(0);
  1025.     }
  1027.     PR_Lock(prefs->lock);
  1028.     rv = pref_set_pref_unlocked(prefs, key, tmp);
  1029.     PR_Unlock(prefs->lock);
  1031.     return rv;
  1032. }
  1034. PRBool PREF_BoolPrefChanged(PrefSet* prefs, char* key, PRBool value)
  1035. {
  1036.     PRBool rv;
  1037.     char* tmp = NULL;
  1039.     PR_ASSERT((prefs != NULL) && (key != NULL));
  1040.     if ((prefs == NULL) || (key == NULL)) {
  1041.         return PR_TRUE; /* this really is an error */
  1042.     }
  1044.     if (value == PR_FALSE) {
  1045.         tmp = STRING_FALSE;
  1046.     }
  1047.     else if (value == PR_TRUE) {
  1048.         tmp = STRING_TRUE;
  1049.     }
  1050.     else {
  1051.         PR_ASSERT(0);
  1052.     }
  1054.     PR_Lock(prefs->lock);
  1055.     rv = pref_pref_changed_unlocked(prefs, key, tmp);
  1056.     PR_Unlock(prefs->lock);
  1058.     return rv;
  1059. }
  1062. SSMStatus PREF_GetIntPref(PrefSet* prefs, char* key, PRIntn* value)
  1063. {
  1064.     SSMStatus rv;
  1065.     char* tmp = NULL;
  1067.     if ((prefs == NULL) || (key == NULL) || (value == NULL)) {
  1068.         return PR_FAILURE;
  1069.     }
  1071.     PR_Lock(prefs->lock);
  1072.     rv = pref_get_pref_unlocked(prefs, key, &tmp);
  1073.     PR_Unlock(prefs->lock);
  1075.     if (rv != PR_SUCCESS) {
  1076.         /* pref item was not found */
  1077.         return rv;
  1078.     }
  1080.     /* convert char* into integer */
  1081.     *value = atoi(tmp);
  1083.     return PR_SUCCESS;
  1084. }
  1087. SSMStatus PREF_SetIntPref(PrefSet* prefs, char* key, PRIntn value)
  1088. {
  1089.     SSMStatus rv;
  1090.     char* tmp = NULL;
  1092.     if ((prefs == NULL) || (key == NULL)) {
  1093.         return PR_FAILURE;
  1094.     }
  1096.     tmp = PR_smprintf("%d", value);
  1097.     if (tmp == NULL) {
  1098.         return PR_FAILURE;
  1099.     }
  1101.     PR_Lock(prefs->lock);
  1102.     rv = pref_set_pref_unlocked(prefs, key, tmp);
  1103.     PR_Unlock(prefs->lock);
  1105.     PR_Free(tmp);
  1106.     return rv;
  1107. }
  1109. PRBool PREF_IntPrefChanged(PrefSet* prefs, char* key, PRIntn value)
  1110. {
  1111.     PRBool rv;
  1112.     char* tmp = NULL;
  1114.     PR_ASSERT((prefs != NULL) && (key != NULL));
  1115.     if ((prefs == NULL) || (key == NULL)) {
  1116.         return PR_TRUE; /* this really is an error */
  1117.     }
  1119.     tmp = PR_smprintf("%d", value);
  1120.     if (tmp == NULL) {
  1121.         /* ouch... */
  1122.         return PR_TRUE;
  1123.     }
  1125.     PR_Lock(prefs->lock);
  1126.     rv = pref_pref_changed_unlocked(prefs, key, tmp);
  1127.     PR_Unlock(prefs->lock);
  1129.     PR_Free(tmp);
  1130.     return rv;
  1131. }
  1133. /******************
  1134.  * These functions allow to handle multiple options specified in 
  1135.  * prefs. 
  1136.  ******************/
  1137. #include "connect.h" /* don't know what to include to use PR_Zalloc */
  1139. SSMStatus pref_append_value(char *** list, char * value)
  1140. {
  1141.     SSMStatus rv = SSM_SUCCESS;
  1142.     static int size, cursize;
  1143.     if (!list || !value)
  1144.         return SSM_FAILURE;
  1145.     
  1146.     /* Quick and dirty check if we already have that value in the list - 
  1147.      * only check the value directly before. Preferences keys seem to go 
  1148.      * in clusters so that might actually work untill there is a better way
  1149.      */
  1150.     if (*list && **list && !PL_strcmp(value, (*list)[cursize-1]))
  1151.         return rv;
  1152.     
  1153.     if (!*list) {
  1154.         size = 12;
  1155.         cursize = 0;
  1156.         *list = (char **)PORT_ZAlloc(sizeof(char *)* size);
  1157.         if (!*list) {
  1158.             rv = SSM_ERR_OUT_OF_MEMORY;
  1159.             goto done;
  1160.         }
  1161.     }
  1162.     else if (cursize == size-2) { 
  1163.         size = size + 12;
  1164.         *list = (char **)PR_Realloc(*list, sizeof(char *)*size);
  1165.         if (!*list) {
  1166.             rv = SSM_ERR_OUT_OF_MEMORY;
  1167.             goto done;
  1168.         }
  1169.         /* clear the memory */
  1170.         memset(*list+cursize, 0, sizeof(char*)*(size-cursize));
  1171.     }
  1172.     (*list)[cursize] = PL_strdup(value);
  1173.     cursize++;
  1174.     
  1175.  done: 
  1176.     return rv;
  1177. }
  1179. /****** retrieve all the values for a parent key:
  1180.  * SSMStatus 
  1181.  * PREF_CreateChildList(PrefSet * prefs, 
  1182.  *                      const char* parent_key, 
  1183.  *                      char **child_list);
  1184.  * 
  1185.  * For parent key x.y retrieves key names directly below x.y :
  1186.  * x.y.a, x.y.b, x.y.c, etc.
  1187.  *
  1188.  * For parent_key == NULL returns all the preferences values. 
  1189.  * (Why would anyone want to do that? )
  1190.  *
  1191.  * Allocates and returns char * array with all the requested values. 
  1192.  * Caller is responsible for freeing memory.
  1193.  *
  1194.  * Used for LDAP server look-up for UI.
  1195.  *****/
  1196. SSMStatus PREF_CreateChildList(PrefSet * prefs, const char* parent_key, 
  1197.                                char ***child_list)
  1198. {
  1199.     SSMStatus rv = SSM_FAILURE;
  1200.     PRCList * link = NULL;
  1201.     char * child, * tmp;
  1202.     int parent_key_len = parent_key?strlen(parent_key):0;
  1203.     
  1204.     if (!prefs || !child_list) 
  1205.         goto loser;
  1207.     *child_list = NULL;
  1208.     
  1209.     /* walk the list untill find interesting key */
  1210.     if (!PR_CLIST_IS_EMPTY(&prefs->list)) {
  1211.         for (link = PR_LIST_HEAD(&prefs->list); link != &prefs->list;
  1212.              link = PR_NEXT_LINK(link)) {
  1213.             PrefItemNode* node = (PrefItemNode*)link;
  1214.             if (!parent_key || ((tmp = strstr(node->item->key, parent_key)) 
  1215.                                 && tmp[parent_key_len] == '.')) {
  1216.                 /* found the key */
  1217.                 /* append "child" string: "child" in parent.child.more */
  1218.                 child = PL_strdup(node->item->key + parent_key_len + 1);
  1219.                 tmp = strtok(child, ".");
  1220.                 rv = pref_append_value(child_list, tmp);
  1221.                 PR_Free(child);
  1222.                 if (rv != SSM_SUCCESS) 
  1223.                     goto loser;
  1224.             }
  1225.         }
  1226.     }
  1227.     rv = SSM_SUCCESS;
  1228.  loser:
  1229.     return rv;
  1230. }
  1234. #endif    /* PREFS LITE (tm) */