Back to index

lightning-sunbird  0.9+nobinonly
Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Static Private Attributes
nsMsgComposeSecure Class Reference

#include <nsMsgComposeSecure.h>

Inheritance diagram for nsMsgComposeSecure:
Inheritance graph
[legend]
Collaboration diagram for nsMsgComposeSecure:
Collaboration graph
[legend]

List of all members.

Public Member Functions

NS_DECL_ISUPPORTS
NS_DECL_NSIMSGCOMPOSESECURE 
nsMsgComposeSecure ()
virtual ~nsMsgComposeSecure ()
nsOutputFileStreamGetOutputStream ()
boolean requiresCryptoEncapsulation (in nsIMsgIdentity aIdentity, in nsIMsgCompFields aCompFields)
void beginCryptoEncapsulation (in nsOutputFileStream aStream, in string aRecipients, in nsIMsgCompFields aCompFields, in nsIMsgIdentity aIdentity, in nsIMsgSendReport sendReport, in boolean aIsDraft)
void finishCryptoEncapsulation (in boolean aAbort, in nsIMsgSendReport sendReport)
void mimeCryptoWriteBlock (in string aBuf, in long aLen)

Private Types

enum  { eBufferSize = 8192 }

Private Member Functions

nsresult MimeInitMultipartSigned (PRBool aOuter, nsIMsgSendReport *sendReport)
nsresult MimeInitEncryption (PRBool aSign, nsIMsgSendReport *sendReport)
nsresult MimeFinishMultipartSigned (PRBool aOuter, nsIMsgSendReport *sendReport)
nsresult MimeFinishEncryption (PRBool aSign, nsIMsgSendReport *sendReport)
nsresult MimeCryptoHackCerts (const char *aRecipients, nsIMsgSendReport *sendReport, PRBool aEncrypt, PRBool aSign)
nsresult GetSMIMEBundleString (const PRUnichar *name, PRUnichar **outString)
nsresult SMIMEBundleFormatStringFromName (const PRUnichar *name, const PRUnichar **params, PRUint32 numParams, PRUnichar **outString)
nsresult ExtractEncryptionState (nsIMsgIdentity *aIdentity, nsIMsgCompFields *aComposeFields, PRBool *aSignMessage, PRBool *aEncrypt)
void SetError (nsIMsgSendReport *sendReport, const PRUnichar *bundle_string)
void SetErrorWithParam (nsIMsgSendReport *sendReport, const PRUnichar *bundle_string, const char *param)

Static Private Member Functions

static void InitializeSMIMEBundle ()

Private Attributes

mimeDeliveryCryptoState mCryptoState
nsOutputFileStreammStream
PRInt16 mHashType
nsCOMPtr< nsICryptoHashmDataHash
MimeEncoderDatamSigEncoderData
char * mMultipartSignedBoundary
nsXPIDLString mSigningCertName
nsCOMPtr< nsIX509CertmSelfSigningCert
nsXPIDLString mEncryptionCertName
nsCOMPtr< nsIX509CertmSelfEncryptionCert
nsCOMPtr< nsIMutableArraymCerts
nsCOMPtr< nsICMSMessagemEncryptionCinfo
nsCOMPtr< nsICMSEncodermEncryptionContext
MimeEncoderDatamCryptoEncoderData
PRBool mIsDraft
char * mBuffer
PRUint32 mBufferedBytes
PRBool mErrorAlreadyReported

Static Private Attributes

static nsCOMPtr< nsIStringBundlemSMIMEBundle = nsnull

Detailed Description

Definition at line 77 of file nsMsgComposeSecure.h.


Member Enumeration Documentation

anonymous enum [private]
Enumerator:
eBufferSize 

Definition at line 120 of file nsMsgComposeSecure.h.

{eBufferSize = 8192};

Constructor & Destructor Documentation

Definition at line 243 of file nsMsgComposeSecure.cpp.

{
  /* member initializers and constructor code */
  mStream = 0;
  mDataHash = 0;
  mSigEncoderData = 0;
  mMultipartSignedBoundary  = 0;
  mSelfSigningCert = 0;
  mSelfEncryptionCert = 0;
  mCerts = 0;
  mEncryptionCinfo = 0;
  mEncryptionContext = 0;
  mCryptoEncoderData = 0;
  mBuffer = 0;
  mBufferedBytes = 0;
}

Definition at line 260 of file nsMsgComposeSecure.cpp.

Here is the call graph for this function:


Member Function Documentation

