IMPLEMENT_ASN1_FUNCTIONS (Asn1PasswordInfoFileContents)

#define VOLT_PASSWORD_SUPPORTED_DIGEST_ALGS VtDerCoderSHA1
#define VOLT_PASSWORD_SUPPORTED_DIGEST_ALGS_COUNT 1

#include <windows.h>
#include <Shlobj.h>
#include <wincrypt.h>

int VtStorageFileWin32 (
   VtStorageCtx storageCtx,
   Pointer info,
   unsigned int flag,
   int providerNum
   )
{
  int status;
  unsigned int pathNameLen, bufferSize, offset;
#if VOLT_ALIGNMENT != 1
  unsigned int pad;
#endif
  VoltStorageCtx *ctx = (VoltStorageCtx *)storageCtx;
  VtLibCtx libraryCtx = ctx->voltObject.libraryCtx;
  VoltLibCtx *libCtx = (VoltLibCtx *)libraryCtx;
  unsigned char *buffer = (unsigned char *)0;
  unsigned char *pathName = (unsigned char *)0;
  VoltDefaultStorageCtx *localCtx =
      (VoltDefaultStorageCtx *)0;
  VtFileCtx fCtx = (VtFileCtx)0;  
  VtFileCtxUseInfo *storageInfo;
  VOLT_DECLARE_FNCT_LINE (fnctLine)
  VOLT_DECLARE_ERROR_TYPE (errorType)

  do
  {
    /* Check the flag, it should be VOLT_STORAGE_CTX_SET_TYPE_FLAG.
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_INVALID_TYPE;
    if (flag != VOLT_STORAGE_CTX_SET_TYPE_FLAG)
      break;

    /* If the associated info is not NULL pointer, it should be a
     * VtFileCtxUseInfo pointer.
     */
    status = VT_ERROR_INVALID_ASSOCIATED_INFO;
    pathName = (char *)0;
    pathNameLen = 0;
    if (info != (Pointer)0)
    {
      storageInfo = (VtFileCtxUseInfo *)info;
      pathName = (char *)(storageInfo->path);
      if (pathName != (char *)0)
        pathNameLen = Z2Strlen (pathName);
      fCtx = storageInfo->fileCtx;      
    }

    /* If a fileCtx was not provided by the caller, try to get one from
     * the libCtx.
     */
    if (fCtx == (VtFileCtx)0)
    {
      fCtx = (VtFileCtx)VoltGetLibCtxInfo (
        (VtLibCtx)libCtx, VOLT_LIB_CTX_INFO_TYPE_FILE_CTX);

      /* If we still don't have a valid file ctx 
       * We can't work. return error
       */
      VOLT_SET_FNCT_LINE (fnctLine)
      if (fCtx == (VtFileCtx)0)
        break;      
    }

    VOLT_SET_FNCT_LINE (fnctLine)
    if (VOLT_OBJECT_TYPE_NOT_EQUAL (fCtx, VOLT_OBJECT_TYPE_FILE_CTX))
      break;

    /* Create the local ctx along with the pathName.
     */
    status = VT_ERROR_MEMORY;
    bufferSize =
      sizeof (VoltDefaultStorageCtx) + sizeof (mIcStoreCtx) +
      pathNameLen + 1 ;
#if VOLT_ALIGNMENT != 1
    /* If the alignment is 1, there's no need to pad. If not, compute
     * the pad length.
     */
    VOLT_COMPUTE_ALIGN_PAD
      (VOLT_ALIGNMENT, sizeof (VoltDefaultStorageCtx), pad)
    bufferSize += pad;
#endif
    buffer = (unsigned char *)Z2Malloc (bufferSize, 0);
    VOLT_SET_FNCT_LINE (fnctLine)
    if (buffer == (unsigned char *)0)
      break;
    Z2Memset (buffer, 0, bufferSize);

    /* Set the fields.
     */
    localCtx = (VoltDefaultStorageCtx *)buffer;
    offset = sizeof (VoltDefaultStorageCtx);
#if VOLT_ALIGNMENT != 1
    offset += pad;
#endif
    localCtx->icStoreCtx = (Pointer)(buffer + offset);
    if (pathNameLen != 0)
    {
      offset += sizeof (mIcStoreCtx);
      localCtx->pathName = (char *)(buffer + offset);
      Z2Memcpy (localCtx->pathName, pathName, pathNameLen);
      localCtx->pathNameLen = pathNameLen;
    }

    /* Clone the File context object to keep a local copy
     * of file context. We may need it later..
     */
    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtCloneObject ((Pointer)fCtx, (Pointer *)&(localCtx->fCtx) );
    if( status != 0)
        break;
    
    localCtx->GetExtraPassword = VoltGetExtraPassword;
    localCtx->ReleaseExtraPassword = VoltReleaseExtraPassword;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = mIcStorageSetup (
      libCtx, (mIcStoreCtx *)(localCtx->icStoreCtx));
    if (status != 0)
      break;

    /* Set the fields of the provider struct. 
     */
    ctx->providerNum                  = providerNum;
    ctx->storageTypeFlag              = VOLT_STORAGE_TYPE_TOOLKIT;
    ctx->localStorageCtx              = (Pointer)localCtx;
    ctx->LocalStorageCtxDestroy       = VoltDefaultStorageCtxDestroy;
    ctx->SetExtraPassword             = VoltWinSetExtraPassword;
    ctx->GetEnvelopeKey               = VoltDefaultGetEnvelopeKey;
    ctx->StoreCurrentDistrict         = VoltDefaultStoreCurrentDistrict;
    ctx->StoreDistrictParameters      = VoltDefaultStoreDistrictParameters;
    ctx->StoreAuthToken               = VoltDefaultStoreAuthToken;
    ctx->StoreIBEPrivateKey           = VoltDefaultStoreIBEPrivateKey;
    ctx->StorePrivateSigningKey       = VoltDefaultStorePrivateSigningKey;
    ctx->StorePublicSigningCert       = VoltDefaultStorePublicSigningCert;
    ctx->GetDistrictParameterCount    = VoltDefaultGetDistrictParameterCount;
    ctx->GetIBEPrivateKeyCount        = VoltDefaultGetIBEPrivateKeyCount;
    ctx->GetPrivateSigningKeyCount    = VoltDefaultGetPrivateSigningKeyCount;
    ctx->GetPublicSigningCertCount    = VoltDefaultGetPublicSigningCertCount;
    ctx->GetAuthTokenCount            = VoltDefaultGetAuthTokenCount;
    ctx->RetrieveNewAuthTokens        = VoltDefaultRetrieveNewAuthTokens;
    ctx->RetrieveCurrentDistrictAlloc = VoltDefaultRetrieveCurrentDistrictAlloc;
    ctx->RetrieveDistrictParameters   = VoltDefaultRetrieveDistrictParameters;
    ctx->RetrieveIBEPrivateKey        = VoltDefaultRetrieveIBEPrivateKey;
    ctx->RetrievePrivateSigningKey    = VoltDefaultRetrievePrivateSigningKey;
    ctx->RetrievePublicSigningCert    = VoltDefaultRetrievePublicSigningCert;
    ctx->DeleteCurrentDistrict        = VoltDefaultDeleteCurrentDistrict;
    ctx->DeleteDistrictParameters     = VoltDefaultDeleteDistrictParameters;
    ctx->DeleteIBEPrivateKey          = VoltDefaultDeleteIBEPrivateKey;
    ctx->DeletePrivateSigningKey      = VoltDefaultDeletePrivateSigningKey;
    ctx->DeletePublicSigningCert      = VoltDefaultDeletePublicSigningCert;
    ctx->DeleteAuthToken              = VoltDefaultDeleteAuthToken;

  } while (0);

  /* If success, we're done.
   */
  if (status == 0)
    return (0);

  /* If error, free up any memory we allocated and log the error
   */
  VoltDefaultStorageCtxDestroy ((Pointer)storageCtx, (Pointer) localCtx);  

  VOLT_LOG_ERROR (
    (VtLibCtx)libCtx, status, errorType, fnctLine,
    "VtStorageFileWin32", (char *)0)

  return (status);
}


