zdm2write.c

IBE是一种非对称密码技术

      break;
      
    case VT_ZDM_PARAM_BUFFER_TYPE:
    
      if (setInfo != (Pointer)0)
      {
        localCtx->mBufferTypeInfo = *(VtBufferTypeInfo*)setInfo;
      }
      else
      {
        Z2Memset(&localCtx->mBufferTypeInfo, 0, sizeof(localCtx->mBufferTypeInfo));
        localCtx->mBufferTypeInfo.bufferType = VT_BUFFER_TYPE_MEMORY;
      }
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamBufferType, setInfo);
      break;
      
    case VT_ZDM_PARAM_FILE_NAME:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamFileName, setInfo);
      if (status == VT_ERROR_INVALID_SECURE_ARCHIVE_ENTRY)
        status = VT_ERROR_INVALID_ZDM_ENTRY;
      break;
              
    case VT_ZDM_PARAM_CURRENT_ENTRY:
    
      zdmCurrentEntryInfo = (VtZDMCurrentEntryInfo*)setInfo;
      
      if (zdmCurrentEntryInfo->type == VT_ZDM_CURRENT_ENTRY_MESSAGE_BODY)
      {
        saCurrentEntryInfo.type = VT_SECURE_ARCHIVE_CURRENT_ENTRY_INDEX;
      }
      else if (zdmCurrentEntryInfo->type == VT_ZDM_CURRENT_ENTRY_ATTACHMENT)
      {
        saCurrentEntryInfo.type = VT_SECURE_ARCHIVE_CURRENT_ENTRY_SECURE;
      }
      else if (zdmCurrentEntryInfo->type == VT_ZDM_CURRENT_ENTRY_DONE)
      {
        if (localCtx->mCurrentEntryType == VT_ZDM_CURRENT_ENTRY_DONE)
          break;
          
        saCurrentEntryInfo.type = VT_SECURE_ARCHIVE_CURRENT_ENTRY_DONE;
        
        /* Update the ZDM attributes in the underlying secure archive */
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VoltZDM2UpdateAttributes(zdmObj);
        if (status != 0)
          break;
        
        /* Add the insecure attributes as an insecure entry to the
         * underlying secure archive
         */
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VoltZDM2WriteInsecureAttributes(zdmObj);
        if (status != 0)
          break;
    
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VoltZDM2SetStaticTemplateVariables(zdmObj);
        if (status != 0)
          break;
        
        localCtx->mState = VOLT_ZDM2_STATE_OUTPUT_UPDATE;
      }
      else
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        status = VT_ERROR_GENERAL;      /* TODO: Better error code */
        break;
      }
      saCurrentEntryInfo.name = (unsigned char*)0;
      saCurrentEntryInfo.index = -1;
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamCurrentEntry, (Pointer)&saCurrentEntryInfo);
      if (status != 0)
        break;
      
      localCtx->mCurrentEntryType = zdmCurrentEntryInfo->type;
      break;
      
    case VT_ZDM_PARAM_MESSAGE_FORMAT:
      
      messageFormat = *(unsigned int*)setInfo;
      
      outputType = (messageFormat == VT_MESSAGE_FORMAT_SECURE_MAIL) ?
        VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ENCRYPTED_INDEX :
        VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ARCHIVE;

      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamOutputType, (Pointer)&outputType);
      if (status != 0)
        break;

      localCtx->mMessageFormat = messageFormat;
      localCtx->mOutputStage = VOLT_ZDM2_OUTPUT_STAGE_NONE;
      localCtx->mOutputOffset = 0;
      localCtx->mMessageDataSize = 0;
      VtDestroyAlgorithmObject(&localCtx->mBase64Encoder);

      break;
    
    case VT_ZDM_PARAM_DATA_PADDING:
      
      dataPaddingInfo = (VtZDMDataPaddingInfo*)setInfo;
      localCtx->mPaddedSize = dataPaddingInfo->paddedSize;
      localCtx->mPadChar = dataPaddingInfo->padChar;
      break;
      
    case VT_ZDM_PARAM_CONTENT_TYPE:
    
      attributeInfo.name = VoltZDM2ContentTypeAttributeName;
      attributeInfo.value = (const unsigned char*)setInfo;
      attributeParam = (localCtx->mCurrentEntryType == VT_ZDM_CURRENT_ENTRY_ATTACHMENT) ?
        VtSecureArchiveParamEntryAttribute : VtSecureArchiveParamArchiveAttribute;
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        attributeParam, (Pointer)&attributeInfo);
      break;
      
    case VT_ZDM_PARAM_CHARACTER_SET:

      attributeInfo.name = VoltZDM2CharacterSetAttributeName;
      attributeInfo.value = (const unsigned char*)setInfo;
      attributeParam = (localCtx->mCurrentEntryType == VT_ZDM_CURRENT_ENTRY_ATTACHMENT) ?
        VtSecureArchiveParamEntryAttribute : VtSecureArchiveParamArchiveAttribute;
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        attributeParam, (Pointer)&attributeInfo);
      break;

    case VT_ZDM_PARAM_ORIGINAL_CHARACTER_SET:
    
      attributeInfo.name = VoltZDM2OriginalCharacterSetAttributeName;
      attributeInfo.value = (const unsigned char*)setInfo;
      attributeParam = (localCtx->mCurrentEntryType == VT_ZDM_CURRENT_ENTRY_ATTACHMENT) ?
        VtSecureArchiveParamEntryAttribute : VtSecureArchiveParamArchiveAttribute;
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        attributeParam, (Pointer)&attributeInfo);
      break;
      
    case VT_ZDM_PARAM_PRIMARY_EMAIL_LIST:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltZDM2EmailRecipientListCopy(libCtx,
        (VtZDMEmailRecipientList*)setInfo,
        &localCtx->mPrimaryEmailRecipientList);
      break;
      
    case VT_ZDM_PARAM_CC_EMAIL_LIST:

      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltZDM2EmailRecipientListCopy(libCtx,
        (VtZDMEmailRecipientList*)setInfo,
        &localCtx->mCCEmailRecipientList);
      break;
    
    case VT_ZDM_PARAM_NEW_LINE_CHAR:
      
      localCtx->mNewLineCharacter = *(unsigned int*)setInfo;
      if (localCtx->mNewLineCharacter == VT_ZDM_NEW_LINE_CR_LF)
        localCtx->mNewLineString = VoltZDM2NewLineCRLF;
      else if (localCtx->mNewLineCharacter == VT_ZDM_NEW_LINE_LF)
        localCtx->mNewLineString = VoltZDM2NewLineLF;
      break;
      
    case VT_ZDM_PARAM_SUBJECT_LINE:

      attributeInfo.name = VoltZDM2SubjectAttributeName;
      attributeInfo.value = (const unsigned char*)setInfo;
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamArchiveAttribute, (Pointer)&attributeInfo);
      break;
      
    case VT_ZDM_PARAM_REPLY_TO:
    
      attributeInfo.name = VoltZDM2ReplyToAttributeName;
      attributeInfo.value = (const unsigned char*)setInfo;
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamArchiveAttribute, (Pointer)&attributeInfo);
      break;
      
    case VT_ZDM_PARAM_MESSAGE_ID:

      messageID = (unsigned char*)setInfo;
      
      /* Keep a copy of the message ID, so we can include it
       * later on in the insecure attributes entry.
       */
      length = Z2Strlen(messageID) + 1;
      localCtx->mMessageID = (unsigned char*) Z3Malloc(length);
      if (localCtx->mMessageID == (unsigned char*)0)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        status = VT_ERROR_MEMORY;
        break;
      }
      Z2Memcpy(localCtx->mMessageID, messageID, length);
      
      attributeInfo.name = VoltZDM2MessageIDAttributeName;
      attributeInfo.value = messageID;
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamArchiveAttribute, (Pointer)&attributeInfo);
      break;

    case VT_ZDM_PARAM_TEMPLATE_CHARSET:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltZDM2SetTemplateVariable(zdmObj,
        VoltZDM2CharSetVariableName, (unsigned char*)setInfo);
      break;
      
    case VT_ZDM_PARAM_DESIGNATED_RECIPIENT:

      VT_ASSERT(localCtx->mTemplateVariables != (VtDataNodeObject)0);
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = Z2Strdup((unsigned char*)setInfo, &localCtx->mDesignatedRecipient);
      if (status != 0)
      {
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        break;
      }

      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltZDM2SetTemplateVariable(zdmObj,
        VoltZDM2DesignatedRecipientVariableName, (unsigned char*)setInfo);
      break;

    case VT_ZDM_PARAM_COMPRESSION_ENABLED:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamCompressionEnabled, setInfo);
      break;
      
    case VT_ZDM_PARAM_SURRENDER_CALLBACK:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetSecureArchiveParam(localCtx->mSecureArchive,
        VtSecureArchiveParamSurrenderCallback, setInfo);
      break;

    case VT_ZDM_PARAM_MAX_INPUT_FIELD_SIZE:
    
      localCtx->mMaxInputFieldSize = *(unsigned int*)setInfo;
      break;
          
    default:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
      status = VT_ERROR_INVALID_SET;
      break;
  }
  
  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, errorType,
    fnctLine, "VoltZDM2WriteSetParam", (unsigned char*)0)
    
  return status;
}