void nsIMsgComposeSecure::beginCryptoEncapsulation ( in nsOutputFileStream  aStream,
in string  aRecipients,
in nsIMsgCompFields  aCompFields,
in nsIMsgIdentity  aIdentity,
in nsIMsgSendReport  sendReport,
in boolean  aIsDraft 
) [inherited]
nsresult nsMsgComposeSecure::ExtractEncryptionState ( nsIMsgIdentity aIdentity,
nsIMsgCompFields aComposeFields,
PRBool aSignMessage,
PRBool aEncrypt 
) [private]

Definition at line 418 of file nsMsgComposeSecure.cpp.

{
  if (!aComposeFields && !aIdentity)
    return NS_ERROR_FAILURE; // kick out...invalid args....

  NS_ENSURE_ARG(aSignMessage);
  NS_ENSURE_ARG(aEncrypt);

  nsCOMPtr<nsISupports> securityInfo;
  if (aComposeFields)
    aComposeFields->GetSecurityInfo(getter_AddRefs(securityInfo));

  if (securityInfo) // if we were given security comp fields, use them.....
  {
    nsCOMPtr<nsIMsgSMIMECompFields> smimeCompFields = do_QueryInterface(securityInfo);
    if (smimeCompFields)
    {
      smimeCompFields->GetSignMessage(aSignMessage);
      smimeCompFields->GetRequireEncryptMessage(aEncrypt);
      return NS_OK;
    }
  }

  // get the default info from the identity....
  PRInt32 ep = 0;
  nsresult testrv = aIdentity->GetIntAttribute("encryptionpolicy", &ep);
  if (NS_FAILED(testrv)) {
    *aEncrypt = PR_FALSE;
  }
  else {
    *aEncrypt = (ep > 0);
  }

  testrv = aIdentity->GetBoolAttribute("sign_mail", aSignMessage);
  if (NS_FAILED(testrv))
  {
    *aSignMessage = PR_FALSE;
  }
  return NS_OK;
}

Here is the call graph for this function:

Definition at line 86 of file nsMsgComposeSecure.h.

{ return mStream;}

Definition at line 301 of file nsMsgComposeSecure.cpp.

