sawrite.c

IBE是一种非对称密码技术

        status = VtCreateDataNodeObject(libCtx,
          VoltSecureArchiveEntryAttributeName, &entryNode);
        if (status != 0)
          break;
        
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtDataNodeInsertChild(entryListNode, entryNode,
          VT_DATA_NODE_INSERT_AT_END);
        if (status != 0)
        {
          VtDestroyDataNodeObject(&entryNode);
          break;
        }
        
        localCtx->mSecureEntryCount++;
      }
      else if (currentEntryInfo->type == VT_SECURE_ARCHIVE_CURRENT_ENTRY_DONE)
      {
        VT_ASSERT(localCtx->mOutputStream != (VtStreamObject)0);
        
        if (localCtx->mArchiveObject != (VtArchiveObject)0)
        {
          /* We've finished inputting all the entry & index data.
          * Now we need to write out the index to the archive and
          * close up the archive before outputting the archive data.
          */
          
          /* The index entry in the archive is composed of the
          * XML-formatted attribute data followed by the optional
          * index data (e.g. the main message body for ZDM2)
          */
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VoltCreateTempBufferStream(libCtx,
            &localCtx->mBufferTypeInfo, &indexStream);
          if (status != 0)
            break;
          
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VoltSecureArchiveUpdateAttributes(secureArchiveObj);
          if (status != 0)
            break;
          
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtStreamWrite(indexStream, VoltSecureArchiveHeadersName,
            Z2Strlen(VoltSecureArchiveHeadersName));
          if (status != 0)
            break;
            
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtStreamWrite(indexStream, ": ", 2);
          if (status != 0)
            break;
            
          formatFlags = VT_DATA_NODE_XML_FORMAT_SET_INDENT(1) |
            VT_DATA_NODE_XML_FORMAT_INDENT_SPACES |
            VT_DATA_NODE_XML_FORMAT_SET_NEW_LINE(VT_DATA_NODE_XML_FORMAT_NEW_LINE_LF) |
            VT_DATA_NODE_XML_FORMAT_SET_SPACES_PER_INDENT(1) |
            VT_DATA_NODE_XML_FORMAT_NEW_LINE_PER_ELEMENT |
            VT_DATA_NODE_XML_FORMAT_INDENT_CHILD_ELEMENTS;
            
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtDataNodeWriteXML(localCtx->mAttributes, formatFlags,
            indexStream);
          if (status != 0)
            break;
          
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtStreamWrite(indexStream, "\n", 1);
          if (status != 0)
            break;
            
          if (localCtx->mIndexDataStream != (VtStreamObject)0)
          {
            VOLT_SET_FNCT_LINE(fnctLine)
            status = VtStreamCopySection(localCtx->mIndexDataStream,
              0, VT_STREAM_SIZE_MAX, indexStream, (VtStreamSize*)0);
            if (status != 0)
              break;
          }
          
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtSetArchiveParam(localCtx->mArchiveObject,
            VtArchiveParamCurrentEntryPath, (Pointer)VoltSecureArchiveIndexFilePathName);
          if (status != 0)
            break;
            
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VoltSecureArchiveEncryptStream(secureArchiveObj,
            indexStream, &localCtx->mEncryptedIndexSize);
          if (status != 0)
            break;
          
          VtDestroyStreamObject(&localCtx->mIndexDataStream);
          
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtArchiveWriteFinal(localCtx->mArchiveObject,
            (unsigned char*)0, 0, (unsigned int*)0);
          if (status != 0)
            break;
          
          VtDestroyArchiveObject(&localCtx->mArchiveObject);
          
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtStreamSetPosition(localCtx->mOutputStream,
            0, VT_STREAM_FROM_START);
          if (status != 0)
            break;
        }
      }
      
      localCtx->mCurrentEntryType = currentEntryInfo->type;
      
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_ENTRY_ATTRIBUTE:
    case VOLT_SECURE_ARCHIVE_PARAM_ARCHIVE_ATTRIBUTE:
    
      attributeInfo = (VtSecureArchiveAttributeInfo*)setInfo;
      if ((attributeInfo->name == (unsigned char*)0) ||
          (attributeInfo->value == (unsigned char*)0))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_ASSOCIATED_INFO;
        break;
      }
      
      if (VoltSecureArchiveHasConsecutiveEOL(attributeInfo->value))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_END_OF_LINES;
        break;
      }
    
      /** TODO: Should check that attribute name isn't one of the
        * attributes used internally by the secure archive object
        */
        
      VT_ASSERT(localCtx->mAttributes != (VtDataNodeObject)0);
      
      if (paramSelector == VOLT_SECURE_ARCHIVE_PARAM_ENTRY_ATTRIBUTE)
      {
        if (localCtx->mCurrentEntryType != VT_SECURE_ARCHIVE_CURRENT_ENTRY_SECURE)
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VT_ERROR_INVALID_SECURE_ARCHIVE_ENTRY;
          break;
        }
        
        VT_ASSERT(localCtx->mSecureEntryCount > 0);
        
        VOLT_SET_ERROR_TYPE(errorType, 0)
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VoltSecureArchiveSetEntryAttribute(secureArchiveObj,
          localCtx->mSecureEntryCount - 1, attributeInfo->name,
          attributeInfo->value);
        if (status != 0)
          break;
      }
      else
      {
        VOLT_SET_ERROR_TYPE(errorType, 0)
        
        status = VtDataNodeResolveChild(localCtx->mAttributes,
          attributeInfo->name, 1, &dataNode);
        if (status != 0)
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          VOLT_SET_ERROR_DESC(description, (unsigned char*)attributeInfo->name)
          status = VT_ERROR_SECURE_ARCHIVE_ATTR_NAME;
          break;
        }
        
        status = VtDataNodeSetStringValue(dataNode, attributeInfo->value);
        if (status != 0)
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VT_ERROR_SECURE_ARCHIVE_SET_ATTR;
          break;
        }
      }
      
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_OUTPUT_STREAM:
    
      outputStream = (VtStreamObject)setInfo;
      if (VOLT_OBJECT_TYPE_NOT_EQUAL(outputStream, VOLT_OBJECT_TYPE_STREAM))
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_ASSOCIATED_INFO;
        break;
      }
      localCtx->mOutputStream = outputStream;
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_COMPRESSION_ENABLED:
    
      localCtx->mCompressionEnabled = (*(int*)setInfo != 0);
      break;
    
    case VOLT_SECURE_ARCHIVE_PARAM_OUTPUT_TYPE:
    
      if (localCtx->mCurrentEntryType != VT_SECURE_ARCHIVE_CURRENT_ENTRY_DONE)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VT_ERROR_INVALID_CALL_ORDER;
        break;
      }
      
      VOLT_SET_ERROR_TYPE(errorType, 0)
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtStreamSetPosition(localCtx->mOutputStream, 0, VT_STREAM_FROM_START);
      if (status != 0)
        break;
        
      localCtx->mOutputType = *(int*)setInfo;
      
      if (localCtx->mOutputType == VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ENCRYPTED_INDEX)
      {
        VtDestroyArchiveObject(&localCtx->mArchiveObject);
        
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtCreateArchiveObject(libCtx, VtArchiveImplZipRead, 
          (Pointer)0, &localCtx->mArchiveObject);
        if (status != 0)
          break;

        bufferTypeInfo.bufferType = VT_BUFFER_TYPE_STREAM;
        bufferTypeInfo.streamObj = localCtx->mOutputStream;
        
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtSetArchiveParam(localCtx->mArchiveObject,
          VtArchiveParamBufferType, (Pointer)&bufferTypeInfo);
        if (status != 0)
          break;
        
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtArchiveReadInit(localCtx->mArchiveObject);
        if (status != 0)
          break;
                  
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtSetArchiveParam(localCtx->mArchiveObject,
          VtArchiveParamCurrentEntryPath,
          (Pointer)VoltSecureArchiveIndexFilePathName);
        if (status != 0)
          break;
      }
      
      break;
      
    case VOLT_SECURE_ARCHIVE_PARAM_SURRENDER_CALLBACK:
    
      VOLT_SET_ERROR_TYPE(errorType, 0)
      VOLT_SET_FNCT_LINE (fnctLine)
      status = VoltSetObjectSurrender (
        (VoltObject *)secureArchiveObj, setInfo, 0, 0, 0);
      break;
       
    default:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VT_ERROR_INVALID_SET;
      break;
  }
  
  VtDestroyStreamObject(&indexStream);

  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, errorType,
    fnctLine, "VoltSecureArchiveWriteSetParam", description)
    
  return status;
}