#if VOLT_COMPILER != VOLT_MS_EVC_4_0

int VtStorageFileWin32Client (
   VtStorageCtx storageCtx,
   Pointer info,
   unsigned int flag,
   int providerNum
   )
{
  int status;
  unsigned int bufferSize, offset;
#if VOLT_ALIGNMENT != 1
  unsigned int pad;
#endif
  VoltStorageCtx *ctx = (VoltStorageCtx *)storageCtx;
  VtLibCtx libraryCtx = ctx->voltObject.libraryCtx;
  VoltLibCtx *libCtx = (VoltLibCtx *)libraryCtx;
  unsigned char *buffer = (unsigned char *)0;
  VoltDefaultStorageCtx *localCtx =
    (VoltDefaultStorageCtx *) 0;
  VtFileCtx fCtx = (VtFileCtx)0;    
  VOLT_DECLARE_FNCT_LINE (fnctLine)
  VOLT_DECLARE_ERROR_TYPE (errorType)

  do
  {
    /* Check the flag, it should be VOLT_STORAGE_CTX_SET_TYPE_FLAG.
     */
    VOLT_SET_ERROR_TYPE (errorType, VT_ERROR_TYPE_PRIMARY)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VT_ERROR_INVALID_TYPE;
    if (flag != VOLT_STORAGE_CTX_SET_TYPE_FLAG)
      break;

    /* If not NULL, the info should be a pointer to a
     * VtWin32ClientStorageInfo struct.
     */    
    status = VT_ERROR_INVALID_ASSOCIATED_INFO;
    if (info != (Pointer)0)
    {      
      fCtx = (VtFileCtx)info;     
    }

    /* If File Ctx has not been provided by the caller
     * Try to use one from the Lib Ctx.
     */
    if (fCtx == (VtFileCtx)0)
    {
      fCtx = (VtFileCtx)VoltGetLibCtxInfo (
        (VtLibCtx)libCtx, VOLT_LIB_CTX_INFO_TYPE_FILE_CTX);

      /* If we still don't have a valid file ctx, we can't do anything,
       * error.
       */
      VOLT_SET_FNCT_LINE (fnctLine)
      if (fCtx == (VtFileCtx)0)
        break;
    }

    VOLT_SET_FNCT_LINE (fnctLine)
    if (VOLT_OBJECT_TYPE_NOT_EQUAL (fCtx, VOLT_OBJECT_TYPE_FILE_CTX))
      break;

    /* Create the local ctx.
     */
    status = VT_ERROR_MEMORY;
    bufferSize = sizeof (VoltDefaultStorageCtx) + sizeof (mIcStoreCtx);
#if VOLT_ALIGNMENT != 1
    /* If the alignment is 1, there's no need to pad. If not, compute
     * the pad length.
     */
    VOLT_COMPUTE_ALIGN_PAD
      (VOLT_ALIGNMENT, sizeof (VoltDefaultStorageCtx), pad)
      bufferSize += pad;
#endif
    buffer = (unsigned char *)Z2Malloc (bufferSize, 0);
    VOLT_SET_FNCT_LINE (fnctLine)
    if (buffer == (unsigned char *)0)
      break;
    Z2Memset (buffer, 0, bufferSize);

    /* Set the fields.
     */
    localCtx = (VoltDefaultStorageCtx *)buffer;
    offset = sizeof (VoltDefaultStorageCtx);
#if VOLT_ALIGNMENT != 1
    offset += pad;
#endif
    localCtx->icStoreCtx = (Pointer)(buffer + offset);

    /* Clone the File context object to keep a local copy
     * of file context.
     */
    VOLT_SET_ERROR_TYPE (errorType, 0)
    VOLT_SET_FNCT_LINE (fnctLine)
    status = VtCloneObject ((Pointer)fCtx, (Pointer *)&(localCtx->fCtx));
    if (status != 0)
      break;
    
    localCtx->GetExtraPassword = VoltGetExtraPasswordClient;
    localCtx->ReleaseExtraPassword = VoltReleaseExtraPasswordClient;

    VOLT_SET_FNCT_LINE (fnctLine)
    status = mIcStorageSetup (
      libCtx, (mIcStoreCtx *)(localCtx->icStoreCtx));
    if (status != 0)
      break;

    /* Set the fields of the provider struct. 
     */
    ctx->providerNum                  = providerNum;    
    ctx->storageTypeFlag              = VOLT_STORAGE_TYPE_CLIENT;
    ctx->localStorageCtx              = (Pointer)localCtx;
    ctx->LocalStorageCtxDestroy       = VoltDefaultStorageCtxDestroy;
    ctx->SetExtraPassword             = VoltWinClientSetExtraPassword;
    ctx->GetEnvelopeKey               = VoltDefaultGetEnvelopeKey;
    ctx->StoreCurrentDistrict         = VoltClientStoreCurrentDistrict;
    ctx->StoreDistrictParameters      = VoltClientStoreDistrictParameters;
    ctx->StoreAuthToken               = VoltClientStoreAuthToken;
    ctx->StoreIBEPrivateKey           = VoltClientStoreIBEPrivateKey;
    ctx->StorePrivateSigningKey       = VoltClientStorePrivateSigningKey;    
    ctx->StorePublicSigningCert       = VoltClientStorePublicSigningCert;
    ctx->GetDistrictParameterCount    = VoltClientGetDistrictParameterCount;
    ctx->GetIBEPrivateKeyCount        = VoltClientGetIBEPrivateKeyCount;
    ctx->GetPrivateSigningKeyCount    = VoltClientGetPrivateSigningKeyCount;
    ctx->GetPublicSigningCertCount    = VoltClientGetPublicSigningCertCount;
    ctx->GetAuthTokenCount            = VoltClientGetAuthTokenCount;
    ctx->RetrieveNewAuthTokens        = VoltClientRetrieveNewAuthTokens;
    ctx->RetrieveCurrentDistrictAlloc = VoltClientRetrieveCurrentDistrictAlloc;
    ctx->RetrieveDistrictParameters   = VoltClientRetrieveDistrictParameters;
    ctx->RetrieveIBEPrivateKey        = VoltClientRetrieveIBEPrivateKey;
    ctx->RetrievePrivateSigningKey    = VoltClientRetrievePrivateSigningKey;
    ctx->RetrievePublicSigningCert    = VoltClientRetrievePublicSigningCert;
    ctx->DeleteCurrentDistrict        = VoltClientDeleteCurrentDistrict;
    ctx->DeleteDistrictParameters     = VoltClientDeleteDistrictParameters;
    ctx->DeleteIBEPrivateKey          = VoltClientDeleteIBEPrivateKey;
    ctx->DeletePrivateSigningKey      = VoltClientDeletePrivateSigningKey;
    ctx->DeletePublicSigningCert      = VoltClientDeletePublicSigningCert;
    ctx->DeleteAuthToken              = VoltClientDeleteAuthToken;

  } while (0);

  /* If success, we're done.
   */
  if (status == 0)
    return (0);

  /* If error, free up any memory we allocated.
   */
  VoltDefaultStorageCtxDestroy ((Pointer)storageCtx, (Pointer) localCtx); 

  VOLT_LOG_ERROR (
    (VtLibCtx)libCtx, status, errorType, fnctLine,
    "VtStorageFileWin32Client", (char *)0)

  return (status);
}

