Windows编程

开发平台：
Visual C++

SMHARC.C：源码内容
							/*
 *  S M H A R C . C
 *
 *  Sample mail handling message archiving
 *  Copyright 1992-95 Microsoft Corporation.  All Rights Reserved.
 */
#include "_pch.h"
/*
 *  FIsLeapYear()
 *
 *  Used to calculate leap years when determining month ranges for
 *  archive folders.
 */
#define FIsLeapYear(_yr) ((!((_yr) % 400) || ((_yr) % 100) && !((_yr) % 4)) ? TRUE : FALSE)
/*
 *  sptMsgDates
 *
 *  The list of properties that are used for archiving.  If
 *  PR_MESSAGE_DELIVERY_TIME is not available, then SMH will use
 *  PR_CLIENT_SUBMIT_TIME.
 */
const static SizedSPropTagArray(2, sptMsgDates) =
{
    2,
    {
        PR_MESSAGE_DELIVERY_TIME,
        PR_CLIENT_SUBMIT_TIME
    }
};
/*
 *  sptFldrDates
 *
 *  Theses properties describe the range of dates that an archive folder
 *  with the returned EntryID will support.  This is used in the call to
 *  find a supporting sub-folder.
 */
const static SizedSPropTagArray (3, sptFldrDates) =
{
    3,
    {
        PR_START_DATE,
        PR_END_DATE,
        PR_ENTRYID
    }
};
/*
 *  rgtstrMonth
 *  rgtstrMonthFull
 *  rgwDaysPerMonth
 *
 *  These arrays are used in the calculation and creation of supporting
 *  archive folders.
 */
const static TCHAR FAR * rgtstrMonth[] =
{
    TEXT ("Jan"),
    TEXT ("Feb"),
    TEXT ("Mar"),
    TEXT ("Apr"),
    TEXT ("May"),
    TEXT ("Jun"),
    TEXT ("Jul"),
    TEXT ("Aug"),
    TEXT ("Sep"),
    TEXT ("Oct"),
    TEXT ("Nov"),
    TEXT ("Dec")
};
const TCHAR FAR * rgtstrMonthFull[] =
{
    TEXT ("January"),
    TEXT ("February"),
    TEXT ("March"),
    TEXT ("April"),
    TEXT ("May"),
    TEXT ("June"),
    TEXT ("July"),
    TEXT ("August"),
    TEXT ("September"),
    TEXT ("October"),
    TEXT ("November"),
    TEXT ("December")
};
const static WORD rgwDaysPerMonth[] =
{
    31, //  JAN
    28, //  FEB
    31, //  MAR
    30, //  APR
    31, //  MAY
    30, //  JUN
    31, //  JUL
    31, //  AUG
    30, //  SEP
    31, //  OCT
    30, //  NOV
    31  //  DEC
};
/*
 *  HrCacheFolder()
 *
 *  Purpose:
 *
 *      Caches the passed in entryid along with a matching folder
 *
 *  Arguments:
 *
 *      lpsmh       pointer to the sentmail handler
 *      cbeid       count of bytes for the entryid to check
 *      lpeid       data for the entryid to check
 *      lpcbeid     points to the cached entryid size
 *      lppeid      points to the cached entryid data
 *      lppfldr     points to the cached mapi folder object
 *      lpfUpdated  points to cache update flag
 *
 *  Returns:
 *
 *      (HRESULT)
 *      lpcbeid     [OUT] size of newly cached entryid
 *      lppeid      [OUT] data of newly cached entryid
 *      lppfldr     [OUT] folder corresponding to cached entryid
 *      lpfUpdated  [OUT] TRUE iff the out folder is not the
 *                          previously cached folder
 */
HRESULT
HrCacheFolder (LPSMH lpsmh,
    LPMDB lpmdbPref,
    ULONG cbeid,
    LPENTRYID lpeid,
    ULONG FAR * lpcbeid,
    LPENTRYID FAR * lppeid,
    LPMAPIFOLDER FAR * lppfldr,
    BOOL far * lpfUpdated)
{
    HRESULT hr;
    ULONG ulType;
    ULONG ulMatch;
    LPMAPIPROP lpmp = NULL;
    /* Init the update flag */
    *lpfUpdated = FALSE;
    /*  Is the topmost sent mail folder the same folder
     *  as the last filtered message?
     */
    hr = lpsmh->lpsess->lpVtbl->CompareEntryIDs (lpsmh->lpsess,
                                        cbeid,
                                        lpeid,
                                        *lpcbeid,
                                        *lppeid,
                                        0,
                                        &ulMatch);
    if (HR_FAILED (hr) || !ulMatch)
    {
        /* Different folder, guess we better toss the cached one */
        (*lpsmh->lpfnFree) (*lppeid);
        *lppeid = NULL;
        *lpcbeid = 0;
        /* Cache the SentMail */
        hr = ResultFromScode ((*lpsmh->lpfnAlloc) (cbeid, lppeid));
        if (HR_FAILED (hr))
            goto ret;
        memcpy (*lppeid, lpeid, (UINT)cbeid);
        *lpcbeid = cbeid;
        *lpfUpdated = TRUE;
    }
    else if (*lppfldr)
        return hrSuccess;
    /* Open the new folder, but try the preferred store first */
    hr = lpmdbPref->lpVtbl->OpenEntry (lpmdbPref,
                                        cbeid,
                                        lpeid,
                                        NULL,
                                        MAPI_BEST_ACCESS,
                                        &ulType,
                                        (LPUNKNOWN FAR *)&lpmp);
    if (HR_FAILED (hr))
    {
        /* Try the MAPI session now and see if we can get the folder */
        
        hr = lpsmh->lpsess->lpVtbl->OpenEntry (lpsmh->lpsess,
                                        cbeid,
                                        lpeid,
                                        NULL,
                                        MAPI_BEST_ACCESS,
                                        &ulType,
                                        (LPUNKNOWN FAR *)&lpmp);
    }
    if (HR_FAILED (hr))
        goto ret;
    if (ulType != MAPI_FOLDER)
    {
        hr = ResultFromScode (MAPI_E_UNEXPECTED_TYPE);
        goto ret;
    }
ret:
    if (HR_FAILED (hr))
    {
        UlRelease (lpmp);
        (*lpsmh->lpfnFree) (*lppeid);
        *lppeid = NULL;
        *lpcbeid = 0;
        lpmp = NULL;
    }
    UlRelease (*lppfldr);
    *lppfldr = (LPMAPIFOLDER)lpmp;
    DebugTraceResult (HrCacheFolder(), hr);
    return hr;
}
/*
 *  HrCreateHashedFolder()
 *
 *  Purpose:
 *
 *      Create/Caches the a folder that satisfies the hash value
 *
 *  Arguments:
 *
 *      lpsmh       pointer to the sentmail handler
 *      lpdft       pointer the the hash interval
 *      lpfldrPar   parnet folder
 *      lpszName    name for folder
 *      lpszComment comment for folder
 *      lpcbeid     points to the cached entryid size
 *      lppeid      points to the cached entryid data
 *      lppfldr     points to the cached mapi folder object
 *
 *  Returns:
 *
 *      (HRESULT)
 *      lpcbeid     [OUT] size of newly cached entryid
 *      lppeid      [OUT] data of newly cached entryid
 *      lppfldr     [OUT] folder corresponding to cached entryid
 */
HRESULT
HrCreateHashedFolder (LPSMH lpsmh,
    LPDFT lpdft,
    LPMAPIFOLDER lpfldrPar,
    LPTSTR lpszName,
    LPTSTR lpszComment,
    ULONG FAR * lpcbeid,
    LPENTRYID FAR * lppeid,
    LPMAPIFOLDER FAR * lppfldr)
{
    HRESULT hr;
    LPMAPIFOLDER lpfldr = NULL;
    LPSPropValue lpval = NULL;
    SPropValue rgval[2] = {0};
    ULONG cval;
    /* Toss the current cache info */
    (*lpsmh->lpfnFree) (*lppeid);
    *lppeid = NULL;
    *lpcbeid = 0;
    /* Create the new folder */
    hr = lpfldrPar->lpVtbl->CreateFolder (lpfldrPar,
                            FOLDER_GENERIC,
                            lpszName,
                            lpszComment,
                            NULL,
                            OPEN_IF_EXISTS,
                            &lpfldr);
    if (HR_FAILED (hr))
        goto ret;
    /* Set the hashing interval properties */
    rgval[0].ulPropTag = PR_START_DATE;
    rgval[0].Value.ft = lpdft->ftStart;
    rgval[1].ulPropTag = PR_END_DATE;
    rgval[1].Value.ft = lpdft->ftEnd;
    hr = lpfldr->lpVtbl->SetProps (lpfldr, 2, rgval, NULL);
    if (HR_FAILED (hr))
        goto ret;
    /* Cache the folder info */
    hr = lpfldr->lpVtbl->GetProps (lpfldr,
                            (LPSPropTagArray)&sptFldrDates,
                            FALSE,
                            &cval,
                            &lpval);
    if (HR_FAILED (hr))
        goto ret;
    /* Make sure we have all the info we need */
    if ((lpval[0].ulPropTag != PR_START_DATE) ||
        (lpval[1].ulPropTag != PR_END_DATE) ||
        (lpval[2].ulPropTag != PR_ENTRYID))
    {
        hr = ResultFromScode (MAPI_E_BAD_VALUE);
        goto ret;
    }
    /* Cache the entryid */
    hr = ResultFromScode ((*lpsmh->lpfnAlloc) (lpval[2].Value.bin.cb, lppeid));
    if (HR_FAILED (hr))
        goto ret;
    memcpy (*lppeid, lpval[2].Value.bin.lpb, (UINT)lpval[2].Value.bin.cb);
    *lpcbeid = lpval[2].Value.bin.cb;
ret:
    (*lpsmh->lpfnFree) (lpval);
    if (HR_FAILED (hr))
    {
        UlRelease (lpfldr);
        lpfldr = NULL;
    }
    UlRelease (*lppfldr);
    *lppfldr = lpfldr;
    DebugTraceResult (HrCreateHashedFolder(), hr);
    return hr;
}
/*
 *  HrCacheHashedFolder()
 *
 *  Purpose:
 *
 *      Caches the folder that matches the hash value (file time)
 *
 *  Arguments:
 *
 *      lpsmh       pointer to the sentmail handler
 *      ft          hash filetime
 *      lpdft       pointer the the hash interval
 *      lpcbeid     points to the cached entryid size
 *      lppeid      points to the cached entryid data
 *      lppfldr     points to the cached mapi folder object
 *      lpfUpdated  points to cache update flag
 *
 *  Returns:
 *
 *      (HRESULT)
 *      lpcbeid     [OUT] size of newly cached entryid
 *      lppeid      [OUT] data of newly cached entryid
 *      lppfldr     [OUT] folder corresponding to cached entryid
 *      lpfUpdated  [OUT] TRUE iff the out folder is not the
 *                          previously cached folder
 */
HRESULT
HrCacheHashedFolder (LPSMH lpsmh,
    LPMDB lpmdbPref,
    FILETIME ft,
    LPDFT lpdft,
    LPMAPIFOLDER lpfldr,
    ULONG FAR * lpcbeid,
    LPENTRYID FAR * lppeid,
    LPMAPIFOLDER FAR * lppfldr,
    BOOL far * lpfUpdated)
{
    HRESULT hr;
    LPMAPIPROP lpmp = NULL;
    LPMAPITABLE lptbl = NULL;
    LPSRow lprw = NULL;
    LPSRowSet lprws = NULL;
    ULONG ulType;
    UINT i;
    /*  Check to see if the new hash fits the
     *  the current hashed folder, if the hash
     *  value does not work, find one that does
     */
    if (!*lpfUpdated &&
        (CompareFileTime (&lpdft->ftStart, &ft) != 1) &&
        (CompareFileTime (&lpdft->ftEnd, &ft) != -1))
    {
        /* The hash works, but do we have a folder? */
        if (*lppfldr)
            return hrSuccess;
        hr = lpsmh->lpsess->lpVtbl->OpenEntry (lpsmh->lpsess,
                                        *lpcbeid,
                                        *lppeid,
                                        NULL,
                                        MAPI_BEST_ACCESS,
                                        &ulType,
                                        (LPUNKNOWN FAR *)&lpmp);
        if (!HR_FAILED (hr) && (ulType != MAPI_FOLDER))
        {
            hr = ResultFromScode (MAPI_E_UNEXPECTED_TYPE);
            UlRelease (lpmp);
            lpmp = NULL;
        }
        goto ret;
    }
    /* Toss the cached info */
    (*lpsmh->lpfnFree) (*lppeid);
    *lppeid = NULL;
    *lpcbeid = 0;
    /* Get the hierachy and set it up to find the target folder */
    hr = lpfldr->lpVtbl->GetHierarchyTable (lpfldr, 0, &lptbl);
    if (HR_FAILED (hr))
        goto ret;
    hr = lptbl->lpVtbl->SetColumns (lptbl, (LPSPropTagArray)&sptFldrDates, 0);
    if (HR_FAILED (hr))
        goto ret;
    hr = lptbl->lpVtbl->QueryRows (lptbl, 12, 0L, &lprws);
    if (HR_FAILED (hr))
        goto ret;
    while (lprws->cRows)
    {
        for (i = 0; i < lprws->cRows; i++)
        {
            lprw = &lprws->aRow[i];
            if (!lpmp &&
                (lprw->lpProps[0].ulPropTag == PR_START_DATE) &&
                (lprw->lpProps[1].ulPropTag == PR_END_DATE) &&
                (CompareFileTime (&lprw->lpProps[0].Value.ft, &ft) != 1) &&
                (CompareFileTime (&lprw->lpProps[1].Value.ft, &ft) != -1))
            {
                /* Hey, this looks like the folder we want */
                hr = HrCacheFolder (lpsmh,
                        lpmdbPref,
                        lprw->lpProps[2].Value.bin.cb,
                        (LPENTRYID)lprw->lpProps[2].Value.bin.lpb,
                        lpcbeid,
                        lppeid,
                        (LPMAPIFOLDER FAR *)&lpmp,
                        lpfUpdated);
                if (!HR_FAILED (hr))
                {
                    lpdft->ftStart = lprw->lpProps[0].Value.ft;
                    lpdft->ftEnd = lprw->lpProps[1].Value.ft;
                }
            }
        }
        /* Clean up the row properies */
        for (i = 0; i < lprws->cRows; i++)
            (*lpsmh->lpfnFree) (lprws->aRow[i].lpProps);
        /* We either found the folder or we had an error */
        if (lpmp || HR_FAILED (hr))
            break;
        /* Clean up the row set */
        (*lpsmh->lpfnFree) (lprws);
        hr = lptbl->lpVtbl->QueryRows (lptbl, 12, 0L, &lprws);
        if (HR_FAILED (hr))
            goto ret;
    }
    /* Clean up the final row set */
    (*lpsmh->lpfnFree) (lprws);
ret:
    UlRelease (lptbl);
    UlRelease (*lppfldr);
    *lppfldr = (LPMAPIFOLDER)lpmp;
    DebugTraceResult (HrCacheHashedFolder(), hr);
    return hr ? hr : (lpmp ? hrSuccess : ResultFromScode (MAPI_E_NOT_FOUND));
}
/*
 *  HrArchiveByDate()
 *
 *  Purpose:
 *
 *      The purpose of this function is to "hash" a single message by
 *      processing based on date.  The most obvious bucket size is
 *      monthly but there is no reason not to make this an option the
 *      user could confiigure.
 *
 *  Arguments:
 *
 *      lpsmh           this filter hook obj
 *      lpft            the date to be filtered against
 *      lpfldrDef       the owning folder of the message
 *      lpmdbDef        the owning store of the message
 *      lpbkit          the cached bucket structure
 *      fCatByYear      uses yearly subfolders iff TRUE
 *      cbeid           cb for entryid of default target for message
 *      lpbeid          pb for entryid of default target for message
 *
 *  Operation:
 *
 *      Opens the suggested folder (if needed) and checks for the
 *      existence of the appropriate "bucket" folder.  If it does exist,
 *      then the  folder is created and cached.  The entryid is grabbed
 *      and passed back in to the spooler.
 *
 *  Returns:
 *
 *      (HRESULT)
 */
HRESULT
HrArchiveByDate (LPSMH lpsmh,
    FILETIME FAR * lpft,
    LPMAPIFOLDER lpfldrDef,
    LPMDB lpmdbDef,
    LPBKIT lpbkit,
    BOOL fCatByYear,
    ULONG cbeid,
    LPBYTE lpeid)
{
    HRESULT hr = hrSuccess;
    BOOL fUpdated = FALSE;
    LPMAPIFOLDER lpfldr;
    SYSTEMTIME st;
    SYSTEMTIME sty;
    TCHAR rgchName[64] = {0};
    
    if (!FileTimeToSystemTime (lpft, &st))
    {
        hr = ResultFromScode (MAPI_E_BAD_VALUE);
        goto ret;
    }
    /* Cache the parent folder */
    hr = HrCacheFolder (lpsmh,
                    lpmdbDef,
                    cbeid,
                    (LPENTRYID)lpeid,
                    &lpbkit->cbeidParent,
                    &lpbkit->lpeidParent,
                    &lpbkit->lpfldrParent,
                    &fUpdated);
    if (HR_FAILED (hr))
        goto ret;
    if (fCatByYear)
    {
        /* Cache the year folder */
        hr = HrCacheHashedFolder (lpsmh,
                    lpmdbDef,
                    *lpft,
                    &lpbkit->dftYr,
                    lpbkit->lpfldrParent,
                    &lpbkit->cbeidYr,
                    &lpbkit->lpeidYr,
                    &lpbkit->lpfldrYr,
                    &fUpdated);
        if (HR_FAILED (hr) && (GetScode (hr) == MAPI_E_NOT_FOUND))
        {
            wsprintf (rgchName, "%04hu", st.wYear);
            sty.wYear = st.wYear;
            sty.wMonth = 1;
            sty.wDayOfWeek = 0;
            sty.wDay = 1;
            sty.wHour = 0;
            sty.wMinute = 0;
            sty.wSecond = 0;
            sty.wMilliseconds = 0;
            if (!SystemTimeToFileTime (&sty, &lpbkit->dftYr.ftStart))
            {
                hr = ResultFromScode (MAPI_E_BAD_VALUE);
                goto ret;
            }
            sty.wMonth = 12;
            sty.wDay = rgwDaysPerMonth[sty.wMonth - 1];
            sty.wDayOfWeek = 0;
            sty.wDay = 31;
            sty.wHour = 23;
            sty.wMinute = 59;
            sty.wSecond = 59;
            sty.wMilliseconds = 999;
            if (!SystemTimeToFileTime (&sty, &lpbkit->dftYr.ftEnd))
            {
                hr = ResultFromScode (MAPI_E_BAD_VALUE);
                goto ret;
            }
            hr = HrCreateHashedFolder (lpsmh,
                            &lpbkit->dftYr,
                            lpbkit->lpfldrParent,
                            rgchName,
                            NULL,
                            &lpbkit->cbeidYr,
                            &lpbkit->lpeidYr,
                            &lpbkit->lpfldrYr);
            if (HR_FAILED (hr))
                goto ret;
        }
        else if (HR_FAILED (hr))
            goto ret;
        lpfldr = lpbkit->lpfldrYr;
    }
    else
        lpfldr = lpbkit->lpfldrParent;
    /* Cache the hashed target folder */
    hr = HrCacheHashedFolder (lpsmh,
                    lpmdbDef,
                    *lpft,
                    &lpbkit->dft,
                    lpfldr,
                    &lpbkit->cbeid,
                    &lpbkit->lpeid,
                    &lpbkit->lpfldr,
                    &fUpdated);
    if (HR_FAILED (hr) && (GetScode (hr) == MAPI_E_NOT_FOUND))
    {
        if (fCatByYear)
        {
            wsprintf (rgchName,
                "%02hu %s",
                st.wMonth,
                rgtstrMonthFull[st.wMonth - 1]);
        }
        else
        {
            wsprintf (rgchName,
                TEXT("'%02hu/%02hu %s"),
                st.wYear % 100,
                st.wMonth,
                rgtstrMonthFull[st.wMonth - 1]);
        }
        st.wDayOfWeek = (st.wDay - st.wDayOfWeek - 1) % 7;
        st.wDay = 1;
        st.wHour = 0;
        st.wMinute = 0;
        st.wSecond = 0;
        st.wMilliseconds = 0;
        if (!SystemTimeToFileTime (&st, &lpbkit->dft.ftStart))
        {
            hr = ResultFromScode (MAPI_E_BAD_VALUE);
            goto ret;
        }
        st.wDay = rgwDaysPerMonth[st.wMonth - 1];
        if ((st.wMonth == 2) && FIsLeapYear (st.wYear))
            st.wDay += 1;
        st.wDayOfWeek = (st.wDayOfWeek + st.wDay - 1) % 7;
        st.wHour = 23;
        st.wMinute = 59;
        st.wSecond = 59;
        st.wMilliseconds = 999;
        if (!SystemTimeToFileTime (&st, &lpbkit->dft.ftEnd))
        {
            hr = ResultFromScode (MAPI_E_BAD_VALUE);
            goto ret;
        }
        hr = HrCreateHashedFolder (lpsmh,
                            &lpbkit->dft,
                            lpfldr,
                            rgchName,
                            NULL,
                            &lpbkit->cbeid,
                            &lpbkit->lpeid,
                            &lpbkit->lpfldr);
    }
ret:
    DebugTraceResult (HrArchiveMessage(), hr);
    return hr;
}
/*
 *  HrArchiveMessage()
 *
 *  Purpose:
 *
 *      The purpose of this function is to "hash" a single message by
 *      processing based on date.  The most obvious bucket size is
 *      monthly but there is no reason not to make this an option the
 *      user could confiigure.
 *
 *  Arguments:
 *
 *      lpsmh           this filter hook obj
 *      lpmsg           the message to be filtered
 *      lpfldrDef       the owning folder of the message
 *      lpmdbDef        the owning store of the message
 *      lpbkit          the cached bucket structure
 *      fCatByYear      uses yearly subfolders iff TRUE
 *      lpcbeid         cb for entryid of default target for message
 *      lppbeid         pb for entryid of default target for message
 *
 *  Operation:
 *
 *      Extracts the date of the message that is to be used in the
 *      archiving, and calls off to HrArchiveByDate().
 *
 *      IMPORTANT: the entryid passed in will be swapped out by this
 *      call.  Therefore the *lppeid buffer must be allocated with the
 *      MAPIAllocateBuffer provider to the filter.
 *
 *  Returns:
 *
 *      (HRESULT)
 *      lpcbeid [out]   the size of the returned EntryID
 *      lppbeid [out]   the data of the returned EntryID
 */
HRESULT
HrArchiveMessage (LPSMH lpsmh,
    LPMESSAGE lpmsg,
    LPMAPIFOLDER lpfldrDef,
    LPMDB lpmdbDef,
    LPBKIT lpbkit,
    BOOL fCatByYear,
    ULONG FAR * lpcbeid,
    LPBYTE FAR * lppeid)
{
    HRESULT hr = hrSuccess;
    FILETIME ft;
    LPSPropValue lpval = NULL;
    ULONG cval;
    /* Quick and dirty parameter check */
    if (IsBadWritePtr (lpsmh, sizeof(SMH)) ||
        IsBadWritePtr (lpcbeid, sizeof(ULONG)) ||
        IsBadWritePtr (lppeid, sizeof(LPBYTE)) ||
        IsBadWritePtr (*lppeid, (UINT)(*lpcbeid)))
        return ResultFromScode (MAPI_E_INVALID_PARAMETER);
    /* Get the date used by the hash */
    hr = lpmsg->lpVtbl->GetProps (lpmsg,
                            (LPSPropTagArray)&sptMsgDates,
                            FALSE,
                            &cval,
                            &lpval);
    if (HR_FAILED (hr))
        goto ret;
    /* Make sure what we end up with is usable */
    if (lpval[0].ulPropTag == PR_MESSAGE_DELIVERY_TIME)
    {
        DebugTrace ("SMH: filtering on PR_MESSAGE_DELIVERY_TIMEn");
        ft = lpval[0].Value.ft;
    }
    else if (lpval[1].ulPropTag == PR_CLIENT_SUBMIT_TIME)
    {
        DebugTrace ("SMH: filtering on PR_CLIENT_SUBMIT_TIMEn");
        ft = lpval[1].Value.ft;
    }
    else
    {
        DebugTrace ("SMH: cannot filter on provided time propsn");
        hr = ResultFromScode (MAPI_E_BAD_VALUE);
        goto ret;
    }
    hr = HrArchiveByDate (lpsmh,
                    &ft,
                    lpfldrDef,
                    lpmdbDef,
                    lpbkit,
                    fCatByYear,
                    *lpcbeid,
                    *lppeid);
ret:
    
    if (!HR_FAILED (hr))
    {
        LPBYTE lpeid;
        /* OK, If we get this far we are moving the message */
        hr = ResultFromScode ((*lpsmh->lpfnAlloc) (lpbkit->cbeid, &lpeid));
        if (HR_FAILED (hr))
            goto ret;
        memcpy (lpeid, lpbkit->lpeid, (UINT)lpbkit->cbeid);
        (*lpsmh->lpfnFree) (*lppeid);
        *lpcbeid = lpbkit->cbeid;
        *lppeid = lpeid;
    }
    (*lpsmh->lpfnFree) (lpval);
    
    DebugTraceResult (HrArchiveMessage(), hr);
    return hr;
}

						