sawrite.c

来自「voltage 公司提供的一个开发Ibe的工具包」· C语言 代码 · 共 2,044 行 · 第 1/5 页

      if (status == VT_ERROR_GET_INFO_UNAVAILABLE)
        status = 0;
      if (status != 0)
        break;
    }
    
    /* Stash away the contexts and random objects, so we can use them later
    * to init the PKCS7 objects.
    */
    localCtx->mPolicyCtx = policyCtx;
    localCtx->mStorageCtx = storageCtx;
    localCtx->mTransportCtx = transportCtx;
    localCtx->mRandom = random;
  
    /* Create the output stream for the archive object */
    if (localCtx->mOutputStream == (VtStreamObject)0)
    {
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VoltCreateTempBufferStream(libCtx,
        &localCtx->mBufferTypeInfo, &localCtx->mOutputStream);
      if (status != 0)
        break;
      VT_ASSERT(localCtx->mOutputStream != (VtStreamObject)0);
      localCtx->mDestroyOutputStream = 1;
    }
    
    /* Create the archive object */
    if (localCtx->mArchiveObject == (VtArchiveObject)0)
    {
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtCreateArchiveObject(libCtx, VtArchiveImplZipWrite,
        (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 = VtArchiveWriteInit(localCtx->mArchiveObject);
      if (status != 0)
        break;
    }
  }
  while (0);
  
  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, 0,
    fnctLine, "VoltSecureArchiveWriteGetParam", (unsigned char*)0)
    
  return status;
}

int VoltSecureArchiveWriteUpdate(
   VtSecureArchiveObject secureArchiveObj,
   unsigned char *inputData,
   unsigned int inputDataLen,
   unsigned char *message,
   unsigned int bufferSize,
   unsigned int *messageLen
)
{
  int status = 0;
  VtLibCtx libCtx = (VtLibCtx)0;
  VoltSecureArchiveWriteLocalCtx* localCtx;
  VtCompressObject compressObj = (VtCompressObject)0;
  VtStreamObject streamObj = (VtStreamObject)0;
  unsigned char* outputBuffer = (unsigned char*)0;
  unsigned char* inputPtr;
  unsigned int remainingInput;
  unsigned int inputConsumed;
  unsigned int compressedBytes;
  VtStreamSize readSize;
  VoltSecureArchiveEntryInfo* secureEntryInfo;
  VOLT_DECLARE_FNCT_LINE(fnctLine)
  VOLT_DECLARE_ERROR_TYPE(errorType)

  VT_ASSERT(secureArchiveObj != (VtSecureArchiveObject)0);
  
  libCtx = secureArchiveObj->voltObject.libraryCtx;
  localCtx = (VoltSecureArchiveWriteLocalCtx*) secureArchiveObj->localCtx;
  
  do
  {
    VOLT_SET_ERROR_TYPE(errorType, 0)

    if (localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_DONE)
    {
      if (localCtx->mOutputType == VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ARCHIVE)
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtStreamRead(localCtx->mOutputStream, message,
          bufferSize, &readSize);
        if (status != 0)
          break;
        *messageLen = readSize;
      }
      else
      {
        VT_ASSERT(localCtx->mOutputType ==
          VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ENCRYPTED_INDEX);
        VT_ASSERT(localCtx->mArchiveObject != (VtArchiveObject)0);
        
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtArchiveReadUpdate(localCtx->mArchiveObject,
          (unsigned char*)0, 0, message, bufferSize, messageLen);
        if (status != 0)
          break;
      }
    }
    else
    {
      /* Create the stream for the current entry if necessary */
      if (localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_INDEX)
      {
        if (localCtx->mIndexDataStream == (VtStreamObject)0)
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VoltCreateTempBufferStream(libCtx,
            &localCtx->mBufferTypeInfo, &localCtx->mIndexDataStream);
          if (status != 0)
            break;
        }
        
        streamObj = localCtx->mIndexDataStream;
      }
      else
      {
        if (localCtx->mCurrentEntryStream == (VtStreamObject)0)
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VoltCreateTempBufferStream(libCtx,
            &localCtx->mBufferTypeInfo, &localCtx->mCurrentEntryStream);
          if (status != 0)
            break;
          
          if (localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_SECURE)
          {
            VOLT_SET_FNCT_LINE(fnctLine)
            status = VtStreamWrite(localCtx->mCurrentEntryStream, "\n", 1);
            if (status != 0)
              break;
          }
        }
        
        streamObj = localCtx->mCurrentEntryStream;
        
        if ((localCtx->mCurrentEntryType == VT_SECURE_ARCHIVE_CURRENT_ENTRY_SECURE) &&
            localCtx->mCompressionEnabled)
        {
          /* Create the compress object if we haven't already */
          if (localCtx->mCompressObject == (VtCompressObject)0)
          {
            VOLT_SET_FNCT_LINE(fnctLine)
            status = VtCreateCompressObject(libCtx, VtCompressImplZlib,
              (Pointer)0, &localCtx->mCompressObject);
            if (status != 0)
              break;
            
            VOLT_SET_FNCT_LINE(fnctLine)
            status = VtCompressInit(localCtx->mCompressObject);
            if (status != 0)
              break;
          }
          
          VT_ASSERT(localCtx->mCompressObject != (VtCompressObject)0);
          
          compressObj = localCtx->mCompressObject;
        }
      }
      
      if (compressObj != (VtCompressObject)0)
      {
        VT_ASSERT(localCtx->mSecureEntryCount > 0);
        
        secureEntryInfo = localCtx->mSecureEntryInfo +
          localCtx->mSecureEntryCount - 1;
        secureEntryInfo->mSize += inputDataLen;
        
        outputBuffer = Z3Malloc(VOLT_TEMP_BUFFER_SIZE);
        if (outputBuffer == (unsigned char*)0)
        {
          VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VT_ERROR_MEMORY;
          break;
        }
        
        inputPtr = inputData;
        remainingInput = inputDataLen;
        
        while (remainingInput > 0)
        {
          VOLT_SET_FNCT_LINE(fnctLine)
          status = VtCompressUpdate(compressObj, 0, inputPtr,
            remainingInput, &inputConsumed, outputBuffer,
            VOLT_TEMP_BUFFER_SIZE, &compressedBytes);
          if (status != 0)
            break;
          
          if (compressedBytes > 0)
          {
            VOLT_SET_FNCT_LINE(fnctLine)
            status = VtStreamWrite(streamObj, outputBuffer, compressedBytes);
            if (status != 0)
              break;
          }
          
          inputPtr += inputConsumed;
          remainingInput -= inputConsumed;
        }
      }
      else
      {
        VOLT_SET_FNCT_LINE(fnctLine)
        status = VtStreamWrite(streamObj, inputData, inputDataLen);
        if (status != 0)
          break;
      }
    }
  }
  while (0);
  
  Z2Free(outputBuffer);
  
  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, errorType,
    fnctLine, "VoltSecureArchiveWriteUpdate", (unsigned char*)0)
    
  return status;
}

