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

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

CA认证

开发平台：

WINDOWS

resource.c：源码内容
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
  2. /*
  3.  * The contents of this file are subject to the Mozilla Public
  4.  * License Version 1.1 (the "License"); you may not use this file
  5.  * except in compliance with the License. You may obtain a copy of
  6.  * the License at http://www.mozilla.org/MPL/
  7.  * 
  8.  * Software distributed under the License is distributed on an "AS
  9.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10.  * implied. See the License for the specific language governing
  11.  * rights and limitations under the License.
  12.  * 
  13.  * The Original Code is the Netscape security libraries.
  14.  * 
  15.  * The Initial Developer of the Original Code is Netscape
  16.  * Communications Corporation.  Portions created by Netscape are 
  17.  * Copyright (C) 1994-2000 Netscape Communications Corporation.  All
  18.  * Rights Reserved.
  19.  * 
  20.  * Contributor(s):
  21.  * 
  22.  * Alternatively, the contents of this file may be used under the
  23.  * terms of the GNU General Public License Version 2 or later (the
  24.  * "GPL"), in which case the provisions of the GPL are applicable 
  25.  * instead of those above.  If you wish to allow use of your 
  26.  * version of this file only under the terms of the GPL and not to
  27.  * allow others to use your version of this file under the MPL,
  28.  * indicate your decision by deleting the provisions above and
  29.  * replace them with the notice and other provisions required by
  30.  * the GPL.  If you do not delete the provisions above, a recipient
  31.  * may use your version of this file under either the MPL or the
  32.  * GPL.
  33.  */
  34. #include "resource.h"
  35. #include "hashtbl.h"
  36. #include "collectn.h"
  37. #include "connect.h"
  38. #include "ctrlconn.h"
  39. #include "dataconn.h"
  40. #include "sslconn.h"
  41. #include "sslskst.h"
  42. #include "certres.h"
  43. #include "keyres.h"
  44. #include "crmfres.h"
  45. #include "p7dconn.h"
  46. #include "p7cinfo.h"
  47. #include "p7econn.h"
  48. #include "hashconn.h"
  49. #include "kgenctxt.h"
  50. #include "servimpl.h"
  51. #include "ssmerrs.h"
  52. #include "nlsutil.h"
  53. #include "advisor.h"
  54. #include "p12res.h"
  55. #include "signtextres.h"
  56. #include "sdrres.h"
  58. #include <stdarg.h>
  60. /* Type registration */
  61. struct SSMResourceClass
  62. {
  63.     /* The type of resource. */
  64.     SSMResourceType        m_classType;
  65.     SSMResourceType        m_superclass;
  67.     /* Name. */
  68.     char *                 m_className;
  70.     /* Data pertaining to each class. */
  71.     SSMClientDestroyAction m_clientDest;
  72.     
  73.     /* Accessor functions. */
  74.     SSMResourceCreateFunc  m_create_func;
  75.     SSMResourceDestroyFunc m_destroy_func;
  76.     SSMResourceShutdownFunc m_shutdown_func;
  77.     SSMResourceGetAttrIDsFunc m_getids_func;
  78.     SSMResourceGetAttrFunc m_get_func;
  79.     SSMResourceSetAttrFunc m_set_func;
  80.     SSMResourcePickleFunc m_pickle_func;
  81.     SSMResourceUnpickleFunc m_unpickle_func;
  82.     SSMResourceHTMLFunc m_html_func;
  83.     SSMResourcePrintFunc m_print_func;
  84.     SSMSubmitHandlerFunc m_submit_func;
  85. };
  87. SSMHashTable *ssm_classRegistry = NULL;
  90. /* Declarations to keep the compiler happy */
  91. SSMStatus SSM_FindResourceClass(SSMResourceType type, SSMResourceClass **cls);
  93. SSMStatus
  94. SSM_ResourceInit()
  95. {
  96.     SSMStatus rv = PR_SUCCESS;
  97.     
  98.     if (ssm_classRegistry == NULL)
  99.         {
  100.         rv = SSM_HashCreate(&ssm_classRegistry);
  101.         PR_ASSERT(ssm_classRegistry != NULL);
  103.         /* Register well-known types. 
  104.            Connection classes fall into this category. */
  105.         SSM_RegisterResourceType("Resource",
  106.                                  SSM_RESTYPE_RESOURCE,
  107.                                  SSM_RESTYPE_NULL,
  108.                                  SSM_CLIENTDEST_NOTHING,
  109.                                  SSMResource_Create,
  110.                                  SSMResource_Destroy,
  111.                                  SSMResource_Shutdown,
  112.                                  SSMResource_GetAttrIDs,
  113.                                  SSMResource_GetAttr,
  114.                                  SSMResource_SetAttr,
  115.                                  SSMResource_Pickle,
  116.                                  SSMResource_Unpickle,
  117.                                  SSMResource_HTML,
  118.                                  SSMResource_Print,
  119.                                  SSMResource_FormSubmitHandler);
  120.         SSM_RegisterResourceType("Connection",
  121.                                  SSM_RESTYPE_CONNECTION,
  122.                                  SSM_RESTYPE_RESOURCE,
  123.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  124.                                  SSMConnection_Create,
  125.                                  SSMConnection_Destroy,
  126.                                  SSMConnection_Shutdown,
  127.                                  SSMConnection_GetAttrIDs,
  128.                                  SSMConnection_GetAttr,
  129.                                  SSMConnection_SetAttr, 
  130.                                  NULL, 
  131.                                  NULL,
  132.                                  NULL,
  133.                                  NULL,
  134.                                  NULL);
  135.         SSM_RegisterResourceType("Control connection",
  136.                                  SSM_RESTYPE_CONTROL_CONNECTION,
  137.                                  SSM_RESTYPE_CONNECTION,
  138.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  139.                                  SSMControlConnection_Create,
  140.                                  SSMControlConnection_Destroy,
  141.                                  SSMControlConnection_Shutdown,
  142.                                  SSMControlConnection_GetAttrIDs,
  143.                                  SSMControlConnection_GetAttr,
  144.                                  NULL, 
  145.                                  NULL, 
  146.                                  NULL,
  147.                                  NULL,
  148.                                  NULL,
  149.                                  SSMControlConnection_FormSubmitHandler);
  150.         SSM_RegisterResourceType("Data connection",
  151.                                  SSM_RESTYPE_DATA_CONNECTION,
  152.                                  SSM_RESTYPE_CONNECTION,
  153.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  154.                                  SSMDataConnection_Create,
  155.                                  SSMDataConnection_Destroy,
  156.                                  SSMDataConnection_Shutdown,
  157.                                  SSMDataConnection_GetAttrIDs,
  158.                                  SSMDataConnection_GetAttr,
  159.                                  NULL, 
  160.                                  NULL, 
  161.                                  NULL,
  162.                                  NULL,
  163.                                  NULL,
  164.                                  NULL);
  165.         SSM_RegisterResourceType("SSL connection",
  166.                                  SSM_RESTYPE_SSL_DATA_CONNECTION,
  167.                                  SSM_RESTYPE_DATA_CONNECTION,
  168.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  169.                                  SSMSSLDataConnection_Create,
  170.                                  SSMSSLDataConnection_Destroy,
  171.                                  SSMSSLDataConnection_Shutdown,
  172.                                  SSMSSLDataConnection_GetAttrIDs,
  173.                                  SSMSSLDataConnection_GetAttr,
  174.                                  SSMSSLDataConnection_SetAttr,
  175.                                  NULL, 
  176.                                  NULL,
  177.                                  NULL,
  178.                                  NULL,
  179.                                  SSMSSLDataConnection_FormSubmitHandler);
  180.         SSM_RegisterResourceType("Hash connection",
  181.                                  SSM_RESTYPE_HASH_CONNECTION,
  182.                                  SSM_RESTYPE_DATA_CONNECTION,
  183.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  184.                                  SSMHashConnection_Create,
  185.                                  SSMHashConnection_Destroy,
  186.                                  SSMHashConnection_Shutdown,
  187.                                  SSMHashConnection_GetAttrIDs,
  188.                                  SSMHashConnection_GetAttr,
  189.                                  NULL,
  190.                                  NULL, 
  191.                                  NULL,
  192.                                  NULL,
  193.                                  NULL,
  194.                                  NULL);
  195.         SSM_RegisterResourceType("PKCS7 decode connection",
  196.                                  SSM_RESTYPE_PKCS7_DECODE_CONNECTION,
  197.                                  SSM_RESTYPE_DATA_CONNECTION,
  198.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  199.                                  SSMP7DecodeConnection_Create,
  200.                                  SSMP7DecodeConnection_Destroy,
  201.                                  SSMP7DecodeConnection_Shutdown,
  202.                                  SSMP7DecodeConnection_GetAttrIDs,
  203.                                  SSMP7DecodeConnection_GetAttr,
  204.                                  NULL,
  205.                                  NULL, 
  206.                                  NULL,
  207.                                  NULL,
  208.                                  NULL,
  209.                                  NULL);
  210.         SSM_RegisterResourceType("PKCS7 encode connection",
  211.                                  SSM_RESTYPE_PKCS7_ENCODE_CONNECTION,
  212.                                  SSM_RESTYPE_DATA_CONNECTION,
  213.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  214.                                  SSMP7EncodeConnection_Create,
  215.                                  SSMP7EncodeConnection_Destroy,
  216.                                  SSMP7EncodeConnection_Shutdown,
  217.                                  NULL,
  218.                                  SSMP7EncodeConnection_GetAttr,
  219.                                  SSMP7EncodeConnection_SetAttr,
  220.                                  NULL, 
  221.                                  NULL,
  222.                                  NULL,
  223.                                  NULL,
  224.                                  NULL);
  225.         SSM_RegisterResourceType("PKCS7 content info",
  226.                                  SSM_RESTYPE_PKCS7_CONTENT_INFO,
  227.                                  SSM_RESTYPE_RESOURCE,
  228.                                  SSM_CLIENTDEST_FREE, /* client destroy */
  229.                                  SSMP7ContentInfo_Create,
  230.                                  SSMP7ContentInfo_Destroy,
  231.                                  NULL,
  232.                                  SSMP7ContentInfo_GetAttrIDs,
  233.                                  SSMP7ContentInfo_GetAttr,
  234.                                  NULL,
  235.                                  NULL, 
  236.                                  NULL,
  237.                                  NULL,
  238.                                  NULL,
  239.                                  NULL);
  240.         SSM_RegisterResourceType("SSL socket status object",
  241.                                  SSM_RESTYPE_SSL_SOCKET_STATUS,
  242.                                  SSM_RESTYPE_RESOURCE,
  243.                                  SSM_CLIENTDEST_FREE, /* client destroy */
  244.                                  SSMSSLSocketStatus_Create,
  245.                                  SSMSSLSocketStatus_Destroy,
  246.                                  NULL,
  247.                                  SSMSSLSocketStatus_GetAttrIDs,
  248.                                  SSMSSLSocketStatus_GetAttr,
  249.                                  NULL,
  250.                                  SSMSSLSocketStatus_Pickle, 
  251.                                  SSMSSLSocketStatus_Unpickle,
  252.                                  SSMSSLSocketStatus_HTML,
  253.                                  NULL,
  254.                                  NULL);
  255.         SSM_RegisterResourceType("Certificate",
  256.                                  SSM_RESTYPE_CERTIFICATE,
  257.                                  SSM_RESTYPE_RESOURCE,
  258.                                  SSM_CLIENTDEST_FREE, /* client destroy */
  259.                                  SSMResourceCert_Create,
  260.                                  SSMResourceCert_Destroy,
  261.                                  NULL,
  262.                                  SSMResourceCert_GetAttrIDs,
  263.                                  SSMResourceCert_GetAttr,
  264.                                  NULL,
  265.                                  SSMResourceCert_Pickle, 
  266.                                  SSMResourceCert_Unpickle,
  267.                                  SSMResourceCert_HTML,
  268.                                  NULL,
  269.                                  SSMResourceCert_FormSubmitHandler);
  270.         SSM_RegisterResourceType("Key pair",
  271.                                  SSM_RESTYPE_KEY_PAIR,
  272.                                  SSM_RESTYPE_RESOURCE,
  273.                                  SSM_CLIENTDEST_FREE, /* client destroy */
  274.                                  SSMKeyPair_Create,
  275.                                  SSMKeyPair_Destroy,
  276.                                  NULL,
  277.                                  NULL,
  278.                                  NULL,
  279.                                  SSMKeyPair_SetAttr,
  280.                                  NULL,
  281.                                  NULL,
  282.                                  NULL,
  283.                                  NULL,
  284.                                  NULL);
  285.         SSM_RegisterResourceType("CRMF request",
  286.                                  SSM_RESTYPE_CRMF_REQUEST,
  287.                                  SSM_RESTYPE_RESOURCE,
  288.                                  SSM_CLIENTDEST_FREE, /* client destroy */
  289.                                  SSMCRMFRequest_Create,
  290.                                  SSMCRMFRequest_Destroy,
  291.                                  NULL,
  292.                                  NULL,
  293.                                  NULL,
  294.                                  SSMCRMFRequest_SetAttr,
  295.                                  NULL,
  296.                                  NULL,
  297.                                  NULL,
  298.                                  NULL,
  299.                                  NULL);
  300.         SSM_RegisterResourceType("Key gen context",
  301.                                  SSM_RESTYPE_KEYGEN_CONTEXT, /* type */
  302.                                  SSM_RESTYPE_RESOURCE, /* superclass */
  303.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  304.                                  SSMKeyGenContext_Create, /* create */
  305.                                  SSMKeyGenContext_Destroy, /* destroy */
  306.                                  SSMKeyGenContext_Shutdown, /* shutdown */
  307.                                  NULL, /* get attr IDs */
  308.                                  SSMKeyGenContext_GetAttr, /* get attr */
  309.                                  SSMKeyGenContext_SetAttr,
  310.                                  NULL, /* pickle */
  311.                                  NULL, /* unpickle */
  312.                                  NULL, /* HTML */
  313.                                  SSMKeyGenContext_Print, /* Print */
  314.                                  SSMKeyGenContext_FormSubmitHandler);
  315.         SSM_RegisterResourceType("Security advisor context",
  316.                                  SSM_RESTYPE_SECADVISOR_CONTEXT,
  317.                                  SSM_RESTYPE_RESOURCE,
  318.                                  SSM_CLIENTDEST_SHUTDOWN, /* client destroy */
  319.                                  NULL,
  320.                                  SSMSecurityAdvisorContext_Destroy,
  321.                                  NULL, 
  322.                                  SSMSecurityAdvisorContext_GetAttrIDs,
  323.                                  SSMSecurityAdvisorContext_GetAttr,
  324.                                  SSMSecurityAdvisorContext_SetAttr,
  325.                                  NULL, 
  326.                                  NULL,
  327.                                  NULL,
  328.                                  SSMSecurityAdvisorContext_Print,
  329.                                  SSMSecurityAdvisorContext_FormSubmitHandler);
  330.         SSM_RegisterResourceType("PKCS12 Context",
  331.                                  SSM_RESTYPE_PKCS12_CONTEXT,
  332.                                  SSM_RESTYPE_RESOURCE,
  333.                                  SSM_CLIENTDEST_FREE,
  334.                                  SSMPKCS12Context_Create,
  335.                                  SSMPKCS12Context_Destroy,
  336.                                  NULL,
  337.                                  NULL,
  338.                                  NULL,
  339.                                  NULL,
  340.                                  NULL,
  341.                                  NULL,
  342.                                  NULL,
  343.                                  SSMPKCS12Context_Print,
  344.                                  SSMPKCS12Context_FormSubmitHandler);
  345.         SSM_RegisterResourceType("SignText Context",
  346.                                  SSM_RESTYPE_SIGNTEXT,
  347.                                  SSM_RESTYPE_RESOURCE,
  348.                                  SSM_CLIENTDEST_FREE,
  349.                                  SSMSignTextResource_Create,
  350.                                  SSMSignTextResource_Destroy,
  351.                                  SSMSignTextResource_Shutdown,
  352.                                  NULL,
  353.                                  SSMSignTextResource_GetAttr,
  354.                                  NULL,
  355.                                  NULL,
  356.                                  NULL,
  357.                                  NULL,
  358.                                  SSMSignTextResource_Print,
  359.                                  SSMSignTextResource_FormSubmitHandler);
  360.         SSM_RegisterResourceType("SDR Context",
  361.                                  SSM_RESTYPE_SDR_CONTEXT,
  362.                                  SSM_RESTYPE_RESOURCE,
  363.                                  SSM_CLIENTDEST_FREE,
  364.                                  SSMSDRContext_Create,
  365.                                  SSMSDRContext_Destroy,
  366.                                  NULL,  /* Shutdown */
  367.                                  NULL,
  368.                                  NULL,
  369.                                  NULL,
  370.                                  NULL,
  371.                                  NULL,
  372.                                  NULL,
  373.                                  NULL,
  374.                                  SSMSDRContext_FormSubmitHandler);
  375.     }
  376.     
  377.     return rv;
  378. }
  380. SSMStatus
  381. SSMResource_Destroy(SSMResource *res, PRBool doFree)
  382. {
  383.     SSMStatus rv;
  384.     SSMResourceID tmpID;
  386.     /* We should have been called from a subclass destructor. */
  387.     PR_ASSERT(doFree == PR_FALSE);
  389.     SSM_DEBUG("Destroying %s (rid %ld).n", res->m_class->m_className, 
  390.               (long) res->m_id);
  392.     rv = SSM_HashRemove(res->m_connection->m_resourceDB, res->m_id,
  393.                         (void **) &res);
  394.     if (rv != PR_SUCCESS)
  395.         return PR_FAILURE;
  397.     rv = SSM_HashRemove(res->m_connection->m_resourceIdDB, (SSMHashKey)res,
  398.                         (void **) &tmpID);
  399.     if (rv != PR_SUCCESS)
  400.         return PR_FAILURE;
  402.     if (res->m_lock)
  403.     {
  404.         PR_DestroyMonitor(res->m_lock);
  405.         res->m_lock = NULL;
  406.     }
  407.     
  408.     if (res->m_UILock)
  409.     {
  410.         PR_DestroyMonitor(res->m_UILock);
  411.         res->m_UILock = NULL;
  412.     }
  413.     if (res->m_formName) {
  414.         PR_Free(res->m_formName);
  415.         res->m_formName = NULL;
  416.     }
  417.     
  418.     return PR_SUCCESS;
  419. }
  421. SSMStatus
  422. SSMResource_Init(SSMControlConnection * conn, SSMResource *res, 
  423.                  SSMResourceType type)
  424. {
  425.     SSMResourceClass *cls;
  426.     SSMStatus rv;
  428.     rv = SSM_FindResourceClass(type, &cls);
  429.     if (rv != PR_SUCCESS)
  430.         goto loser;
  432.     res->m_class = cls;
  433.     res->m_classType = type;
  434.     res->m_buttonType = SSM_BUTTON_NONE;
  435.     res->m_clientDest = cls->m_clientDest;
  436.     res->m_destroy_func = cls->m_destroy_func;
  437.     res->m_shutdown_func = cls->m_shutdown_func;
  438.     res->m_getids_func = cls->m_getids_func;
  439.     res->m_get_func = cls->m_get_func;
  440.     res->m_set_func = cls->m_set_func;
  441.     res->m_pickle_func = cls->m_pickle_func;
  442.     res->m_html_func = cls->m_html_func;
  443.     res->m_print_func = cls->m_print_func;
  444.     res->m_submit_func = cls->m_submit_func;
  445.     res->m_connection = conn;
  446.     res->m_lock = PR_NewMonitor();
  447.     if (!res->m_lock)
  448.         goto loser;
  450.     if (conn != NULL)
  451.         res->m_id = SSMControlConnection_GenerateResourceID(conn);
  453.     /* will create this monitor when needed */
  454.     res->m_UILock = NULL;
  455.     res->m_formName = NULL;
  456.     res->m_fileName = NULL;
  457.     res->m_clientContext.len = 0;
  458.     res->m_clientContext.data = NULL;
  459.     
  460.     res->m_clientCount = 0;
  461.     res->m_refCount = 1;
  462.     res->m_resourceShutdown = PR_FALSE;
  464.     SSM_DEBUG("Created %s with rid %ld.n", cls->m_className,
  465.               (long)res->m_id);
  467.     if (SSMControlConnection_AddResource(res, res->m_id) != PR_SUCCESS)
  468.         goto loser;
  469.     
  470.     return PR_SUCCESS;
  471.  loser:
  472.     if (rv == PR_SUCCESS)
  473.         rv = PR_FAILURE;
  474.     return rv;
  475. }
  477. SSMStatus
  478. SSM_FindResourceClass(SSMResourceType type, SSMResourceClass **cls)
  479. {
  480.     SSMStatus rv = PR_SUCCESS;
  482.     *cls = NULL; /* in case we fail */
  483.     PR_ASSERT(ssm_classRegistry != NULL);
  485.     rv = SSM_HashFind(ssm_classRegistry, type, (void **) cls);
  486.     return rv;
  487. }
  489. PRBool
  490. SSM_IsA(SSMResource *res, SSMResourceType type)
  491. {
  492.     return (res && (res->m_classType == type));
  493. }
  495. PRBool
  496. SSM_IsAKindOf(SSMResource *res, SSMResourceType type)
  497. {
  498.     PRBool result = PR_FALSE;
  499.     SSMResourceClass *cls;
  501.     if (!res) return PR_FALSE;
  503.     SSM_FindResourceClass( res->m_classType, &cls);
  504.     while (cls && (cls->m_classType != type))
  505.         SSM_FindResourceClass(cls->m_superclass, &cls);
  506.     result = (cls != NULL);
  507.     return result;
  508. }
  510. SSMStatus
  511. SSM_RegisterResourceType(char *name,
  512.                          SSMResourceType type,
  513.                          SSMResourceType superClass,
  514.                          SSMClientDestroyAction destAction,
  515.                          SSMResourceCreateFunc createFunc,
  516.                          SSMResourceDestroyFunc destFunc,
  517.                          SSMResourceShutdownFunc shutFunc,
  518.                          SSMResourceGetAttrIDsFunc getIDsFunc,
  519.                          SSMResourceGetAttrFunc getFunc,
  520.                          SSMResourceSetAttrFunc setFunc,
  521.                          SSMResourcePickleFunc  pickleFunc, 
  522.                          SSMResourceUnpickleFunc unpickleFunc,
  523.                          SSMResourceHTMLFunc    htmlFunc,
  524.                          SSMResourcePrintFunc   printFunc,
  525.                          SSMSubmitHandlerFunc   submitFunc)
  526. {
  527.     SSMResourceClass *cls, *super = NULL;
  528.     SSMStatus rv = PR_SUCCESS;
  530.     /* If a superclass was specified, find it. */
  531.     if (superClass)
  532.     {
  533.         rv = SSM_FindResourceClass(superClass, &super);
  534.         if (rv != PR_SUCCESS) goto loser;
  535.     }
  536.         
  537.     /* Create a new entry for the class. */
  538.     cls = (SSMResourceClass *) PR_CALLOC(sizeof(SSMResourceClass));
  539.     if (!cls) goto loser;
  541.     /* Start with the superclass' methods, then overlay the new ones. */
  542.     if (super)
  543.         (void) memcpy(cls, super, sizeof(SSMResourceClass));
  545.     cls->m_className = name;
  546.     cls->m_classType = type;
  547.     cls->m_superclass = superClass;
  548.     cls->m_clientDest = destAction;
  550.     if (createFunc != NULL)
  551.         cls->m_create_func = createFunc;
  552.     if (destFunc != NULL)
  553.         cls->m_destroy_func = destFunc;
  554.     if (shutFunc != NULL)
  555.         cls->m_shutdown_func = shutFunc;
  556.     if (getIDsFunc != NULL)
  557.         cls->m_getids_func = getIDsFunc;
  558.     if (getFunc != NULL)
  559.         cls->m_get_func = getFunc;
  560.     if (setFunc != NULL)
  561.         cls->m_set_func = setFunc;
  562.     if (pickleFunc != NULL)
  563.         cls->m_pickle_func = pickleFunc;
  564.     if (unpickleFunc != NULL) 
  565.         cls->m_unpickle_func = unpickleFunc;
  566.     if (htmlFunc != NULL)
  567.         cls->m_html_func = htmlFunc;
  568.     if (printFunc != NULL)
  569.         cls->m_print_func = printFunc;
  570.     if (submitFunc != NULL)
  571.         cls->m_submit_func = submitFunc;
  573.     rv = SSM_HashInsert(ssm_classRegistry, type, cls);
  574.     if (rv != PR_SUCCESS) goto loser;
  576.     return PR_SUCCESS;
  577.  loser:
  578.     if (rv == PR_SUCCESS) rv = PR_FAILURE;
  579.     if (cls) PR_Free(cls);
  580.     return rv;
  581. }
  583. SSMStatus
  584. SSM_CreateResource(SSMResourceType type, void *arg, 
  585.                    SSMControlConnection * connection,
  586.                    SSMResourceID *resID, SSMResource **result)
  587. {
  588.     SSMStatus rv;
  589.     SSMResourceClass *cls = NULL;
  590.     SSMResource *res = NULL;
  591.     
  592.     rv = SSM_FindResourceClass(type, &cls);
  593.     if (rv != PR_SUCCESS) goto loser;
  595.     PR_ASSERT(cls != NULL);
  596.     
  597.     /* Call the create function in this class. */
  598.     rv = (*cls->m_create_func)(arg, connection, &res);
  599.     if ((rv != PR_SUCCESS) && (rv != SSM_ERR_DEFER_RESPONSE))
  600.         goto loser;
  602.     *resID = res->m_id;
  604.     *result = res;
  605.     return rv;
  607.  loser:
  608.     if (res) 
  609.     {
  610.         res->m_refCount = 1; /* so that it is destroyed */
  611.         SSM_FreeResource(res);
  612.     }
  613.     return rv;
  614. }
  616. SSMStatus
  617. SSM_GetResourceReference(SSMResource *res)
  618. {
  619.     SSMResource_Invariant(res);
  621.     SSM_LockResource(res);
  622.     res->m_refCount++;
  623.     SSM_DEBUG("Get ref - rsrcid: %ld ++refcnt: %ldn", res->m_id, res->m_refCount);
  624.     switch (res->m_classType) {
  625.     case SSM_RESTYPE_CONTROL_CONNECTION:
  626.         SSM_DEBUG("Getting a reference for the control connectionn");
  627.         break;
  628.     default:
  629.         break;
  630.     }
  631.     SSM_UnlockResource(res);
  633.     return PR_SUCCESS;
  634. }
  636. SSMStatus
  637. SSM_FreeResource(SSMResource *res)
  638. {
  639.     PRIntn refcnt;
  641.     PR_ASSERT(res != NULL);
  643.     SSMResource_Invariant(res);
  644. PR_ASSERT(res->m_refCount > 0);
  646.     SSM_LockResource(res);
  647.     refcnt = --(res->m_refCount);
  648.     SSM_DEBUG("Free ref - rsrcid: %ld --refcnt: %ldn", res->m_id, res->m_refCount);
  649.     res->m_refCount = refcnt;
  650.     switch (res->m_classType) {
  651.     case SSM_RESTYPE_CONTROL_CONNECTION:
  652.         SSM_DEBUG("Giving up a reference to the control connectionn");
  653.         break;
  654.     default:
  655.         break;
  656.     }
  657.     SSM_UnlockResource(res);
  659.     /* need to handle race condition on destroy */
  660.     if (refcnt <= 0)
  661.     {
  662.         SSM_DEBUG("Destroying resource.n", 
  663.                                    refcnt);
  664.         return (*res->m_destroy_func)(res, PR_TRUE);
  665.     }
  667.     return PR_SUCCESS;
  668. }
  670. SSMStatus
  671. SSM_GetResAttribute(SSMResource *res, SSMAttributeID fieldID,
  672.                     SSMResourceAttrType attrType, SSMAttributeValue *value)
  673. {
  674.     PR_ASSERT(res != NULL);
  675.     SSMResource_Invariant(res);
  676.     return (*res->m_get_func)(res,fieldID,attrType,value);
  677. }
  679. SSMStatus
  680. SSM_SetResAttribute(SSMResource *res, SSMAttributeID fieldID,
  681.                     SSMAttributeValue *value)
  682. {
  683.     PR_ASSERT(res != NULL);
  684.     SSMResource_Invariant(res);
  685.     return (*res->m_set_func)(res,fieldID,value);
  686. }
  688. SSMStatus 
  689. SSM_PickleResource(SSMResource * res, PRIntn * len, void ** value)
  690. {
  691.     PR_ASSERT(res != NULL);
  692.     return(*res->m_pickle_func)(res, len, value);
  693. }
  695. SSMStatus 
  696. SSM_HTMLResource(SSMResource *res, PRIntn *len, void **value)
  697. {
  698.     PR_ASSERT(res != NULL);
  699.     return(*res->m_html_func)(res, len, value);
  700. }
  702. SSMStatus
  703. SSM_ClientGetResourceReference(SSMResource *res, SSMResourceID *id)
  704. {
  705.     SSM_LockResource(res);
  706.     res->m_clientCount++;
  707.     SSM_DEBUG("Get client ref - rsrcid: %ld ++clientcnt: %ldn",
  708.               res->m_id, res->m_clientCount);
  709.     SSM_GetResourceReference(res);
  710.     if (id)
  711.         *id = res->m_id;
  712.     SSM_UnlockResource(res);
  713.     return PR_SUCCESS;
  714. }
  715.   
  716. /*
  717.  * Unpickle function is similar to create function. Need the switch statement
  718.  * to call  
  719.  * Unpickle function for different resources.  
  720.  */  
  721. SSMStatus 
  722. SSM_UnpickleResource(SSMResource ** res, SSMResourceType type, 
  723.                      SSMControlConnection * connection,
  724.                      PRIntn len, void * value)
  725. {
  726.     SSMStatus rv = PR_SUCCESS;
  728.     PR_ASSERT(res != NULL);
  729.     if (!res || !value) {
  730.         PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
  731.         goto loser;
  732.     }
  733.     *res = NULL; /* in case we fail */
  734.     switch (type) { 
  735.     case SSM_RESTYPE_CERTIFICATE:
  736.         rv = SSMResourceCert_Unpickle(res, connection, len, value);
  737.         break;
  738.     case SSM_RESTYPE_SSL_SOCKET_STATUS:
  739.         rv = SSMSSLSocketStatus_Unpickle(res, connection, len, value);
  740.         break;
  741.     case SSM_RESTYPE_HASH_CONNECTION:
  742.     case SSM_RESTYPE_PKCS7_DECODE_CONNECTION:
  743.     case SSM_RESTYPE_SSL_DATA_CONNECTION:
  744.     default:
  745.         rv = PR_FAILURE;
  746.     }
  747.     goto done;
  748. loser:
  749.     if (rv == PR_SUCCESS) 
  750.         rv = PR_FAILURE;
  751.     if (res && *res) {
  752.         PR_Free(*res);
  753.         *res = NULL;
  754.     }
  755. done:
  756.     return rv;
  757. }
  760. SSMStatus
  761. SSM_ShutdownResource(SSMResource *res, SSMStatus status)
  762. {
  763.     PR_ASSERT(res->m_shutdown_func);
  764.     if (res->m_shutdown_func)
  765.         return (*res->m_shutdown_func)(res, status);
  766.     else
  767.         return PR_FAILURE;
  768. }
  770. SSMStatus 
  771. SSM_ClientDestroyResource(SSMControlConnection * connection, 
  772.                           SSMResourceID rid, SSMResourceType objType)
  773. {
  774.     SSMStatus rv;
  775.     SSMResource *res = NULL;
  776.     PRIntn clientCount;
  778.     rv = SSMControlConnection_GetResource(connection, rid, &res);
  779.     if (rv != PR_SUCCESS)
  780.         goto done;
  782.     PR_ASSERT(res);
  783.     /* If the object is of the right type, free the reference. */
  784.     if (!SSM_IsAKindOf(res, objType))
  785.     {
  786.         rv = SSM_ERR_BAD_RESOURCE_TYPE;
  787.         goto done;
  788.     }
  790.     SSM_LockResource(res);
  792.     clientCount = --(res->m_clientCount);
  793.     SSM_DEBUG("Free client ref - rsrcid: %ld --clientcnt: %ldn",
  794.               res->m_id, res->m_clientCount);
  795.     /* Also release the resource that was added when the client got
  796.      * its resource
  797.      */
  798.     SSM_FreeResource(res);
  799.     PR_ASSERT(clientCount >= 0);
  800.     if((clientCount == 0)  && (res->m_threadCount > 0))
  801.     {
  802.         SSM_DEBUG("ClientDestroy: Shutting down resource %ld.n",
  803.                   (long)res->m_id);
  804.         rv = SSM_ShutdownResource(res, SSM_ERR_CLIENT_DESTROY);
  805.         if (rv != PR_SUCCESS)
  806.             goto locked_done;
  807.     }
  809. locked_done:
  810.     SSM_UnlockResource(res);
  811. done:
  812.     if (res != NULL)
  813.         rv = SSM_FreeResource(res);
  814.     SSM_DEBUG("ClientDestroy returning status %d.n", rv);
  815.     return rv;
  816. }
  818. SSMStatus 
  819. SSM_MessageFormatResource(SSMResource *res,
  820.                           char *fmt,
  821.                           PRIntn numParams,
  822.   char ** value,
  823.                           char **resultStr)
  824. {
  825.     SSMStatus rv = SSM_FAILURE;
  827.     if (res->m_print_func)
  828.         rv = (*(res->m_print_func))(res, fmt, numParams, value, resultStr);
  829.     return rv;
  830. }
  832. SSMStatus
  833. SSMResource_Shutdown(SSMResource *res, SSMStatus status)
  834. {
  835.     SSMStatus rv = PR_SUCCESS;
  836.     SSM_LockResource(res);
  837.     if ((res->m_status == PR_SUCCESS) || (res->m_status == SSM_ERR_CLIENT_DESTROY))
  838.     {
  839.         SSM_DEBUG("Shutting down %s with rid %ld. Status == %d.n", 
  840.                   res->m_class->m_className, 
  841.                   (long) res->m_id, status);
  842.         res->m_status = status;
  844.         /* If there is a thread waiting for us to shut down, notify it. */
  845.         if (res->m_waitThread)
  846.             SSM_NotifyResource(res);
  847.     }
  848.     else
  849.         rv = SSM_ERR_ALREADY_SHUT_DOWN;
  850.     res->m_resourceShutdown = PR_TRUE;
  851.     SSM_UnlockResource(res);
  853.     return rv;
  854. }
  856. void
  857. SSMResource_Invariant(SSMResource *res)
  858. {
  859. #ifdef DEBUG
  860.     if (res)
  861.     {
  862.         PR_ASSERT(res->m_id != 0);
  863.         PR_ASSERT(SSM_IsAKindOf(res, SSM_RESTYPE_RESOURCE));
  864.         PR_ASSERT(res->m_refCount >= 0);
  865.         PR_ASSERT(res->m_destroy_func != NULL);
  866.         PR_ASSERT(res->m_shutdown_func != NULL);
  867.         PR_ASSERT(res->m_getids_func != NULL);
  868.         PR_ASSERT(res->m_get_func != NULL);
  869.         PR_ASSERT(res->m_set_func != NULL);
  870.         PR_ASSERT(res->m_connection != NULL);
  871.     }
  872. #endif
  873. }
  875. SSMStatus
  876. SSMResource_Create(void *arg, SSMControlConnection * connection, 
  877.                    SSMResource **res)
  878. {
  879.     /* never instantiate a bare SSMResource */
  880.     *res = NULL;
  881.     return PR_FAILURE;
  882. }
  884. SSMStatus
  885. SSMResource_GetAttr(SSMResource *res,
  886.                     SSMAttributeID fieldID, 
  887.                     SSMResourceAttrType attrType,
  888.                     SSMAttributeValue *value)
  889. {
  890.     return SSM_ERR_BAD_ATTRIBUTE_ID;
  891. }
  893. SSMStatus
  894. SSMResource_GetAttrIDs(SSMResource *res,
  895.                        SSMAttributeID **ids,
  896.                        PRIntn *count)
  897. {
  898.     /* return 0 attributes */
  899.     *ids = (SSMAttributeID *) PR_CALLOC(0);
  900.     *count = 0;
  901.     return PR_SUCCESS;
  902. }
  904. SSMStatus
  905. SSMResource_SetAttr(SSMResource *res,
  906.                     SSMAttributeID attrID,
  907.                     SSMAttributeValue *value)
  908. {
  909.     return PR_FAILURE; /* nothing client-accessible in the base class */
  910. }
  912. SSMStatus
  913. SSMResource_Pickle(SSMResource *res, PRIntn * len, void **value)
  914. {
  915.     return PR_FAILURE;
  916. }
  918. SSMStatus
  919. SSMResource_Unpickle(SSMResource ** res, SSMControlConnection *conn,
  920.                      PRIntn len, void * value)
  921. {
  922.     return PR_FAILURE;
  923. }
  925. SSMStatus
  926. SSMResource_HTML(SSMResource *res, PRIntn * len, void ** value)
  927. {
  928.     return PR_FAILURE;
  929. }
  931. SSMStatus 
  932. SSMResource_Print(SSMResource   *res, char *fmt, PRIntn numParams, 
  933.   char ** value, char **resultStr)
  934. {
  935.     PR_ASSERT(res != NULL && fmt != NULL && resultStr != NULL);
  936.     if (numParams > 3) 
  937.       SSM_DEBUG("SSMResource_Print: too many parameters!n");
  938.     switch (numParams) {
  939.       case (3): 
  940.         *resultStr = PR_smprintf(fmt, res->m_id, *value, *(value+1),*(value+2));
  941.         break;
  942.       case (2): 
  943. *resultStr = PR_smprintf(fmt, res->m_id, *value, *(value+1));
  944.         break;
  945.       case (1):
  946.         *resultStr = PR_smprintf(fmt, res->m_id, *value);
  947.         break;
  948.       default:
  949.         *resultStr = PR_smprintf(fmt, res->m_id);
  950.     }
  951.     if (*resultStr == NULL) {
  952.         return PR_FAILURE;
  953.     }
  955.     return PR_SUCCESS;
  956. }
  958. SSMStatus
  959. SSMResource_FormSubmitHandler(SSMResource *res,
  960.                               HTTPRequest *req)
  961. {
  962.     return SSM_HTTPDefaultCommandHandler(req);
  963. }
  965. void
  966. SSM_LockResource(SSMResource *res)
  967. {
  968.     PR_EnterMonitor(res->m_lock);
  969. }
  971. SSMStatus
  972. SSM_UnlockResource(SSMResource *res)
  973. {
  974.     return PR_ExitMonitor(res->m_lock);
  975. }
  977. SSMStatus
  978. SSM_WaitResource(SSMResource *res, PRIntervalTime ticks)
  979. {
  980.     return PR_Wait(res->m_lock, ticks);
  981. }
  983. SSMStatus
  984. SSM_NotifyResource(SSMResource *res)
  985. {
  986.     return PR_Notify(res->m_lock);
  987. }
  989. /* 
  990.    Wait for a resource to shut down. 
  991.    ### mwelch We use WaitResource() in another context, namely where
  992.    data connections hand over a newly opened port number to their
  993.    control connections. Can we guard against the case where we have an
  994.    initializing data connection upon which a thread decides to wait for 
  995.    shutdown?
  996. */
  997. SSMStatus
  998. SSM_WaitForResourceShutdown(SSMResource *res)
  999. {
  1000.     SSMStatus rv = PR_SUCCESS;
  1001.     SSM_LockResource(res);
  1002.     PR_ASSERT(res->m_waitThread == NULL);
  1004.     if (res->m_waitThread)
  1005.         rv = PR_FAILURE;
  1006.     else if (!res->m_resourceShutdown)
  1007.     {
  1008.         res->m_waitThread = PR_GetCurrentThread();
  1009.         do 
  1010.             SSM_WaitResource(res, PR_INTERVAL_NO_TIMEOUT);
  1011.         while (res->m_threadCount > 0);
  1012.         res->m_waitThread = NULL;
  1013.     } 
  1014.     else 
  1015.     {
  1016.         rv = SSM_ERR_ALREADY_SHUT_DOWN;
  1017.     }
  1018.     
  1019.     SSM_UnlockResource(res);
  1020.     return rv;
  1021. }
  1023. char * 
  1024. SSM_ResourceClassName(SSMResource *res)
  1025. {
  1026.     return res->m_class->m_className;
  1027. }
  1029. void SSM_LockUIEvent(SSMResource * res)
  1030. {
  1031.   if (res->m_UILock == NULL)
  1032.     res->m_UILock = PR_NewMonitor();
  1033.   PR_ASSERT(res->m_UILock);
  1034.   PR_EnterMonitor(res->m_UILock);
  1035. }
  1037. SSMStatus SSM_UnlockUIEvent(SSMResource *res)
  1038. {
  1039.   PR_ASSERT(res->m_UILock);
  1040.   if (res->m_UILock != NULL) {
  1041.     return PR_ExitMonitor(res->m_UILock);
  1042.   }
  1043.   return PR_FAILURE;
  1044. }
  1046. SSMStatus SSM_WaitUIEvent(SSMResource * res, PRIntervalTime ticks)
  1047. { 
  1048.   PR_ASSERT(res->m_UILock);
  1049.   if (res->m_UILock)
  1050.     {
  1051.      res->m_UIBoolean = PR_FALSE;
  1052.      while (!res->m_UIBoolean)
  1053.        PR_Wait(res->m_UILock, ticks);
  1054.      return PR_ExitMonitor(res->m_UILock);
  1055.     }
  1056.   /* if we used UILock once, chances are we'll need it again? */
  1057.   return PR_FAILURE;
  1058. }
  1060. SSMStatus SSM_NotifyUIEvent(SSMResource * res)
  1061. {
  1062.   SSMStatus rv = PR_FAILURE;
  1064.   PR_ASSERT(res->m_UILock);
  1065.   if (res->m_UILock)
  1066.     {
  1067.      PR_EnterMonitor(res->m_UILock);
  1068.      res->m_UIBoolean = PR_TRUE;
  1069.      rv =PR_Notify(res->m_UILock);
  1070.      PR_ExitMonitor(res->m_UILock);
  1071.     }
  1072.   return rv;
  1073. }
  1077. SSMStatus SSM_WaitForOKCancelEvent(SSMResource *res, PRIntervalTime ticks)
  1078. {
  1079.   PRStatus rv;
  1080.   if (res->m_UILock == NULL) {
  1081.     /* We might have been waken up by a spurious notify,
  1082.      * so we don't allocate a new monitor every time.
  1083.      */
  1084.     res->m_UILock = PR_NewMonitor();
  1085.   }
  1086.   PR_EnterMonitor(res->m_UILock);
  1087.   rv = PR_Wait(res->m_UILock, ticks);
  1088.   PR_ExitMonitor(res->m_UILock);
  1089.   return rv;
  1090. }
  1092. SSMStatus SSM_NotifyOKCancelEvent(SSMResource *res)
  1093. {
  1094.   SSMStatus rv = PR_FAILURE;
  1096.   if (res->m_UILock) {
  1097.     PR_EnterMonitor(res->m_UILock);
  1098.     rv = PR_Notify(res->m_UILock);
  1099.     PR_ExitMonitor(res->m_UILock);
  1100.   }
  1101.   return rv;
  1102. }
  1104. SSMStatus
  1105. SSM_HandlePromptReply(SSMResource *res, char *reply)
  1106. {
  1107.     /* Currently, only SSMPKCS12Context supports this, 
  1108.      * perhaps in the future we'll add more general support.
  1109.      */
  1110.     if (!SSM_IsAKindOf(res, SSM_RESTYPE_PKCS12_CONTEXT)) {
  1111.         return PR_FAILURE;
  1112.     }
  1113.     return SSMPKCS12Context_ProcessPromptReply(res, reply);
  1114. }
  1116. PRThread *
  1117. SSM_CreateThread(SSMResource *res, void (*func)(void *arg))
  1118. {
  1119.     PRThread *thd = NULL;
  1121.     PR_ASSERT(res != NULL);
  1122.     PR_ASSERT(func != NULL);
  1124.     SSM_LockResource(res);
  1125.     thd = SSM_CreateAndRegisterThread(PR_USER_THREAD, 
  1126.                           func, 
  1127.                           (void *)res, 
  1128.                           PR_PRIORITY_NORMAL,
  1129.                           PR_LOCAL_THREAD,
  1130.                           PR_UNJOINABLE_THREAD, 0);
  1131.     if (thd) {
  1132.         res->m_threadCount++;
  1133.     }
  1134.     SSM_UnlockResource(res);
  1136.     return thd;
  1137. }