#endif /* VOLT_COMPILER != VOLT_MS_EVC_4_0 */

int getICDirectory (
   VoltLibCtx *libCtx,
   unsigned char *buf,
   int bufLen
   )
{
  int status;
  HRESULT shStatus;
  BOOL shBool;
  TCHAR path[VOLT_MAX_PATH + 1];
  char *VoltageName = "Voltage";
  char *temp;
  int len, VoltageNameLen;
  LPMALLOC mal = (LPMALLOC)0;
  ITEMIDLIST *idl = (ITEMIDLIST *)0;
  LPSTR szConverted = (LPSTR)0;

  Z2Memset (path, 0, sizeof (path));
  Z2Memset (buf, 0, bufLen);
  VoltageNameLen = 7;
  temp = (char *)buf;

  do
  {
    status = VT_ERROR_ENTRY_NOT_FOUND;
    shStatus = SHGetSpecialFolderLocation (NULL, CSIDL_APPDATA, &idl);
    if (shStatus != S_OK)
      break;

    SHGetMalloc (&mal);

    shBool = SHGetPathFromIDList (idl, path);

    mal->lpVtbl->Free (mal, (void *)idl);

    if (shBool != TRUE)
      break;

    len = _tcslen (path);
    if (path[len - 1] != '\\')
    {
      path[len] = '\\';
      path[len + 1] = '\0';
      len++;
    }

#ifdef UNICODE