int VoltSecureArchiveWriteFinal(
   VtSecureArchiveObject secureArchiveObj,
   unsigned char *output,
   unsigned int bufferSize,
   unsigned int *outputLen
)
{
  int status = 0;
  VtLibCtx libCtx = (VtLibCtx)0;
  VoltSecureArchiveWriteLocalCtx* localCtx;
  VtStreamSize position;
  VtStreamSize size;
  VtStreamSize readSize;
  unsigned int remaining;
  VOLT_DECLARE_FNCT_LINE(fnctLine)
  VOLT_DECLARE_ERROR_TYPE(errorType)
  
  VT_ASSERT(secureArchiveObj != (VtSecureArchiveObject)0);
  
  libCtx = secureArchiveObj->voltObject.libraryCtx;
  localCtx = (VoltSecureArchiveWriteLocalCtx*) secureArchiveObj->localCtx;
  
  do
  {
    VOLT_SET_ERROR_TYPE(errorType, 0)

    if (localCtx->mOutputType == VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ARCHIVE)
    {
      /* Get the current position and size of the output stream so we
      * can see how much data is remaining. Since this is the final
      * call, the output buffer that was passed in needs to be big
      * enough to hold all of the remaining archive data. Otherwise
      * we return VT_ERROR_BUFFER_TOO_SMALL.
      */
      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;
      
      remaining = size - position;
    
      if (remaining > bufferSize)
      {
        VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)
        VOLT_SET_FNCT_LINE(fnctLine)
        *outputLen = remaining;
        status = VT_ERROR_BUFFER_TOO_SMALL;
        break;
      }
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtStreamRead(localCtx->mOutputStream, output,
        bufferSize, &readSize);
      *outputLen = (unsigned int) readSize;
    }
    else
    {
      VT_ASSERT(localCtx->mOutputType ==
        VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ENCRYPTED_INDEX);
      VT_ASSERT(localCtx->mArchiveObject != (VtArchiveObject)0);
      
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VtArchiveReadFinal(localCtx->mArchiveObject, 
        output, bufferSize, outputLen);
    }
  }
  while (0);
  
  VOLT_LOG_ERROR_COMPARE(status, libCtx, status, errorType,
    fnctLine, "VoltSecureArchiveWriteFinal", (unsigned char*)0)
    
  return status;
}