int VoltSecureArchiveWriteGetParam(
   VtSecureArchiveObject secureArchiveObj,
   int paramSelector,
   Pointer* getInfo
)
{
  int status = 0;
  VtLibCtx libCtx = (VtLibCtx)0;
  VoltSecureArchiveWriteLocalCtx* localCtx;
  VtStreamSize position;
  VtStreamSize size;
  VOLT_DECLARE_FNCT_LINE(fnctLine)
  VOLT_DECLARE_ERROR_TYPE(errorType)

  VT_ASSERT(secureArchiveObj != (VtSecureArchiveObject)0);
  
  libCtx = secureArchiveObj->voltObject.libraryCtx;
  VT_ASSERT(libCtx != (VtLibCtx)0);
  localCtx = (VoltSecureArchiveWriteLocalCtx*) secureArchiveObj->localCtx;
  VT_ASSERT(localCtx != (VoltSecureArchiveWriteLocalCtx*)0);
  
  VOLT_SET_ERROR_TYPE(errorType, 0)
  
  switch (paramSelector)
  {
    case VOLT_SECURE_ARCHIVE_PARAM_SIGNER_ID:
    
      *(VtIdentityObject*)getInfo = localCtx->mSignerID;
      break;
    
    case VOLT_SECURE_ARCHIVE_PARAM_RECIPIENT_LIST:

      *getInfo = (Pointer)(localCtx->mRecipientList);
      if (localCtx->mRecipientList != (VtIdentityList)0)
        break;

      /* If there's no recipientList, there might be a
       * recipientInfoList.
       */
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VT_ERROR_GET_INFO_UNAVAILABLE;
      if (localCtx->mRecipientInfoList == (VtRecipientInfoList)0)
        break;

      status = 0;
      *getInfo = (Pointer)
        &(((VoltRecipientInfoList *)(localCtx->mRecipientInfoList))->idListRef);
      break;

    case VOLT_SECURE_ARCHIVE_PARAM_RECIPIENT_INFO_LIST:

      VOLT_SET_FNCT_LINE(fnctLine)
      status = VT_ERROR_GET_INFO_UNAVAILABLE;
      if (localCtx->mRecipientInfoList == (VtRecipientInfoList)0)
        break;

      status = 0;
      *getInfo = (Pointer)(localCtx->mRecipientInfoList);
      break;

    case VOLT_SECURE_ARCHIVE_PARAM_ATTRIBUTES_NODE:
      
      *(VtDataNodeObject*)getInfo = localCtx->mAttributes;
      break;
    
    case VOLT_SECURE_ARCHIVE_PARAM_INDEX_SIZE:
      
      *(unsigned int*)getInfo = localCtx->mEncryptedIndexSize;
      break;
    
    case VOLT_SECURE_ARCHIVE_PARAM_REMAINING_OUTPUT_SIZE:
    
      if (localCtx->mCurrentEntryType != VT_SECURE_ARCHIVE_CURRENT_ENTRY_DONE)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        status = VT_ERROR_INVALID_CALL_ORDER;
        break;
      }
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtStreamGetPosition(localCtx->mOutputStream, &position);
      if (status != 0)
        break;
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtStreamGetSize(localCtx->mOutputStream, &size);
      if (status != 0)
        break;
      
      *(unsigned int*)getInfo = size - position;
      
      break;
      
    default:
    
      VOLT_SET_FNCT_LINE(fnctLine)
      VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
      status = VT_ERROR_INVALID_GET;
      break;
  }
  
  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, 0,
    fnctLine, "VoltSecureArchiveWriteGetParam", (unsigned char*)0)
    
  return status;
}

int VoltSecureArchiveWriteInit(
   VtSecureArchiveObject secureArchiveObj,
   VtPolicyCtx policyCtx,
   VtStorageCtx storageCtx,
   VtTransportCtx transportCtx,
   VtRandomObject random
)
{
  int status = 0;
  VtLibCtx libCtx = (VtLibCtx)0;
  VoltSecureArchiveWriteLocalCtx* localCtx;
  VtBufferTypeInfo bufferTypeInfo;
  VOLT_DECLARE_FNCT_LINE(fnctLine)

  VT_ASSERT(secureArchiveObj != (VtSecureArchiveObject)0);
  
  libCtx = secureArchiveObj->voltObject.libraryCtx;
  VT_ASSERT(libCtx != (VtLibCtx)0);
  localCtx = (VoltSecureArchiveWriteLocalCtx*) secureArchiveObj->localCtx;
  VT_ASSERT(localCtx != (VoltSecureArchiveWriteLocalCtx*)0);
  
  do
  {
    if (policyCtx != (VtPolicyCtx)0)
    {