sawrite.c

IBE是一种非对称密码技术

        break;
      
      if (localCtx->mCompressionEnabled)
        secureEntryInfo->mCompressedSize = entrySize;
      else
        secureEntryInfo->mSize = entrySize;

      prefixLength = Z2Strlen(VoltSecureArchiveFilePrefixPathName);
      Z2Memcpy(entryName, VoltSecureArchiveFilePrefixPathName, prefixLength);
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltNumToDecimalString(localCtx->mSecureEntryCount - 1,
        entryName + prefixLength, sizeof(entryName) - prefixLength, libCtx);
      if (status != 0)
        break;
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetArchiveParam(localCtx->mArchiveObject,
        VtArchiveParamCurrentEntryPath, (Pointer)entryName);
      if (status != 0)
        break;
        
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltSecureArchiveEncryptStream(secureArchiveObj,
        localCtx->mCurrentEntryStream, (unsigned int*)0);
      if (status != 0)
        break;
    }
    else if (localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_INSECURE)
    {
      buffer = (unsigned char*) Z3Malloc(VOLT_TEMP_BUFFER_SIZE);
      if (buffer == (unsigned char*)0)
      {
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_MEMORY;
        break;
      }
      
      /* Set the current entry of the archive object to be the previously
       * set insecure entry name
       */
      if (localCtx->mInsecureEntryName == (unsigned char*)0)
      {
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_CALL_ORDER;
        break;
      }
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtSetArchiveParam(localCtx->mArchiveObject,
        VtArchiveParamCurrentEntryPath,
        (Pointer)localCtx->mInsecureEntryName);
      if (status != 0)
        break;
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtStreamSetPosition(localCtx->mCurrentEntryStream,
        0, VT_STREAM_FROM_START);
      if (status != 0)
        break;
        
      /* Copy the contents of the entry stream over to the archive */
      for (;;)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtStreamRead(localCtx->mCurrentEntryStream,
          buffer, VOLT_TEMP_BUFFER_SIZE, &readSize);
        if (status != 0)
        {
          if (status == VT_ERROR_END_OF_STREAM)
            status = 0;
          break;
        }
        
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtArchiveWriteUpdate(localCtx->mArchiveObject,
          buffer, readSize, (unsigned char*)0, 0, (unsigned int*)0);
        if (status != 0)
          break;
      }
    }
  }
  while (0);
  
  VtDestroyStreamObject(&localCtx->mCurrentEntryStream);
  Z2Free(buffer);
  
  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, errorType,
    fnctLine, "VoltSecureArchiveWriteCurrentEntry", (unsigned char*)0)
    
  return status;
}

