Changeset 21354 for trunk/src


Ignore:
Timestamp:
Feb 21, 2010, 5:32:09 PM (16 years ago)
Author:
rlwalsh
Message:

eliminate VACPP warning & info msgs - see Ticket #1

Location:
trunk/src/crypt32
Files:
26 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/crypt32/base64.c

    r21311 r21354  
    379379        if (!ret)
    380380            outLen += len;
    381         if (cchString - (nextBlock - pszString) <= 0)
     381        if ((LONG)cchString - (nextBlock - pszString) <= 0)
    382382            nextBlock = NULL;
    383383    }

  • trunk/src/crypt32/cert.c

    r21311 r21354  
    2020#include <assert.h>
    2121#include <stdarg.h>
     22#include <string.h>
    2223
    2324#define NONAMELESSUNION
    … …  
    124125
    125126    CryptMemFree(certContext->pbCertEncoded);
    126     LocalFree(certContext->pCertInfo);
     127    LocalFree((HANDLE)certContext->pCertInfo);
    127128}
    128129
    … …  
    892893
    893894            len = rsaPubKey->bitlen;
    894             LocalFree(buf);
     895            LocalFree((HANDLE)buf);
    895896        }
    896897    }
    … …  
    10461047
    10471048    if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER,
    1048      subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
     1049     subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)) != NULL)
    10491050    {
    10501051        CERT_AUTHORITY_KEY_ID_INFO *info;
    … …  
    10771078            else
    10781079                ret = FALSE;
    1079             LocalFree(info);
     1080            LocalFree((HANDLE)info);
    10801081        }
    10811082    }
    10821083    else if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2,
    1083      subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
     1084     subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)) != NULL)
    10841085    {
    10851086        CERT_AUTHORITY_KEY_ID2_INFO *info;
    … …  
    11311132            else
    11321133                ret = FALSE;
    1133             LocalFree(info);
     1134            LocalFree((HANDLE)info);
    11341135        }
    11351136    }
    … …  
    15661567                CryptDestroyHash(hHash);
    15671568            }
    1568             LocalFree(buf);
     1569            LocalFree((HANDLE)buf);
    15691570        }
    15701571    }
    … …  
    16121613            }
    16131614        }
    1614         LocalFree(info);
     1615        LocalFree((HANDLE)info);
    16151616    }
    16161617    return ret;
    … …  
    18781879                ret = FALSE;
    18791880            }
    1880             LocalFree(signedCert);
     1881            LocalFree((HANDLE)signedCert);
    18811882        }
    18821883    }
    … …  
    19841985    }
    19851986    if (usage)
    1986         LocalFree(usage);
     1987        LocalFree((HANDLE)usage);
    19871988    TRACE("returning %d\n", ret);
    19881989    return ret;
    … …  
    20062007            ret = CertSetCertificateContextProperty(pCertContext,
    20072008             CERT_ENHKEY_USAGE_PROP_ID, 0, &blob);
    2008             LocalFree(blob.pbData);
     2009            LocalFree((HANDLE)blob.pbData);
    20092010        }
    20102011    }
    … …  
    24612462                context = CertCreateCertificateContext(X509_ASN_ENCODING,
    24622463                 encodedSignedCert, encodedSignedCertSize);
    2463                 LocalFree(encodedSignedCert);
     2464                LocalFree((HANDLE)encodedSignedCert);
    24642465            }
    24652466        }
    … …  
    26972698                if (context && !(dwFlags & CERT_CREATE_SELFSIGN_NO_KEY_INFO))
    26982699                    CertContext_SetKeyProvInfo(context, pKeyProvInfo, hProv);
    2699                 LocalFree(blob.pbData);
     2700                LocalFree((HANDLE)blob.pbData);
    27002701            }
    27012702        }

  • trunk/src/crypt32/chain.c

    r21311 r21354  
    1818 */
    1919#include <stdarg.h>
     20#include <string.h>
    2021#define NONAMELESSUNION
    2122#include "windef.h"
    … …  
    361362         CERT_TRUST_IS_NOT_SIGNATURE_VALID;
    362363    }
    363     CRYPT_CheckTrustedStatus(hRoot, rootElement);
     364    CRYPT_CheckTrustedStatus((HCERTSTORE)hRoot, rootElement);
    364365}
    365366
    … …  
    391392                constraints->fCA =
    392393                 info->SubjectType.pbData[0] & CERT_CA_SUBJECT_FLAG;
    393             LocalFree(info);
     394            LocalFree((HANDLE)info);
    394395        }
    395396    }
    … …  
    430431
    431432    if ((validBasicConstraints = CRYPT_DecodeBasicConstraints(cert,
    432      &constraints, TRUE)))
     433     &constraints, TRUE)) != NULL)
    433434    {
    434435        if (!constraints.fCA)
    … …  
    499500    else if (!name)
    500501        ; /* no match */
    501     else if ((at = strchrW(constraint, '@')))
     502    else if ((at = strchrW(constraint, '@')) != NULL)
    502503        match = !lstrcmpiW(constraint, name);
    503504    else
    504505    {
    505         if ((at = strchrW(name, '@')))
     506        if ((at = strchrW(name, '@')) != NULL)
    506507            match = url_matches(constraint, at + 1, trustErrorStatus);
    507508        else
    … …  
    609610
    610611        if ((ext = CertFindExtension(szOID_SUBJECT_ALT_NAME, cert->cExtension,
    611          cert->rgExtension)))
     612         cert->rgExtension)) != NULL)
    612613        {
    613614            CERT_ALT_NAME_INFO *subjectName;
    … …  
    631632                     trustErrorStatus,
    632633                     0, CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT);
    633                 LocalFree(subjectName);
     634                LocalFree((HANDLE)subjectName);
    634635            }
    635636        }
    … …  
    654655
    655656    if ((ext = CertFindExtension(szOID_NAME_CONSTRAINTS, cert->cExtension,
    656      cert->rgExtension)))
     657     cert->rgExtension)) != NULL)
    657658    {
    658659        DWORD size;
    … …  
    687688
    688689        if ((nameConstraints = CRYPT_GetNameConstraints(
    689          chain->rgpElement[i]->pCertContext->pCertInfo)))
     690         chain->rgpElement[i]->pCertContext->pCertInfo)) != NULL)
    690691        {
    691692            for (j = i - 1; j >= 0; j--)
    … …  
    706707                }
    707708            }
    708             LocalFree(nameConstraints);
     709            LocalFree((HANDLE)nameConstraints);
    709710        }
    710711    }
    … …  
    772773        rootElement->TrustStatus.dwInfoStatus |=
    773774         CERT_TRUST_IS_SELF_SIGNED | CERT_TRUST_HAS_NAME_MATCH_ISSUER;
    774         CRYPT_CheckRootCert(engine->hRoot, rootElement);
     775        CRYPT_CheckRootCert((HCERTCHAINENGINE)engine->hRoot, rootElement);
    775776    }
    776777    CRYPT_CombineTrustStatus(&chain->TrustStatus, &rootElement->TrustStatus);
    … …  
    786787    *infoStatus = 0;
    787788    if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER,
    788      subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
     789     subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)) != NULL)
    789790    {
    790791        CERT_AUTHORITY_KEY_ID_INFO *info;
    … …  
    822823                    *infoStatus = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
    823824            }
    824             LocalFree(info);
     825            LocalFree((HANDLE)info);
    825826        }
    826827    }
    827828    else if ((ext = CertFindExtension(szOID_AUTHORITY_KEY_IDENTIFIER2,
    828      subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)))
     829     subject->pCertInfo->cExtension, subject->pCertInfo->rgExtension)) != NULL)
    829830    {
    830831        CERT_AUTHORITY_KEY_ID2_INFO *info;
    … …  
    878879                    *infoStatus = CERT_TRUST_HAS_KEY_MATCH_ISSUER;
    879880            }
    880             LocalFree(info);
     881            LocalFree((HANDLE)info);
    881882        }
    882883    }
    … …  
    975976     */
    976977    if ((ret = CRYPT_GetSimpleChainForCert(engine, world, cert, pTime,
    977      &simpleChain)))
     978     &simpleChain)) != NULL)
    978979    {
    979980        PCertificateChain chain = CryptMemAlloc(sizeof(CertificateChain));

  • trunk/src/crypt32/collectionstore.c

    r21311 r21354  
    1717 */
    1818#include <stdarg.h>
     19#include <string.h>
    1920#include "windef.h"
    2021#include "winbase.h"
    … …  
    6061    }
    6162    cs->cs.DebugInfo->Spare[0] = 0;
    62     DeleteCriticalSection(&cs->cs);
     63    DeleteCriticalSection((CRITICAL_SECTION*)&cs->cs);
    6364    CRYPT_FreeStore((PWINECRYPT_CERTSTORE)store);
    6465}
    … …  
    106107        PWINE_STORE_LIST_ENTRY entry, next;
    107108
    108         EnterCriticalSection(&store->cs);
     109        EnterCriticalSection((CRITICAL_SECTION*)&store->cs);
    109110        LIST_FOR_EACH_ENTRY_SAFE(entry, next, &store->stores,
    110111         WINE_STORE_LIST_ENTRY, entry)
    … …  
    121122            }
    122123        }
    123         LeaveCriticalSection(&store->cs);
     124        LeaveCriticalSection((CRITICAL_SECTION*)&store->cs);
    124125        if (!storeEntry)
    125126            SetLastError(E_ACCESSDENIED);
    … …  
    221222    TRACE("(%p, %p)\n", store, pPrev);
    222223
    223     EnterCriticalSection(&cs->cs);
     224    EnterCriticalSection((CRITICAL_SECTION*)&cs->cs);
    224225    if (pPrev)
    225226    {
    … …  
    249250        }
    250251    }
    251     LeaveCriticalSection(&cs->cs);
     252    LeaveCriticalSection((CRITICAL_SECTION*)&cs->cs);
    252253    if (ret)
    253254        ((PCERT_CONTEXT)ret)->hCertStore = store;
    … …  
    300301    TRACE("(%p, %p)\n", store, pPrev);
    301302
    302     EnterCriticalSection(&cs->cs);
     303    EnterCriticalSection((CRITICAL_SECTION*)&cs->cs);
    303304    if (pPrev)
    304305    {
    … …  
    327328        }
    328329    }
    329     LeaveCriticalSection(&cs->cs);
     330    LeaveCriticalSection((CRITICAL_SECTION*)&cs->cs);
    330331    if (ret)
    331332        ((PCRL_CONTEXT)ret)->hCertStore = store;
    … …  
    378379    TRACE("(%p, %p)\n", store, pPrev);
    379380
    380     EnterCriticalSection(&cs->cs);
     381    EnterCriticalSection((CRITICAL_SECTION*)&cs->cs);
    381382    if (pPrev)
    382383    {
    … …  
    405406        }
    406407    }
    407     LeaveCriticalSection(&cs->cs);
     408    LeaveCriticalSection((CRITICAL_SECTION*)&cs->cs);
    408409    if (ret)
    409410        ((PCTL_CONTEXT)ret)->hCertStore = store;
    … …  
    451452            store->hdr.ctls.enumContext    = CRYPT_CollectionEnumCTL;
    452453            store->hdr.ctls.deleteContext  = CRYPT_CollectionDeleteCTL;
    453             InitializeCriticalSection(&store->cs);
    454             store->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PWINE_COLLECTIONSTORE->cs");
     454            InitializeCriticalSection((CRITICAL_SECTION*)&store->cs);
     455            store->cs.DebugInfo->Spare[0] = (DWORD)(DWORD_PTR)(__FILE__ ": PWINE_COLLECTIONSTORE->cs");
    455456            list_init(&store->stores);
    456457        }
    … …  
    498499        list_init(&entry->entry);
    499500        TRACE("%p: adding %p, priority %d\n", collection, entry, dwPriority);
    500         EnterCriticalSection(&collection->cs);
     501        EnterCriticalSection((CRITICAL_SECTION*)&collection->cs);
    501502        if (dwPriority)
    502503        {
    … …  
    519520        else
    520521            list_add_tail(&collection->stores, &entry->entry);
    521         LeaveCriticalSection(&collection->cs);
     522        LeaveCriticalSection((CRITICAL_SECTION*)&collection->cs);
    522523        ret = TRUE;
    523524    }
    … …  
    550551        return;
    551552    }
    552     EnterCriticalSection(&collection->cs);
     553    EnterCriticalSection((CRITICAL_SECTION*)&collection->cs);
    553554    LIST_FOR_EACH_ENTRY_SAFE(store, next, &collection->stores,
    554555     WINE_STORE_LIST_ENTRY, entry)
    … …  
    562563        }
    563564    }
    564     LeaveCriticalSection(&collection->cs);
    565 }
     565    LeaveCriticalSection((CRITICAL_SECTION*)&collection->cs);
     566}

  • trunk/src/crypt32/context.c

    r21311 r21354  
    1818#include <assert.h>
    1919#include <stdarg.h>
     20#include <string.h>
    2021#include "windef.h"
    2122#include "winbase.h"
    … …  
    196197        list->contextInterface = contextInterface;
    197198        list->contextSize = contextSize;
    198         InitializeCriticalSection(&list->cs);
    199         list->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ContextList.cs");
     199        InitializeCriticalSection((CRITICAL_SECTION*)&list->cs);
     200        list->cs.DebugInfo->Spare[0] = (DWORD)(DWORD_PTR)(__FILE__ ": ContextList.cs");
    200201        list_init(&list->contexts);
    201202    }
    … …  
    234235
    235236        TRACE("adding %p\n", context);
    236         EnterCriticalSection(&list->cs);
     237        EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    237238        if (toReplace)
    238239        {
    … …  
    248249        else
    249250            list_add_head(&list->contexts, entry);
    250         LeaveCriticalSection(&list->cs);
     251        LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    251252    }
    252253    return context;
    … …  
    258259    void *ret;
    259260
    260     EnterCriticalSection(&list->cs);
     261    EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    261262    if (pPrev)
    262263    {
    … …  
    268269    else
    269270        listNext = list_next(&list->contexts, &list->contexts);
    270     LeaveCriticalSection(&list->cs);
     271    LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    271272
    272273    if (listNext)
    … …  
    284285    struct list *entry = ContextList_ContextToEntry(list, context);
    285286
    286     EnterCriticalSection(&list->cs);
     287    EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    287288    list_remove(entry);
    288     LeaveCriticalSection(&list->cs);
     289    LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    289290    list->contextInterface->confree(context);
    290291}
    … …  
    294295    struct list *entry, *next;
    295296
    296     EnterCriticalSection(&list->cs);
     297    EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    297298    LIST_FOR_EACH_SAFE(entry, next, &list->contexts)
    298299    {
    … …  
    303304        list->contextInterface->confree(context);
    304305    }
    305     LeaveCriticalSection(&list->cs);
     306    LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    306307}
    307308
    … …  
    310311    ContextList_Empty(list);
    311312    list->cs.DebugInfo->Spare[0] = 0;
    312     DeleteCriticalSection(&list->cs);
     313    DeleteCriticalSection((CRITICAL_SECTION*)&list->cs);
    313314    CryptMemFree(list);
    314315}

  • trunk/src/crypt32/crl.c

    r21311 r21354  
    2020#include <assert.h>
    2121#include <stdarg.h>
     22#include <string.h>
    2223#include "windef.h"
    2324#include "winbase.h"
    … …  
    239240
    240241    CryptMemFree(crlContext->pbCrlEncoded);
    241     LocalFree(crlContext->pCrlInfo);
     242    LocalFree((HANDLE)crlContext->pCrlInfo);
    242243}
    243244

  • trunk/src/crypt32/crypt32_private.h

    r21325 r21354  
    397397#define strcasecmp  lstrcmpiA
    398398
     399/**
     400 *  In crypt32\main.c but not prototyped elsewhere
     401 */
     402
     403int vsnprintf (char *buf, int n, const char *fmt, va_list args);
     404int snprintf (char *buf, int n, const char *fmt, ...);
     405
    399406#endif

  • trunk/src/crypt32/ctl.c

    r21311 r21354  
    2020#include <assert.h>
    2121#include <stdarg.h>
     22#include <string.h>
    2223
    2324#define NONAMELESSUNION
    … …  
    426427        CryptMemFree(ctl);
    427428        ctl = NULL;
    428         LocalFree(ctlInfo);
     429        LocalFree((HANDLE)ctlInfo);
    429430        CryptMemFree(content);
    430431        CryptMsgClose(msg);
    … …  
    447448    CryptMemFree(ctlContext->pbCtlEncoded);
    448449    CryptMemFree(ctlContext->pbCtlContext);
    449     LocalFree(ctlContext->pCtlInfo);
     450    LocalFree((HANDLE)ctlContext->pCtlInfo);
    450451}
    451452

  • trunk/src/crypt32/decode.c

    r21311 r21354  
    3838#include <stdio.h>
    3939#include <stdlib.h>
     40#include <string.h>
     41#include <ctype.h>
    4042
    4143#define NONAMELESSUNION
    … …  
    4648#include "winnls.h"
    4749#include "snmp.h"
    48 #include "wine/debug.h"
    49 #include "wine/exception.h"
     50#include "wine\debug.h"
     51#include "wine\exception.h"
    5052#include "crypt32_private.h"
    5153
    … …  
    224226            *(BYTE **)pvStructInfo = pDecodePara->pfnAlloc(bytesNeeded);
    225227        else
    226             *(BYTE **)pvStructInfo = LocalAlloc(0, bytesNeeded);
     228            *(BYTE **)pvStructInfo = (BYTE*)LocalAlloc(0, bytesNeeded);
    227229        if (!*(BYTE **)pvStructInfo)
    228230            ret = FALSE;
    … …  
    246248        pDecodePara->pfnFree(pv);
    247249    else
    248         LocalFree(pv);
     250        LocalFree((HANDLE)pv);
    249251}
    250252
    … …  
    329331
    330332            if ((ret = CRYPT_GetLengthIndefinite(ptr,
    331              cbEncoded - (ptr - pbEncoded), &itemLen)))
     333             cbEncoded - (ptr - pbEncoded), &itemLen)) != FALSE)
    332334            {
    333335                BYTE itemLenBytes = GET_LEN_BYTES(ptr[1]);
    … …  
    484486        DWORD dataLen;
    485487
    486         if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
     488        if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    487489        {
    488490            DWORD lenBytes = GET_LEN_BYTES(pbEncoded[1]), cbDecoded;
    … …  
    547549                    *pcbStructInfo = bytesNeeded;
    548550                else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
    549                  pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
     551                 pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    550552                {
    551553                    BYTE *nextData;
    … …  
    623625        DWORD dataLen;
    624626
    625         if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
     627        if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    626628        {
    627629            DWORD bytesNeeded, cItems = 0, decoded;
    … …  
    664666                         */
    665667                        if ((ret = CRYPT_GetLengthIndefinite(ptr,
    666                          cbEncoded - (ptr - pbEncoded), &itemDataLen)))
     668                         cbEncoded - (ptr - pbEncoded), &itemDataLen)) != FALSE)
    667669                        {
    668670                            if (itemDataLen == CMSG_INDEFINITE_LENGTH)
    … …  
    712714                    *pcbStructInfo = bytesNeeded;
    713715                else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
    714                  pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
     716                 pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    715717                {
    716718                    DWORD i;
    … …  
    778780    DWORD dataLen;
    779781
    780     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     782    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    781783    {
    782784        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    790792        if (!pvStructInfo)
    791793            *pcbStructInfo = bytesNeeded;
    792         else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, bytesNeeded)))
     794        else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, bytesNeeded)) != FALSE)
    793795        {
    794796            CRYPT_DER_BLOB *blob;
    … …  
    902904    DWORD dataLen;
    903905
    904     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     906    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    905907    {
    906908        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    939941    DWORD dataLen;
    940942
    941     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     943    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    942944    {
    943945        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    10461048                 signedCert->ToBeSigned.cbData, dwFlags, pDecodePara,
    10471049                 pvStructInfo, pcbStructInfo);
    1048                 LocalFree(signedCert);
     1050                LocalFree((HANDLE)signedCert);
    10491051            }
    10501052        }
    … …  
    11861188                 signedCrl->ToBeSigned.cbData, dwFlags, pDecodePara,
    11871189                 pvStructInfo, pcbStructInfo);
    1188                 LocalFree(signedCrl);
     1190                LocalFree((HANDLE)signedCrl);
    11891191            }
    11901192        }
    … …  
    12171219     pvStructInfo, *pcbStructInfo);
    12181220
    1219     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     1221    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    12201222    {
    12211223        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    14341436    CERT_NAME_VALUE *value = (CERT_NAME_VALUE *)pvStructInfo;
    14351437
    1436     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     1438    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    14371439    {
    14381440        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    16211623    CERT_NAME_VALUE *value = (CERT_NAME_VALUE *)pvStructInfo;
    16221624
    1623     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     1625    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    16241626    {
    16251627        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    19521954            done = TRUE;
    19531955        else if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded,
    1954          &dataLen)))
     1956         &dataLen)) != FALSE)
    19551957        {
    19561958            BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    20042006     pvStructInfo, *pcbStructInfo);
    20052007
    2006     if ((ret = CRYPT_FindEncodedLen(pbEncoded, cbEncoded, &encodedLen)))
     2008    if ((ret = CRYPT_FindEncodedLen(pbEncoded, cbEncoded, &encodedLen)) != FALSE)
    20072009    {
    20082010        if (!(dwFlags & CRYPT_DECODE_NOCOPY_FLAG))
    … …  
    22292231        else if ((ret = CRYPT_AsnDecodeSMIMECapabilitiesInternal(pbEncoded,
    22302232         cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
    2231          NULL)))
     2233         NULL)) != FALSE)
    22322234        {
    22332235            if (!pvStructInfo)
    22342236                *pcbStructInfo = bytesNeeded;
    22352237            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    2236              pvStructInfo, pcbStructInfo, bytesNeeded)))
     2238             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    22372239            {
    22382240                PCRYPT_SMIME_CAPABILITIES capabilities;
    … …  
    22672269    LPSTR *pStr = pvStructInfo;
    22682270
    2269     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     2271    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    22702272    {
    22712273        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    24002402    DWORD dataLen;
    24012403
    2402     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     2404    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    24032405    {
    24042406        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    25692571                *pcbStructInfo = bytesNeeded;
    25702572            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    2571              pvStructInfo, pcbStructInfo, bytesNeeded)))
     2573             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    25722574            {
    25732575                PCERT_POLICY_QUALIFIER_USER_NOTICE notice;
    … …  
    26402642                *pcbStructInfo = bytesNeeded;
    26412643            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    2642              pvStructInfo, pcbStructInfo, bytesNeeded)))
     2644             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    26432645            {
    26442646                PCRYPT_ATTRIBUTE attr;
    … …  
    26992701        else if ((ret = CRYPT_AsnDecodePKCSAttributesInternal(pbEncoded,
    27002702         cbEncoded, dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded,
    2701          NULL)))
     2703         NULL)) != FALSE)
    27022704        {
    27032705            if (!pvStructInfo)
    27042706                *pcbStructInfo = bytesNeeded;
    27052707            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    2706              pvStructInfo, pcbStructInfo, bytesNeeded)))
     2708             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    27072709            {
    27082710                PCRYPT_ATTRIBUTES attrs;
    … …  
    27902792
    27912793        if ((ret = CRYPT_AsnDecodePubKeyInfoInternal(pbEncoded, cbEncoded,
    2792          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
     2794         dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)) != FALSE)
    27932795        {
    27942796            if (!pvStructInfo)
    27952797                *pcbStructInfo = bytesNeeded;
    27962798            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    2797              pvStructInfo, pcbStructInfo, bytesNeeded)))
     2799             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    27982800            {
    27992801                PCERT_PUBLIC_KEY_INFO info;
    … …  
    28832885        return FALSE;
    28842886    }
    2885     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     2887    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    28862888    {
    28872889        switch (pbEncoded[0] & ASN_TYPE_MASK)
    … …  
    31683170     * Check the outer length is valid:
    31693171     */
    3170     if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)))
     3172    if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    31713173    {
    31723174        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    31783180            cbEncoded -= 2; /* space for 0 TLV */
    31793181        /* Check the inner length is valid: */
    3180         if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &innerLen)))
     3182        if ((ret = CRYPT_GetLengthIndefinite(pbEncoded, cbEncoded, &innerLen)) != FALSE)
    31813183        {
    31823184            DWORD decodedLen;
    … …  
    33143316
    33153317        if ((ret = CRYPT_AsnDecodeAltNameInternal(pbEncoded, cbEncoded,
    3316          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
     3318         dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)) != FALSE)
    33173319        {
    33183320            if (!pvStructInfo)
    33193321                *pcbStructInfo = bytesNeeded;
    33203322            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    3321              pvStructInfo, pcbStructInfo, bytesNeeded)))
     3323             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    33223324            {
    33233325                CERT_ALT_NAME_INFO *name;
    … …  
    36073609            }
    36083610            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    3609              pvStructInfo, pcbStructInfo, bytesNeeded)))
     3611             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    36103612            {
    36113613                BLOBHEADER *hdr;
    … …  
    36283630                 decodedKey->modulus.cbData);
    36293631            }
    3630             LocalFree(decodedKey);
     3632            LocalFree((HANDLE)decodedKey);
    36313633        }
    36323634    }
    … …  
    36503652     pvStructInfo, *pcbStructInfo, pcbDecoded);
    36513653
    3652     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     3654    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    36533655    {
    36543656        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    37133715        }
    37143716        else if ((ret = CRYPT_AsnDecodeOctetsInternal(pbEncoded, cbEncoded,
    3715          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
     3717         dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)) != FALSE)
    37163718        {
    37173719            if (!pvStructInfo)
    37183720                *pcbStructInfo = bytesNeeded;
    37193721            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    3720              pvStructInfo, pcbStructInfo, bytesNeeded)))
     3722             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    37213723            {
    37223724                CRYPT_DATA_BLOB *blob;
    … …  
    37513753     pvStructInfo, *pcbStructInfo, pcbDecoded);
    37523754
    3753     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     3755    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    37543756    {
    37553757        if (dwFlags & CRYPT_DECODE_NOCOPY_FLAG)
    … …  
    38203822        }
    38213823        else if ((ret = CRYPT_AsnDecodeBitsInternal(pbEncoded, cbEncoded,
    3822          dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
     3824         dwFlags & ~CRYPT_DECODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)) != FALSE)
    38233825        {
    38243826            if (!pvStructInfo)
    38253827                *pcbStructInfo = bytesNeeded;
    38263828            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    3827              pvStructInfo, pcbStructInfo, bytesNeeded)))
     3829             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    38283830            {
    38293831                CRYPT_BIT_BLOB *blob;
    … …  
    38653867        if (!pvStructInfo)
    38663868            *pcbStructInfo = sizeof(int);
    3867         else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, sizeof(int))))
     3869        else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo, sizeof(int))) != FALSE)
    38683870        {
    38693871            int val, i;
    … …  
    39173919                *pcbStructInfo = bytesNeeded;
    39183920            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    3919              pvStructInfo, pcbStructInfo, bytesNeeded)))
     3921             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    39203922            {
    39213923                if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
    … …  
    39433945    DWORD bytesNeeded, dataLen;
    39443946
    3945     if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     3947    if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    39463948    {
    39473949        BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    40034005                *pcbStructInfo = bytesNeeded;
    40044006            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    4005              pvStructInfo, pcbStructInfo, bytesNeeded)))
     4007             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    40064008            {
    40074009                CRYPT_INTEGER_BLOB *blob;
    … …  
    40374039        DWORD bytesNeeded, dataLen;
    40384040
    4039         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     4041        if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    40404042        {
    40414043            BYTE lenBytes = GET_LEN_BYTES(pbEncoded[1]);
    … …  
    40974099
    40984100        if ((ret = CRYPT_AsnDecodeUnsignedIntegerInternal(pbEncoded, cbEncoded,
    4099          dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)))
     4101         dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, &bytesNeeded, NULL)) != FALSE)
    41004102        {
    41014103            if (!pvStructInfo)
    41024104                *pcbStructInfo = bytesNeeded;
    41034105            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    4104              pvStructInfo, pcbStructInfo, bytesNeeded)))
     4106             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    41054107            {
    41064108                CRYPT_INTEGER_BLOB *blob;
    … …  
    41714173                }
    41724174                if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    4173                  pvStructInfo, pcbStructInfo, sizeof(unsigned int))))
     4175                 pvStructInfo, pcbStructInfo, sizeof(unsigned int))) != FALSE)
    41744176                {
    41754177                    if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
    … …  
    43294331                        *pcbStructInfo = sizeof(FILETIME);
    43304332                    else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
    4331                      sizeof(FILETIME))))
     4333                     sizeof(FILETIME))) != FALSE)
    43324334                        ret = SystemTimeToFileTime(&sysTime,
    43334335                         (FILETIME *)pvStructInfo);
    … …  
    43584360                *pcbStructInfo = bytesNeeded;
    43594361            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags,
    4360              pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)))
     4362             pDecodePara, pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    43614363            {
    43624364                if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
    … …  
    44374439                        *pcbStructInfo = sizeof(FILETIME);
    44384440                    else if ((ret = CRYPT_DecodeCheckSpace(pcbStructInfo,
    4439                      sizeof(FILETIME))))
     4441                     sizeof(FILETIME))) != FALSE)
    44404442                        ret = SystemTimeToFileTime(&sysTime,
    44414443                         (FILETIME *)pvStructInfo);
    … …  
    44884490                *pcbStructInfo = bytesNeeded;
    44894491            else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    4490              pvStructInfo, pcbStructInfo, bytesNeeded)))
     4492             pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    44914493            {
    44924494                if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
    … …  
    45194521            DWORD bytesNeeded, dataLen, remainingLen, cValue;
    45204522
    4521             if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     4523            if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    45224524            {
    45234525                BYTE lenBytes;
    … …  
    45554557                        *pcbStructInfo = bytesNeeded;
    45564558                    else if ((ret = CRYPT_DecodeEnsureSpace(dwFlags, pDecodePara,
    4557                      pvStructInfo, pcbStructInfo, bytesNeeded)))
     4559                     pvStructInfo, pcbStructInfo, bytesNeeded)) != FALSE)
    45584560                    {
    45594561                        if (dwFlags & CRYPT_DECODE_ALLOC_FLAG)
    … …  
    46224624        DWORD bytesNeeded, dataLen;
    46234625
    4624         if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)))
     4626        if ((ret = CRYPT_GetLen(pbEncoded, cbEncoded, &dataLen)) != FALSE)
    46254627        {
    46264628            struct AsnArrayDescriptor arrayDesc = {

  • trunk/src/crypt32/encode.c

    r21311 r21354  
    3838#include <stdio.h>
    3939#include <stdlib.h>
     40#include <string.h>
    4041
    4142#define NONAMELESSUNION
    … …  
    111112            *(BYTE **)pbEncoded = pEncodePara->pfnAlloc(bytesNeeded);
    112113        else
    113             *(BYTE **)pbEncoded = LocalAlloc(0, bytesNeeded);
     114            *(BYTE **)pbEncoded = (BYTE*)LocalAlloc(0, bytesNeeded);
    114115        if (!*(BYTE **)pbEncoded)
    115116            ret = FALSE;
    … …  
    200201        {
    201202            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    202              pcbEncoded, bytesNeeded)))
     203             pcbEncoded, bytesNeeded)) != FALSE)
    203204            {
    204205                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    234235
    235236    if ((ret = item->encodeFunc(dwCertEncodingType, lpszStructType,
    236      item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len)))
     237     item->pvStructInfo, dwFlags & ~CRYPT_ENCODE_ALLOC_FLAG, NULL, NULL, &len)) != FALSE)
    237238    {
    238239        DWORD dataLen, bytesNeeded;
    … …  
    243244            *pcbEncoded = bytesNeeded;
    244245        else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    245          pbEncoded, pcbEncoded, bytesNeeded)))
     246         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    246247        {
    247248            if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    332333    {
    333334        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    334          pcbEncoded, blob->cbData)))
     335         pcbEncoded, blob->cbData)) != FALSE)
    335336        {
    336337            if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    594595        {
    595596            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    596              pcbEncoded, bytesNeeded)))
     597             pcbEncoded, bytesNeeded)) != FALSE)
    597598            {
    598599                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    751752            {
    752753                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    753                  pbEncoded, pcbEncoded, bytesNeeded)))
     754                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    754755                {
    755756                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    909910    {
    910911        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    911          pbEncoded, pcbEncoded, bytesNeeded)))
     912         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    912913        {
    913914            if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    943944    {
    944945        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    945          pbEncoded, pcbEncoded, bytesNeeded)))
     946         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    946947        {
    947948            DWORD i;
    … …  
    981982    {
    982983        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    983          pbEncoded, pcbEncoded, bytesNeeded)))
     984         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    984985        {
    985986            if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    11711172    }
    11721173    else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    1173      pbEncoded, pcbEncoded, bytesNeeded)))
     1174     pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    11741175    {
    11751176        if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    12491250            *pcbEncoded = bytesNeeded;
    12501251        else if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    1251          pbEncoded, pcbEncoded, bytesNeeded)))
     1252         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    12521253        {
    12531254            if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    13831384            {
    13841385                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    1385                  pbEncoded, pcbEncoded, bytesNeeded)))
     1386                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    13861387                {
    13871388                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    15171518        {
    15181519            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    1519              pbEncoded, pcbEncoded, bytesNeeded)))
     1520             pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    15201521            {
    15211522                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    16691670            {
    16701671                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    1671                  pbEncoded, pcbEncoded, bytesNeeded)))
     1672                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    16721673                {
    16731674                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    17241725        {
    17251726            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    1726              pcbEncoded, bytesNeeded)))
     1727             pcbEncoded, bytesNeeded)) != FALSE)
    17271728            {
    17281729                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    19471948    {
    19481949        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    1949          pbEncoded, pcbEncoded, bytesNeeded)))
     1950         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    19501951        {
    19511952            DWORD i;
    … …  
    19681969        pEncodePara->pfnFree(pv);
    19691970    else
    1970         LocalFree(pv);
     1971        LocalFree((HANDLE)pv);
    19711972}
    19721973
    … …  
    19881989    {
    19891990        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    1990          pbEncoded, pcbEncoded, bytesNeeded)))
     1991         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    19911992        {
    19921993            DWORD i;
    … …  
    20422043    {
    20432044        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2044          pbEncoded, pcbEncoded, bytesNeeded)))
     2045         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    20452046        {
    20462047            DWORD i;
    … …  
    20892090    {
    20902091        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2091          pbEncoded, pcbEncoded, bytesNeeded)))
     2092         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    20922093        {
    20932094            DWORD i;
    … …  
    21372138    {
    21382139        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2139          pbEncoded, pcbEncoded, bytesNeeded)))
     2140         pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    21402141        {
    21412142            DWORD i;
    … …  
    22602261            {
    22612262                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2262                  pbEncoded, pcbEncoded, bytesNeeded)))
     2263                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    22632264                {
    22642265                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    25712572            {
    25722573                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2573                  pbEncoded, pcbEncoded, bytesNeeded)))
     2574                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    25742575                {
    25752576                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    27072708            {
    27082709                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2709                  pbEncoded, pcbEncoded, bytesNeeded)))
     2710                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    27102711                {
    27112712                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    28562857            {
    28572858                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2858                  pbEncoded, pcbEncoded, bytesNeeded)))
     2859                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    28592860                {
    28602861                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    29372938            {
    29382939                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    2939                  pbEncoded, pcbEncoded, bytesNeeded)))
     2940                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    29402941                {
    29412942                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    30343035        {
    30353036            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    3036              pcbEncoded, bytesNeeded)))
     3037             pcbEncoded, bytesNeeded)) != FALSE)
    30373038            {
    30383039                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    30953096        {
    30963097            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    3097              pcbEncoded, bytesNeeded)))
     3098             pcbEncoded, bytesNeeded)) != FALSE)
    30983099            {
    30993100                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    32343235        {
    32353236            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    3236              pcbEncoded, bytesNeeded)))
     3237             pcbEncoded, bytesNeeded)) != FALSE)
    32373238            {
    32383239                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    33043305        {
    33053306            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    3306              pcbEncoded, bytesNeeded)))
     3307             pcbEncoded, bytesNeeded)) != FALSE)
    33073308            {
    33083309                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    33883389            {
    33893390                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    3390                  pbEncoded, pcbEncoded, bytesNeeded)))
     3391                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    33913392                {
    33923393                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    35163517        {
    35173518            if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    3518              pcbEncoded, bytesNeeded)))
     3519             pcbEncoded, bytesNeeded)) != FALSE)
    35193520            {
    35203521                if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    36473648                {
    36483649                    if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    3649                      pbEncoded, pcbEncoded, bytesNeeded)))
     3650                     pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    36503651                    {
    36513652                        if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    37103711            {
    37113712                if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara,
    3712                  pbEncoded, pcbEncoded, bytesNeeded)))
     3713                 pbEncoded, pcbEncoded, bytesNeeded)) != FALSE)
    37133714                {
    37143715                    if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    39533954             dwFlags, pEncodePara, pbEncoded, pcbEncoded);
    39543955        for (i = 0; i < permitted.cBlob; i++)
    3955             LocalFree(permitted.rgBlob[i].pbData);
     3956            LocalFree((HANDLE)permitted.rgBlob[i].pbData);
    39563957        for (i = 0; i < excluded.cBlob; i++)
    3957             LocalFree(excluded.rgBlob[i].pbData);
     3958            LocalFree((HANDLE)excluded.rgBlob[i].pbData);
    39583959    }
    39593960    __EXCEPT(1)
    … …  
    45484549    if (!pszPublicKeyObjId)
    45494550        pszPublicKeyObjId = oid;
    4550     if ((ret = CryptGetUserKey(hCryptProv, dwKeySpec, &key)))
     4551    if ((ret = CryptGetUserKey(hCryptProv, dwKeySpec, &key)) != FALSE)
    45514552    {
    45524553        DWORD keySize = 0;

  • trunk/src/crypt32/filestore.c

    r21311 r21354  
    4343    if (store->dirty)
    4444        CertSaveStore(store->memStore, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
    45          store->type, CERT_STORE_SAVE_TO_FILE, store->file, 0);
     45         store->type, CERT_STORE_SAVE_TO_FILE, (void*)store->file, 0);
    4646    CertCloseStore(store->memStore, dwFlags);
    4747    CloseHandle(store->file);
    … …  
    186186            ret = CertSaveStore(store->memStore,
    187187             X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
    188              store->type, CERT_STORE_SAVE_TO_FILE, store->file, 0);
     188             store->type, CERT_STORE_SAVE_TO_FILE, (void*)store->file, 0);
    189189        else
    190190            ret = TRUE;
    … …  
    198198
    199199static void *fileProvFuncs[] = {
    200     CRYPT_FileCloseStore,
     200    (void*)CRYPT_FileCloseStore,
    201201    NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
    202     CRYPT_FileWriteCert,
    203     CRYPT_FileDeleteCert,
     202    (void*)CRYPT_FileWriteCert,
     203    (void*)CRYPT_FileDeleteCert,
    204204    NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
    205205    NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
    206     CRYPT_FileWriteCRL,
    207     CRYPT_FileDeleteCRL,
     206    (void*)CRYPT_FileWriteCRL,
     207    (void*)CRYPT_FileDeleteCRL,
    208208    NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
    209209    NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */
    210     CRYPT_FileWriteCTL,
    211     CRYPT_FileDeleteCTL,
     210    (void*)CRYPT_FileWriteCTL,
     211    (void*)CRYPT_FileDeleteCTL,
    212212    NULL, /* CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC */
    213     CRYPT_FileControl,
     213    (void*)CRYPT_FileControl,
    214214};
    215215

  • trunk/src/crypt32/main.c

    r21325 r21354  
    2121#include <stdarg.h>
    2222#include <stdio.h>
     23#include <string.h>
    2324
    2425#include "windef.h"

  • trunk/src/crypt32/makefile

    r21321 r21354  
    1818# Overrides.
    1919#
    20 CDEFINES = $(CDEFINES) -DWIN32 -DSTDARG -DTHINK_C
     20#/*RLW - neither Think_C nor StdArg are referenced anywhere
     21#CDEFINES = $(CDEFINES) -DWIN32 -DSTDARG -DTHINK_C
     22CDEFINES = $(CDEFINES) -DWIN32
    2123
    2224#

  • trunk/src/crypt32/message.c

    r21311 r21354  
    1818
    1919#include <stdarg.h>
     20#include <string.h>
    2021#include "windef.h"
    2122#include "winbase.h"

  • trunk/src/crypt32/msg.c

    r21311 r21354  
    2121
    2222#include <stdarg.h>
     23#include <string.h>
    2324#define NONAMELESSUNION
    2425#include "windef.h"
    … …  
    113114
    114115    if (msg->bare_content != empty_data_content)
    115         LocalFree(msg->bare_content);
     116        LocalFree((HANDLE)msg->bare_content);
    116117}
    117118
    … …  
    134135    {
    135136        if ((ret = CRYPT_EncodeEnsureSpace(dwFlags, pEncodePara, pbEncoded,
    136          pcbEncoded, 1 + lenBytes)))
     137         pcbEncoded, 1 + lenBytes)) != FALSE)
    137138        {
    138139            if (dwFlags & CRYPT_ENCODE_ALLOC_FLAG)
    … …  
    156157         0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x80,0x24,0x80 };
    157158
    158         header->pbData = LocalAlloc(0, sizeof(headerValue));
     159        header->pbData = (BYTE*)LocalAlloc(0, sizeof(headerValue));
    159160        if (header->pbData)
    160161        {
    … …  
    211212                     msg->base.stream_info.pvArg, header.pbData, header.cbData,
    212213                     FALSE);
    213                     LocalFree(header.pbData);
     214                    LocalFree((HANDLE)header.pbData);
    214215                }
    215216            }
    … …  
    230231                     msg->base.stream_info.pvArg, header, headerLen,
    231232                     FALSE);
    232                     LocalFree(header);
     233                    LocalFree((HANDLE)header);
    233234                }
    234235            }
    … …  
    437438             pcbData);
    438439        CryptMemFree(digestedData.hash.pbData);
    439         LocalFree(digestedData.ContentInfo.Content.pbData);
     440        LocalFree((HANDLE)digestedData.ContentInfo.Content.pbData);
    440441    }
    441442    return ret;
    … …  
    10391040                 &msg_data->info->rgSignerInfo[signerIndex].AuthAttrs,
    10401041                 &messageDigestAttr);
    1041                 LocalFree(encodedHash.pbData);
     1042                LocalFree((HANDLE)encodedHash.pbData);
    10421043            }
    10431044        }
    … …  
    10931094                     msg_data->signerHandles[i].authAttrHash, encodedAttrs,
    10941095                     size, 0);
    1095                     LocalFree(encodedAttrs);
     1096                    LocalFree((HANDLE)encodedAttrs);
    10961097                }
    10971098            }
    … …  
    12531254        {
    12541255            ret = CRYPT_AsnEncodeCMSSignedInfo(&info, pvData, pcbData);
    1255             LocalFree(info.content.Content.pbData);
     1256            LocalFree((HANDLE)info.content.Content.pbData);
    12561257        }
    12571258        break;
    … …  
    14951496        if (msg->u.signed_data.info)
    14961497        {
    1497             LocalFree(msg->u.signed_data.info);
     1498            LocalFree((HANDLE)msg->u.signed_data.info);
    14981499            CSignedMsgData_CloseHandles(&msg->u.signed_data);
    14991500        }
    … …  
    15411542        ret = ContextPropertyList_SetProperty(msg->properties,
    15421543         CMSG_CONTENT_PARAM, data->pbData, data->cbData);
    1543         LocalFree(data);
     1544        LocalFree((HANDLE)data);
    15441545    }
    15451546    return ret;
    … …  
    16201621        ContextPropertyList_SetProperty(msg->properties, CMSG_HASH_DATA_PARAM,
    16211622         digestedData->hash.pbData, digestedData->hash.cbData);
    1622         LocalFree(digestedData);
     1623        LocalFree((HANDLE)digestedData);
    16231624    }
    16241625    return ret;
    … …  
    16531654    {
    16541655    case CMSG_DATA:
    1655         if ((ret = CDecodeMsg_DecodeDataContent(msg, blob)))
     1656        if ((ret = CDecodeMsg_DecodeDataContent(msg, blob)) != FALSE)
    16561657            msg->type = CMSG_DATA;
    16571658        break;
    16581659    case CMSG_HASHED:
    1659         if ((ret = CDecodeMsg_DecodeHashedContent(msg, blob)))
     1660        if ((ret = CDecodeMsg_DecodeHashedContent(msg, blob)) != FALSE)
    16601661            msg->type = CMSG_HASHED;
    16611662        break;
    … …  
    16651666        break;
    16661667    case CMSG_SIGNED:
    1667         if ((ret = CDecodeMsg_DecodeSignedContent(msg, blob)))
     1668        if ((ret = CDecodeMsg_DecodeSignedContent(msg, blob)) != FALSE)
    16681669            msg->type = CMSG_SIGNED;
    16691670        break;
    … …  
    16941695                ret = FALSE;
    16951696            }
    1696             LocalFree(info);
     1697            LocalFree((HANDLE)info);
    16971698        }
    16981699    }
    … …  
    17791780                    ret = CSignedMsgData_Update(&msg->u.signed_data,
    17801781                     blob->pbData, blob->cbData, TRUE, Verify);
    1781                     LocalFree(blob);
     1782                    LocalFree((HANDLE)blob);
    17821783                }
    17831784            }
    … …  
    22832284                    ret = CRYPT_CopyParam(pvData, pcbData, blob->pbData,
    22842285                     blob->cbData);
    2285                     LocalFree(blob);
     2286                    LocalFree((HANDLE)blob);
    22862287                }
    22872288            }

  • trunk/src/crypt32/object.c

    r21311 r21354  
    1919 */
    2020#include <stdarg.h>
     21#include <string.h>
    2122#define NONAMELESSUNION
    2223#include "windef.h"
    … …  
    694695    }
    695696    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_KEY_USAGE,
    696      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size)))
     697     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size)) != FALSE)
    697698    {
    698699        WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN];
    … …  
    791792            }
    792793        }
    793         LocalFree(bits);
     794        LocalFree((HANDLE)bits);
    794795    }
    795796    return ret;
    … …  
    818819    }
    819820    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_BASIC_CONSTRAINTS2,
    820      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
     821     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)) != FALSE)
    821822    {
    822823        static const WCHAR pathFmt[] = { '%','d',0 };
    … …  
    889890            str += strlenW(pathLength);
    890891        }
    891         LocalFree(info);
     892        LocalFree((HANDLE)info);
    892893    }
    893894    return ret;
    … …  
    12031204
    12041205    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_ALTERNATE_NAME,
    1205      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
     1206     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)) != FALSE)
    12061207    {
    12071208        ret = CRYPT_FormatAltNameInfo(dwFormatStrType, 0, info, pbFormat, pcbFormat);
    1208         LocalFree(info);
     1209        LocalFree((HANDLE)info);
    12091210    }
    12101211    return ret;
    … …  
    12741275    }
    12751276    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_AUTHORITY_KEY_ID2,
    1276      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
     1277     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)) != FALSE)
    12771278    {
    12781279        DWORD bytesNeeded = sizeof(WCHAR); /* space for the NULL terminator */
    … …  
    13871388            }
    13881389        }
    1389         LocalFree(info);
     1390        LocalFree((HANDLE)info);
    13901391    }
    13911392    return ret;
    … …  
    14151416    if ((ret = CryptDecodeObjectEx(dwCertEncodingType,
    14161417     X509_AUTHORITY_INFO_ACCESS, pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG,
    1417      NULL, &info, &size)))
     1418     NULL, &info, &size)) != FALSE)
    14181419    {
    14191420        DWORD bytesNeeded = sizeof(WCHAR);
    … …  
    16071608            }
    16081609        }
    1609         LocalFree(info);
     1610        LocalFree((HANDLE)info);
    16101611    }
    16111612    return ret;
    … …  
    17211722    }
    17221723    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_CRL_DIST_POINTS,
    1723      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)))
     1724     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &info, &size)) != FALSE)
    17241725    {
    17251726        static const WCHAR numFmt[] = { '%','d',0 };
    … …  
    19341935            }
    19351936        }
    1936         LocalFree(info);
     1937        LocalFree((HANDLE)info);
    19371938    }
    19381939    return ret;
    … …  
    19541955    }
    19551956    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_ENHANCED_KEY_USAGE,
    1956      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &usage, &size)))
     1957     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &usage, &size)) != FALSE)
    19571958    {
    19581959        WCHAR unknown[MAX_STRING_RESOURCE_LEN];
    … …  
    20352036            }
    20362037        }
    2037         LocalFree(usage);
     2038        LocalFree((HANDLE)usage);
    20382039    }
    20392040    return ret;
    … …  
    20652066    }
    20662067    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_BITS,
    2067      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size)))
     2068     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &bits, &size)) != FALSE)
    20682069    {
    20692070        WCHAR infoNotAvailable[MAX_STRING_RESOURCE_LEN];
    … …  
    21412142            }
    21422143        }
    2143         LocalFree(bits);
     2144        LocalFree((HANDLE)bits);
    21442145    }
    21452146    return ret;
    … …  
    21692170    if ((ret = CryptDecodeObjectEx(dwCertEncodingType,
    21702171     SPC_FINANCIAL_CRITERIA_STRUCT, pbEncoded, cbEncoded, 0, NULL, &criteria,
    2171      &size)))
     2172     &size)) != FALSE)
    21722173    {
    21732174        static BOOL stringsLoaded = FALSE;
    … …  
    22662267    }
    22672268    if ((ret = CryptDecodeObjectEx(dwCertEncodingType, X509_UNICODE_ANY_STRING,
    2268      pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &value, &size)))
     2269     pbEncoded, cbEncoded, CRYPT_DECODE_ALLOC_FLAG, NULL, &value, &size)) != FALSE)
    22692270    {
    22702271        if (!pbFormat)

  • trunk/src/crypt32/oid.c

    r21311 r21354  
    2323#include <stdio.h>
    2424#include <stdarg.h>
     25#include <string.h>
    2526#define NONAMELESSUNION
    2627#include "windef.h"
    … …  
    6162    0, 0, &funcSetCS,
    6263    { &funcSetCSDebug.ProcessLocksList, &funcSetCSDebug.ProcessLocksList },
    63     0, 0, { (DWORD_PTR)(__FILE__ ": funcSetCS") }
     64    0, 0, { (DWORD)(DWORD_PTR)(__FILE__ ": funcSetCS") }
    6465};
    6566static RTL_CRITICAL_SECTION funcSetCS = { &funcSetCSDebug, -1, 0, 0, 0, 0 };
    … …  
    106107        }
    107108        setCursor->cs.DebugInfo->Spare[0] = 0;
    108         DeleteCriticalSection(&setCursor->cs);
     109        DeleteCriticalSection((CRITICAL_SECTION*)&setCursor->cs);
    109110        CryptMemFree(setCursor);
    110111    }
    … …  
    121122    TRACE("(%s, %x)\n", debugstr_a(pszFuncName), dwFlags);
    122123
    123     EnterCriticalSection(&funcSetCS);
     124    EnterCriticalSection((CRITICAL_SECTION*)&funcSetCS);
    124125    LIST_FOR_EACH_ENTRY(cursor, &funcSets, struct OIDFunctionSet, next)
    125126    {
    … …  
    139140            if (ret->name)
    140141            {
    141                 InitializeCriticalSection(&ret->cs);
    142                 ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": OIDFunctionSet.cs");
     142                InitializeCriticalSection((CRITICAL_SECTION*)&ret->cs);
     143                ret->cs.DebugInfo->Spare[0] = (DWORD)(DWORD_PTR)(__FILE__ ": OIDFunctionSet.cs");
    143144                list_init(&ret->functions);
    144145                strcpy(ret->name, pszFuncName);
    … …  
    152153        }
    153154    }
    154     LeaveCriticalSection(&funcSetCS);
     155    LeaveCriticalSection((CRITICAL_SECTION*)&funcSetCS);
    155156
    156157    return (HCRYPTOIDFUNCSET)ret;
    … …  
    252253        DWORD i;
    253254
    254         EnterCriticalSection(&set->cs);
     255        EnterCriticalSection((CRITICAL_SECTION*)&set->cs);
    255256        for (i = 0; ret && i < cFuncEntry; i++)
    256257        {
    … …  
    281282                ret = FALSE;
    282283        }
    283         LeaveCriticalSection(&set->cs);
     284        LeaveCriticalSection((CRITICAL_SECTION*)&set->cs);
    284285    }
    285286    else
    … …  
    339340                    if (lib)
    340341                    {
    341                         *ppvFuncAddr = GetProcAddress(lib, funcName);
     342                        *ppvFuncAddr = (LPVOID)GetProcAddress(lib, funcName);
    342343                        if (*ppvFuncAddr)
    343344                        {
    … …  
    399400        struct OIDFunction *function;
    400401
    401         EnterCriticalSection(&set->cs);
     402        EnterCriticalSection((CRITICAL_SECTION*)&set->cs);
    402403        LIST_FOR_EACH_ENTRY(function, &set->functions, struct OIDFunction, next)
    403404        {
    … …  
    424425            }
    425426        }
    426         LeaveCriticalSection(&set->cs);
     427        LeaveCriticalSection((CRITICAL_SECTION*)&set->cs);
    427428    }
    428429    if (!*ppvFuncAddr)
    … …  
    461462    if (*lib)
    462463    {
    463         *ppvFuncAddr = GetProcAddress(*lib, func);
     464        *ppvFuncAddr = (LPVOID)GetProcAddress(*lib, func);
    464465        if (*ppvFuncAddr)
    465466            ret = TRUE;
    … …  
    648649    {
    649650        r = RegSetValueExA(hKey, "FuncName", 0, REG_SZ,
    650              (const BYTE*)pszOverrideFuncName, lstrlenA(pszOverrideFuncName) + 1);
     651             (LPBYTE)pszOverrideFuncName, lstrlenA(pszOverrideFuncName) + 1);
    651652        if (r != ERROR_SUCCESS) goto error_close_key;
    652653    }
    653     r = RegSetValueExW(hKey, DllW, 0, REG_SZ, (const BYTE*) pwszDll,
     654    r = RegSetValueExW(hKey, DllW, 0, REG_SZ, (LPBYTE) pwszDll,
    654655         (lstrlenW(pwszDll) + 1) * sizeof (WCHAR));
    655656
    … …  
    758759    else
    759760    {
    760         rc = RegSetValueExW(hKey, pwszValueName, 0, dwValueType, pbValueData,
     761        rc = RegSetValueExW(hKey, pwszValueName, 0, dwValueType, (LPBYTE)pbValueData,
    761762         cbValueData);
    762763        if (rc)
    … …  
    928929    LONG r;
    929930
    930     if ((r = RegSetValueExW(key, DllW, 0, REG_MULTI_SZ, (const BYTE *)dlls,
    931      len * sizeof (WCHAR))))
     931    if ((r = RegSetValueExW(key, DllW, 0, REG_MULTI_SZ, (LPBYTE)dlls,
     932     len * sizeof (WCHAR))) != 0)
    932933        SetLastError(r);
    933934    return r == ERROR_SUCCESS;
    … …  
    990991
    991992    dlls = CRYPT_GetDefaultOIDDlls(key);
    992     if ((ret = CRYPT_RemoveStringFromMultiString(dlls, pwszDll)))
     993    if ((ret = CRYPT_RemoveStringFromMultiString(dlls, pwszDll)) != FALSE)
    993994        ret = CRYPT_SetDefaultOIDDlls(key, dlls);
    994995    CryptMemFree(dlls);
    … …  
    10311032    0, 0, &oidInfoCS,
    10321033    { &oidInfoCSDebug.ProcessLocksList, &oidInfoCSDebug.ProcessLocksList },
    1033     0, 0, { (DWORD_PTR)(__FILE__ ": oidInfoCS") }
     1034    0, 0, { (DWORD)(DWORD_PTR)(__FILE__ ": oidInfoCS") }
    10341035};
    10351036static RTL_CRITICAL_SECTION oidInfoCS = { &oidInfoCSDebug, -1, 0, 0, 0, 0 };
    … …  
    14091410            LPCWSTR stringresource = NULL;
    14101411            int len = LoadStringW(hInstance,
    1411              (UINT_PTR)oidInfoConstructors[i].pwszName,
     1412             (UINT)(UINT_PTR)oidInfoConstructors[i].pwszName,
    14121413             (LPWSTR)&stringresource, 0);
    14131414
    … …  
    14261427                    info->info.dwGroupId = oidInfoConstructors[i].dwGroupId;
    14271428                    info->info.u.Algid = oidInfoConstructors[i].Algid;
    1428                     if (stringresource && (char*)stringresource != 0xAAAAAAAA)
     1429                    if (stringresource && (char*)stringresource != (char*)0xAAAAAAAA)
    14291430                        memcpy(info + 1, stringresource, len*sizeof(WCHAR));
    14301431                    ((LPWSTR)(info + 1))[len] = 0;
    … …  
    14501451    LIST_FOR_EACH_ENTRY_SAFE(info, next, &oidInfo, struct OIDInfo, entry)
    14511452    {
    1452         if (info > 0x10000)
    1453         {
    1454             if (&info->entry  > 0x10000)
     1453        if (info > (struct OIDInfo*)0x10000)
     1454        {
     1455            if (&info->entry > (struct list*)0x10000)
    14551456                list_remove(&info->entry);
    14561457            CryptMemFree(info);
    … …  
    14711472     pfnEnumOIDInfo);
    14721473
    1473     EnterCriticalSection(&oidInfoCS);
     1474    EnterCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    14741475    LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
    14751476    {
    … …  
    14811482        }
    14821483    }
    1483     LeaveCriticalSection(&oidInfoCS);
     1484    LeaveCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    14841485    return ret;
    14851486}
    … …  
    14991500
    15001501        TRACE("CRYPT_OID_INFO_ALGID_KEY: %d\n", *(DWORD *)pvKey);
    1501         EnterCriticalSection(&oidInfoCS);
     1502        EnterCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15021503        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
    15031504        {
    … …  
    15091510            }
    15101511        }
    1511         LeaveCriticalSection(&oidInfoCS);
     1512        LeaveCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15121513        break;
    15131514    }
    … …  
    15171518
    15181519        TRACE("CRYPT_OID_INFO_NAME_KEY: %s\n", debugstr_w((LPWSTR)pvKey));
    1519         EnterCriticalSection(&oidInfoCS);
     1520        EnterCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15201521        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
    15211522        {
    … …  
    15271528            }
    15281529        }
    1529         LeaveCriticalSection(&oidInfoCS);
     1530        LeaveCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15301531        break;
    15311532    }
    … …  
    15361537
    15371538        TRACE("CRYPT_OID_INFO_OID_KEY: %s\n", debugstr_a(oid));
    1538         EnterCriticalSection(&oidInfoCS);
     1539        EnterCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15391540        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
    15401541        {
    … …  
    15461547            }
    15471548        }
    1548         LeaveCriticalSection(&oidInfoCS);
     1549        LeaveCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15491550        break;
    15501551    }
    … …  
    15541555
    15551556        TRACE("CRYPT_OID_INFO_SIGN_KEY: %d\n", *(DWORD *)pvKey);
    1556         EnterCriticalSection(&oidInfoCS);
     1557        EnterCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15571558        LIST_FOR_EACH_ENTRY(info, &oidInfo, struct OIDInfo, entry)
    15581559        {
    … …  
    15671568            }
    15681569        }
    1569         LeaveCriticalSection(&oidInfoCS);
     1570        LeaveCriticalSection((CRITICAL_SECTION*)&oidInfoCS);
    15701571        break;
    15711572    }

  • trunk/src/crypt32/proplist.c

    r21311 r21354  
    1818#include <assert.h>
    1919#include <stdarg.h>
     20#include <string.h>
    2021#include "windef.h"
    2122#include "winbase.h"
    … …  
    4748    if (list)
    4849    {
    49         InitializeCriticalSection(&list->cs);
    50         list->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PCONTEXT_PROPERTY_LIST->cs");
     50        InitializeCriticalSection((CRITICAL_SECTION*)&list->cs);
     51        list->cs.DebugInfo->Spare[0] = (DWORD)(DWORD_PTR)(__FILE__ ": PCONTEXT_PROPERTY_LIST->cs");
    5152        list_init(&list->properties);
    5253    }
    … …  
    6667    }
    6768    list->cs.DebugInfo->Spare[0] = 0;
    68     DeleteCriticalSection(&list->cs);
     69    DeleteCriticalSection((CRITICAL_SECTION*)&list->cs);
    6970    CryptMemFree(list);
    7071}
    … …  
    7879    TRACE("(%p, %d, %p)\n", list, id, blob);
    7980
    80     EnterCriticalSection(&list->cs);
     81    EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    8182    LIST_FOR_EACH_ENTRY(prop, &list->properties, CONTEXT_PROPERTY, entry)
    8283    {
    … …  
    8990        }
    9091    }
    91     LeaveCriticalSection(&list->cs);
     92    LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    9293    return ret;
    9394}
    … …  
    112113        BOOL found = FALSE;
    113114
    114         EnterCriticalSection(&list->cs);
     115        EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    115116        LIST_FOR_EACH_ENTRY(prop, &list->properties, CONTEXT_PROPERTY, entry)
    116117        {
    … …  
    142143                CryptMemFree(data);
    143144        }
    144         LeaveCriticalSection(&list->cs);
     145        LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    145146    }
    146147    return ret;
    … …  
    151152    PCONTEXT_PROPERTY prop, next;
    152153
    153     EnterCriticalSection(&list->cs);
     154    EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    154155    LIST_FOR_EACH_ENTRY_SAFE(prop, next, &list->properties, CONTEXT_PROPERTY,
    155156     entry)
    … …  
    163164        }
    164165    }
    165     LeaveCriticalSection(&list->cs);
     166    LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    166167}
    167168
    … …  
    173174    DWORD ret;
    174175
    175     EnterCriticalSection(&list->cs);
     176    EnterCriticalSection((CRITICAL_SECTION*)&list->cs);
    176177    if (id)
    177178    {
    … …  
    199200    else
    200201        ret = 0;
    201     LeaveCriticalSection(&list->cs);
     202    LeaveCriticalSection((CRITICAL_SECTION*)&list->cs);
    202203    return ret;
    203204}
    … …  
    208209    PCONTEXT_PROPERTY prop;
    209210
    210     EnterCriticalSection(&from->cs);
     211    EnterCriticalSection((CRITICAL_SECTION*)&from->cs);
    211212    LIST_FOR_EACH_ENTRY(prop, &from->properties, CONTEXT_PROPERTY, entry)
    212213    {
    … …  
    214215         prop->cbData);
    215216    }
    216     LeaveCriticalSection(&from->cs);
    217 }
     217    LeaveCriticalSection((CRITICAL_SECTION*)&from->cs);
     218}

  • trunk/src/crypt32/protectdata.c

    r21311 r21354  
    264264    /*if (pSerial->cbData<256) pSerial->cbData=256;*/
    265265
    266     pSerial->pbData=LocalAlloc(LPTR,pSerial->cbData);
     266    pSerial->pbData=(BYTE*)LocalAlloc(LPTR,pSerial->cbData);
    267267    if (!pSerial->pbData) return FALSE;
    268268
    … …  
    338338        ERR("struct size changed!? %u != expected %u\n",
    339339            ptr - pSerial->pbData, dwStruct);
    340         LocalFree(pSerial->pbData);
     340        LocalFree((HANDLE)pSerial->pbData);
    341341        pSerial->pbData=NULL;
    342342        pSerial->cbData=0;
    … …  
    410410
    411411    /* cipher_alg */
    412     if (!unserialize_dword(ptr,&index,size,&pInfo->cipher_alg))
     412    if (!unserialize_dword(ptr,&index,size,(DWORD*)&pInfo->cipher_alg))
    413413    {
    414414        ERR("reading cipher_alg failed!\n");
    … …  
    439439   
    440440    /* hash_alg */
    441     if (!unserialize_dword(ptr,&index,size,&pInfo->hash_alg))
     441    if (!unserialize_dword(ptr,&index,size,(DWORD*)&pInfo->hash_alg))
    442442    {
    443443        ERR("reading hash_alg failed!\n");
    … …  
    598598    pInfo->null0=0x0000;
    599599
    600     if ((pInfo->szDataDescr=CryptMemAlloc((dwStrLen+1)*sizeof(WCHAR))))
     600    if ((pInfo->szDataDescr=CryptMemAlloc((dwStrLen+1)*sizeof(WCHAR))) != NULL)
    601601    {
    602602        memcpy(pInfo->szDataDescr,szDataDescr,(dwStrLen+1)*sizeof(WCHAR));
    … …  
    613613
    614614    /* allocate memory to hold a salt */
    615     if ((pInfo->salt.pbData=CryptMemAlloc(CRYPT32_PROTECTDATA_SALT_LEN)))
     615    if ((pInfo->salt.pbData=CryptMemAlloc(CRYPT32_PROTECTDATA_SALT_LEN)) != NULL)
    616616    {
    617617        /* generate random salt */
    … …  
    794794    {
    795795        TRACE_DATA_BLOB(pOptionalEntropy);
    796         TRACE("  %s\n",debugstr_an((LPCSTR)pOptionalEntropy->pbData,pOptionalEntropy->cbData));
     796        TRACE("  %s\n", debugstr_an((LPCSTR)pOptionalEntropy->pbData,pOptionalEntropy->cbData));
    797797    }
    798798
    … …  
    10711071    /* prepare for plaintext */
    10721072    pDataOut->cbData=protect_data.cipher.cbData;
    1073     if (!(pDataOut->pbData=LocalAlloc( LPTR, pDataOut->cbData)))
     1073    if (!(pDataOut->pbData=(BYTE*)LocalAlloc( LPTR, pDataOut->cbData)))
    10741074    {
    10751075        ERR("CryptMemAlloc\n");
    … …  
    10871087        SetLastError(ERROR_INVALID_DATA);
    10881088
    1089         LocalFree( pDataOut->pbData );
     1089        LocalFree((HANDLE)pDataOut->pbData );
    10901090        pDataOut->pbData = NULL;
    10911091        pDataOut->cbData = 0;
    … …  
    10981098    if (ppszDataDescr)
    10991099    {
    1100         if (!(*ppszDataDescr = LocalAlloc(LPTR,dwLength)))
     1100        if (!(*ppszDataDescr = (LPWSTR)LocalAlloc(LPTR,dwLength)))
    11011101        {
    11021102            ERR("LocalAlloc (ppszDataDescr)\n");

  • trunk/src/crypt32/provstore.c

    r21311 r21354  
    292292        ret->hdr.control = CRYPT_ProvControl;
    293293        if (pProvInfo->cStoreProvFunc > CERT_STORE_PROV_CLOSE_FUNC)
    294             ret->provCloseStore =
     294            ret->provCloseStore = (PFN_CERT_STORE_PROV_CLOSE)
    295295             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_CLOSE_FUNC];
    296296        else
    … …  
    298298        if (pProvInfo->cStoreProvFunc >
    299299         CERT_STORE_PROV_WRITE_CERT_FUNC)
    300             ret->provWriteCert = pProvInfo->rgpvStoreProvFunc[
    301              CERT_STORE_PROV_WRITE_CERT_FUNC];
     300            ret->provWriteCert = (PFN_CERT_STORE_PROV_WRITE_CERT)
     301             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_WRITE_CERT_FUNC];
    302302        else
    303303            ret->provWriteCert = NULL;
    304304        if (pProvInfo->cStoreProvFunc >
    305305         CERT_STORE_PROV_DELETE_CERT_FUNC)
    306             ret->provDeleteCert = pProvInfo->rgpvStoreProvFunc[
    307              CERT_STORE_PROV_DELETE_CERT_FUNC];
     306            ret->provDeleteCert =  (PFN_CERT_STORE_PROV_DELETE_CERT)
     307             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_DELETE_CERT_FUNC];
    308308        else
    309309            ret->provDeleteCert = NULL;
    310310        if (pProvInfo->cStoreProvFunc >
    311311         CERT_STORE_PROV_WRITE_CRL_FUNC)
    312             ret->provWriteCrl = pProvInfo->rgpvStoreProvFunc[
    313              CERT_STORE_PROV_WRITE_CRL_FUNC];
     312            ret->provWriteCrl = (PFN_CERT_STORE_PROV_WRITE_CRL)
     313             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_WRITE_CRL_FUNC];
    314314        else
    315315            ret->provWriteCrl = NULL;
    316316        if (pProvInfo->cStoreProvFunc >
    317317         CERT_STORE_PROV_DELETE_CRL_FUNC)
    318             ret->provDeleteCrl = pProvInfo->rgpvStoreProvFunc[
    319              CERT_STORE_PROV_DELETE_CRL_FUNC];
     318            ret->provDeleteCrl = (PFN_CERT_STORE_PROV_DELETE_CRL)
     319             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_DELETE_CRL_FUNC];
    320320        else
    321321            ret->provDeleteCrl = NULL;
    322322        if (pProvInfo->cStoreProvFunc >
    323323         CERT_STORE_PROV_WRITE_CTL_FUNC)
    324             ret->provWriteCtl = pProvInfo->rgpvStoreProvFunc[
    325              CERT_STORE_PROV_WRITE_CTL_FUNC];
     324            ret->provWriteCtl = (PFN_CERT_STORE_PROV_WRITE_CTL)
     325             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_WRITE_CTL_FUNC];
    326326        else
    327327            ret->provWriteCtl = NULL;
    328328        if (pProvInfo->cStoreProvFunc >
    329329         CERT_STORE_PROV_DELETE_CTL_FUNC)
    330             ret->provDeleteCtl = pProvInfo->rgpvStoreProvFunc[
    331              CERT_STORE_PROV_DELETE_CTL_FUNC];
     330            ret->provDeleteCtl = (PFN_CERT_STORE_PROV_DELETE_CTL)
     331             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_DELETE_CTL_FUNC];
    332332        else
    333333            ret->provDeleteCtl = NULL;
    334334        if (pProvInfo->cStoreProvFunc >
    335335         CERT_STORE_PROV_CONTROL_FUNC)
    336             ret->provControl = pProvInfo->rgpvStoreProvFunc[
    337              CERT_STORE_PROV_CONTROL_FUNC];
     336            ret->provControl = (PFN_CERT_STORE_PROV_CONTROL)
     337             pProvInfo->rgpvStoreProvFunc[CERT_STORE_PROV_CONTROL_FUNC];
    338338        else
    339339            ret->provControl = NULL;

  • trunk/src/crypt32/regstore.c

    r21311 r21354  
    194194    if (!rc)
    195195    {
    196         rc = RegSetValueExW(subKey, BlobW, 0, REG_BINARY, buf, len);
     196        rc = RegSetValueExW(subKey, BlobW, 0, REG_BINARY, (BYTE*)buf, len);
    197197        RegCloseKey(subKey);
    198198    }
    … …  
    270270                WCHAR asciiHash[20 * 2 + 1];
    271271
    272                 EnterCriticalSection(&store->cs);
     272                EnterCriticalSection((CRITICAL_SECTION*)&store->cs);
    273273                LIST_FOR_EACH_ENTRY_SAFE(toDelete, next, listToDelete[i],
    274274                 WINE_HASH_TO_DELETE, entry)
    … …  
    287287                    CryptMemFree(toDelete);
    288288                }
    289                 LeaveCriticalSection(&store->cs);
     289                LeaveCriticalSection((CRITICAL_SECTION*)&store->cs);
    290290            }
    291291            ret = CRYPT_SerializeContextsToReg(key, interfaces[i],
    … …  
    329329    RegCloseKey(store->key);
    330330    store->cs.DebugInfo->Spare[0] = 0;
    331     DeleteCriticalSection(&store->cs);
     331    DeleteCriticalSection((CRITICAL_SECTION*)&store->cs);
    332332    CryptMemFree(store);
    333333}
    … …  
    372372            if (ret)
    373373            {
    374                 EnterCriticalSection(&store->cs);
     374                EnterCriticalSection((CRITICAL_SECTION*)&store->cs);
    375375                list_add_tail(deleteList, &toDelete->entry);
    376                 LeaveCriticalSection(&store->cs);
     376                LeaveCriticalSection((CRITICAL_SECTION*)&store->cs);
    377377            }
    378378            else
    … …  
    488488
    489489static void *regProvFuncs[] = {
    490     CRYPT_RegCloseStore,
     490    (void*)CRYPT_RegCloseStore,
    491491    NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
    492     CRYPT_RegWriteCert,
    493     CRYPT_RegDeleteCert,
     492    (void*)CRYPT_RegWriteCert,
     493    (void*)CRYPT_RegDeleteCert,
    494494    NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
    495495    NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
    496     CRYPT_RegWriteCRL,
    497     CRYPT_RegDeleteCRL,
     496    (void*)CRYPT_RegWriteCRL,
     497    (void*)CRYPT_RegDeleteCRL,
    498498    NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
    499499    NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */
    500     CRYPT_RegWriteCTL,
    501     CRYPT_RegDeleteCTL,
     500    (void*)CRYPT_RegWriteCTL,
     501    (void*)CRYPT_RegDeleteCTL,
    502502    NULL, /* CERT_STORE_PROV_SET_CTL_PROPERTY_FUNC */
    503     CRYPT_RegControl,
     503    (void*)CRYPT_RegControl,
    504504};
    505505
    … …  
    548548                    regInfo->memStore = memStore;
    549549                    regInfo->key = key;
    550                     InitializeCriticalSection(&regInfo->cs);
    551                     regInfo->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": PWINE_REGSTOREINFO->cs");
     550                    InitializeCriticalSection((CRITICAL_SECTION*)&regInfo->cs);
     551                    regInfo->cs.DebugInfo->Spare[0] = (DWORD)(DWORD_PTR)(__FILE__ ": PWINE_REGSTOREINFO->cs");
    552552                    list_init(&regInfo->certsToDelete);
    553553                    list_init(&regInfo->crlsToDelete);

  • trunk/src/crypt32/rootstore.c

    r21325 r21354  
    1616 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
    1717 */
     18
    1819#include <os2win.h>
    1920#include <odinwrap.h>
    … …  
    2223#include <stdarg.h>
    2324#include <stdio.h>
     25#include <string.h>
    2426#include <sys/types.h>
    2527#include <sys/stat.h>
    … …  
    2830#endif
    2931#include <fcntl.h>
     32#if __IBMC__ || __IBMCPP__
     33#include <io.h>
     34#endif
    3035#ifdef HAVE_UNISTD_H
    3136#include <unistd.h>
    … …  
    229234            name = buf;
    230235        }
    231         LocalFree(nameInfo);
     236        LocalFree((HANDLE)nameInfo);
    232237    }
    233238    return name;
    … …  
    299304    TRACE("\n");
    300305
    301     fp = odin_fdopen(fd, "r");
     306    fp = fdopen(fd, "r");
    302307    if (fp)
    303308    {
    … …  
    426431    NULL, /* CERT_STORE_PROV_CLOSE_FUNC */
    427432    NULL, /* CERT_STORE_PROV_READ_CERT_FUNC */
    428     CRYPT_RootWriteCert,
    429     CRYPT_RootDeleteCert,
     433    (void*)CRYPT_RootWriteCert,
     434    (void*)CRYPT_RootDeleteCert,
    430435    NULL, /* CERT_STORE_PROV_SET_CERT_PROPERTY_FUNC */
    431436    NULL, /* CERT_STORE_PROV_READ_CRL_FUNC */
    432     CRYPT_RootWriteCRL,
    433     CRYPT_RootDeleteCRL,
     437    (void*)CRYPT_RootWriteCRL,
     438    (void*)CRYPT_RootDeleteCRL,
    434439    NULL, /* CERT_STORE_PROV_SET_CRL_PROPERTY_FUNC */
    435440    NULL, /* CERT_STORE_PROV_READ_CTL_FUNC */

  • trunk/src/crypt32/serialize.c

    r21311 r21354  
    2121
    2222#include <stdarg.h>
     23#include <string.h>
    2324#include "windef.h"
    2425#include "winbase.h"
    … …  
    615616static BOOL CRYPT_FileOutputFunc(void *handle, const void *buffer, DWORD size)
    616617{
    617     return WriteFile(handle, buffer, size, &size, NULL);
     618    return WriteFile((HANDLE)handle, buffer, size, &size, NULL);
    618619}
    619620
    … …  
    622623    SetFilePointer(file, 0, NULL, FILE_BEGIN);
    623624    return CRYPT_WriteSerializedStoreToStream(store, CRYPT_FileOutputFunc,
    624      file);
     625     (void*)file);
    625626}
    626627
    … …  
    739740            ret = CRYPT_SavePKCSToMem(store, dwMsgAndCertEncodingType, &blob);
    740741            if (ret)
    741                 ret = WriteFile(handle, blob.pbData, blob.cbData,
     742                ret = WriteFile((HANDLE)handle, blob.pbData, blob.cbData,
    742743                 &blob.cbData, NULL);
    743744        }
    … …  
    755756 DWORD dwMsgAndCertEncodingType, void *handle)
    756757{
    757     return CRYPT_WriteSerializedStoreToFile(handle, store);
     758    return CRYPT_WriteSerializedStoreToFile((HANDLE)handle, store);
    758759}
    759760
    … …  
    857858        break;
    858859    case CERT_STORE_SAVE_TO_FILENAME_A:
    859         handle = CreateFileA((LPCSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
     860        handle = (void*)CreateFileA((LPCSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
    860861         CREATE_ALWAYS, 0, NULL);
    861862        saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?
    … …  
    863864        break;
    864865    case CERT_STORE_SAVE_TO_FILENAME_W:
    865         handle = CreateFileW((LPCWSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
     866        handle = (void*)CreateFileW((LPCWSTR)pvSaveToPara, GENERIC_WRITE, 0, NULL,
    866867         CREATE_ALWAYS, 0, NULL);
    867868        saveFunc = dwSaveAs == CERT_STORE_SAVE_AS_STORE ?

  • trunk/src/crypt32/sip.c

    r21311 r21354  
    2121#include <stdarg.h>
    2222#include <stdio.h>
     23#include <string.h>
    2324
    2425#define WINE_LARGE_INTEGER /* for QuadPart in LARGE_INTEGER */
    … …  
    177178
    178179    /* write the values */
    179     r = RegSetValueExW( hKey, szFuncName, 0, REG_SZ, (const BYTE*) szFunction,
     180    r = RegSetValueExW( hKey, szFuncName, 0, REG_SZ, (BYTE*) szFunction,
    180181                        ( lstrlenW( szFunction ) + 1 ) * sizeof (WCHAR) );
    181182    if( r != ERROR_SUCCESS ) goto error_close_key;
    182     r = RegSetValueExW( hKey, szDllName, 0, REG_SZ, (const BYTE*) szDll,
     183    r = RegSetValueExW( hKey, szDllName, 0, REG_SZ, (BYTE*) szDll,
    183184                        ( lstrlenW( szDll ) + 1) * sizeof (WCHAR) );
    184185
    … …  
    282283    if (!lib)
    283284        goto end;
    284     func = GetProcAddress(lib, functionName);
     285    func = (void*)GetProcAddress(lib, functionName);
    285286    if (func)
    286287        *pLib = lib;
    … …  
    456457                {
    457458                    HMODULE lib;
    458                     pfnIsFileSupported isMy = CRYPT_LoadSIPFuncFromKey(subKey,
    459                      &lib);
     459                    pfnIsFileSupported isMy =
     460                       (pfnIsFileSupported)CRYPT_LoadSIPFuncFromKey(subKey, &lib);
    460461
    461462                    if (isMy)
    … …  
    494495                    {
    495496                        HMODULE lib;
    496                         pfnIsFileSupportedName isMy2 =
     497                        pfnIsFileSupportedName isMy2 = (pfnIsFileSupportedName)
    497498                         CRYPT_LoadSIPFuncFromKey(subKey, &lib);
    498499
    … …  
    572573    { &providers_cs_debug.ProcessLocksList,
    573574    &providers_cs_debug.ProcessLocksList },
    574     0, 0, { (DWORD_PTR)(__FILE__ ": providers_cs") }
     575    0, 0, { (DWORD)(DWORD_PTR)(__FILE__ ": providers_cs") }
    575576};
    576577static RTL_CRITICAL_SECTION providers_cs = { &providers_cs_debug, -1, 0, 0, 0, 0 };
    … …  
    584585        prov->subject = *pgSubject;
    585586        prov->info = *info;
    586         EnterCriticalSection(&providers_cs);
     587        EnterCriticalSection((CRITICAL_SECTION*)&providers_cs);
    587588        list_add_tail(&providers, &prov->entry);
    588         LeaveCriticalSection(&providers_cs);
     589        LeaveCriticalSection((CRITICAL_SECTION*)&providers_cs);
    589590    }
    590591}
    … …  
    594595    WINE_SIP_PROVIDER *provider = NULL, *ret = NULL;
    595596
    596     EnterCriticalSection(&providers_cs);
     597    EnterCriticalSection((CRITICAL_SECTION*)&providers_cs);
    597598    LIST_FOR_EACH_ENTRY(provider, &providers, WINE_SIP_PROVIDER, entry)
    598599    {
    … …  
    602603    if (provider && IsEqualGUID(pgSubject, &provider->subject))
    603604        ret = provider;
    604     LeaveCriticalSection(&providers_cs);
     605    LeaveCriticalSection((CRITICAL_SECTION*)&providers_cs);
    605606    return ret;
    606607}
    … …  
    631632    HMODULE lib = NULL, temp = NULL;
    632633
    633     sip.pfGet = CRYPT_LoadSIPFunc(pgSubject, szGetSigned, &lib);
     634    sip.pfGet = (pCryptSIPGetSignedDataMsg)CRYPT_LoadSIPFunc(pgSubject, szGetSigned, &lib);
    634635    if (!sip.pfGet)
    635636        goto error;
    636     sip.pfPut = CRYPT_LoadSIPFunc(pgSubject, szPutSigned, &temp);
     637    sip.pfPut = (pCryptSIPPutSignedDataMsg)CRYPT_LoadSIPFunc(pgSubject, szPutSigned, &temp);
    637638    if (!sip.pfPut || temp != lib)
    638639        goto error;
    639640    FreeLibrary(temp);
    640     sip.pfCreate = CRYPT_LoadSIPFunc(pgSubject, szCreate, &temp);
     641    sip.pfCreate = (pCryptSIPCreateIndirectData)CRYPT_LoadSIPFunc(pgSubject, szCreate, &temp);
    641642    if (!sip.pfCreate || temp != lib)
    642643        goto error;
    643644    FreeLibrary(temp);
    644     sip.pfVerify = CRYPT_LoadSIPFunc(pgSubject, szVerify, &temp);
     645    sip.pfVerify = (pCryptSIPVerifyIndirectData)CRYPT_LoadSIPFunc(pgSubject, szVerify, &temp);
    645646    if (!sip.pfVerify || temp != lib)
    646647        goto error;
    647648    FreeLibrary(temp);
    648     sip.pfRemove = CRYPT_LoadSIPFunc(pgSubject, szRemoveSigned, &temp);
     649    sip.pfRemove = (pCryptSIPRemoveSignedDataMsg)CRYPT_LoadSIPFunc(pgSubject, szRemoveSigned, &temp);
    649650    if (!sip.pfRemove || temp != lib)
    650651        goto error;
    … …  
    720721    TRACE("(%p %p %p)\n", pSubjectInfo, pcbIndirectData, pIndirectData);
    721722
    722     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
     723    if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)) != NULL)
    723724        ret = sip->info.pfCreate(pSubjectInfo, pcbIndirectData, pIndirectData);
    724725    TRACE("returning %d\n", ret);
    … …  
    738739          pcbSignedDataMsg, pbSignedDataMsg);
    739740
    740     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
     741    if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)) != NULL)
    741742        ret = sip->info.pfGet(pSubjectInfo, pdwEncodingType, dwIndex,
    742743         pcbSignedDataMsg, pbSignedDataMsg);
    … …  
    757758          cbSignedDataMsg, pbSignedDataMsg);
    758759
    759     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
     760    if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)) != NULL)
    760761        ret = sip->info.pfPut(pSubjectInfo, pdwEncodingType, pdwIndex,
    761762         cbSignedDataMsg, pbSignedDataMsg);
    … …  
    775776    TRACE("(%p %d)\n", pSubjectInfo, dwIndex);
    776777
    777     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
     778    if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)) != NULL)
    778779        ret = sip->info.pfRemove(pSubjectInfo, dwIndex);
    779780    TRACE("returning %d\n", ret);
    … …  
    792793    TRACE("(%p %p)\n", pSubjectInfo, pIndirectData);
    793794
    794     if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)))
     795    if ((sip = CRYPT_GetCachedSIP(pSubjectInfo->pgSubjectType)) != NULL)
    795796        ret = sip->info.pfVerify(pSubjectInfo, pIndirectData);
    796797    TRACE("returning %d\n", ret);

  • trunk/src/crypt32/store.c

    r21311 r21354  
    2929#include <assert.h>
    3030#include <stdarg.h>
     31#include <string.h>
    3132#include "windef.h"
    3233#include "winbase.h"
    … …  
    426427        if (!rc)
    427428        {
    428             store = CRYPT_RegOpenStore(hCryptProv, dwFlags, key);
     429            store = CRYPT_RegOpenStore(hCryptProv, dwFlags, (const void*)key);
    429430            RegCloseKey(key);
    430431        }
    … …  
    575576
    576577static void *msgProvFuncs[] = {
    577     CRYPT_MsgCloseStore,
     578    (void*)CRYPT_MsgCloseStore,
    578579};
    579580

  • trunk/src/crypt32/str.c

    r21311 r21354  
    1717 */
    1818#include <stdarg.h>
     19#include <string.h>
     20#include <ctype.h>
    1921#include "windef.h"
    2022#include "winbase.h"
    … …  
    277279            else rdn++;
    278280        }
    279         LocalFree(info);
     281        LocalFree((HANDLE)info);
    280282    }
    281283    if (psz && csz)
    … …  
    457459            else rdn++;
    458460        }
    459         LocalFree(info);
     461        LocalFree((HANDLE)info);
    460462    }
    461463    if (psz && csz)
    … …  
    499501        LPWSTR x500, errorStr;
    500502
    501         if ((x500 = CryptMemAlloc(len * sizeof(WCHAR))))
     503        if ((x500 = CryptMemAlloc(len * sizeof(WCHAR))) != NULL)
    502504        {
    503505            MultiByteToWideChar(CP_ACP, 0, pszX500, -1, x500, len);
    … …  
    746748    BOOL ret = FALSE;
    747749
    748     TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID),
    749      debugstr_wn(value->start, value->end - value->start));
     750    TRACE("OID %s, value %s\n", debugstr_a(keyOID->pszOID), debugstr_wn(value->start, value->end - value->start));
    750751
    751752    if (!info->rgRDN)
    … …  
    882883
    883884        for (j = 0; j < info.rgRDN[i].cRDNAttr; j++)
    884             LocalFree(info.rgRDN[i].rgRDNAttr[j].Value.pbData);
     885            LocalFree((HANDLE)info.rgRDN[i].rgRDNAttr[j].Value.pbData);
    885886        CryptMemFree(info.rgRDN[i].rgRDNAttr);
    886887    }
    … …  
    998999            ret = 0;
    9991000        if (info)
    1000             LocalFree(info);
     1001            LocalFree((HANDLE)info);
    10011002        break;
    10021003    }
Note: See TracChangeset for help on using the changeset viewer.