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

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

CA认证

开发平台：

WINDOWS

dbck.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. /*
  35. ** dbck.c
  36. **
  37. ** utility for fixing corrupt cert databases
  38. **
  39. */
  40. #include <stdio.h>
  41. #include <string.h>
  43. #include "secutil.h"
  44. #include "cdbhdl.h"
  45. #include "certdb.h"
  46. #include "cert.h"
  47. #include "nspr.h"
  48. #include "prtypes.h"
  49. #include "prtime.h"
  50. #include "prlong.h"
  52. static char *progName;
  54. /* placeholders for pointer error types */
  55. static void *WrongEntry;
  56. static void *NoNickname;
  57. static void *NoSMime;
  59. enum {
  60.     GOBOTH = 0,
  61.     GORIGHT,
  62.     GOLEFT
  63. };
  65. typedef struct
  66. {
  67.     PRBool verbose;
  68.     PRBool dograph;
  69.     PRFileDesc *out;
  70.     PRFileDesc *graphfile;
  71.     int dbErrors[10];
  72. } dbDebugInfo;
  74. /*
  75.  * A list node for a cert db entry.  The index is a unique identifier
  76.  * to use for creating generic maps of a db.  This struct handles
  77.  * the cert, nickname, and smime db entry types, as all three have a
  78.  * single handle to a subject entry.
  79.  * This structure is pointed to by certDBEntryListNode->appData.
  80.  */
  81. typedef struct 
  82. {
  83.     PRArenaPool *arena;
  84.     int index;
  85.     certDBEntryListNode *pSubject;
  86. } certDBEntryMap;
  88. /*
  89.  * Subject entry is special case, it has bidirectional handles.  One
  90.  * subject entry can point to several certs (using the same DN), and
  91.  * a nickname and/or smime entry.
  92.  * This structure is pointed to by certDBEntryListNode->appData.
  93.  */
  94. typedef struct
  95. {
  96.     PRArenaPool *arena;
  97.     int index;
  98.     int numCerts;
  99.     certDBEntryListNode **pCerts;
  100.     certDBEntryListNode *pNickname;
  101.     certDBEntryListNode *pSMime;
  102. } certDBSubjectEntryMap;
  104. /*
  105.  * A map of a certdb.
  106.  */
  107. typedef struct
  108. {
  109.     int numCerts;
  110.     int numSubjects;
  111.     int numNicknames;
  112.     int numSMime;
  113.     certDBEntryListNode certs;      /* pointer to head of cert list */
  114.     certDBEntryListNode subjects;   /* pointer to head of subject list */
  115.     certDBEntryListNode nicknames;  /* pointer to head of nickname list */
  116.     certDBEntryListNode smime;      /* pointer to head of smime list */
  117. } certDBArray;
  119. /* Cast list to the base element, a certDBEntryListNode. */
  120. #define LISTNODE_CAST(node) 
  121.     ((certDBEntryListNode *)(node))
  123. static void 
  124. Usage(char *progName)
  125. {
  126. #define FPS fprintf(stderr, 
  127.     FPS "Type %s -H for more detailed descriptionsn", progName);
  128.     FPS "Usage:  %s -D [-d certdir] [-i dbname] [-m] [-v  [-f dumpfile]]n", 
  129. progName);
  130.     FPS "        %s -R -o newdbname [-d certdir] [-i dbname] [-aprsx] [-v [-f dumpfile]]n", 
  131. progName);
  132.     exit(-1);
  133. }
  135. static void
  136. LongUsage(char *progName)
  137. {
  138.     FPS "%-15s Display this help message.n",
  139. "-H");
  140.     FPS "%-15s Dump analysis.  No changes will be made to the database.n",
  141. "-D");
  142.     FPS "%-15s Cert database directory (default is ~/.netscape)n",
  143. "   -d certdir");
  144.     FPS "%-15s Input cert database name (default is cert7.db)n",
  145. "   -i dbname");
  146.     FPS "%-15s Mail a graph of the database to certdb@netscape.com.n",
  147. "   -m");
  148.     FPS "%-15s This will produce an index graph of your cert db and sendn",
  149. "");
  150.     FPS "%-15s it to Netscape for analysis.  Personal info will be removed.n",
  151. "");
  152.     FPS "%-15s Verbose mode.  Dumps the entire contents of your cert7.db.n",
  153. "   -v");
  154.     FPS "%-15s File to dump verbose output into.n",
  155. "   -f dumpfile");
  156.     FPS "%-15s Repair the database.  The program will look for brokenn",
  157. "-R");
  158.     FPS "%-15s dependencies between subject entries and certificates,n",
  159.         "");
  160.     FPS "%-15s between nickname entries and subjects, and between SMIMEn",
  161.         "");
  162.     FPS "%-15s profiles and subjects.  Any duplicate entries will ben",
  163.         "");
  164.     FPS "%-15s removed, any missing entries will be created.n",
  165.         "");
  166.     FPS "%-15s File to store new database in (default is new_cert7.db)n",
  167. "   -o newdbname");
  168.     FPS "%-15s Cert database directory (default is ~/.netscape)n",
  169. "   -d certdir");
  170.     FPS "%-15s Input cert database name (default is cert7.db)n",
  171. "   -i dbname");
  172.     FPS "%-15s Prompt before removing any certificates.n",
  173.         "   -p");
  174.     FPS "%-15s Keep all possible certificates.  Only remove certificatesn",
  175. "   -a");
  176.     FPS "%-15s which prevent creation of a consistent database.  Thus anyn",
  177. "");
  178.     FPS "%-15s expired or redundant entries will be kept.n",
  179. "");
  180.     FPS "%-15s Keep redundant nickname/email entries.  It is possiblen",
  181. "   -r");
  182.     FPS "%-15s only one such entry will be usable.n",
  183. "");
  184.     FPS "%-15s Don't require an S/MIME profile in order to keep an S/MIMEn",
  185. "   -s");
  186.     FPS "%-15s cert.  An empty profile will be created.n",
  187. "");
  188.     FPS "%-15s Keep expired certificates.n",
  189. "   -x");
  190.     FPS "%-15s Verbose mode - report all activity while recovering db.n",
  191. "   -v");
  192.     FPS "%-15s File to dump verbose output into.n",
  193. "   -f dumpfile");
  194.     FPS "n");
  195.     exit(-1);
  196. #undef FPS
  197. }
  199. /*******************************************************************
  200.  *
  201.  *  Functions for dbck.
  202.  *
  203.  ******************************************************************/
  205. void
  206. printHexString(PRFileDesc *out, SECItem *hexval)
  207. {
  208.     int i;
  209.     for (i = 0; i < hexval->len; i++) {
  210. if (i != hexval->len - 1) {
  211.     PR_fprintf(out, "%02x:", hexval->data[i]);
  212. } else {
  213.     PR_fprintf(out, "%02x", hexval->data[i]);
  214. }
  215.     }
  216.     PR_fprintf(out, "n");
  217. }
  219. typedef enum {
  220. /* 0*/ NoSubjectForCert = 0,
  221. /* 1*/ SubjectHasNoKeyForCert,
  222. /* 2*/ NoNicknameOrSMimeForSubject,
  223. /* 3*/ WrongNicknameForSubject,
  224. /* 4*/ NoNicknameEntry,
  225. /* 5*/ WrongSMimeForSubject,
  226. /* 6*/ NoSMimeEntry,
  227. /* 7*/ NoSubjectForNickname,
  228. /* 8*/ NoSubjectForSMime,
  229. /* 9*/ NicknameAndSMimeEntry
  230. } dbErrorType;
  232. static char *dbErrorString[] = {
  233. /* 0*/ "<CERT ENTRY>nDid not find a subject entry for this certificate.",
  234. /* 1*/ "<SUBJECT ENTRY>nSubject has certKey which is not in db.",
  235. /* 2*/ "<SUBJECT ENTRY>nSubject does not have a nickname or email address.",
  236. /* 3*/ "<SUBJECT ENTRY>nUsing this subject's nickname, found a nickname entry for a different subject.",
  237. /* 4*/ "<SUBJECT ENTRY>nDid not find a nickname entry for this subject.",
  238. /* 5*/ "<SUBJECT ENTRY>nUsing this subject's email, found an S/MIME entry for a different subject.",
  239. /* 6*/ "<SUBJECT ENTRY>nDid not find an S/MIME entry for this subject.",
  240. /* 7*/ "<NICKNAME ENTRY>nDid not find a subject entry for this nickname.",
  241. /* 8*/ "<S/MIME ENTRY>nDid not find a subject entry for this S/MIME profile.",
  242. };
  244. SECStatus
  245. dumpCertificate(CERTCertificate *cert, int num, PRFileDesc *outfile)
  246. {
  247.     int userCert = 0;
  248.     CERTCertTrust *trust = cert->trust;
  249.     userCert = (SEC_GET_TRUST_FLAGS(trust, trustSSL) & CERTDB_USER) ||
  250.                (SEC_GET_TRUST_FLAGS(trust, trustEmail) & CERTDB_USER) ||
  251.                (SEC_GET_TRUST_FLAGS(trust, trustObjectSigning) & CERTDB_USER);
  252.     if (num >= 0) {
  253. PR_fprintf(outfile, "Certificate: %3dn", num);
  254.     } else {
  255. PR_fprintf(outfile, "Certificate:n");
  256.     }
  257.     PR_fprintf(outfile, "----------------n");
  258.     if (userCert)
  259. PR_fprintf(outfile, "(User Cert)n");
  260.     PR_fprintf(outfile, "## SUBJECT:  %sn", cert->subjectName);
  261.     PR_fprintf(outfile, "## ISSUER:  %sn", cert->issuerName);
  262.     PR_fprintf(outfile, "## SERIAL NUMBER:  ");
  263.     printHexString(outfile, &cert->serialNumber);
  264.     {  /*  XXX should be separate function.  */
  265. int64 timeBefore, timeAfter;
  266. PRExplodedTime beforePrintable, afterPrintable;
  267. char *beforestr, *afterstr;
  268. DER_UTCTimeToTime(&timeBefore, &cert->validity.notBefore);
  269. DER_UTCTimeToTime(&timeAfter, &cert->validity.notAfter);
  270. PR_ExplodeTime(timeBefore, PR_GMTParameters, &beforePrintable);
  271. PR_ExplodeTime(timeAfter, PR_GMTParameters, &afterPrintable);
  272. beforestr = PORT_Alloc(100);
  273. afterstr = PORT_Alloc(100);
  274. PR_FormatTime(beforestr, 100, "%a %b %d %H:%M:%S %Y", &beforePrintable);
  275. PR_FormatTime(afterstr, 100, "%a %b %d %H:%M:%S %Y", &afterPrintable);
  276. PR_fprintf(outfile, "## VALIDITY:  %s to %sn", beforestr, afterstr);
  277.     }
  278.     PR_fprintf(outfile, "n");
  279.     return SECSuccess;
  280. }
  282. SECStatus
  283. dumpCertEntry(certDBEntryCert *entry, int num, PRFileDesc *outfile)
  284. {
  285.     CERTCertificate *cert;
  286.     cert = CERT_DecodeDERCertificate(&entry->derCert, PR_FALSE, NULL);
  287.     if (!cert) {
  288. fprintf(stderr, "Failed to decode certificate.n");
  289. return SECFailure;
  290.     }
  291.     cert->trust = &entry->trust;
  292.     dumpCertificate(cert, num, outfile);
  293.     CERT_DestroyCertificate(cert);
  294.     return SECSuccess;
  295. }
  297. SECStatus
  298. dumpSubjectEntry(certDBEntrySubject *entry, int num, PRFileDesc *outfile)
  299. {
  300.     char *subjectName;
  301.     subjectName = CERT_DerNameToAscii(&entry->derSubject);
  302.     PR_fprintf(outfile, "Subject: %3dn", num);
  303.     PR_fprintf(outfile, "------------n");
  304.     PR_fprintf(outfile, "## %sn", subjectName);
  305.     if (entry->nickname)
  306. PR_fprintf(outfile, "## Subject nickname:  %sn", entry->nickname);
  307.     if (entry->emailAddr)
  308. PR_fprintf(outfile, "## Subject email address:  %sn", 
  309.            entry->emailAddr);
  310.     PR_fprintf(outfile, "## This subject has %d cert(s).n", entry->ncerts);
  311.     PR_fprintf(outfile, "n");
  312.     PORT_Free(subjectName);
  313.     return SECSuccess;
  314. }
  316. SECStatus
  317. dumpNicknameEntry(certDBEntryNickname *entry, int num, PRFileDesc *outfile)
  318. {
  319.     PR_fprintf(outfile, "Nickname: %3dn", num);
  320.     PR_fprintf(outfile, "-------------n");
  321.     PR_fprintf(outfile, "##  "%s"nn", entry->nickname);
  322.     return SECSuccess;
  323. }
  325. SECStatus
  326. dumpSMimeEntry(certDBEntrySMime *entry, int num, PRFileDesc *outfile)
  327. {
  328.     PR_fprintf(outfile, "S/MIME Profile: %3dn", num);
  329.     PR_fprintf(outfile, "-------------------n");
  330.     PR_fprintf(outfile, "##  "%s"n", entry->emailAddr);
  331.     PR_fprintf(outfile, "##  OPTIONS:  ");
  332.     printHexString(outfile, &entry->smimeOptions);
  333.     PR_fprintf(outfile, "##  TIMESTAMP:  ");
  334.     printHexString(outfile, &entry->optionsDate);
  335.     PR_fprintf(outfile, "n");
  336.     return SECSuccess;
  337. }
  339. SECStatus
  340. mapCertEntries(certDBArray *dbArray)
  341. {
  342.     certDBEntryCert *certEntry;
  343.     certDBEntrySubject *subjectEntry;
  344.     certDBEntryListNode *certNode, *subjNode;
  345.     certDBSubjectEntryMap *smap;
  346.     certDBEntryMap *map;
  347.     PRArenaPool *tmparena;
  348.     SECItem derSubject;
  349.     SECItem certKey;
  350.     PRCList *cElem, *sElem;
  351.     int i;
  353.     /* Arena for decoded entries */
  354.     tmparena = PORT_NewArena(DER_DEFAULT_CHUNKSIZE);
  355.     if (tmparena == NULL) {
  356. PORT_SetError(SEC_ERROR_NO_MEMORY);
  357. return SECFailure;
  358.     }
  360.     /* Iterate over cert entries and map them to subject entries. 
  361.      * NOTE: mapSubjectEntries must be called first to alloc memory
  362.      * for array of subject->cert map.
  363.      */
  364.     for (cElem = PR_LIST_HEAD(&dbArray->certs.link); 
  365.          cElem != &dbArray->certs.link; cElem = PR_NEXT_LINK(cElem)) {
  366. certNode = LISTNODE_CAST(cElem);
  367. certEntry = (certDBEntryCert *)&certNode->entry;
  368. map = (certDBEntryMap *)certNode->appData;
  369. CERT_NameFromDERCert(&certEntry->derCert, &derSubject);
  370. CERT_KeyFromDERCert(tmparena, &certEntry->derCert, &certKey);
  371. /*  Loop over found subjects for cert's DN.  */
  372. for (sElem = PR_LIST_HEAD(&dbArray->subjects.link);
  373.      sElem != &dbArray->subjects.link; sElem = PR_NEXT_LINK(sElem)) {
  374.     subjNode = LISTNODE_CAST(sElem);
  375.     subjectEntry = (certDBEntrySubject *)&subjNode->entry;
  376.     if (SECITEM_ItemsAreEqual(&derSubject, &subjectEntry->derSubject)) {
  377. /*  Found matching subject name, create link.  */
  378. map->pSubject = subjNode;
  379. /*  Make sure subject entry has cert's key.  */
  380. for (i=0; i<subjectEntry->ncerts; i++) {
  381.     if (SECITEM_ItemsAreEqual(&certKey,
  382.                               &subjectEntry->certKeys[i])) {
  383. /*  Found matching cert key.  */
  384. smap = (certDBSubjectEntryMap *)subjNode->appData;
  385. smap->pCerts[i] = certNode;
  386. break;
  387.     }
  388. }
  389.     }
  390. }
  391.     }
  392.     PORT_FreeArena(tmparena, PR_FALSE);
  393.     return SECSuccess;
  394. }
  396. SECStatus
  397. mapSubjectEntries(certDBArray *dbArray)
  398. {
  399.     certDBEntrySubject *subjectEntry;
  400.     certDBEntryNickname *nicknameEntry;
  401.     certDBEntrySMime *smimeEntry;
  402.     certDBEntryListNode *subjNode, *nickNode, *smimeNode;
  403.     certDBSubjectEntryMap *subjMap;
  404.     certDBEntryMap *nickMap, *smimeMap;
  405.     PRCList *sElem, *nElem, *mElem;
  407.     for (sElem = PR_LIST_HEAD(&dbArray->subjects.link);
  408.          sElem != &dbArray->subjects.link; sElem = PR_NEXT_LINK(sElem)) {
  409. /* Iterate over subject entries and map subjects to nickname
  410.  * and smime entries.  The cert<->subject map will be handled
  411.  * by a subsequent call to mapCertEntries.
  412.  */
  413. subjNode = LISTNODE_CAST(sElem);
  414. subjectEntry = (certDBEntrySubject *)&subjNode->entry;
  415. subjMap = (certDBSubjectEntryMap *)subjNode->appData;
  416. /* need to alloc memory here for array of matching certs. */
  417. subjMap->pCerts = PORT_ArenaAlloc(subjMap->arena, 
  418.                                   subjectEntry->ncerts*sizeof(int));
  419. subjMap->numCerts = subjectEntry->ncerts;
  420. if (subjectEntry->nickname) {
  421.     /* Subject should have a nickname entry, so create a link. */
  422.     for (nElem = PR_LIST_HEAD(&dbArray->nicknames.link);
  423.          nElem != &dbArray->nicknames.link; 
  424.          nElem = PR_NEXT_LINK(nElem)) {
  425. /*  Look for subject's nickname in nickname entries.  */
  426. nickNode = LISTNODE_CAST(nElem);
  427. nicknameEntry = (certDBEntryNickname *)&nickNode->entry;
  428. nickMap = (certDBEntryMap *)nickNode->appData;
  429. if (PL_strcmp(subjectEntry->nickname, 
  430.               nicknameEntry->nickname) == 0) {
  431.     /*  Found a nickname entry for subject's nickname.  */
  432.     if (SECITEM_ItemsAreEqual(&subjectEntry->derSubject,
  433.                               &nicknameEntry->subjectName)) {
  434. /*  Nickname and subject match.  */
  435. subjMap->pNickname = nickNode;
  436. nickMap->pSubject = subjNode;
  437.     } else {
  438. /*  Nickname entry found is for diff. subject.  */
  439. subjMap->pNickname = WrongEntry;
  440.     }
  441. }
  442.     }
  443. } else {
  444.     subjMap->pNickname = NoNickname;
  445. }
  446. if (subjectEntry->emailAddr) {
  447.     /* Subject should have an smime entry, so create a link. */
  448.     for (mElem = PR_LIST_HEAD(&dbArray->smime.link);
  449.          mElem != &dbArray->smime.link; mElem = PR_NEXT_LINK(mElem)) {
  450. /*  Look for subject's email in S/MIME entries.  */
  451. smimeNode = LISTNODE_CAST(mElem);
  452. smimeEntry = (certDBEntrySMime *)&smimeNode->entry;
  453. smimeMap = (certDBEntryMap *)smimeNode->appData;
  454. if (PL_strcmp(subjectEntry->emailAddr, 
  455.               smimeEntry->emailAddr) == 0) {
  456.     /*  Found a S/MIME entry for subject's email.  */
  457.     if (SECITEM_ItemsAreEqual(&subjectEntry->derSubject,
  458.                               &smimeEntry->subjectName)) {
  459. /*  S/MIME entry and subject match.  */
  460. subjMap->pSMime = smimeNode;
  461. smimeMap->pSubject = subjNode;
  462.     } else {
  463. /*  S/MIME entry found is for diff. subject.  */
  464. subjMap->pSMime = WrongEntry;
  465.     }
  466. }
  467.     }
  468. } else {
  469.     subjMap->pSMime = NoSMime;
  470. }
  471.     }
  472.     return SECSuccess;
  473. }
  475. void
  476. printnode(dbDebugInfo *info, const char *str, int num)
  477. {
  478.     if (!info->dograph)
  479. return;
  480.     if (num < 0) {
  481. PR_fprintf(info->graphfile, str);
  482.     } else {
  483. PR_fprintf(info->graphfile, str, num);
  484.     }
  485. }
  487. PRBool
  488. map_handle_is_ok(dbDebugInfo *info, void *mapPtr, int indent)
  489. {
  490.     if (mapPtr == NULL) {
  491. if (indent > 0)
  492.     printnode(info, "                ", -1);
  493. if (indent >= 0)
  494.     printnode(info, "******************* ", -1);
  495. return PR_FALSE;
  496.     } else if (mapPtr == WrongEntry) {
  497. if (indent > 0)
  498.     printnode(info, "                  ", -1);
  499. if (indent >= 0)
  500.     printnode(info, "??????????????????? ", -1);
  501. return PR_FALSE;
  502.     } else {
  503. return PR_TRUE;
  504.     }
  505. }
  507. /* these call each other */
  508. void print_smime_graph(dbDebugInfo *info, certDBEntryMap *smimeMap, 
  509.                        int direction);
  510. void print_nickname_graph(dbDebugInfo *info, certDBEntryMap *nickMap, 
  511.                           int direction);
  512. void print_subject_graph(dbDebugInfo *info, certDBSubjectEntryMap *subjMap, 
  513.                          int direction, int optindex, int opttype);
  514. void print_cert_graph(dbDebugInfo *info, certDBEntryMap *certMap, 
  515.                       int direction);
  517. /* Given an smime entry, print its unique identifier.  If GOLEFT is 
  518.  * specified, print the cert<-subject<-smime map, else just print
  519.  * the smime entry.
  520.  */
  521. void
  522. print_smime_graph(dbDebugInfo *info, certDBEntryMap *smimeMap, int direction)
  523. {
  524.     certDBSubjectEntryMap *subjMap;
  525.     certDBEntryListNode *subjNode;
  526.     if (direction == GOLEFT) {
  527. /* Need to output subject and cert first, see print_subject_graph */
  528. subjNode = smimeMap->pSubject;
  529. if (map_handle_is_ok(info, (void *)subjNode, 1)) {
  530.     subjMap = (certDBSubjectEntryMap *)subjNode->appData; 
  531.     print_subject_graph(info, subjMap, GOLEFT,
  532.                         smimeMap->index, certDBEntryTypeSMimeProfile);
  533. } else {
  534.     printnode(info, "<---- S/MIME   %5d   ", smimeMap->index);
  535. }
  536.     } else {
  537. printnode(info, "S/MIME   %5d   ", smimeMap->index);
  538.     }
  539. }
  541. /* Given a nickname entry, print its unique identifier.  If GOLEFT is 
  542.  * specified, print the cert<-subject<-nickname map, else just print
  543.  * the nickname entry.
  544.  */
  545. void
  546. print_nickname_graph(dbDebugInfo *info, certDBEntryMap *nickMap, int direction)
  547. {
  548.     certDBSubjectEntryMap *subjMap;
  549.     certDBEntryListNode *subjNode;
  550.     if (direction == GOLEFT) {
  551. /* Need to output subject and cert first, see print_subject_graph */
  552. subjNode = nickMap->pSubject;
  553. if (map_handle_is_ok(info, (void *)subjNode, 1)) {
  554.     subjMap = (certDBSubjectEntryMap *)subjNode->appData;
  555.     print_subject_graph(info, subjMap, GOLEFT,
  556.                         nickMap->index, certDBEntryTypeNickname);
  557. } else {
  558.     printnode(info, "<---- Nickname %5d   ", nickMap->index);
  559. }
  560.     } else {
  561. printnode(info, "Nickname %5d   ", nickMap->index);
  562.     }
  563. }
  565. /* Given a subject entry, if going right print the graph of the nickname|smime
  566.  * that it maps to (by its unique identifier); and if going left
  567.  * print the list of certs that it points to.
  568.  */
  569. void
  570. print_subject_graph(dbDebugInfo *info, certDBSubjectEntryMap *subjMap, 
  571.                     int direction, int optindex, int opttype)
  572. {
  573.     certDBEntryMap *map;
  574.     certDBEntryListNode *node;
  575.     int i;
  576.     /* The first line of output always contains the cert id, subject id,
  577.      * and nickname|smime id.  Subsequent lines may contain additional
  578.      * cert id's for the subject if going left or both directions.
  579.      * Ex. of printing the graph for a subject entry:
  580.      * Cert 3 <- Subject 5 -> Nickname 32
  581.      * Cert 8 /
  582.      * Cert 9 /
  583.      * means subject 5 has 3 certs, 3, 8, and 9, and corresponds
  584.      * to nickname entry 32.
  585.      * To accomplish the above, it is required to dump the entire first
  586.      * line left-to-right, regardless of the input direction, and then
  587.      * finish up any remaining cert entries.  Hence the code is uglier
  588.      * than one may expect.
  589.      */
  590.     if (direction == GOLEFT || direction == GOBOTH) {
  591. /* In this case, nothing should be output until the first cert is
  592.  * located and output (cert 3 in the above example).
  593.  */
  594. if (subjMap->numCerts == 0 || subjMap->pCerts == NULL)
  595.     /* XXX uh-oh */
  596.     return;
  597. /* get the first cert and dump it. */
  598. node = subjMap->pCerts[0];
  599. if (map_handle_is_ok(info, (void *)node, 0)) {
  600.     map = (certDBEntryMap *)node->appData;
  601.     /* going left here stops. */
  602.     print_cert_graph(info, map, GOLEFT); 
  603. }
  604. /* Now it is safe to output the subject id. */
  605. if (direction == GOLEFT)
  606.     printnode(info, "Subject  %5d <---- ", subjMap->index);
  607. else /* direction == GOBOTH */
  608.     printnode(info, "Subject  %5d ----> ", subjMap->index);
  609.     }
  610.     if (direction == GORIGHT || direction == GOBOTH) { 
  611. /* Okay, now output the nickname|smime for this subject. */
  612. if (direction != GOBOTH) /* handled above */
  613.    printnode(info, "Subject  %5d ----> ", subjMap->index);
  614. if (subjMap->pNickname) {
  615.     node = subjMap->pNickname;
  616.     if (map_handle_is_ok(info, (void *)node, 0)) {
  617. map = (certDBEntryMap *)node->appData;
  618. /* going right here stops. */
  619. print_nickname_graph(info, map, GORIGHT);
  620.     }
  621. }
  622. if (subjMap->pSMime) {
  623.     node = subjMap->pSMime;
  624.     if (map_handle_is_ok(info, (void *)node, 0)) {
  625. map = (certDBEntryMap *)node->appData;
  626. /* going right here stops. */
  627. print_smime_graph(info, map, GORIGHT); 
  628.     }
  629. }
  630. if (!subjMap->pNickname && !subjMap->pSMime) {
  631.     printnode(info, "******************* ", -1);
  632. }
  633.     }
  634.     if (direction != GORIGHT) { /* going right has only one cert */
  635. if (opttype == certDBEntryTypeNickname)
  636.     printnode(info, "Nickname %5d   ", optindex);
  637. else if (opttype == certDBEntryTypeSMimeProfile)
  638.     printnode(info, "S/MIME   %5d   ", optindex);
  639. for (i=1 /* 1st one already done */; i<subjMap->numCerts; i++) {
  640.     printnode(info, "n", -1); /* start a new line */
  641.     node = subjMap->pCerts[i];
  642.     if (map_handle_is_ok(info, (void *)node, 0)) {
  643. map = (certDBEntryMap *)node->appData;
  644. /* going left here stops. */
  645. print_cert_graph(info, map, GOLEFT); 
  646. printnode(info, "/", -1);
  647.     }
  648. }
  649.     }
  650. }
  652. /* Given a cert entry, print its unique identifer.  If GORIGHT is specified,
  653.  * print the cert->subject->nickname|smime map, else just print
  654.  * the cert entry.
  655.  */
  656. void
  657. print_cert_graph(dbDebugInfo *info, certDBEntryMap *certMap, int direction)
  658. {
  659.     certDBSubjectEntryMap *subjMap;
  660.     certDBEntryListNode *subjNode;
  661.     if (direction == GOLEFT) {
  662. printnode(info, "Cert     %5d <---- ", certMap->index);
  663. /* only want cert entry, terminate here. */
  664. return;
  665.     }
  666.     /* Keep going right then. */
  667.     printnode(info, "Cert     %5d ----> ", certMap->index);
  668.     subjNode = certMap->pSubject;
  669.     if (map_handle_is_ok(info, (void *)subjNode, 0)) {
  670. subjMap = (certDBSubjectEntryMap *)subjNode->appData;
  671. print_subject_graph(info, subjMap, GORIGHT, -1, -1);
  672.     }
  673. }
  675. SECStatus
  676. computeDBGraph(certDBArray *dbArray, dbDebugInfo *info)
  677. {
  678.     PRCList *cElem, *sElem, *nElem, *mElem;
  679.     certDBEntryListNode *node;
  680.     certDBEntryMap *map;
  681.     certDBSubjectEntryMap *subjMap;
  683.     /* Graph is of this form:
  684.      *
  685.      * certs:
  686.      * cert ---> subject ---> (nickname|smime)
  687.      *
  688.      * subjects:
  689.      * cert <--- subject ---> (nickname|smime)
  690.      *
  691.      * nicknames and smime:
  692.      * cert <--- subject <--- (nickname|smime)
  693.      */
  695.     /* Print cert graph. */
  696.     for (cElem = PR_LIST_HEAD(&dbArray->certs.link);
  697.          cElem != &dbArray->certs.link; cElem = PR_NEXT_LINK(cElem)) {
  698. /* Print graph of everything to right of cert entry. */
  699. node = LISTNODE_CAST(cElem);
  700. map = (certDBEntryMap *)node->appData;
  701. print_cert_graph(info, map, GORIGHT);
  702. printnode(info, "n", -1);
  703.     }
  704.     printnode(info, "n", -1);
  706.     /* Print subject graph. */
  707.     for (sElem = PR_LIST_HEAD(&dbArray->subjects.link);
  708.          sElem != &dbArray->subjects.link; sElem = PR_NEXT_LINK(sElem)) {
  709. /* Print graph of everything to both sides of subject entry. */
  710. node = LISTNODE_CAST(sElem);
  711. subjMap = (certDBSubjectEntryMap *)node->appData;
  712. print_subject_graph(info, subjMap, GOBOTH, -1, -1);
  713. printnode(info, "n", -1);
  714.     }
  715.     printnode(info, "n", -1);
  717.     /* Print nickname graph. */
  718.     for (nElem = PR_LIST_HEAD(&dbArray->nicknames.link);
  719.          nElem != &dbArray->nicknames.link; nElem = PR_NEXT_LINK(nElem)) {
  720. /* Print graph of everything to left of nickname entry. */
  721. node = LISTNODE_CAST(nElem);
  722. map = (certDBEntryMap *)node->appData;
  723. print_nickname_graph(info, map, GOLEFT);
  724. printnode(info, "n", -1);
  725.     }
  726.     printnode(info, "n", -1);
  728.     /* Print smime graph. */
  729.     for (mElem = PR_LIST_HEAD(&dbArray->smime.link);
  730.          mElem != &dbArray->smime.link; mElem = PR_NEXT_LINK(mElem)) {
  731. /* Print graph of everything to left of smime entry. */
  732. node = LISTNODE_CAST(mElem);
  733. if (node == NULL) break;
  734. map = (certDBEntryMap *)node->appData;
  735. print_smime_graph(info, map, GOLEFT);
  736. printnode(info, "n", -1);
  737.     }
  738.     printnode(info, "n", -1);
  740.     return SECSuccess;
  741. }
  743. /*
  744.  * List the entries in the db, showing handles between entry types.
  745.  */
  746. void
  747. verboseOutput(certDBArray *dbArray, dbDebugInfo *info)
  748. {
  749.     int i, ref;
  750.     PRCList *elem;
  751.     certDBEntryListNode *node;
  752.     certDBEntryMap *map;
  753.     certDBSubjectEntryMap *smap;
  754.     certDBEntrySubject *subjectEntry;
  756.     /* List certs */
  757.     for (elem = PR_LIST_HEAD(&dbArray->certs.link);
  758.          elem != &dbArray->certs.link; elem = PR_NEXT_LINK(elem)) {
  759. node = LISTNODE_CAST(elem);
  760. map = (certDBEntryMap *)node->appData;
  761. dumpCertEntry((certDBEntryCert*)&node->entry, map->index, info->out);
  762. /* walk the cert handle to it's subject entry */
  763. if (map_handle_is_ok(info, map->pSubject, -1)) {
  764.     smap = (certDBSubjectEntryMap *)map->pSubject->appData;
  765.     ref = smap->index;
  766.     PR_fprintf(info->out, "-->(subject %d)nnn", ref);
  767. } else {
  768.     PR_fprintf(info->out, "-->(MISSING SUBJECT ENTRY)nnn");
  769. }
  770.     }
  771.     /* List subjects */
  772.     for (elem = PR_LIST_HEAD(&dbArray->subjects.link);
  773.          elem != &dbArray->subjects.link; elem = PR_NEXT_LINK(elem)) {
  774. node = LISTNODE_CAST(elem);
  775. subjectEntry = (certDBEntrySubject *)&node->entry;
  776. smap = (certDBSubjectEntryMap *)node->appData;
  777. dumpSubjectEntry(subjectEntry, smap->index, info->out);
  778. /* iterate over subject's certs */
  779. for (i=0; i<smap->numCerts; i++) {
  780.     /* walk each subject handle to it's cert entries */
  781.     if (map_handle_is_ok(info, smap->pCerts[i], -1)) {
  782. ref = ((certDBEntryMap *)smap->pCerts[i]->appData)->index;
  783. PR_fprintf(info->out, "-->(%d. certificate %d)n", i, ref);
  784.     } else {
  785. PR_fprintf(info->out, "-->(%d. MISSING CERT ENTRY)n", i);
  786.     }
  787. }
  788. if (subjectEntry->nickname) {
  789.     /* walk each subject handle to it's nickname entry */
  790.     if (map_handle_is_ok(info, smap->pNickname, -1)) {
  791. ref = ((certDBEntryMap *)smap->pNickname->appData)->index;
  792. PR_fprintf(info->out, "-->(nickname %d)n", ref);
  793.     } else {
  794. PR_fprintf(info->out, "-->(MISSING NICKNAME ENTRY)n");
  795.     }
  796. }
  797. if (subjectEntry->emailAddr) {
  798.     /* walk each subject handle to it's smime entry */
  799.     if (map_handle_is_ok(info, smap->pSMime, -1)) {
  800. ref = ((certDBEntryMap *)smap->pSMime->appData)->index;
  801. PR_fprintf(info->out, "-->(s/mime %d)n", ref);
  802.     } else {
  803. PR_fprintf(info->out, "-->(MISSING S/MIME ENTRY)n");
  804.     }
  805. }
  806. PR_fprintf(info->out, "nn");
  807.     }
  808.     for (elem = PR_LIST_HEAD(&dbArray->nicknames.link);
  809.          elem != &dbArray->nicknames.link; elem = PR_NEXT_LINK(elem)) {
  810. node = LISTNODE_CAST(elem);
  811. map = (certDBEntryMap *)node->appData;
  812. dumpNicknameEntry((certDBEntryNickname*)&node->entry, map->index, 
  813.                   info->out);
  814. if (map_handle_is_ok(info, map->pSubject, -1)) {
  815.     ref = ((certDBEntryMap *)map->pSubject->appData)->index;
  816.     PR_fprintf(info->out, "-->(subject %d)nnn", ref);
  817. } else {
  818.     PR_fprintf(info->out, "-->(MISSING SUBJECT ENTRY)nnn");
  819. }
  820.     }
  821.     for (elem = PR_LIST_HEAD(&dbArray->smime.link);
  822.          elem != &dbArray->smime.link; elem = PR_NEXT_LINK(elem)) {
  823. node = LISTNODE_CAST(elem);
  824. map = (certDBEntryMap *)node->appData;
  825. dumpSMimeEntry((certDBEntrySMime*)&node->entry, map->index, info->out);
  826. if (map_handle_is_ok(info, map->pSubject, -1)) {
  827.     ref = ((certDBEntryMap *)map->pSubject->appData)->index;
  828.     PR_fprintf(info->out, "-->(subject %d)nnn", ref);
  829. } else {
  830.     PR_fprintf(info->out, "-->(MISSING SUBJECT ENTRY)nnn");
  831. }
  832.     }
  833.     PR_fprintf(info->out, "nn");
  834. }
  836. char *errResult[] = {
  837.     "Certificate entries that had no subject entry.", 
  838.     "Certificate entries that had no key in their subject entry.", 
  839.     "Subject entries that had no nickname or email address.",
  840.     "Redundant nicknames (subjects with the same nickname).",
  841.     "Subject entries that had no nickname entry.",
  842.     "Redundant email addresses (subjects with the same email address).",
  843.     "Subject entries that had no S/MIME entry.",
  844.     "Nickname entries that had no subject entry.", 
  845.     "S/MIME entries that had no subject entry.",
  846. };
  848. int
  849. fillDBEntryArray(CERTCertDBHandle *handle, certDBEntryType type, 
  850.                  certDBEntryListNode *list)
  851. {
  852.     PRCList *elem;
  853.     certDBEntryListNode *node;
  854.     certDBEntryMap *mnode;
  855.     certDBSubjectEntryMap *smnode;
  856.     PRArenaPool *arena;
  857.     int count = 0;
  858.     /* Initialize a dummy entry in the list.  The list head will be the
  859.      * next element, so this element is skipped by for loops.
  860.      */
  861.     PR_INIT_CLIST((PRCList *)list);
  862.     /* Collect all of the cert db entries for this type into a list. */
  863.     SEC_TraverseDBEntries(handle, type, SEC_GetCertDBEntryList, 
  864.                           (PRCList *)list);
  865.     for (elem = PR_LIST_HEAD(&list->link); 
  866.          elem != &list->link; elem = PR_NEXT_LINK(elem)) {
  867. /* Iterate over the entries and ... */
  868. node = (certDBEntryListNode *)elem;
  869. if (type != certDBEntryTypeSubject) {
  870.     arena = PORT_NewArena(sizeof(*mnode));
  871.     mnode = (certDBEntryMap *)PORT_ArenaZAlloc(arena, sizeof(*mnode));
  872.     mnode->arena = arena;
  873.     /* ... assign a unique index number to each node, and ... */
  874.     mnode->index = count;
  875.     /* ... set the map pointer for the node. */
  876.     node->appData = (void *)mnode;
  877. } else {
  878.     /* allocate some room for the cert pointers also */
  879.     arena = PORT_NewArena(sizeof(*smnode) + 20*sizeof(void *));
  880.     smnode = (certDBSubjectEntryMap *)
  881.               PORT_ArenaZAlloc(arena, sizeof(*smnode));
  882.     smnode->arena = arena;
  883.     smnode->index = count;
  884.     node->appData = (void *)smnode;
  885. }
  886. count++;
  887.     }
  888.     return count;
  889. }
  891. void
  892. freeDBEntryList(PRCList *list)
  893. {
  894.     PRCList *next, *elem;
  895.     certDBEntryListNode *node;
  896.     certDBEntryMap *map;
  898.     for (elem = PR_LIST_HEAD(list); elem != list;) { 
  899. next = PR_NEXT_LINK(elem);
  900. node = (certDBEntryListNode *)elem;
  901. map = (certDBEntryMap *)node->appData;
  902. PR_REMOVE_LINK(&node->link);
  903. PORT_FreeArena(map->arena, PR_TRUE);
  904. PORT_FreeArena(node->entry.common.arena, PR_TRUE);
  905. elem = next;
  906.     }
  907. }
  909. void
  910. DBCK_DebugDB(CERTCertDBHandle *handle, PRFileDesc *out, PRFileDesc *mailfile)
  911. {
  912.     int i, nCertsFound, nSubjFound, nErr;
  913.     int nCerts, nSubjects, nSubjCerts, nNicknames, nSMime;
  914.     PRCList *elem;
  915.     char c;
  916.     dbDebugInfo info;
  917.     certDBArray dbArray;
  919.     PORT_Memset(&dbArray, 0, sizeof(dbArray));
  920.     PORT_Memset(&info, 0, sizeof(info));
  921.     info.verbose = (out == NULL) ? PR_FALSE : PR_TRUE ;
  922.     info.dograph = (mailfile == NULL) ? PR_FALSE : PR_TRUE ;
  923.     info.out = (out) ? out : PR_STDOUT;
  924.     info.graphfile = mailfile;
  926.     /*  Fill the array structure with cert/subject/nickname/smime entries.  */
  927.     dbArray.numCerts = fillDBEntryArray(handle, certDBEntryTypeCert, 
  928.                                         &dbArray.certs);
  929.     dbArray.numSubjects = fillDBEntryArray(handle, certDBEntryTypeSubject, 
  930.                                            &dbArray.subjects);
  931.     dbArray.numNicknames = fillDBEntryArray(handle, certDBEntryTypeNickname, 
  932.                                             &dbArray.nicknames);
  933.     dbArray.numSMime = fillDBEntryArray(handle, certDBEntryTypeSMimeProfile, 
  934.                                         &dbArray.smime);
  936.     /*  Compute the map between the database entries.  */
  937.     mapSubjectEntries(&dbArray);
  938.     mapCertEntries(&dbArray);
  939.     computeDBGraph(&dbArray, &info);
  941.     /*  Store the totals for later reference.  */
  942.     nCerts = dbArray.numCerts;
  943.     nSubjects = dbArray.numSubjects;
  944.     nNicknames = dbArray.numNicknames;
  945.     nSMime = dbArray.numSMime;
  946.     nSubjCerts = 0;
  947.     for (elem = PR_LIST_HEAD(&dbArray.subjects.link);
  948.          elem != &dbArray.subjects.link; elem = PR_NEXT_LINK(elem)) {
  949. certDBSubjectEntryMap *smap;
  950. smap = (certDBSubjectEntryMap *)LISTNODE_CAST(elem)->appData;
  951. nSubjCerts += smap->numCerts;
  952.     }
  954.     if (info.verbose) {
  955. /*  Dump the database contents.  */
  956. verboseOutput(&dbArray, &info);
  957.     }
  959.     freeDBEntryList(&dbArray.certs.link);
  960.     freeDBEntryList(&dbArray.subjects.link);
  961.     freeDBEntryList(&dbArray.nicknames.link);
  962.     freeDBEntryList(&dbArray.smime.link);
  964.     PR_fprintf(info.out, "n");
  965.     PR_fprintf(info.out, "Database statistics:n");
  966.     PR_fprintf(info.out, "N0: Found %4d Certificate entries.n", 
  967.                           nCerts);
  968.     PR_fprintf(info.out, "N1: Found %4d Subject entries (unique DN's).n", 
  969.                           nSubjects);
  970.     PR_fprintf(info.out, "N2: Found %4d Cert keys within Subject entries.n", 
  971.                           nSubjCerts);
  972.     PR_fprintf(info.out, "N3: Found %4d Nickname entries.n", 
  973.                           nNicknames);
  974.     PR_fprintf(info.out, "N4: Found %4d S/MIME entries.n", 
  975.                           nSMime);
  976.     PR_fprintf(info.out, "n");
  978.     nErr = 0;
  979.     for (i=0; i<sizeof(errResult)/sizeof(char*); i++) {
  980. PR_fprintf(info.out, "E%d: Found %4d %sn", 
  981.            i, info.dbErrors[i], errResult[i]);
  982. nErr += info.dbErrors[i];
  983.     }
  984.     PR_fprintf(info.out, "--------------n    Found %4d errors in database.n", 
  985.                nErr);
  987.     PR_fprintf(info.out, "nCertificates:n");
  988.     PR_fprintf(info.out, "N0 == N2 + E%d + E%dn", NoSubjectForCert, 
  989.                                                    SubjectHasNoKeyForCert);
  990.     nCertsFound = nSubjCerts +
  991.                   info.dbErrors[NoSubjectForCert] +
  992.                   info.dbErrors[SubjectHasNoKeyForCert];
  993.     c = (nCertsFound == nCerts) ? '=' : '!';
  994.     PR_fprintf(info.out, "%d %c= %d + %d + %dn", nCerts, c, nSubjCerts, 
  995.                   info.dbErrors[NoSubjectForCert],
  996.                   info.dbErrors[SubjectHasNoKeyForCert]);
  997.     PR_fprintf(info.out, "nSubjects:n");
  998.     PR_fprintf(info.out, "N1 == N3 + N4 + E%d + E%d + E%d + E%d + E%d - E%d - E%dn",
  999.                   NoNicknameOrSMimeForSubject, WrongNicknameForSubject,
  1000.   NoNicknameEntry, WrongSMimeForSubject, NoSMimeEntry,
  1001.   NoSubjectForNickname, NoSubjectForSMime);
  1002.     PR_fprintf(info.out, "      - #(subjects with both nickname and S/MIME entries)n");
  1003.     nSubjFound = nNicknames + nSMime + 
  1004.                  info.dbErrors[NoNicknameOrSMimeForSubject] +
  1005.  info.dbErrors[WrongNicknameForSubject] +
  1006.  info.dbErrors[NoNicknameEntry] +
  1007.  info.dbErrors[WrongSMimeForSubject] +
  1008.                  info.dbErrors[NoSMimeEntry] -
  1009.  info.dbErrors[NoSubjectForNickname] -
  1010.  info.dbErrors[NoSubjectForSMime] -
  1011.  info.dbErrors[NicknameAndSMimeEntry];
  1012.     c = (nSubjFound == nSubjects) ? '=' : '!';
  1013.     PR_fprintf(info.out, "%d %c= %d + %d + %d + %d + %d + %d + %d - %d - %d - %dn",
  1014.                   nSubjects, c, nNicknames, nSMime,
  1015.                   info.dbErrors[NoNicknameOrSMimeForSubject],
  1016.   info.dbErrors[WrongNicknameForSubject],
  1017.   info.dbErrors[NoNicknameEntry],
  1018.   info.dbErrors[WrongSMimeForSubject],
  1019.                   info.dbErrors[NoSMimeEntry],
  1020.   info.dbErrors[NoSubjectForNickname],
  1021.   info.dbErrors[NoSubjectForSMime],
  1022.   info.dbErrors[NicknameAndSMimeEntry]);
  1023.     PR_fprintf(info.out, "n");
  1024. }
  1026. #ifdef DORECOVER
  1027. enum {
  1028.     dbInvalidCert = 0,
  1029.     dbNoSMimeProfile,
  1030.     dbOlderCert,
  1031.     dbBadCertificate,
  1032.     dbCertNotWrittenToDB
  1033. };
  1035. typedef struct dbRestoreInfoStr
  1036. {
  1037.     CERTCertDBHandle *handle;
  1038.     PRBool verbose;
  1039.     PRFileDesc *out;
  1040.     int nCerts;
  1041.     int nOldCerts;
  1042.     int dbErrors[5];
  1043.     PRBool removeType[3];
  1044.     PRBool promptUser[3];
  1045. } dbRestoreInfo;
  1047. char *
  1048. IsEmailCert(CERTCertificate *cert)
  1049. {
  1050.     char *email, *tmp1, *tmp2;
  1051.     PRBool isCA;
  1052.     int len;
  1054.     if (!cert->subjectName) {
  1055. return NULL;
  1056.     }
  1058.     tmp1 = PORT_Strstr(cert->subjectName, "E=");
  1059.     tmp2 = PORT_Strstr(cert->subjectName, "MAIL=");
  1060.     /* XXX Nelson has cert for KTrilli which does not have either
  1061.      * of above but is email cert (has cert->emailAddr). 
  1062.      */
  1063.     if (!tmp1 && !tmp2 && !cert->emailAddr) {
  1064. return NULL;
  1065.     }
  1067.     /*  Server or CA cert, not personal email.  */
  1068.     isCA = CERT_IsCACert(cert, NULL);
  1069.     if (isCA)
  1070. return NULL;
  1072.     /*  XXX CERT_IsCACert advertises checking the key usage ext.,
  1073. but doesn't appear to. */
  1074.     /*  Check the key usage extension.  */
  1075.     if (cert->keyUsagePresent) {
  1076. /*  Must at least be able to sign or encrypt (not neccesarily
  1077.  *  both if it is one of a dual cert).  
  1078.  */
  1079. if (!((cert->rawKeyUsage & KU_DIGITAL_SIGNATURE) || 
  1080.               (cert->rawKeyUsage & KU_KEY_ENCIPHERMENT)))
  1081.     return NULL;
  1083. /*  CA cert, not personal email.  */
  1084. if (cert->rawKeyUsage & (KU_KEY_CERT_SIGN | KU_CRL_SIGN))
  1085.     return NULL;
  1086.     }
  1088.     if (cert->emailAddr) {
  1089. email = PORT_Strdup(cert->emailAddr);
  1090.     } else {
  1091. if (tmp1)
  1092.     tmp1 += 2; /* "E="  */
  1093. else
  1094.     tmp1 = tmp2 + 5; /* "MAIL=" */
  1095. len = strcspn(tmp1, ", ");
  1096. email = (char*)PORT_Alloc(len+1);
  1097. PORT_Strncpy(email, tmp1, len);
  1098. email[len] = '';
  1099.     }
  1101.     return email;
  1102. }
  1104. SECStatus
  1105. deleteit(CERTCertificate *cert, void *arg)
  1106. {
  1107.     return SEC_DeletePermCertificate(cert);
  1108. }
  1110. /*  Different than DeleteCertificate - has the added bonus of removing
  1111.  *  all certs with the same DN.  
  1112.  */
  1113. SECStatus
  1114. deleteAllEntriesForCert(CERTCertDBHandle *handle, CERTCertificate *cert,
  1115.                         PRFileDesc *outfile)
  1116. {
  1117. #if 0
  1118.     certDBEntrySubject *subjectEntry;
  1119.     certDBEntryNickname *nicknameEntry;
  1120.     certDBEntrySMime *smimeEntry;
  1121.     int i;
  1122. #endif
  1124.     if (outfile) {
  1125. PR_fprintf(outfile, "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$nn");
  1126. PR_fprintf(outfile, "Deleting redundant certificate:n");
  1127. dumpCertificate(cert, -1, outfile);
  1128.     }
  1130.     CERT_TraverseCertsForSubject(handle, cert->subjectList, deleteit, NULL);
  1131. #if 0
  1132.     CERT_LockDB(handle);
  1133.     subjectEntry = ReadDBSubjectEntry(handle, &cert->derSubject);
  1134.     /*  It had better be there, or created a bad db.  */
  1135.     PORT_Assert(subjectEntry);
  1136.     for (i=0; i<subjectEntry->ncerts; i++) {
  1137. DeleteDBCertEntry(handle, &subjectEntry->certKeys[i]);
  1138.     }
  1139.     DeleteDBSubjectEntry(handle, &cert->derSubject);
  1140.     if (subjectEntry->emailAddr) {
  1141. smimeEntry = ReadDBSMimeEntry(handle, subjectEntry->emailAddr);
  1142. if (smimeEntry) {
  1143.     if (SECITEM_ItemsAreEqual(&subjectEntry->derSubject,
  1144.                               &smimeEntry->subjectName))
  1145. /*  Only delete it if it's for this subject!  */
  1146. DeleteDBSMimeEntry(handle, subjectEntry->emailAddr);
  1147.     SEC_DestroyDBEntry((certDBEntry*)smimeEntry);
  1148. }
  1149.     }
  1150.     if (subjectEntry->nickname) {
  1151. nicknameEntry = ReadDBNicknameEntry(handle, subjectEntry->nickname);
  1152. if (nicknameEntry) {
  1153.     if (SECITEM_ItemsAreEqual(&subjectEntry->derSubject,
  1154.                               &nicknameEntry->subjectName))
  1155. /*  Only delete it if it's for this subject!  */
  1156. DeleteDBNicknameEntry(handle, subjectEntry->nickname);
  1157.     SEC_DestroyDBEntry((certDBEntry*)nicknameEntry);
  1158. }
  1159.     }
  1160.     SEC_DestroyDBEntry((certDBEntry*)subjectEntry);
  1161.     CERT_UnlockDB(handle);
  1162. #endif
  1163.     return SECSuccess;
  1164. }
  1166. void
  1167. getCertsToDelete(char *numlist, int len, int *certNums, int nCerts)
  1168. {
  1169.     int j, num;
  1170.     char *numstr, *numend, *end;
  1172.     numstr = numlist;
  1173.     end = numstr + len - 1;
  1174.     while (numstr != end) {
  1175. numend = strpbrk(numstr, ", n");
  1176. *numend = '';
  1177. if (PORT_Strlen(numstr) == 0)
  1178.     return;
  1179. num = PORT_Atoi(numstr);
  1180. if (numstr == numlist)
  1181.     certNums[0] = num;
  1182. for (j=1; j<nCerts+1; j++) {
  1183.     if (num == certNums[j]) {
  1184. certNums[j] = -1;
  1185. break;
  1186.     }
  1187. }
  1188. if (numend == end)
  1189.     break;
  1190. numstr = strpbrk(numend+1, "0123456789");
  1191.     }
  1192. }
  1194. PRBool
  1195. userSaysDeleteCert(CERTCertificate **certs, int nCerts,
  1196.                    int errtype, dbRestoreInfo *info, int *certNums)
  1197. {
  1198.     char response[32];
  1199.     int32 nb;
  1200.     int i;
  1201.     /*  User wants to remove cert without prompting.  */
  1202.     if (info->promptUser[errtype] == PR_FALSE)
  1203. return (info->removeType[errtype]);
  1204.     switch (errtype) {
  1205.     case dbInvalidCert:
  1206. PR_fprintf(PR_STDOUT, "********  Expired ********n");
  1207. PR_fprintf(PR_STDOUT, "Cert has expired.nn");
  1208. dumpCertificate(certs[0], -1, PR_STDOUT);
  1209. PR_fprintf(PR_STDOUT,
  1210.            "Keep it? (y/n - this one, Y/N - all expired certs) [n] ");
  1211. break;
  1212.     case dbNoSMimeProfile:
  1213. PR_fprintf(PR_STDOUT, "********  No Profile ********n");
  1214. PR_fprintf(PR_STDOUT, "S/MIME cert has no profile.nn");
  1215. dumpCertificate(certs[0], -1, PR_STDOUT);
  1216. PR_fprintf(PR_STDOUT,
  1217.       "Keep it? (y/n - this one, Y/N - all S/MIME w/o profile) [n] ");
  1218. break;
  1219.     case dbOlderCert:
  1220. PR_fprintf(PR_STDOUT, "*******  Redundant nickname/email *******nn");
  1221. PR_fprintf(PR_STDOUT, "These certs have the same nickname/email:n");
  1222. for (i=0; i<nCerts; i++)
  1223.     dumpCertificate(certs[i], i, PR_STDOUT);
  1224. PR_fprintf(PR_STDOUT, 
  1225. "Enter the certs you would like to keep from those listed above.n");
  1226. PR_fprintf(PR_STDOUT, 
  1227. "Use a comma-separated list of the cert numbers (ex. 0, 8, 12).n");
  1228. PR_fprintf(PR_STDOUT, 
  1229. "The first cert in the list will be the primary certn");
  1230. PR_fprintf(PR_STDOUT, 
  1231. " accessed by the nickname/email handle.n");
  1232. PR_fprintf(PR_STDOUT, 
  1233. "List cert numbers to keep here, or hit entern");
  1234. PR_fprintf(PR_STDOUT, 
  1235. " to always keep only the newest cert:  ");
  1236. break;
  1237.     default:
  1238.     }
  1239.     nb = PR_Read(PR_STDIN, response, sizeof(response));
  1240.     PR_fprintf(PR_STDOUT, "nn");
  1241.     if (errtype == dbOlderCert) {
  1242. if (!isdigit(response[0])) {
  1243.     info->promptUser[errtype] = PR_FALSE;
  1244.     info->removeType[errtype] = PR_TRUE;
  1245.     return PR_TRUE;
  1246. }
  1247. getCertsToDelete(response, nb, certNums, nCerts);
  1248. return PR_TRUE;
  1249.     }
  1250.     /*  User doesn't want to be prompted for this type anymore.  */
  1251.     if (response[0] == 'Y') {
  1252. info->promptUser[errtype] = PR_FALSE;
  1253. info->removeType[errtype] = PR_FALSE;
  1254. return PR_FALSE;
  1255.     } else if (response[0] == 'N') {
  1256. info->promptUser[errtype] = PR_FALSE;
  1257. info->removeType[errtype] = PR_TRUE;
  1258. return PR_TRUE;
  1259.     }
  1260.     return (response[0] != 'y') ? PR_TRUE : PR_FALSE;
  1261. }
  1263. SECStatus
  1264. addCertToDB(certDBEntryCert *certEntry, dbRestoreInfo *info, 
  1265.             CERTCertDBHandle *oldhandle)
  1266. {
  1267.     SECStatus rv = SECSuccess;
  1268.     PRBool allowOverride;
  1269.     PRBool userCert;
  1270.     SECCertTimeValidity validity;
  1271.     CERTCertificate *oldCert = NULL;
  1272.     CERTCertificate *dbCert = NULL;
  1273.     CERTCertificate *newCert = NULL;
  1274.     CERTCertTrust *trust;
  1275.     certDBEntrySMime *smimeEntry = NULL;
  1276.     char *email = NULL;
  1277.     char *nickname = NULL;
  1278.     int nCertsForSubject = 1;
  1280.     oldCert = CERT_DecodeDERCertificate(&certEntry->derCert, PR_FALSE,
  1281.                                         certEntry->nickname);
  1282.     if (!oldCert) {
  1283. info->dbErrors[dbBadCertificate]++;
  1284. SEC_DestroyDBEntry((certDBEntry*)certEntry);
  1285. return SECSuccess;
  1286.     }
  1288.     oldCert->dbEntry = certEntry;
  1289.     oldCert->trust = &certEntry->trust;
  1290.     oldCert->dbhandle = oldhandle;
  1292.     trust = oldCert->trust;
  1294.     info->nOldCerts++;
  1296.     if (info->verbose)
  1297. PR_fprintf(info->out, "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%nn");
  1299.     if (oldCert->nickname)
  1300. nickname = PORT_Strdup(oldCert->nickname);
  1302.     /*  Always keep user certs.  Skip ahead.  */
  1303.     /*  XXX if someone sends themselves a signed message, it is possible
  1304. for their cert to be imported as an "other" cert, not a user cert.
  1305. this mucks with smime entries...  */
  1306.     userCert = (SEC_GET_TRUST_FLAGS(trust, trustSSL) & CERTDB_USER) ||
  1307.                (SEC_GET_TRUST_FLAGS(trust, trustEmail) & CERTDB_USER) ||
  1308.                (SEC_GET_TRUST_FLAGS(trust, trustObjectSigning) & CERTDB_USER);
  1309.     if (userCert)
  1310. goto createcert;
  1312.     /*  If user chooses so, ignore expired certificates.  */
  1313.     allowOverride = (PRBool)((oldCert->keyUsage == certUsageSSLServer) ||
  1314.                          (oldCert->keyUsage == certUsageSSLServerWithStepUp));
  1315.     validity = CERT_CheckCertValidTimes(oldCert, PR_Now(), allowOverride);
  1316.     /*  If cert expired and user wants to delete it, ignore it. */
  1317.     if ((validity != secCertTimeValid) && 
  1318.  userSaysDeleteCert(&oldCert, 1, dbInvalidCert, info, 0)) {
  1319. info->dbErrors[dbInvalidCert]++;
  1320. if (info->verbose) {
  1321.     PR_fprintf(info->out, "Deleting expired certificate:n");
  1322.     dumpCertificate(oldCert, -1, info->out);
  1323. }
  1324. goto cleanup;
  1325.     }
  1327.     /*  New database will already have default certs, don't attempt
  1328. to overwrite them.  */
  1329.     dbCert = CERT_FindCertByDERCert(info->handle, &oldCert->derCert);
  1330.     if (dbCert) {
  1331. info->nCerts++;
  1332. if (info->verbose) {
  1333.     PR_fprintf(info->out, "Added certificate to database:n");
  1334.     dumpCertificate(oldCert, -1, info->out);
  1335. }
  1336. goto cleanup;
  1337.     }
  1338.     
  1339.     /*  Determine if cert is S/MIME and get its email if so.  */
  1340.     email = IsEmailCert(oldCert);
  1342.     /*
  1343. XXX  Just create empty profiles?
  1344.     if (email) {
  1345. SECItem *profile = CERT_FindSMimeProfile(oldCert);
  1346. if (!profile &&
  1347.     userSaysDeleteCert(&oldCert, 1, dbNoSMimeProfile, info, 0)) {
  1348.     info->dbErrors[dbNoSMimeProfile]++;
  1349.     if (info->verbose) {
  1350. PR_fprintf(info->out, 
  1351.            "Deleted cert missing S/MIME profile.n");
  1352. dumpCertificate(oldCert, -1, info->out);
  1353.     }
  1354.     goto cleanup;
  1355. } else {
  1356.     SECITEM_FreeItem(profile);
  1357. }
  1358.     }
  1359.     */
  1361. createcert:
  1363.     /*  Sometimes happens... */
  1364.     if (!nickname && userCert)
  1365. nickname = PORT_Strdup(oldCert->subjectName);
  1367.     /*  Create a new certificate, copy of the old one.  */
  1368.     newCert = CERT_NewTempCertificate(info->handle, &oldCert->derCert, 
  1369.                                       nickname, PR_FALSE, PR_TRUE);
  1370.     if (!newCert) {
  1371. PR_fprintf(PR_STDERR, "Unable to create new certificate.n");
  1372. dumpCertificate(oldCert, -1, PR_STDERR);
  1373. info->dbErrors[dbBadCertificate]++;
  1374. goto cleanup;
  1375.     }
  1377.     /*  Add the cert to the new database.  */
  1378.     rv = CERT_AddTempCertToPerm(newCert, nickname, oldCert->trust);
  1379.     if (rv) {
  1380. PR_fprintf(PR_STDERR, "Failed to write temp cert to perm database.n");
  1381. dumpCertificate(oldCert, -1, PR_STDERR);
  1382. info->dbErrors[dbCertNotWrittenToDB]++;
  1383. goto cleanup;
  1384.     }
  1386.     if (info->verbose) {
  1387. PR_fprintf(info->out, "Added certificate to database:n");
  1388. dumpCertificate(oldCert, -1, info->out);
  1389.     }
  1391.     /*  If the cert is an S/MIME cert, and the first with it's subject,
  1392.      *  modify the subject entry to include the email address,
  1393.      *  CERT_AddTempCertToPerm does not do email addresses and S/MIME entries.
  1394.      */
  1395.     if (smimeEntry) { /*&& !userCert && nCertsForSubject == 1) { */
  1396. #if 0
  1397. UpdateSubjectWithEmailAddr(newCert, email);
  1398. #endif
  1399. SECItem emailProfile, profileTime;
  1400. rv = CERT_FindFullSMimeProfile(oldCert, &emailProfile, &profileTime);
  1401. /*  calls UpdateSubjectWithEmailAddr  */
  1402. if (rv == SECSuccess)
  1403.     rv = CERT_SaveSMimeProfile(newCert, &emailProfile, &profileTime);
  1404.     }
  1406.     info->nCerts++;
  1408. cleanup:
  1410.     if (nickname)
  1411. PORT_Free(nickname);
  1412.     if (email)
  1413. PORT_Free(email);
  1414.     if (oldCert)
  1415. CERT_DestroyCertificate(oldCert);
  1416.     if (dbCert)
  1417. CERT_DestroyCertificate(dbCert);
  1418.     if (newCert)
  1419. CERT_DestroyCertificate(newCert);
  1420.     if (smimeEntry)
  1421. SEC_DestroyDBEntry((certDBEntry*)smimeEntry);
  1422.     return SECSuccess;
  1423. }
  1425. #if 0
  1426. SECStatus
  1427. copyDBEntry(SECItem *data, SECItem *key, certDBEntryType type, void *pdata)
  1428. {
  1429.     SECStatus rv;
  1430.     CERTCertDBHandle *newdb = (CERTCertDBHandle *)pdata;
  1431.     certDBEntryCommon common;
  1432.     SECItem dbkey;
  1434.     common.type = type;
  1435.     common.version = CERT_DB_FILE_VERSION;
  1436.     common.flags = data->data[2];
  1437.     common.arena = NULL;
  1439.     dbkey.len = key->len + SEC_DB_KEY_HEADER_LEN;
  1440.     dbkey.data = (unsigned char *)PORT_Alloc(dbkey.len*sizeof(unsigned char));
  1441.     PORT_Memcpy(&dbkey.data[SEC_DB_KEY_HEADER_LEN], key->data, key->len);
  1442.     dbkey.data[0] = type;
  1444.     rv = WriteDBEntry(newdb, &common, &dbkey, data);
  1446.     PORT_Free(dbkey.data);
  1447.     return rv;
  1448. }
  1449. #endif
  1451. int
  1452. certIsOlder(CERTCertificate **cert1, CERTCertificate** cert2)
  1453. {
  1454.     return !CERT_IsNewer(*cert1, *cert2);
  1455. }
  1457. int
  1458. findNewestSubjectForEmail(CERTCertDBHandle *handle, int subjectNum,
  1459.                           certDBArray *dbArray, dbRestoreInfo *info,
  1460.                           int *subjectWithSMime, int *smimeForSubject)
  1461. {
  1462.     int newestSubject;
  1463.     int subjectsForEmail[50];
  1464.     int i, j, ns, sNum;
  1465.     certDBEntryListNode *subjects = &dbArray->subjects;
  1466.     certDBEntryListNode *smime = &dbArray->smime;
  1467.     certDBEntrySubject *subjectEntry1, *subjectEntry2;
  1468.     certDBEntrySMime *smimeEntry;
  1469.     CERTCertificate **certs;
  1470.     CERTCertificate *cert;
  1471.     CERTCertTrust *trust;
  1472.     PRBool userCert;
  1473.     int *certNums;
  1475.     ns = 0;
  1476.     subjectEntry1 = (certDBEntrySubject*)&subjects.entries[subjectNum];
  1477.     subjectsForEmail[ns++] = subjectNum;
  1479.     *subjectWithSMime = -1;
  1480.     *smimeForSubject = -1;
  1481.     newestSubject = subjectNum;
  1483.     cert = CERT_FindCertByKey(handle, &subjectEntry1->certKeys[0]);
  1484.     if (cert) {
  1485. trust = cert->trust;
  1486. userCert = (SEC_GET_TRUST_FLAGS(trust, trustSSL) & CERTDB_USER) ||
  1487.           (SEC_GET_TRUST_FLAGS(trust, trustEmail) & CERTDB_USER) ||
  1488.          (SEC_GET_TRUST_FLAGS(trust, trustObjectSigning) & CERTDB_USER);
  1489. CERT_DestroyCertificate(cert);
  1490.     }
  1492.     /*  Loop over the remaining subjects.  */
  1493.     for (i=subjectNum+1; i<subjects.numEntries; i++) {
  1494. subjectEntry2 = (certDBEntrySubject*)&subjects.entries[i];
  1495. if (!subjectEntry2)
  1496.     continue;
  1497. if (subjectEntry2->emailAddr && 
  1498.      PORT_Strcmp(subjectEntry1->emailAddr, 
  1499.                  subjectEntry2->emailAddr) == 0) {
  1500.     /*  Found a subject using the same email address.  */
  1501.     subjectsForEmail[ns++] = i;
  1502. }
  1503.     }
  1505.     /*  Find the S/MIME entry for this email address.  */
  1506.     for (i=0; i<smime.numEntries; i++) {
  1507. smimeEntry = (certDBEntrySMime*)&smime.entries[i];
  1508. if (smimeEntry->common.arena == NULL)
  1509.     continue;
  1510. if (PORT_Strcmp(subjectEntry1->emailAddr, smimeEntry->emailAddr) == 0) {
  1511.     /*  Find which of the subjects uses this S/MIME entry.  */
  1512.     for (j=0; j<ns && *subjectWithSMime < 0; j++) {
  1513. sNum = subjectsForEmail[j];
  1514. subjectEntry2 = (certDBEntrySubject*)&subjects.entries[sNum];
  1515. if (SECITEM_ItemsAreEqual(&smimeEntry->subjectName,
  1516.                           &subjectEntry2->derSubject)) {
  1517.     /*  Found the subject corresponding to the S/MIME entry. */
  1518.     *subjectWithSMime = sNum;
  1519.     *smimeForSubject = i;
  1520. }
  1521.     }
  1522.     SEC_DestroyDBEntry((certDBEntry*)smimeEntry);
  1523.     PORT_Memset(smimeEntry, 0, sizeof(certDBEntry));
  1524.     break;
  1525. }
  1526.     }
  1528.     if (ns <= 1)
  1529. return subjectNum;
  1531.     if (userCert)
  1532. return *subjectWithSMime;
  1534.     /*  Now find which of the subjects has the newest cert.  */
  1535.     certs = (CERTCertificate**)PORT_Alloc(ns*sizeof(CERTCertificate*));
  1536.     certNums = (int*)PORT_Alloc((ns+1)*sizeof(int));
  1537.     certNums[0] = 0;
  1538.     for (i=0; i<ns; i++) {
  1539. sNum = subjectsForEmail[i];
  1540. subjectEntry1 = (certDBEntrySubject*)&subjects.entries[sNum];
  1541. certs[i] = CERT_FindCertByKey(handle, &subjectEntry1->certKeys[0]);
  1542. certNums[i+1] = i;
  1543.     }
  1544.     /*  Sort the array by validity.  */
  1545.     qsort(certs, ns, sizeof(CERTCertificate*), 
  1546.           (int (*)(const void *, const void *))certIsOlder);
  1547.     newestSubject = -1;
  1548.     for (i=0; i<ns; i++) {
  1549. sNum = subjectsForEmail[i];
  1550. subjectEntry1 = (certDBEntrySubject*)&subjects.entries[sNum];
  1551. if (SECITEM_ItemsAreEqual(&subjectEntry1->derSubject,
  1552.                           &certs[0]->derSubject))
  1553.     newestSubject = sNum;
  1554. else
  1555.     SEC_DestroyDBEntry((certDBEntry*)subjectEntry1);
  1556.     }
  1557.     if (info && userSaysDeleteCert(certs, ns, dbOlderCert, info, certNums)) {
  1558. for (i=1; i<ns+1; i++) {
  1559.     if (certNums[i] >= 0 && certNums[i] != certNums[0]) {
  1560. deleteAllEntriesForCert(handle, certs[certNums[i]], info->out);
  1561. info->dbErrors[dbOlderCert]++;
  1562.     }
  1563. }
  1564.     }
  1565.     CERT_DestroyCertArray(certs, ns);
  1566.     return newestSubject;
  1567. }
  1569. CERTCertDBHandle *
  1570. DBCK_ReconstructDBFromCerts(CERTCertDBHandle *oldhandle, char *newdbname,
  1571.                             PRFileDesc *outfile, PRBool removeExpired,
  1572.                             PRBool requireProfile, PRBool singleEntry,
  1573.                             PRBool promptUser)
  1574. {
  1575.     SECStatus rv;
  1576.     dbRestoreInfo info;
  1577.     certDBEntryContentVersion *oldContentVersion;
  1578.     certDBArray dbArray;
  1579.     int i;
  1581.     PORT_Memset(&dbArray, 0, sizeof(dbArray));
  1582.     PORT_Memset(&info, 0, sizeof(info));
  1583.     info.verbose = (outfile) ? PR_TRUE : PR_FALSE;
  1584.     info.out = (outfile) ? outfile : PR_STDOUT;
  1585.     info.removeType[dbInvalidCert] = removeExpired;
  1586.     info.removeType[dbNoSMimeProfile] = requireProfile;
  1587.     info.removeType[dbOlderCert] = singleEntry;
  1588.     info.promptUser[dbInvalidCert]  = promptUser;
  1589.     info.promptUser[dbNoSMimeProfile]  = promptUser;
  1590.     info.promptUser[dbOlderCert]  = promptUser;
  1592.     /*  Allocate a handle to fill with CERT_OpenCertDB below.  */
  1593.     info.handle = (CERTCertDBHandle *)PORT_ZAlloc(sizeof(CERTCertDBHandle));
  1594.     if (!info.handle) {
  1595. fprintf(stderr, "unable to get database handle");
  1596. return NULL;
  1597.     }
  1599.     /*  Create a certdb with the most recent set of roots.  */
  1600.     rv = CERT_OpenCertDBFilename(info.handle, newdbname, PR_FALSE);
  1602.     if (rv) {
  1603. fprintf(stderr, "could not open certificate database");
  1604. goto loser;
  1605.     }
  1607.     /*  Create certificate, subject, nickname, and email records.
  1608.      *  mcom_db seems to have a sequential access bug.  Though reads and writes
  1609.      *  should be allowed during traversal, they seem to screw up the sequence.
  1610.      *  So, stuff all the cert entries into an array, and loop over the array
  1611.      *  doing read/writes in the db.
  1612.      */
  1613.     fillDBEntryArray(oldhandle, certDBEntryTypeCert, &dbArray.certs);
  1614.     for (elem = PR_LIST_HEAD(&dbArray->certs.link);
  1615.          elem != &dbArray->certs.link; elem = PR_NEXT_LINK(elem)) {
  1616. node = LISTNODE_CAST(elem);
  1617. addCertToDB((certDBEntryCert*)&node->entry, &info, oldhandle);
  1618. /* entries get destroyed in addCertToDB */
  1619.     }
  1620. #if 0
  1621.     rv = SEC_TraverseDBEntries(oldhandle, certDBEntryTypeSMimeProfile, 
  1622.                                copyDBEntry, info.handle);
  1623. #endif
  1625.     /*  Fix up the pointers between (nickname|S/MIME) --> (subject).
  1626.      *  Create S/MIME entries for S/MIME certs.
  1627.      *  Have the S/MIME entry point to the last-expiring cert using
  1628.      *  an email address.
  1629.      */
  1630. #if 0
  1631.     CERT_RedoHandlesForSubjects(info.handle, singleEntry, &info);
  1632. #endif
  1634.     freeDBEntryList(&dbArray.certs.link);
  1636.     /*  Copy over the version record.  */
  1637.     /*  XXX Already exists - and _must_ be correct... */
  1638.     /*
  1639.     versionEntry = ReadDBVersionEntry(oldhandle);
  1640.     rv = WriteDBVersionEntry(info.handle, versionEntry);
  1641.     */
  1643.     /*  Copy over the content version record.  */
  1644.     /*  XXX Can probably get useful info from old content version?
  1645.      *      Was this db created before/after this tool?  etc.
  1646.      */
  1647. #if 0
  1648.     oldContentVersion = ReadDBContentVersionEntry(oldhandle);
  1649.     CERT_SetDBContentVersion(oldContentVersion->contentVersion, info.handle); 
  1650. #endif
  1652. #if 0
  1653.     /*  Copy over the CRL & KRL records.  */
  1654.     rv = SEC_TraverseDBEntries(oldhandle, certDBEntryTypeRevocation, 
  1655.                                copyDBEntry, info.handle);
  1656.     /*  XXX Only one KRL, just do db->get? */
  1657.     rv = SEC_TraverseDBEntries(oldhandle, certDBEntryTypeKeyRevocation, 
  1658.                                copyDBEntry, info.handle);
  1659. #endif
  1661.     PR_fprintf(info.out, "Database had %d certificates.n", info.nOldCerts);
  1663.     PR_fprintf(info.out, "Reconstructed %d certificates.n", info.nCerts);
  1664.     PR_fprintf(info.out, "(ax) Rejected %d expired certificates.n", 
  1665.                        info.dbErrors[dbInvalidCert]);
  1666.     PR_fprintf(info.out, "(as) Rejected %d S/MIME certificates missing a profile.n", 
  1667.                        info.dbErrors[dbNoSMimeProfile]);
  1668.     PR_fprintf(info.out, "(ar) Rejected %d certificates for which a newer certificate was found.n", 
  1669.                        info.dbErrors[dbOlderCert]);
  1670.     PR_fprintf(info.out, "     Rejected %d corrupt certificates.n", 
  1671.                        info.dbErrors[dbBadCertificate]);
  1672.     PR_fprintf(info.out, "     Rejected %d certificates which did not write to the DB.n", 
  1673.                        info.dbErrors[dbCertNotWrittenToDB]);
  1675.     if (rv)
  1676. goto loser;
  1678.     return info.handle;
  1680. loser:
  1681.     if (info.handle) 
  1682. PORT_Free(info.handle);
  1683.     return NULL;
  1684. }
  1685. #endif /* DORECOVER */
  1687. enum {
  1688.     cmd_Debug = 0,
  1689.     cmd_LongUsage,
  1690.     cmd_Recover
  1691. };
  1693. enum {
  1694.     opt_KeepAll = 0,
  1695.     opt_CertDir,
  1696.     opt_Dumpfile,
  1697.     opt_InputDB,
  1698.     opt_OutputDB,
  1699.     opt_Mailfile,
  1700.     opt_Prompt,
  1701.     opt_KeepRedundant,
  1702.     opt_KeepNoSMimeProfile,
  1703.     opt_Verbose,
  1704.     opt_KeepExpired
  1705. };
  1707. static secuCommandFlag dbck_commands[] =
  1708. {
  1709.     { /* cmd_Debug,    */  'D', PR_FALSE, 0, PR_FALSE },
  1710.     { /* cmd_LongUsage,*/  'H', PR_FALSE, 0, PR_FALSE },
  1711.     { /* cmd_Recover,  */  'R', PR_FALSE, 0, PR_FALSE }
  1712. };
  1714. static secuCommandFlag dbck_options[] =
  1715. {
  1716.     { /* opt_KeepAll,           */  'a', PR_FALSE, 0, PR_FALSE },
  1717.     { /* opt_CertDir,           */  'd', PR_TRUE,  0, PR_FALSE },
  1718.     { /* opt_Dumpfile,          */  'f', PR_TRUE,  0, PR_FALSE },
  1719.     { /* opt_InputDB,           */  'i', PR_TRUE,  0, PR_FALSE },
  1720.     { /* opt_OutputDB,          */  'o', PR_TRUE,  0, PR_FALSE },
  1721.     { /* opt_Mailfile,          */  'm', PR_FALSE, 0, PR_FALSE },
  1722.     { /* opt_Prompt,            */  'p', PR_FALSE, 0, PR_FALSE },
  1723.     { /* opt_KeepRedundant,     */  'r', PR_FALSE, 0, PR_FALSE },
  1724.     { /* opt_KeepNoSMimeProfile,*/  's', PR_FALSE, 0, PR_FALSE },
  1725.     { /* opt_Verbose,           */  'v', PR_FALSE, 0, PR_FALSE },
  1726.     { /* opt_KeepExpired,       */  'x', PR_FALSE, 0, PR_FALSE }
  1727. };
  1729. int 
  1730. main(int argc, char **argv)
  1731. {
  1732.     CERTCertDBHandle *certHandle;
  1734.     PRFileInfo fileInfo;
  1735.     PRFileDesc *mailfile = NULL;
  1736.     PRFileDesc *dumpfile = NULL;
  1738.     char * pathname     = 0;
  1739.     char * fullname     = 0;
  1740.     char * newdbname    = 0;
  1742.     PRBool removeExpired, requireProfile, singleEntry;
  1743.     
  1744.     SECStatus rv;
  1746.     secuCommand dbck;
  1747.     dbck.numCommands = sizeof(dbck_commands) / sizeof(secuCommandFlag);
  1748.     dbck.numOptions = sizeof(dbck_options) / sizeof(secuCommandFlag);
  1749.     dbck.commands = dbck_commands;
  1750.     dbck.options = dbck_options;
  1752.     progName = strrchr(argv[0], '/');
  1753.     progName = progName ? progName+1 : argv[0];
  1755.     rv = SECU_ParseCommandLine(argc, argv, progName, &dbck);
  1757.     if (rv != SECSuccess)
  1758. Usage(progName);
  1760.     if (dbck.commands[cmd_LongUsage].activated)
  1761. LongUsage(progName);
  1763.     if (!dbck.commands[cmd_Debug].activated &&
  1764.         !dbck.commands[cmd_Recover].activated) {
  1765. PR_fprintf(PR_STDERR, "Please specify -D or -R.n");
  1766. Usage(progName);
  1767.     }
  1769.     removeExpired = !(dbck.options[opt_KeepAll].activated ||
  1770.                       dbck.options[opt_KeepExpired].activated);
  1772.     requireProfile = !(dbck.options[opt_KeepAll].activated ||
  1773.                     dbck.options[opt_KeepNoSMimeProfile].activated);
  1775.     singleEntry = !(dbck.options[opt_KeepAll].activated ||
  1776.                     dbck.options[opt_KeepRedundant].activated);
  1778.     if (dbck.options[opt_OutputDB].activated) {
  1779. newdbname = PL_strdup(dbck.options[opt_OutputDB].arg);
  1780.     } else {
  1781. newdbname = PL_strdup("new_cert7.db");
  1782.     }
  1784.     /*  Create a generic graph of the database.  */
  1785.     if (dbck.options[opt_Mailfile].activated) {
  1786. mailfile = PR_Open("./mailfile", PR_RDWR | PR_CREATE_FILE, 00660);
  1787. if (!mailfile) {
  1788.     fprintf(stderr, "Unable to create mailfile.n");
  1789.     return -1;
  1790. }
  1791.     }
  1793.     /*  Dump all debugging info while running.  */
  1794.     if (dbck.options[opt_Verbose].activated) {
  1795. if (dbck.options[opt_Dumpfile].activated) {
  1796.     dumpfile = PR_Open(dbck.options[opt_Dumpfile].arg,
  1797.                        PR_RDWR | PR_CREATE_FILE, 00660);
  1798. }
  1799. if (!dumpfile) {
  1800.     fprintf(stderr, "Unable to create dumpfile.n");
  1801.     return -1;
  1802. }
  1803.     }
  1805.     /*  Set the cert database directory.  */
  1806.     if (dbck.options[opt_CertDir].activated) {
  1807. SECU_ConfigDirectory(dbck.options[opt_CertDir].arg);
  1808.     }
  1810.     PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1);
  1811.     SEC_Init();
  1813.     certHandle = (CERTCertDBHandle *)PORT_ZAlloc(sizeof(CERTCertDBHandle));
  1814.     if (!certHandle) {
  1815. SECU_PrintError(progName, "unable to get database handle");
  1816. return -1;
  1817.     }
  1819.     /*  Open the possibly corrupt database.  */
  1820.     if (dbck.options[opt_InputDB].activated) {
  1821. pathname = SECU_ConfigDirectory(NULL);
  1822. fullname = PR_smprintf("%s/%s", pathname, 
  1823.                                 dbck.options[opt_InputDB].arg);
  1824. if (PR_GetFileInfo(fullname, &fileInfo) != PR_SUCCESS) {
  1825.     fprintf(stderr, "Unable to read file "%s".n", fullname);
  1826.     return -1;
  1827. }
  1828. rv = CERT_OpenCertDBFilename(certHandle, fullname, PR_TRUE);
  1829.     } else {
  1830. /*  Use the default.  */
  1831. fullname = SECU_CertDBNameCallback(NULL, CERT_DB_FILE_VERSION);
  1832. if (PR_GetFileInfo(fullname, &fileInfo) != PR_SUCCESS) {
  1833.     fprintf(stderr, "Unable to read file "%s".n", fullname);
  1834.     return -1;
  1835. }
  1836. rv = CERT_OpenCertDB(certHandle, PR_TRUE, 
  1837.                      SECU_CertDBNameCallback, NULL);
  1838.     }
  1840.     if (rv) {
  1841. SECU_PrintError(progName, "unable to open cert database");
  1842. return -1;
  1843.     }
  1845.     if (dbck.commands[cmd_Debug].activated) {
  1846. DBCK_DebugDB(certHandle, dumpfile, mailfile);
  1847. return 0;
  1848.     }
  1850. #ifdef DORECOVER
  1851.     if (dbck.commands[cmd_Recover].activated) {
  1852. DBCK_ReconstructDBFromCerts(certHandle, newdbname,
  1853.                             dumpfile, removeExpired, 
  1854.                             requireProfile, singleEntry, 
  1855.                             dbck.options[opt_Prompt].activated);
  1856. return 0;
  1857.     }
  1858. #endif
  1860.     if (mailfile)
  1861. PR_Close(mailfile);
  1862.     if (dumpfile)
  1863. PR_Close(dumpfile);
  1864.     if (certHandle) {
  1865. CERT_ClosePermCertDB(certHandle);
  1866. PORT_Free(certHandle);
  1867.     }
  1868.     return -1;
  1869. }