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

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

CA认证

开发平台：

WINDOWS

crmfreq.c：源码内容
  1. /* -*- Mode: C; tab-width: 8 -*-*/
  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.  */
  35. #include "crmf.h"
  36. #include "crmfi.h"
  37. #include "keyhi.h"
  38. #include "secder.h"
  40. /*
  41.  * Macro that returns PR_TRUE if the pointer is not NULL.
  42.  * If the pointer is NULL, then the macro will return PR_FALSE.
  43.  */
  44. #define IS_NOT_NULL(ptr) ((ptr) == NULL) ? PR_FALSE : PR_TRUE
  46. const unsigned char hexTrue  = 0xff;
  47. const unsigned char hexFalse = 0x00;
  50. SECStatus
  51. crmf_encode_integer(PRArenaPool *poolp, SECItem *dest, long value) 
  52. {
  53.     SECItem *dummy;
  55.     dummy = SEC_ASN1EncodeInteger(poolp, dest, value);
  56.     PORT_Assert (dummy == dest);
  57.     if (dummy == NULL) {
  58.         return SECFailure;
  59.     }
  60.     return SECSuccess;
  61. }
  63. static SECStatus
  64. crmf_copy_secitem (PRArenaPool *poolp, SECItem *dest, SECItem *src)
  65. {
  66.     return  SECITEM_CopyItem (poolp, dest, src); 
  67. }
  69. PRBool
  70. CRMF_DoesRequestHaveField (CRMFCertRequest       *inCertReq, 
  71.    CRMFCertTemplateField  inField)
  72. {
  73.   
  74.     PORT_Assert(inCertReq != NULL);
  75.     if (inCertReq == NULL) {
  76.         return PR_FALSE;
  77.     }
  78.     switch (inField) {
  79.     case crmfVersion:
  80.         return inCertReq->certTemplate.version.data != NULL;
  81.     case crmfSerialNumber:
  82.         return inCertReq->certTemplate.serialNumber.data != NULL;
  83.     case crmfSigningAlg:
  84.         return inCertReq->certTemplate.signingAlg != NULL;
  85.     case crmfIssuer:
  86.         return inCertReq->certTemplate.issuer != NULL;
  87.     case crmfValidity:
  88.         return inCertReq->certTemplate.validity != NULL;
  89.     case crmfSubject:
  90.         return inCertReq->certTemplate.subject != NULL;
  91.     case crmfPublicKey:
  92.         return inCertReq->certTemplate.publicKey != NULL;
  93.     case crmfIssuerUID:
  94.         return inCertReq->certTemplate.issuerUID.data != NULL;
  95.     case crmfSubjectUID:
  96.         return inCertReq->certTemplate.subjectUID.data != NULL;
  97.     case crmfExtension:
  98.         return CRMF_CertRequestGetNumberOfExtensions(inCertReq) != 0;
  99.     }
  100.     return PR_FALSE;
  101. }
  103. CRMFCertRequest *
  104. CRMF_CreateCertRequest (long inRequestID) {
  105.     PRArenaPool     *poolp;
  106.     CRMFCertRequest *certReq;
  107.     SECStatus        rv;
  108.     
  109.     poolp = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);
  110.     if (poolp == NULL) {
  111.         goto loser;
  112.     }
  113.     
  114.     certReq=PORT_ArenaZNew(poolp,CRMFCertRequest);
  115.     if (certReq == NULL) {
  116.         goto loser;
  117.     }
  119.     certReq->poolp = poolp;
  120.     certReq->requestID = inRequestID;
  121.     
  122.     rv = crmf_encode_integer(poolp, &(certReq->certReqId), inRequestID);
  123.     if (rv != SECSuccess) {
  124.         goto loser;
  125.     }
  127.     return certReq;
  128.  loser:
  129.     if (poolp) {
  130.         PORT_FreeArena(poolp, PR_FALSE);
  131.     }
  132.     return NULL;
  133. }
  135. SECStatus
  136. CRMF_DestroyCertRequest(CRMFCertRequest *inCertReq)
  137. {
  138.     PORT_Assert(inCertReq != NULL);
  139.     if (inCertReq != NULL) {
  140.         if (inCertReq->certTemplate.extensions) {
  141.     PORT_Free(inCertReq->certTemplate.extensions);
  142. }
  143. if (inCertReq->controls) {
  144.     /* Right now we don't support EnveloppedData option,
  145.      * so we won't go through and delete each occurrence of 
  146.      * an EnveloppedData in the control.
  147.      */
  148.     PORT_Free(inCertReq->controls);
  149. }
  150. if (inCertReq->poolp) {
  151.     PORT_FreeArena(inCertReq->poolp, PR_TRUE);
  152. }
  153.     }
  154.     return SECSuccess;
  155. }
  157. static SECStatus
  158. crmf_template_add_version(PRArenaPool *poolp, SECItem *dest, long version)
  159. {
  160.     return (crmf_encode_integer(poolp, dest, version));
  161. }
  163. static SECStatus
  164. crmf_template_add_serialnumber(PRArenaPool *poolp, SECItem *dest, long serial)
  165. {
  166.     return (crmf_encode_integer(poolp, dest, serial));
  167. }
  169. SECStatus
  170. crmf_template_copy_secalg (PRArenaPool *poolp, SECAlgorithmID **dest, 
  171.    SECAlgorithmID* src)
  172. {
  173.     SECStatus         rv;
  174.     void             *mark;
  175.     SECAlgorithmID   *mySecAlg;
  177.     if (poolp != NULL) {
  178.         mark = PORT_ArenaMark(poolp);
  179.     }
  180.     *dest = mySecAlg = PORT_ArenaZNew(poolp, SECAlgorithmID);
  181.     if (mySecAlg == NULL) {
  182.         goto loser;
  183.     }
  184.     rv = SECOID_CopyAlgorithmID(poolp, mySecAlg, src);
  185.     if (rv != SECSuccess) {
  186.         goto loser;
  187.     }
  188.     if (poolp != NULL) {
  189.         PORT_ArenaUnmark(poolp, mark);
  190.     }
  191.     return SECSuccess;
  193.  loser:
  194.     *dest = NULL;
  195.     if (poolp != NULL) {
  196.         PORT_ArenaRelease(poolp, mark);
  197.     }
  198.     return SECFailure;
  199. }
  201. SECStatus
  202. crmf_copy_cert_name(PRArenaPool *poolp, CERTName **dest, 
  203.     CERTName *src)
  204. {
  205.     CERTName *newName;
  206.     SECStatus rv;
  207.     void     *mark;
  209.     mark = PORT_ArenaMark(poolp);
  210.     *dest = newName = PORT_ArenaZNew(poolp, CERTName);
  211.     if (newName == NULL) {
  212.         goto loser;
  213.     }
  215.     rv = CERT_CopyName(poolp, newName, src);
  216.     if (rv != SECSuccess) {
  217.       goto loser;
  218.     }
  219.     PORT_ArenaUnmark(poolp, mark);
  220.     return SECSuccess;
  221.  loser:
  222.     PORT_ArenaRelease(poolp, mark);
  223.     *dest = NULL;
  224.     return SECFailure;
  225. }
  227. static SECStatus
  228. crmf_template_add_issuer (PRArenaPool *poolp, CERTName **dest, 
  229.   CERTName* issuerName)
  230. {
  231.     return crmf_copy_cert_name(poolp, dest, issuerName);
  232. }
  235. static SECStatus
  236. crmf_encode_utctime(PRArenaPool *poolp, SECItem *destTime, PRTime time)
  237. {
  238.     SECItem   tmpItem;
  239.     SECStatus rv;
  242.     rv = DER_TimeToUTCTime (&tmpItem, time);
  243.     if (rv != SECSuccess) {
  244.         return rv;
  245.     }
  246.     rv = SECITEM_CopyItem(poolp, destTime, &tmpItem);
  247.     PORT_Free(tmpItem.data);
  248.     return rv;
  249. }
  251. static SECStatus
  252. crmf_template_add_validity (PRArenaPool *poolp, CRMFOptionalValidity **dest,
  253.     CRMFValidityCreationInfo *info)
  254. {
  255.     SECStatus             rv;
  256.     void                 *mark; 
  257.     CRMFOptionalValidity *myValidity;
  259.     /*First off, let's make sure at least one of the two fields is present*/
  260.     if (!info  || (!info->notBefore && !info->notAfter)) {
  261.         return SECFailure;
  262.     }
  263.     mark = PORT_ArenaMark (poolp);
  264.     *dest = myValidity = PORT_ArenaZNew(poolp, CRMFOptionalValidity);
  265.     if (myValidity == NULL) {
  266.         goto loser;
  267.     }
  269.     if (info->notBefore) {
  270.         rv = crmf_encode_utctime (poolp, &myValidity->notBefore, 
  271.   *info->notBefore);
  272. if (rv != SECSuccess) {
  273.     goto loser;
  274. }
  275.     }
  276.     if (info->notAfter) {
  277.         rv = crmf_encode_utctime (poolp, &myValidity->notAfter,
  278.   *info->notAfter);
  279. if (rv != SECSuccess) {
  280.     goto loser;
  281. }
  282.     }
  283.     PORT_ArenaUnmark(poolp, mark);
  284.     return SECSuccess;
  285.  loser:
  286.     PORT_ArenaRelease(poolp, mark);
  287.     *dest = NULL;
  288.     return SECFailure;
  289. }
  291. static SECStatus
  292. crmf_template_add_subject (PRArenaPool *poolp, CERTName **dest,
  293.    CERTName *subject)
  294. {
  295.     return crmf_copy_cert_name(poolp, dest, subject);
  296. }
  298. SECStatus
  299. crmf_template_add_public_key(PRArenaPool *poolp, 
  300.      CERTSubjectPublicKeyInfo **dest,
  301.      CERTSubjectPublicKeyInfo  *pubKey)
  302. {
  303.     CERTSubjectPublicKeyInfo *spki;
  304.     SECStatus rv;
  306.     *dest = spki = (poolp == NULL) ?
  307.                               PORT_ZNew(CERTSubjectPublicKeyInfo) :
  308.                               PORT_ArenaZNew (poolp, CERTSubjectPublicKeyInfo);
  309.     if (spki == NULL) {
  310.         goto loser;
  311.     }
  312.     rv = SECKEY_CopySubjectPublicKeyInfo (poolp, spki, pubKey);
  313.     if (rv != SECSuccess) {
  314.         goto loser;
  315.     }
  316.     return SECSuccess;
  317.  loser:
  318.     if (poolp == NULL && spki != NULL) {
  319.         SECKEY_DestroySubjectPublicKeyInfo(spki);
  320.     }
  321.     *dest = NULL;
  322.     return SECFailure;
  323. }
  325. static SECStatus
  326. crmf_copy_bitstring (PRArenaPool *poolp, SECItem *dest, SECItem *src)
  327. {
  328.     SECStatus rv;
  329.     int origLenBits, numBytesToCopy;
  330.     
  331.     origLenBits = src->len;
  332.     numBytesToCopy = CRMF_BITS_TO_BYTES(origLenBits);
  333.     rv = crmf_copy_secitem(poolp, dest, src);
  334.     src->len = origLenBits;
  335.     dest->len = origLenBits;
  336.     return rv;
  337. }
  339. static SECStatus
  340. crmf_template_add_issuer_uid(PRArenaPool *poolp, SECItem *dest,
  341.      SECItem *issuerUID)
  342. {
  343.     return crmf_copy_bitstring (poolp, dest, issuerUID);
  344. }
  346. static SECStatus
  347. crmf_template_add_subject_uid(PRArenaPool *poolp, SECItem *dest, 
  348.       SECItem *subjectUID)
  349. {
  350.     return crmf_copy_bitstring (poolp, dest, subjectUID);
  351. }
  353. static void
  354. crmf_zeroize_new_extensions (CRMFCertExtension **extensions,
  355.      int numToZeroize) 
  356. {
  357.     PORT_Memset((void*)extensions, 0, sizeof(CERTCertExtension*)*numToZeroize);
  358. }
  360. /*
  361.  * The strategy for adding templates will differ from all the other
  362.  * attributes in the template.  First, we want to allow the client
  363.  * of this API to set extensions more than just once.  So we will
  364.  * need the ability grow the array of extensions.  Since arenas don't
  365.  * give us the realloc function, we'll use the generic PORT_* functions
  366.  * to allocate the array of pointers *ONLY*.  Then we will allocate each
  367.  * individual extension from the arena that comes along with the certReq
  368.  * structure that owns this template.
  369.  */
  370. static SECStatus
  371. crmf_template_add_extensions(PRArenaPool *poolp, CRMFCertTemplate *inTemplate,
  372.      CRMFCertExtCreationInfo *extensions)
  373. {
  374.     void               *mark;
  375.     int                 newSize, oldSize, i;
  376.     SECStatus           rv;
  377.     CRMFCertExtension **extArray;
  378.     CRMFCertExtension  *newExt, *currExt;
  380.     mark = PORT_ArenaMark(poolp);
  381.     if (inTemplate->extensions == NULL) {
  382.         newSize = extensions->numExtensions;
  383.         extArray = PORT_ZNewArray(CRMFCertExtension*,newSize+1);
  384.     } else {
  385.         newSize = inTemplate->numExtensions + extensions->numExtensions;
  386.         extArray = PORT_Realloc(inTemplate->extensions, 
  387. sizeof(CRMFCertExtension*)*(newSize+1));
  388.     }
  389.     if (extArray == NULL) {
  390.         goto loser;
  391.     }
  392.     oldSize                   = inTemplate->numExtensions;
  393.     inTemplate->extensions    = extArray;
  394.     inTemplate->numExtensions = newSize;
  395.     for (i=oldSize; i < newSize; i++) {
  396.         newExt = PORT_ArenaZNew(poolp, CRMFCertExtension);
  397. if (newExt == NULL) {
  398.     goto loser2;
  399. }
  400. currExt = extensions->extensions[i-oldSize];
  401. rv = crmf_copy_secitem(poolp, &(newExt->id), &(currExt->id));
  402. if (rv != SECSuccess) {
  403.     goto loser2;
  404. }
  405. rv = crmf_copy_secitem(poolp, &(newExt->critical),
  406.        &(currExt->critical));
  407. if (rv != SECSuccess) {
  408.     goto loser2;
  409. }
  410. rv = crmf_copy_secitem(poolp, &(newExt->value), &(currExt->value));
  411. if (rv != SECSuccess) {
  412.     goto loser2;
  413. }
  414. extArray[i] = newExt;
  415.     }
  416.     extArray[newSize] = NULL;
  417.     PORT_ArenaUnmark(poolp, mark);
  418.     return SECSuccess;
  419.  loser2:
  420.     crmf_zeroize_new_extensions (&(inTemplate->extensions[oldSize]),
  421.  extensions->numExtensions);
  422.     inTemplate->numExtensions = oldSize;
  423.  loser:
  424.     PORT_ArenaRelease(poolp, mark);
  425.     return SECFailure;
  426. }
  428. SECStatus
  429. CRMF_CertRequestSetTemplateField(CRMFCertRequest       *inCertReq, 
  430.  CRMFCertTemplateField  inTemplateField,
  431.  void                  *data)
  432. {
  433.     CRMFCertTemplate *certTemplate;
  434.     PRArenaPool      *poolp;
  435.     SECStatus         rv = SECFailure;
  436.     void             *mark;
  437.     
  439.     if (inCertReq == NULL) {
  440.         return SECFailure;
  441.     }
  443.     certTemplate = &(inCertReq->certTemplate);
  445.     poolp = inCertReq->poolp;
  446.     mark = PORT_ArenaMark(poolp);
  447.     switch (inTemplateField) {
  448.     case crmfVersion:
  449.       rv = crmf_template_add_version(poolp,&(certTemplate->version), 
  450.      *(long*)data);
  451.       break;
  452.     case crmfSerialNumber:
  453.       rv = crmf_template_add_serialnumber(poolp, 
  454.   &(certTemplate->serialNumber),
  455.   *(long*)data);
  456.       break;
  457.     case crmfSigningAlg:
  458.       rv = crmf_template_copy_secalg (poolp, &(certTemplate->signingAlg),
  459.       (SECAlgorithmID*)data);
  460.       break;
  461.     case crmfIssuer:
  462.       rv = crmf_template_add_issuer (poolp, &(certTemplate->issuer), 
  463.      (CERTName*)data);
  464.       break;
  465.     case crmfValidity:
  466.       rv = crmf_template_add_validity (poolp, &(certTemplate->validity),
  467.        (CRMFValidityCreationInfo*)data);
  468.       break;
  469.     case crmfSubject:
  470.       rv = crmf_template_add_subject (poolp, &(certTemplate->subject),
  471.       (CERTName*)data);
  472.       break;
  473.     case crmfPublicKey:
  474.       rv = crmf_template_add_public_key(poolp, &(certTemplate->publicKey),
  475. (CERTSubjectPublicKeyInfo*)data);
  476.       break;
  477.     case crmfIssuerUID:
  478.       rv = crmf_template_add_issuer_uid(poolp, &(certTemplate->issuerUID),
  479. (SECItem*)data);
  480.       break;
  481.     case crmfSubjectUID:
  482.       rv = crmf_template_add_subject_uid(poolp, &(certTemplate->subjectUID),
  483.  (SECItem*)data);
  484.       break;
  485.     case crmfExtension:
  486.       rv = crmf_template_add_extensions(poolp, certTemplate, 
  487. (CRMFCertExtCreationInfo*)data);
  488.       break;
  489.     }
  490.     if (rv != SECSuccess) {
  491.         PORT_ArenaRelease(poolp, mark);
  492.     } else {
  493.         PORT_ArenaUnmark(poolp, mark);
  494.     }
  495.     return rv;
  496. }
  498. SECStatus
  499. CRMF_CertReqMsgSetCertRequest (CRMFCertReqMsg  *inCertReqMsg, 
  500.        CRMFCertRequest *inCertReq)
  501. {
  502.     PORT_Assert (inCertReqMsg != NULL && inCertReq != NULL);
  503.     if (inCertReqMsg == NULL || inCertReq == NULL) {
  504.         return SECFailure;
  505.     }
  506.     inCertReqMsg->certReq = crmf_copy_cert_request(inCertReqMsg->poolp,
  507.    inCertReq);
  508.     return (inCertReqMsg->certReq == NULL) ? SECFailure : SECSuccess;
  509. }
  511. CRMFCertReqMsg*
  512. CRMF_CreateCertReqMsg(void)
  513. {
  514.     PRArenaPool    *poolp;
  515.     CRMFCertReqMsg *reqMsg;
  517.     poolp = PORT_NewArena(CRMF_DEFAULT_ARENA_SIZE);
  518.     if (poolp == NULL) {
  519.         goto loser;
  520.     }
  521.     reqMsg = PORT_ArenaZNew(poolp, CRMFCertReqMsg);
  522.     if (reqMsg == NULL) {
  523.         goto loser;
  524.     }
  525.     reqMsg->poolp = poolp;
  526.     return reqMsg;
  527.     
  528.  loser:
  529.     if (poolp) {
  530.         PORT_FreeArena(poolp, PR_FALSE);
  531.     }
  532.     return NULL;
  533. }
  535. SECStatus 
  536. CRMF_DestroyCertReqMsg(CRMFCertReqMsg *inCertReqMsg)
  537. {
  538.     PORT_Assert(inCertReqMsg != NULL && inCertReqMsg->poolp != NULL);
  539.     if (!inCertReqMsg->isDecoded) {
  540.         if (inCertReqMsg->certReq->certTemplate.extensions != NULL) {
  541.     PORT_Free(inCertReqMsg->certReq->certTemplate.extensions);
  542. }
  543. if (inCertReqMsg->certReq->controls != NULL) {
  544.     PORT_Free(inCertReqMsg->certReq->controls);
  545. }
  546.     }
  547.     PORT_FreeArena(inCertReqMsg->poolp, PR_TRUE);
  548.     return SECSuccess;
  549. }
  551. CRMFCertExtension*
  552. crmf_create_cert_extension(PRArenaPool *poolp, 
  553.    SECOidTag    id,
  554.    PRBool       isCritical,
  555.    SECItem     *data)
  556. {
  557.     CRMFCertExtension *newExt;
  558.     SECOidData        *oidData;
  559.     SECStatus          rv;
  561.     newExt = (poolp == NULL) ? PORT_ZNew(CRMFCertExtension) :
  562.                                PORT_ArenaZNew(poolp, CRMFCertExtension);
  563.     if (newExt == NULL) {
  564.         goto loser;
  565.     }
  566.     oidData = SECOID_FindOIDByTag(id);
  567.     if (oidData == NULL || 
  568. oidData->supportedExtension != SUPPORTED_CERT_EXTENSION) {
  569.        goto loser;
  570.     }
  572.     rv = SECITEM_CopyItem(poolp, &(newExt->id), &(oidData->oid));
  573.     if (rv != SECSuccess) {
  574.         goto loser;
  575.     }
  577.     rv = SECITEM_CopyItem(poolp, &(newExt->value), data);
  578.     if (rv != SECSuccess) {
  579.         goto loser;
  580.     }
  582.     if (isCritical) {
  583.         newExt->critical.data = (poolp == NULL) ? 
  584.                                 PORT_New(unsigned char) :
  585.                                 PORT_ArenaNew(poolp, unsigned char);
  586. if (newExt->critical.data == NULL) {
  587.     goto loser;
  588. }
  589. newExt->critical.data[0] = hexTrue;
  590. newExt->critical.len = 1;
  591.     }
  592.     return newExt;
  593.  loser:
  594.     if (newExt != NULL && poolp == NULL) {
  595.         CRMF_DestroyCertExtension(newExt);
  596.     }
  597.     return NULL;
  598. }
  600. CRMFCertExtension *
  601. CRMF_CreateCertExtension(SECOidTag id,
  602.  PRBool    isCritical,
  603.  SECItem  *data) 
  604. {
  605.     return crmf_create_cert_extension(NULL, id, isCritical, data);
  606. }
  608. SECStatus
  609. crmf_destroy_cert_extension(CRMFCertExtension *inExtension, PRBool freeit)
  610. {
  611.     if (inExtension != NULL) {
  612.         SECITEM_FreeItem (&(inExtension->id), PR_FALSE);
  613. SECITEM_FreeItem (&(inExtension->value), PR_FALSE);
  614. SECITEM_FreeItem (&(inExtension->critical), PR_FALSE);
  615. if (freeit) {
  616.     PORT_Free(inExtension);
  617. }
  618.     }
  619.     return SECSuccess;
  620. }
  622. SECStatus
  623. CRMF_DestroyCertExtension(CRMFCertExtension *inExtension)
  624. {
  625.     return crmf_destroy_cert_extension(inExtension, PR_TRUE);
  626. }
  628. SECStatus
  629. CRMF_DestroyCertReqMessages(CRMFCertReqMessages *inCertReqMsgs) 
  630. {
  631.     PORT_Assert (inCertReqMsgs != NULL);
  632.     if (inCertReqMsgs != NULL) {
  633.         PORT_FreeArena(inCertReqMsgs->poolp, PR_TRUE);
  634.     }
  635.     return SECSuccess;
  636. }
  638. static PRBool
  639. crmf_item_has_data(SECItem *item)
  640. {
  641.     if (item != NULL && item->data != NULL) {
  642.         return PR_TRUE;
  643.     }
  644.     return PR_FALSE;
  645. }
  647. PRBool
  648. CRMF_CertRequestIsFieldPresent(CRMFCertRequest       *inCertReq,
  649.        CRMFCertTemplateField  inTemplateField)
  650. {
  651.     PRBool             retVal;
  652.     CRMFCertTemplate *certTemplate;
  654.     PORT_Assert(inCertReq != NULL);
  655.     if (inCertReq == NULL) {
  656.         /* This is probably some kind of error, but this is 
  657.  * the safest return value for this function.
  658.  */
  659.         return PR_FALSE;
  660.     }
  661.     certTemplate = &inCertReq->certTemplate;
  662.     switch (inTemplateField) {
  663.     case crmfVersion:
  664.       retVal = crmf_item_has_data(&certTemplate->version);
  665.       break;
  666.     case crmfSerialNumber:
  667.       retVal = crmf_item_has_data(&certTemplate->serialNumber);
  668.       break;
  669.     case crmfSigningAlg:
  670.       retVal = IS_NOT_NULL(certTemplate->signingAlg);
  671.       break;
  672.     case crmfIssuer:
  673.       retVal = IS_NOT_NULL(certTemplate->issuer);
  674.       break;
  675.     case crmfValidity:
  676.       retVal = IS_NOT_NULL(certTemplate->validity);
  677.       break;
  678.     case crmfSubject:
  679.       retVal = IS_NOT_NULL(certTemplate->subject);
  680.       break;
  681.     case crmfPublicKey:
  682.       retVal = IS_NOT_NULL(certTemplate->publicKey);
  683.       break;
  684.     case crmfIssuerUID:
  685.       retVal = crmf_item_has_data(&certTemplate->issuerUID);
  686.       break;
  687.     case crmfSubjectUID:
  688.       retVal = crmf_item_has_data(&certTemplate->subjectUID);
  689.       break;
  690.     case crmfExtension:
  691.       retVal = IS_NOT_NULL(certTemplate->extensions);
  692.       break;
  693.     default:
  694.       retVal = PR_FALSE;
  695.     }
  696.     return retVal;
  697. }