int VoltSecureArchiveWriteSetParam(
  VtSecureArchiveObject secureArchiveObj,
  int paramSelector,
  Pointer setInfo
)
{
  int status = 0;
  VoltSecureArchiveWriteLocalCtx* localCtx;
  VtLibCtx libCtx = (VtLibCtx)0;
  VtIdentityObject signerID;
  VtSecureArchiveSignerInfo* signerInfo;
  VtIdentityList recipientList;
  VtRecipientInfoList recipientInfoList;
  VtStreamObject outputStream;
  VtSecureArchiveAttributeInfo* attributeInfo;
  VtDataNodeObject dataNode;
  VoltSecureArchiveEntryInfo* secureEntryInfo;
  unsigned char* name;
  unsigned int nameLength;
  unsigned char* nameCopy;
  VtSecureArchiveCurrentEntryInfo* currentEntryInfo;
  VoltSecureArchiveEntryInfo* newSecureEntryInfo;
  int newSecureEntryMax;
  VtDataNodeObject entryListNode = (VtDataNodeObject)0;
  VtDataNodeObject entryNode = (VtDataNodeObject)0;
  unsigned int formatFlags;
  VtStreamObject indexStream = (VtStreamObject)0;
  VtBufferTypeInfo bufferTypeInfo;
  VOLT_DECLARE_FNCT_LINE(fnctLine)
  VOLT_DECLARE_ERROR_TYPE(errorType)
  VOLT_DECLARE_ERROR_DESC(description)
  
  VT_ASSERT(secureArchiveObj != (VtSecureArchiveObject)0);
  
  VOLT_SET_ERROR_DESC(description, 0)
  
  libCtx = secureArchiveObj->voltObject.libraryCtx;
  VT_ASSERT(libCtx != (VtLibCtx)0);
  localCtx = (VoltSecureArchiveWriteLocalCtx*) secureArchiveObj->localCtx;
  VT_ASSERT(localCtx != (VoltSecureArchiveWriteLocalCtx*)0);
  
  VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)

  switch (paramSelector)
  {
    case VOLT_SECURE_ARCHIVE_PARAM_SIGNER_ID:
    
      signerID = (VtIdentityObject)setInfo;
      
      /* Check that we were passed a valid identity object */
      if (VOLT_OBJECT_TYPE_NOT_EQUAL(signerID, VOLT_OBJECT_TYPE_IDENTITY))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_ASSOCIATED_INFO;
        break;
      }
      
      /* The caller should only set the signer ID once (either via
        * SetSignerID or SetSignerInfo, so it's an error if the signer
        * has already been set.
        */
      if ((localCtx->mSignerID != (VtIdentityObject)0) ||
          (localCtx->mSignerCert != (VtCertObject)0) ||
          (localCtx->mSignerPrivateKey != (VtKeyObject)0))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_CALL_ORDER;
        break;
      }
      
      /* Clone the identity object, so we're not dependent on the caller
        * not destroying the identity object.
        */
      VOLT_SET_FNCT_LINE(fnctLine)
      VOLT_SET_ERROR_TYPE(errorType, 0)
      status = VtCloneObject((Pointer)signerID,
        (Pointer*)&localCtx->mSignerID);
        
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_SIGNER_INFO:
    
      signerInfo = (VtSecureArchiveSignerInfo*) setInfo;
      
      /* The caller should only set the signer info once (either via
        * SetSignerID or SetSignerInfo, so it's an error if the signer
        * has already been set.
        */
      if ((localCtx->mSignerID != (VtIdentityObject)0) ||
          (localCtx->mSignerCert != (VtCertObject)0) ||
          (localCtx->mSignerPrivateKey != (VtKeyObject)0))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_CALL_ORDER;
        break;
      }

      VOLT_SET_ERROR_TYPE(errorType, 0)
      
      if (signerInfo->privateKey != (VtKeyObject)0)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtCloneObject((Pointer)signerInfo->privateKey,
          (Pointer*)&localCtx->mSignerPrivateKey);
        if (status != 0)
          break;
      }
      
      if (signerInfo->signerCert != (VtCertObject)0)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtCloneObject((Pointer)signerInfo->signerCert,
          (Pointer*)&localCtx->mSignerCert);
        if (status != 0)
          break;
      }
      
      if (signerInfo->signerId != (VtIdentityObject)0)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtCloneObject((Pointer)signerInfo->signerId,
          (Pointer*)&localCtx->mSignerID);
        if (status != 0)
          break;
      }

      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_RECIPIENT_LIST:
      
      recipientList = (VtIdentityList)setInfo;
      
      /* Check that we were passed a valid identity object */
      if (VOLT_OBJECT_TYPE_NOT_EQUAL(recipientList, VOLT_OBJECT_TYPE_IDENTITY_LIST))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_ASSOCIATED_INFO;
        break;
      }
      
      VOLT_SET_ERROR_TYPE(errorType, 0)
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtCloneObject((Pointer)recipientList,
        (Pointer*)&localCtx->mRecipientList);
      
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_RECIPIENT_INFO_LIST:

      recipientInfoList = (VtRecipientInfoList)setInfo;

      /* Check that we were passed a valid identity object */
      if (VOLT_OBJECT_TYPE_NOT_EQUAL(
        recipientInfoList, VOLT_OBJECT_TYPE_RECIP_INFO_LIST))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_ASSOCIATED_INFO;
        break;
      }

      VOLT_SET_ERROR_TYPE(errorType, 0)
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtCloneObject((Pointer)recipientInfoList,
        (Pointer*)&localCtx->mRecipientInfoList);

      break;

    case VOLT_SECURE_ARCHIVE_PARAM_3DESCBC:
    
      localCtx->mEncryptionParam = VtPkcs7ParamEnv3DESCBC;
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_AES128CBC:
    
      localCtx->mEncryptionParam = VtPkcs7ParamEnvAES128CBC;
      break;
      
    case VOLT_SECURE_ARCHIVE_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;
      }
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_FILE_NAME:
    
      name = (unsigned char*)setInfo;

      if (VoltSecureArchiveHasConsecutiveEOL(name))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_END_OF_LINES;
        break;
      }
      
      nameLength = Z2Strlen(name);
      nameCopy = (unsigned char*) Z3Malloc(nameLength + 1);
      if (nameCopy == (unsigned char*)0)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_MEMORY;
        break;
      }
      
      Z2Memcpy(nameCopy, name, nameLength + 1);
      
      if (localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_SECURE)
      {
        if (localCtx->mSecureEntryCount <= 0)
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VT_ERROR_INVALID_SECURE_ARCHIVE_ENTRY;
        }
        else
        {
          VT_ASSERT(localCtx->mSecureEntryInfo);
          secureEntryInfo = localCtx->mSecureEntryInfo + localCtx->mSecureEntryCount - 1;
          Z2Free(secureEntryInfo->mName);
          secureEntryInfo->mName = nameCopy;
          nameCopy = (unsigned char*)0;
        }
      }
      else if (localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_INSECURE)
      {
        /* Free up the old name if necessary. Store the copy of the
          * name in the local context. It will be used later when we
          * write the data to the underlying archive object.
          */
        Z2Free(localCtx->mInsecureEntryName);
        
        /* Copy the name field over to the secure archive object. 
          */
        localCtx->mInsecureEntryName = nameCopy;
        nameCopy = (unsigned char*)0;
      }
      else
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_SECURE_ARCHIVE_ENTRY;
      }
      Z2Free(nameCopy);
      break;
    
    case VOLT_SECURE_ARCHIVE_PARAM_MOD_DATE:
      
      if ((localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_SECURE) &&
        (localCtx->mSecureEntryCount > 0))
      {
        VT_ASSERT(localCtx->mSecureEntryInfo);
        secureEntryInfo = localCtx->mSecureEntryInfo +
          localCtx->mSecureEntryCount - 1;
        secureEntryInfo->mModDate = *(VtTime*)setInfo;
        secureEntryInfo->mModDateSet = 1;
      }
      else
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_SECURE_ARCHIVE_ENTRY;
      }
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_CURRENT_ENTRY:
    
      VOLT_SET_ERROR_TYPE(errorType, 0)
      
      if (localCtx->mCurrentEntryStream != (VtStreamObject)0)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VoltSecureArchiveWriteCurrentEntry(secureArchiveObj);
        if (status != 0)
          break;
      }
      
      currentEntryInfo = (VtSecureArchiveCurrentEntryInfo*)setInfo;
      
      if (currentEntryInfo->type == VT_SECURE_ARCHIVE_CURRENT_ENTRY_SECURE)
      {
        /* Expand the secure entry array if necessary */
        if (localCtx->mSecureEntryCount == localCtx->mSecureEntryMax)
        {
          newSecureEntryMax = (localCtx->mSecureEntryMax * 2) + 1;
          newSecureEntryInfo = (VoltSecureArchiveEntryInfo*)
            Z3Malloc(newSecureEntryMax * sizeof(VoltSecureArchiveEntryInfo));
          if (newSecureEntryInfo == (VoltSecureArchiveEntryInfo*)0)
          {
            VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
            VOLT_SET_FNCT_LINE(fnctLine)
            status = VT_ERROR_MEMORY;
            break;
          }
          Z2Memset(newSecureEntryInfo, 0, newSecureEntryMax *
            sizeof(VoltSecureArchiveEntryInfo));
          Z2Memcpy(newSecureEntryInfo, localCtx->mSecureEntryInfo,
            localCtx->mSecureEntryCount * sizeof(VoltSecureArchiveEntryInfo));
          Z2Free(localCtx->mSecureEntryInfo);
          localCtx->mSecureEntryInfo = newSecureEntryInfo;
          localCtx->mSecureEntryMax = newSecureEntryMax;
        }
        
        VT_ASSERT(localCtx->mSecureEntryCount < localCtx->mSecureEntryMax);
        
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtDataNodeResolveChild(localCtx->mAttributes,
          VoltSecureArchiveEntryListAttributeName, 1, &entryListNode);
        if (status != 0)
          break;
        
        VOLT_SET_FNCT_LINE(fnctLine)