int VtSecureArchiveImplWrite(
   VtSecureArchiveObject* obj,
   Pointer associatedInfo,
   unsigned int flags
)
{
  int status = 0;  
  VoltSecureArchiveObject* secureArchiveObj = (VoltSecureArchiveObject*)0;  
  VoltSecureArchiveWriteLocalCtx* localCtx = (VoltSecureArchiveWriteLocalCtx*)0;
  VtLibCtx libCtx = (VtLibCtx)0;
  VOLT_DECLARE_FNCT_LINE(fnctLine)
  VOLT_DECLARE_ERROR_TYPE(errorType)
  
  VT_ASSERT(obj != (VtSecureArchiveObject*)0);
  VT_ASSERT(*obj != (VtSecureArchiveObject)0);
  
  do
  {
    VOLT_SET_ERROR_TYPE(errorType, VT_ERROR_TYPE_PRIMARY)

    if ((obj == (VtSecureArchiveObject*)0) ||
        (*obj == (VtSecureArchiveObject)0))
    {
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VT_ERROR_NULL_ARG;
      break;
    }
    
    if (associatedInfo != (Pointer)0)
    {
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VT_ERROR_INVALID_ASSOCIATED_INFO;
      break;
    }
    
    secureArchiveObj = (VoltSecureArchiveObject*)(*obj);
    libCtx = secureArchiveObj->voltObject.libraryCtx;
  
    /* Do parameter check for correct type */
    if (flags != VOLT_SECURE_ARCHIVE_SET_TYPE_FLAG)
    {
      VOLT_SET_FNCT_LINE(fnctLine)
	    status = VT_ERROR_INVALID_TYPE;
	    break;
    }
    
    localCtx = (VoltSecureArchiveWriteLocalCtx*)
      Z3Malloc(sizeof(VoltSecureArchiveWriteLocalCtx));
    if (localCtx == (VoltSecureArchiveWriteLocalCtx*)0)
    {
      VOLT_SET_FNCT_LINE(fnctLine)
      status = VT_ERROR_MEMORY;
      break;
    }
    
    Z2Memset(localCtx, 0, sizeof(VoltSecureArchiveWriteLocalCtx));
    
    VOLT_SET_ERROR_TYPE(errorType, 0)

    VOLT_SET_FNCT_LINE(fnctLine)
    status = VtCreateDataNodeObject(libCtx, VoltSecureArchiveRootAttributeName,
      &localCtx->mAttributes);
    if (status != 0)
      break;
    
    localCtx->mBufferTypeInfo.bufferType = VT_BUFFER_TYPE_MEMORY;
    localCtx->mEncryptionParam = VtPkcs7ParamEnvAES128CBC;
    localCtx->mCompressionEnabled = 1;
    localCtx->mCurrentEntryType = VT_SECURE_ARCHIVE_CURRENT_ENTRY_INDEX;
    localCtx->mOutputType = VOLT_SECURE_ARCHIVE_OUTPUT_TYPE_ARCHIVE;
    
    secureArchiveObj->localCtx = (Pointer) localCtx;
    
    secureArchiveObj->SetParam = VoltSecureArchiveWriteSetParam;
    secureArchiveObj->GetParam = VoltSecureArchiveWriteGetParam;
    secureArchiveObj->WriteInit = VoltSecureArchiveWriteInit;
    secureArchiveObj->WriteUpdate = VoltSecureArchiveWriteUpdate;
    secureArchiveObj->WriteFinal = VoltSecureArchiveWriteFinal;
    secureArchiveObj->LocalCtxDestroy = VoltSecureArchiveWriteLocalCtxDestroy;
  }
  while(0);  

  if (status != 0)
  {
    VoltSecureArchiveWriteLocalCtxDestroy((Pointer)secureArchiveObj, (Pointer)localCtx);
    
    VOLT_LOG_ERROR(libCtx, status, errorType, fnctLine,
      "VtSecureArchiveImplWrite", (char *)0)
  }
    
  return status;
}