static int VoltZDM2GetZDMLocationAndVersion(
  VtDistrictObject districtObj,
  unsigned char** zdmLocation,
  int* zdmVersion
)
{
  int status = 0;
  VtLibCtx libCtx;
  VtX509ExtensionList* extensionList;
  unsigned int index;
  UInt32 lenLo, lenHi;
  VtItem* zdmLocationItem = (VtItem*)0;
  unsigned int tag, lengthLen, valueLen;
  unsigned char oldZdrLocationOid[VoltParamExtOldZdrOidBytesLen] =
    { VoltParamExtOldZdrOidBytes };
  unsigned char newZdrLocationOid[VoltParamExtZdrSrvOidBytesLen] =
    { VoltParamExtZdrSrvOidBytes };
  unsigned char zdrVersionOid[VoltParamExtZdrVersionOidBytesLen] =
    { VoltParamExtZdrVersionOidBytes };
  int foundNewZdrLocation = 0;
  VOLT_DECLARE_FNCT_LINE(fnctLine)
  VOLT_DECLARE_ERROR_TYPE(errorType)

  VT_ASSERT(districtObj != (VtDistrictObject)0);
  VT_ASSERT(zdmLocation != (Pointer*)0);
  VT_ASSERT(zdmVersion != (unsigned int*)0);
  
  libCtx = districtObj->voltObject.libraryCtx;
  VT_ASSERT(libCtx != (VtLibCtx)0);
  
  *zdmLocation = (unsigned char*)0;
  *zdmVersion = 1;
  
  VOLT_SET_ERROR_TYPE(errorType, 0)

  do
  {
    VOLT_SET_FNCT_LINE(fnctLine)
    status = VtGetDistrictParam(districtObj, VtDistrictParamExtensions,
      (Pointer *)&extensionList);
    if (status == VT_ERROR_GET_INFO_UNAVAILABLE)
    {
      status = 0;
      break;
    }
    if (status != 0)
      break;

    for (index = 0; index < extensionList->count; ++index)
    {
      /* Check for the new ZDR location extension */
      if ((extensionList->extensions[index].oid.len ==
        VoltParamExtZdrSrvOidBytesLen) &&
        (Z2Memcmp(extensionList->extensions[index].oid.data,
        newZdrLocationOid, VoltParamExtZdrSrvOidBytesLen) == 0))
      {
        zdmLocationItem = &(extensionList->extensions[index].value);
        foundNewZdrLocation = 1;
      }

      /* If we haven't found the new location, then check for
       * the old ZDR location extension
       */
      else if (!foundNewZdrLocation &&
        (extensionList->extensions[index].oid.len ==
        VoltParamExtOldZdrOidBytesLen) &&
        (Z2Memcmp(extensionList->extensions[index].oid.data,
        oldZdrLocationOid, VoltParamExtOldZdrOidBytesLen) == 0))
      {
        zdmLocationItem = &(extensionList->extensions[index].value);
      }
      
      /* Check for the version extension */
      else if ((extensionList->extensions[index].oid.len ==
        VoltParamExtZdrVersionOidBytesLen) &&
        (Z2Memcmp(extensionList->extensions[index].oid.data,
        zdrVersionOid, VoltParamExtZdrVersionOidBytesLen) == 0))
      {
        /* TODO: Real decoding logic */
        if ((extensionList->extensions[index].value.len != 3) ||
          (extensionList->extensions[index].value.data[0] != 2) ||
          (extensionList->extensions[index].value.data[1] != 1))
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
          status = VT_ERROR_INVALID_ZDM_VERSION;
          break;
        }
        *zdmVersion = extensionList->extensions[index].value.data[2];
      }
    }
    
    if (status != 0)
      break;
      
    if (zdmLocationItem != (VtItem*)0)
    {
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltDecodeTagAndLen (
        libCtx, zdmLocationItem->data, zdmLocationItem->len, &tag, &lengthLen,
        &lenLo, &lenHi, sizeof (unsigned int));
      if (status != 0)
        break;

      valueLen = (unsigned int)lenLo;
      
      *zdmLocation = (unsigned char*) Z3Malloc(valueLen + 1);
      if (*zdmLocation == (unsigned char*)0)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        status = VT_ERROR_MEMORY;
        break;
      }
      
      Z2Memcpy(*zdmLocation, zdmLocationItem->data + lengthLen + 1, valueLen);
      (*zdmLocation)[valueLen] = 0;
    }
  }
  while (0);
  
  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, errorType,
    fnctLine, "VoltZDM2GetZDMLocationAndVersion", (unsigned char*)0)
    
  return status;
}

static int VoltZDM2GetDistrictParamInfo(
  VtZDMObject zdmObj,
  VtIdentityObject identity,
  unsigned char** zdmLocation,
  int* supportedVersion,
  int* external
)
{
  int status = 0;
  VoltZDM2WriteLocalCtx* localCtx;
  VtLibCtx libCtx = (VtLibCtx)0;
  VtDistrictObject district = (VtDistrictObject)0;
  unsigned int encodingLen;
  unsigned char* districtName;
  unsigned int districtNameLen;
  unsigned char* address;