{
  nsresult rv = NS_ERROR_FAILURE;

  *outString = nsnull;

  if ( ! mSMIMEBundle ) {
    InitializeSMIMEBundle();
    if ( ! mSMIMEBundle ) {
      return rv;
    }
  }

  if (name) {
    rv = mSMIMEBundle->GetStringFromName(name, outString);
    if (NS_SUCCEEDED(rv)) {
      rv = NS_OK;
    }
  }

  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 350 of file nsMsgComposeSecure.cpp.

{
  nsresult rv;

  nsCOMPtr<nsIStringBundleService> bundleService(do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv));

  if ( NS_FAILED(rv) ) {
    return;
  }  

  bundleService->CreateBundle(SMIME_STRBUNDLE_URL,
                              getter_AddRefs(mSMIMEBundle));
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsMsgComposeSecure::MimeCryptoHackCerts ( const char *  aRecipients,
nsIMsgSendReport sendReport,
PRBool  aEncrypt,
PRBool  aSign 
) [private]

Definition at line 877 of file nsMsgComposeSecure.cpp.

{
  char *all_mailboxes = 0, *mailboxes = 0, *mailbox_list = 0;
  const char *mailbox = 0;
  PRUint32 count = 0;
  nsCOMPtr<nsIX509CertDB> certdb = do_GetService(NS_X509CERTDB_CONTRACTID);
  nsresult res;
  nsCOMPtr<nsIMsgHeaderParser> pHeader = do_GetService(NS_MAILNEWS_MIME_HEADER_PARSER_CONTRACTID, &res);
  NS_ENSURE_SUCCESS(res,res);

  res = NS_NewArray(getter_AddRefs(mCerts));
  if (NS_FAILED(res)) {
    return res;
  }

  PR_ASSERT(aEncrypt || aSign);
  certdb->FindEmailEncryptionCert(mEncryptionCertName, getter_AddRefs(mSelfEncryptionCert));
  certdb->FindEmailSigningCert(mSigningCertName, getter_AddRefs(mSelfSigningCert));

  // must have both the signing and encryption certs to sign
  if ((mSelfSigningCert == nsnull) && aSign) {
    SetError(sendReport, NS_LITERAL_STRING("NoSenderSigningCert").get());
    res = NS_ERROR_FAILURE;
    goto FAIL;
  }

  if ((mSelfEncryptionCert == nsnull) && aEncrypt) {
    SetError(sendReport, NS_LITERAL_STRING("NoSenderEncryptionCert").get());
    res = NS_ERROR_FAILURE;
    goto FAIL;
  }

  pHeader->ExtractHeaderAddressMailboxes(nsnull,aRecipients, &all_mailboxes);
  pHeader->RemoveDuplicateAddresses(nsnull, all_mailboxes, 0, PR_FALSE /*removeAliasesToMe*/, &mailboxes);
  if (all_mailboxes) {
    nsMemory::Free(all_mailboxes);
    all_mailboxes = nsnull;
  }

  if (mailboxes) {
    pHeader->ParseHeaderAddresses (nsnull, mailboxes, 0, &mailbox_list, &count);
    nsMemory::Free(mailboxes);
    mailboxes = nsnull;
  }
  if (count < 0) return count;

  if (aEncrypt && mSelfEncryptionCert) {
    // Make sure self's configured cert is prepared for being used
    // as an email recipient cert.
    
    nsCOMPtr<nsISMimeCert> sc = do_QueryInterface(mSelfEncryptionCert);
    if (sc) {
      sc->SaveSMimeProfile();
    }
  }

  /* If the message is to be encrypted, then get the recipient certs */
  if (aEncrypt) {
    mailbox = mailbox_list;

    PRBool already_added_self_cert = PR_FALSE;

    for (; count > 0; count--) {
      nsCString mailbox_lowercase;
      ToLowerCase(nsDependentCString(mailbox), mailbox_lowercase);
      nsCOMPtr<nsIX509Cert> cert;
      certdb->FindCertByEmailAddress(nsnull, mailbox_lowercase.get(), getter_AddRefs(cert));
      PRBool foundValidCert = PR_FALSE;

      if (cert) {
        PRUint32 verification_result;

        if (NS_SUCCEEDED(
            cert->VerifyForUsage(nsIX509Cert::CERT_USAGE_EmailRecipient, &verification_result))
            &&
            nsIX509Cert::VERIFIED_OK == verification_result)
        {
          foundValidCert = PR_TRUE;
        }
      }
      
      if (!foundValidCert) {
        // Failure to find a valid encryption cert is fatal.
        // here I assume that mailbox contains ascii rather than utf8.
        SetErrorWithParam(sendReport, NS_LITERAL_STRING("MissingRecipientEncryptionCert").get(), mailbox);
        res = NS_ERROR_FAILURE;
        goto FAIL;
      }

    /* #### see if recipient requests `signedData'.
     if (...) no_clearsigning_p = PR_TRUE;
     (This is the only reason we even bother looking up the certs
     of the recipients if we're sending a signed-but-not-encrypted
     message.)
     */

      PRBool isSame;
      if (NS_SUCCEEDED(cert->Equals(mSelfEncryptionCert, &isSame))
          && isSame) {
        already_added_self_cert = PR_TRUE;
      }

      mCerts->AppendElement(cert, PR_FALSE);
      // To understand this loop, especially the "+= strlen +1", look at the documentation
      // of ParseHeaderAddresses. Basically, it returns a list of zero terminated strings.
      mailbox += strlen(mailbox) + 1;
    }
    
    if (!already_added_self_cert) {
      mCerts->AppendElement(mSelfEncryptionCert, PR_FALSE);
    }
  }
FAIL:
  if (mailbox_list) {
    nsMemory::Free(mailbox_list);
  }
  return res;
}

Here is the call graph for this function:

void nsIMsgComposeSecure::mimeCryptoWriteBlock ( in string  aBuf,
in long  aLen 
) [inherited]

Definition at line 822 of file nsMsgComposeSecure.cpp.

{
  nsresult rv;

  /* If this object is both encrypted and signed, close off the
   signature first (since it's inside.) */
  if (aSign) {
    rv = MimeFinishMultipartSigned (PR_FALSE, sendReport);
    if (NS_FAILED(rv)) {
      goto FAIL;
    }
  }

  /* Close off the opaque encrypted blob.
   */
  PR_ASSERT(mEncryptionContext);

  if (mBufferedBytes) {
    rv = mEncryptionContext->Update(mBuffer, mBufferedBytes);
    mBufferedBytes = 0;
    if (NS_FAILED(rv)) {
      PR_ASSERT(PR_GetError() < 0);
      goto FAIL;
    }
  }
  
  rv = mEncryptionContext->Finish();
  if (NS_FAILED(rv)) {
    SetError(sendReport, NS_LITERAL_STRING("ErrorCanNotEncrypt").get());
    goto FAIL;
  }

  mEncryptionContext = 0;

  PR_ASSERT(mEncryptionCinfo);
  if (!mEncryptionCinfo) {
    rv = NS_ERROR_FAILURE;
  }
  if (mEncryptionCinfo) {
    mEncryptionCinfo = 0;
  }

  /* Shut down the base64 encoder. */
  rv = MIME_EncoderDestroy(mCryptoEncoderData, PR_FALSE);
  mCryptoEncoderData = 0;

  if (PRInt32(mStream->write(CRLF, 2)) < 2)
    rv = NS_ERROR_FAILURE;

 FAIL:
  return rv;
}

Here is the call graph for this function:

Definition at line 685 of file nsMsgComposeSecure.cpp.

{
  int status;
  nsresult rv;
  nsCOMPtr<nsICMSMessage> cinfo = do_CreateInstance(NS_CMSMESSAGE_CONTRACTID, &rv);
  nsCOMPtr<nsICMSEncoder> encoder = do_CreateInstance(NS_CMSENCODER_CONTRACTID, &rv);
  char * header = nsnull;

  /* Compute the hash...
   */

  nsCAutoString hashString;
  mDataHash->Finish(PR_FALSE, hashString);

  mDataHash = 0;

  status = PR_GetError();
  if (status < 0) goto FAIL;

  /* Write out the headers for the signature.
   */
  PRInt32 L;
  header =
    PR_smprintf(CRLF
          "--%s" CRLF
          "Content-Type: " APPLICATION_XPKCS7_SIGNATURE
            "; name=\"smime.p7s\"" CRLF
          "Content-Transfer-Encoding: " ENCODING_BASE64 CRLF
          "Content-Disposition: attachment; "
            "filename=\"smime.p7s\"" CRLF
          "Content-Description: %s" CRLF
          CRLF,
          mMultipartSignedBoundary,
          MIME_SMIME_SIGNATURE_CONTENT_DESCRIPTION);
  if (!header) {
    rv = NS_ERROR_OUT_OF_MEMORY;
    goto FAIL;
  }

  L = strlen(header);
  if (aOuter) {
    /* If this is the outer block, write it to the file. */
    if (PRInt32(mStream->write(header, L)) < L) {
      rv = MK_MIME_ERROR_WRITING_FILE;
    } 
  } else {
    /* If this is an inner block, feed it through the crypto stream. */
    rv = MimeCryptoWriteBlock (header, L);
  }

  PR_Free(header);

  /* Create the signature...
   */

  PR_ASSERT(mHashType == nsICryptoHash::SHA1);

  PR_ASSERT (mSelfSigningCert);
  PR_SetError(0,0);
  


  rv = cinfo->CreateSigned(mSelfSigningCert, mSelfEncryptionCert, (unsigned char*)hashString.get(), hashString.Length());
  if (NS_FAILED(rv))  {
    SetError(sendReport, NS_LITERAL_STRING("ErrorCanNotSign").get());
    goto FAIL;
  }

  /* Initialize the base64 encoder for the signature data.
   */
  PR_ASSERT(!mSigEncoderData);
  mSigEncoderData =
  MIME_B64EncoderInit((aOuter
            ? mime_encoder_output_fn
            : mime_nested_encoder_output_fn),
             this);
  if (!mSigEncoderData) {
    rv = NS_ERROR_OUT_OF_MEMORY;
    goto FAIL;
  }

  /* Write out the signature.
   */
  PR_SetError(0,0);
  rv = encoder->Start(cinfo, mime_crypto_write_base64, mSigEncoderData);
  if (NS_FAILED(rv)) {
    SetError(sendReport, NS_LITERAL_STRING("ErrorCanNotSign").get());
    goto FAIL;
  }

  // We're not passing in any data, so no update needed.
  rv = encoder->Finish();
  if (NS_FAILED(rv)) {
    SetError(sendReport, NS_LITERAL_STRING("ErrorCanNotSign").get());
    goto FAIL;
  }

  /* Shut down the sig's base64 encoder.
   */
  rv = MIME_EncoderDestroy(mSigEncoderData, PR_FALSE);
  mSigEncoderData = 0;
  if (NS_FAILED(rv)) {
    goto FAIL;
  }

  /* Now write out the terminating boundary.
   */
  {
  PRInt32 L;
  char *header = PR_smprintf(CRLF "--%s--" CRLF,
                 mMultipartSignedBoundary);
  PR_Free(mMultipartSignedBoundary);
  mMultipartSignedBoundary = 0;

  if (!header) {
    rv = NS_ERROR_OUT_OF_MEMORY;
    goto FAIL;
  }
  L = strlen(header);
  if (aOuter) {
    /* If this is the outer block, write it to the file. */
    if (PRInt32(mStream->write(header, L)) < L)
      rv = MK_MIME_ERROR_WRITING_FILE;
  } else {
    /* If this is an inner block, feed it through the crypto stream. */
    rv = MimeCryptoWriteBlock (header, L);
  }
  }

FAIL:
  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 601 of file nsMsgComposeSecure.cpp.

{
  nsresult rv;

  /* First, construct and write out the opaque-crypto-blob MIME header data.
   */

  char *s =
  PR_smprintf("Content-Type: " APPLICATION_XPKCS7_MIME
          "; name=\"smime.p7m\"" CRLF
        "Content-Transfer-Encoding: " ENCODING_BASE64 CRLF
        "Content-Disposition: attachment"
          "; filename=\"smime.p7m\"" CRLF
        "Content-Description: %s" CRLF
        CRLF,
        MIME_SMIME_ENCRYPTED_CONTENT_DESCRIPTION);
  PRInt32 L;
  if (!s) return NS_ERROR_OUT_OF_MEMORY;
  L = strlen(s);
  if (PRInt32(mStream->write(s, L)) < L) {
    return NS_ERROR_FAILURE;
  }
  PR_Free(s);
  s = 0;

  /* Now initialize the crypto library, so that we can filter the object
   to be encrypted through it.
   */

  if (!mIsDraft) {
    PRUint32 numCerts;
    mCerts->GetLength(&numCerts);
    PR_ASSERT(numCerts > 0);
    if (numCerts == 0) return NS_ERROR_FAILURE;
  }

  /* Initialize the base64 encoder. */
  PR_ASSERT(!mCryptoEncoderData);
  mCryptoEncoderData = MIME_B64EncoderInit(mime_encoder_output_fn,
                          this);
  if (!mCryptoEncoderData) {
    return NS_ERROR_OUT_OF_MEMORY;
  }

  /* Initialize the encrypter (and add the sender's cert.) */
  PR_ASSERT(mSelfEncryptionCert);
  PR_SetError(0,0);
  mEncryptionCinfo = do_CreateInstance(NS_CMSMESSAGE_CONTRACTID, &rv);
  if (NS_FAILED(rv)) return rv;
  rv = mEncryptionCinfo->CreateEncrypted(mCerts);
  if (NS_FAILED(rv)) {
    SetError(sendReport, NS_LITERAL_STRING("ErrorCanNotEncrypt").get());
    goto FAIL;
  }

  mEncryptionContext = do_CreateInstance(NS_CMSENCODER_CONTRACTID, &rv);
  if (NS_FAILED(rv)) return rv;

  if (!mBuffer) {
    mBuffer = new char[eBufferSize];
    if (!mBuffer)
      return NS_ERROR_OUT_OF_MEMORY;
  }

  mBufferedBytes = 0;

  rv = mEncryptionContext->Start(mEncryptionCinfo, mime_crypto_write_base64, mCryptoEncoderData);
  if (NS_FAILED(rv)) {
    SetError(sendReport, NS_LITERAL_STRING("ErrorCanNotEncrypt").get());
    goto FAIL;
  }

  /* If we're signing, tack a multipart/signed header onto the front of
   the data to be encrypted, and initialize the sign-hashing code too.
   */
  if (aSign) {
    rv = MimeInitMultipartSigned(PR_FALSE, sendReport);
    if (NS_FAILED(rv)) goto FAIL;
  }

 FAIL:
  return rv;
}

Here is the call graph for this function:

Definition at line 554 of file nsMsgComposeSecure.cpp.

{
  /* First, construct and write out the multipart/signed MIME header data.
   */
  nsresult rv = NS_OK;
  char *header = 0;
  PRInt32 L;

  rv = make_multipart_signed_header_string(aOuter, &header,
                    &mMultipartSignedBoundary);
  if (NS_FAILED(rv)) goto FAIL;

  L = strlen(header);

  if (aOuter){
    /* If this is the outer block, write it to the file. */
    if (PRInt32(mStream->write(header, L)) < L) {
      rv = MK_MIME_ERROR_WRITING_FILE;
    }
  } else {
    /* If this is an inner block, feed it through the crypto stream. */
    rv = MimeCryptoWriteBlock (header, L);
  }

  PR_Free(header);
  if (NS_FAILED(rv)) goto FAIL;

  /* Now initialize the crypto library, so that we can compute a hash
   on the object which we are signing.
   */

  mHashType = nsICryptoHash::SHA1;

  PR_SetError(0,0);
  mDataHash = do_CreateInstance("@mozilla.org/security/hash;1", &rv);
  if (NS_FAILED(rv)) return 0;

  rv = mDataHash->Init(mHashType);
  if (NS_FAILED(rv)) {
    goto FAIL;
  }

  PR_SetError(0,0);
 FAIL:
  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsMsgComposeSecure::SetError ( nsIMsgSendReport sendReport,
const PRUnichar bundle_string 
) [private]

Definition at line 364 of file nsMsgComposeSecure.cpp.

{
  if (!sendReport || !bundle_string)
    return;

  if (mErrorAlreadyReported)
    return;

  mErrorAlreadyReported = PR_TRUE;
  
  nsXPIDLString errorString;
  nsresult res;

  res = GetSMIMEBundleString(bundle_string,
                             getter_Copies(errorString));

  if (NS_SUCCEEDED(res) && !errorString.IsEmpty())
  {
    sendReport->SetMessage(nsIMsgSendReport::process_Current,
                           errorString.get(),
                           PR_TRUE);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void nsMsgComposeSecure::SetErrorWithParam ( nsIMsgSendReport sendReport,
const PRUnichar bundle_string,
const char *  param 
) [private]

Definition at line 388 of file nsMsgComposeSecure.cpp.

{
  if (!sendReport || !bundle_string || !param)
    return;

  if (mErrorAlreadyReported)
    return;

  mErrorAlreadyReported = PR_TRUE;
  
  nsXPIDLString errorString;
  nsresult res;
  const PRUnichar *params[1];

  NS_ConvertASCIItoUCS2 ucs2(param);
  params[0]= ucs2.get();

  res = SMIMEBundleFormatStringFromName(bundle_string,
                                        params,
                                        1,
                                        getter_Copies(errorString));

  if (NS_SUCCEEDED(res) && !errorString.IsEmpty())
  {
    sendReport->SetMessage(nsIMsgSendReport::process_Current,
                           errorString.get(),
                           PR_TRUE);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

nsresult nsMsgComposeSecure::SMIMEBundleFormatStringFromName ( const PRUnichar name,
const PRUnichar **  params,
PRUint32  numParams,
PRUnichar **  outString 
) [private]

Definition at line 328 of file nsMsgComposeSecure.cpp.

{

  nsresult rv = NS_ERROR_FAILURE;

  if ( ! mSMIMEBundle ) {
    InitializeSMIMEBundle();
    if ( ! mSMIMEBundle ) {
      return rv;
    }
  }

  if (name) {
    rv = mSMIMEBundle->FormatStringFromName(name, params, 
                                             numParams, outString);
  }
  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Member Data Documentation

char* nsMsgComposeSecure::mBuffer [private]

Definition at line 121 of file nsMsgComposeSecure.h.

Definition at line 122 of file nsMsgComposeSecure.h.

Definition at line 112 of file nsMsgComposeSecure.h.

Definition at line 117 of file nsMsgComposeSecure.h.

Definition at line 102 of file nsMsgComposeSecure.h.

Definition at line 105 of file nsMsgComposeSecure.h.

Definition at line 110 of file nsMsgComposeSecure.h.

Definition at line 113 of file nsMsgComposeSecure.h.

Definition at line 114 of file nsMsgComposeSecure.h.

Definition at line 124 of file nsMsgComposeSecure.h.

Definition at line 104 of file nsMsgComposeSecure.h.

Definition at line 118 of file nsMsgComposeSecure.h.

Definition at line 107 of file nsMsgComposeSecure.h.

Definition at line 111 of file nsMsgComposeSecure.h.

Definition at line 109 of file nsMsgComposeSecure.h.

Definition at line 106 of file nsMsgComposeSecure.h.

Definition at line 108 of file nsMsgComposeSecure.h.

Definition at line 115 of file nsMsgComposeSecure.h.

Definition at line 103 of file nsMsgComposeSecure.h.


The documentation for this class was generated from the following files: