home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / netds / adsi / sampprov / common.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-29  |  8.3 KB  |  417 lines
  1. /*++
  2.  
  3. Copyright (c) 1996 Microsoft Corporation
  4.  
  5. Module Name:
  6.  
  7.     Common.cpp
  8.  
  9. Abstract:
  10.  
  11.     Contains routines and properties that are common to
  12.     all tshirt objects. thsirt objects get the routines and
  13.     properties through C++ inheritance.
  14.  
  15. Author:
  16.  
  17. Environment:
  18.  
  19.     User mode
  20.  
  21. Revision History :
  22.  
  23. --*/
  24. #include "adssmp.h"
  25. #pragma hdrstop
  26.  
  27.  
  28. FILTERS Filters[] = {
  29.                     {L"organizational unit", SampleDS_OU_ID},
  30.                     {L"class", SampleDS_CLASS_ID},
  31.                     {L"property", SampleDS_PROPERTY_ID}
  32.                   };
  33.  
  34. #define MAX_FILTERS  (sizeof(Filters)/sizeof(FILTERS))
  35.  
  36. PFILTERS  gpFilters = Filters;
  37. DWORD gdwMaxFilters = MAX_FILTERS;
  38.  
  39. extern WCHAR * g_szProviderName;
  40.  
  41. HRESULT
  42. xx_put_BSTR(BSTR* lppItemName, BSTR lpName)
  43. {
  44.     if (*lppItemName) {
  45.         SysFreeString(*lppItemName);
  46.         *lppItemName = NULL;
  47.     }
  48.  
  49.     if (!lpName) {
  50.         RRETURN(S_OK);
  51.     }
  52.  
  53.     *lppItemName = SysAllocString(lpName);
  54.  
  55.     if (!*lppItemName) {
  56.         RRETURN(E_FAIL);
  57.     }
  58.     RRETURN(S_OK);
  59. }
  60.  
  61. HRESULT
  62. xx_put_LONG(long * plnItem, long lnItem)
  63. {
  64.     *plnItem = lnItem;
  65.     RRETURN(S_OK);
  66. }
  67.  
  68. HRESULT
  69. xx_put_DATE(DATE * pdaItem, DATE daItem)
  70. {
  71.     *pdaItem = daItem;
  72.     RRETURN(S_OK);
  73. }
  74.  
  75.  
  76. HRESULT
  77. xx_put_VARIANT_BOOL(VARIANT_BOOL * pfItem, VARIANT_BOOL fItem)
  78. {
  79.     *pfItem = fItem;
  80.     RRETURN(S_OK);
  81. }
  82.  
  83.  
  84. HRESULT
  85. xx_put_VARIANT(VARIANT * * ppvItem, VARIANT vItem)
  86. {
  87.     if (!*ppvItem) {
  88.         if (!(*ppvItem = (VARIANT *)AllocProvMem(sizeof(VARIANT)))){
  89.             RRETURN(E_OUTOFMEMORY);
  90.         }
  91.     }
  92.     RRETURN(VariantCopy(*ppvItem, &vItem));
  93. }
  94.  
  95. HRESULT
  96. BuildADsPath(
  97.     BSTR Parent,
  98.     BSTR Name,
  99.     BSTR *pADsPath
  100.     )
  101. {
  102.     WCHAR ADsPath[MAX_PATH];
  103.     WCHAR ProviderName[MAX_PATH];
  104.     HRESULT hr = S_OK;
  105.  
  106.     //
  107.     // We will assert if bad parameters are passed to us.
  108.     // This is because this should never be the case. This
  109.     // is an internal call
  110.     //
  111.  
  112.     ADsAssert(Parent && Name);
  113.     ADsAssert(pADsPath);
  114.  
  115.  
  116.     //
  117.     // Special case the Namespace object; if
  118.     // the parent is L"ADs:", then Name = ADsPath
  119.     //
  120.  
  121.     if (!_wcsicmp(Parent, L"ADs:")) {
  122.         RRETURN(xx_put_BSTR(pADsPath, Name));
  123.     }
  124.  
  125.     //
  126.     // The rest of the cases we expect valid data,
  127.     // Path, Parent and Name are read-only, the end-user
  128.     // cannot modify this data
  129.     //
  130.  
  131.     //
  132.     // For first level objects we do not add
  133.     // the first backslash; so we examine that the parent is
  134.     // L"Sample:" and skip the slash otherwise we start with
  135.     // the slash
  136.     //
  137.  
  138.     wsprintf(ProviderName, L"%s:", g_szProviderName);
  139.  
  140.     wcscpy(ADsPath, Parent);
  141.  
  142.     if (_wcsicmp(ADsPath, ProviderName)) {
  143.         wcscat(ADsPath, L"/");
  144.     }else {
  145.         wcscat(ADsPath, L"//");
  146.     }
  147.     wcscat(ADsPath, Name);
  148.  
  149.     hr = xx_put_BSTR(pADsPath, ADsPath);
  150.  
  151.     RRETURN(hr);
  152. }
  153.  
  154. HRESULT
  155. BuildSchemaPath(
  156.     BSTR bstrADsPath,
  157.     BSTR bstrClass,
  158.     BSTR *pSchemaPath
  159.     )
  160. {
  161.     WCHAR ADsSchema[MAX_PATH];
  162.     OBJECTINFO ObjectInfo;
  163.     POBJECTINFO pObjectInfo = &ObjectInfo;
  164.     CLexer Lexer(bstrADsPath);
  165.     HRESULT hr = S_OK;
  166.  
  167.     wcscpy(ADsSchema, L"");
  168.  
  169.     if (bstrClass && *bstrClass) {
  170.         memset(pObjectInfo, 0, sizeof(OBJECTINFO));
  171.         hr = ADsObject(&Lexer, pObjectInfo);
  172.         BAIL_ON_FAILURE(hr);
  173.  
  174.         if (pObjectInfo->RootRDN) {
  175.  
  176.             wsprintf(ADsSchema,L"%s://",pObjectInfo->ProviderName);
  177.             wcscat(ADsSchema, pObjectInfo->RootRDN);
  178.             wcscat(ADsSchema,L"/schema/");
  179.             wcscat(ADsSchema, bstrClass);
  180.  
  181.         }
  182.     }
  183.  
  184.     hr = ProvAllocString( ADsSchema, pSchemaPath);
  185.  
  186. error:
  187.  
  188.     if (pObjectInfo) {
  189.  
  190.         //
  191.         // BugBug - KrishnaG; free up this piece of memory
  192.         //
  193.     }
  194.     RRETURN(hr);
  195. }
  196.  
  197.  
  198. HRESULT
  199. BuildADsGuid(
  200.     REFCLSID clsid,
  201.     BSTR *pADsClass
  202. ){
  203.     WCHAR ADsClass[MAX_PATH];
  204.  
  205.     StringFromGUID2(clsid, ADsClass, 256);
  206.  
  207.     RRETURN(xx_put_BSTR(pADsClass, ADsClass));
  208. }
  209.  
  210.  
  211. typedef struct _typeinfotable
  212. {
  213.     GUID iid;
  214.     ITypeInfo * pTypeInfo;
  215.     struct _typeinfotable *pNext;
  216. }TYPEINFO_TABLE, *PTYPEINFO_TABLE;
  217.  
  218.  
  219. PTYPEINFO_TABLE gpTypeInfoTable = NULL;
  220.  
  221. ITypeInfo *
  222. FindTypeInfo(
  223.     PTYPEINFO_TABLE pTypeInfoTable,
  224.     REFIID iid
  225. ){
  226.     PTYPEINFO_TABLE pTemp = NULL;
  227.  
  228.     pTemp = pTypeInfoTable;
  229.  
  230.     while (pTemp) {
  231.         if (IsEqualIID(iid, pTemp->iid)) {
  232.             return(pTemp->pTypeInfo);
  233.         }
  234.         pTemp = pTemp->pNext;
  235.     }
  236.     return(NULL);
  237. }
  238.  
  239.  
  240. PTYPEINFO_TABLE
  241. AddTypeInfo(
  242.     PTYPEINFO_TABLE pTypeInfoTable,
  243.     REFIID iid,
  244.     ITypeInfo * pTypeInfo
  245. ){
  246.     PTYPEINFO_TABLE pTemp = NULL;
  247.  
  248.     pTemp = (PTYPEINFO_TABLE)AllocProvMem(
  249.                     sizeof(TYPEINFO_TABLE)
  250.                     );
  251.     if (!pTemp) {
  252.         return(NULL);
  253.     }
  254.  
  255.     memcpy(&pTemp->iid, &iid, sizeof(GUID));
  256.     pTemp->pTypeInfo = pTypeInfo;
  257.     pTemp->pNext = pTypeInfoTable;
  258.  
  259.     return(pTemp);
  260. }
  261.  
  262. HRESULT
  263. LoadTypeInfoEntry(
  264.     CDispatchMgr *pDispMgr,
  265.     REFIID libid,
  266.     REFIID iid,
  267.     void * pIntf,
  268.     DISPID SpecialId
  269. ){
  270.     ITypeInfo * pTypeInfo = NULL;
  271.     HRESULT hr;
  272.  
  273.     pTypeInfo = FindTypeInfo(
  274.                     gpTypeInfoTable,
  275.                     iid
  276.                     );
  277.     if (!pTypeInfo) {
  278.  
  279.         hr = LoadTypeInfo(libid, iid, &pTypeInfo);
  280.         BAIL_IF_ERROR(hr);
  281.  
  282.         gpTypeInfoTable = AddTypeInfo(
  283.                                 gpTypeInfoTable,
  284.                                 iid,
  285.                                 pTypeInfo
  286.                                 );
  287.         if (!gpTypeInfoTable) {
  288.             hr = HRESULT_FROM_WIN32(GetLastError());
  289.             BAIL_IF_ERROR(hr);
  290.         }
  291.     }
  292.     pTypeInfo->AddRef();
  293.  
  294.  
  295.     hr = pDispMgr->AddTypeInfo(pTypeInfo, pIntf);
  296.     BAIL_IF_ERROR(hr);
  297.  
  298.     if (SpecialId == -4) {
  299.         hr = pDispMgr->MarkAsNewEnum(pTypeInfo);
  300.     }
  301.  
  302.     RRETURN(S_OK);
  303.  
  304. cleanup:
  305.  
  306.    if (pTypeInfo) {
  307.        pTypeInfo->Release();
  308.    }
  309.     RRETURN(hr);
  310. }
  311.  
  312. HRESULT
  313. ValidateOutParameter(BSTR * retval)
  314. {
  315.     if (!retval) {
  316.         RRETURN(E_ADS_BAD_PARAMETER);
  317.     }
  318.     RRETURN(S_OK);
  319. }
  320.  
  321.  
  322. PKEYDATA
  323. CreateTokenList(
  324.     LPWSTR   pKeyData,
  325.     WCHAR ch
  326. ){
  327.     DWORD       cTokens;
  328.     DWORD       cb;
  329.     PKEYDATA    pResult;
  330.     LPWSTR       pDest;
  331.     LPWSTR       psz = pKeyData;
  332.     LPWSTR      *ppToken;
  333.     WCHAR szTokenList[MAX_PATH];
  334.  
  335.  
  336.     if (!psz || !*psz)
  337.         return NULL;
  338.  
  339.     wsprintf(szTokenList, L"%c", ch);
  340.  
  341.     cTokens=1;
  342.  
  343.     // Scan through the string looking for commas,
  344.     // ensuring that each is followed by a non-NULL character:
  345.  
  346.     while ((psz = wcschr(psz, ch)) && psz[1]) {
  347.  
  348.         cTokens++;
  349.         psz++;
  350.     }
  351.  
  352.     cb = sizeof(KEYDATA) + (cTokens-1) * sizeof(LPWSTR) +
  353.          wcslen(pKeyData)*sizeof(WCHAR) + sizeof(WCHAR);
  354.  
  355.     if (!(pResult = (PKEYDATA)AllocProvMem(cb)))
  356.         return NULL;
  357.  
  358.     // Initialise pDest to point beyond the token pointers:
  359.  
  360.     pDest = (LPWSTR)((LPBYTE)pResult + sizeof(KEYDATA) +
  361.                                       (cTokens-1) * sizeof(LPWSTR));
  362.  
  363.     // Then copy the key data buffer there:
  364.  
  365.     wcscpy(pDest, pKeyData);
  366.  
  367.     ppToken = pResult->pTokens;
  368.  
  369.  
  370.     // Remember, wcstok has the side effect of replacing the delimiter
  371.     // by NULL, which is precisely what we want:
  372.  
  373.     psz = wcstok (pDest, szTokenList);
  374.  
  375.     while (psz) {
  376.  
  377.         *ppToken++ = psz;
  378.         psz = wcstok (NULL, szTokenList);
  379.     }
  380.  
  381.     pResult->cTokens = cTokens;
  382.  
  383.     return( pResult );
  384. }
  385.  
  386. //+------------------------------------------------------------------------
  387. //
  388. //  Function:   LoadTypeInfo
  389. //
  390. //  Synopsis:   Loads a typeinfo from a registered typelib.
  391. //
  392. //  Arguments:  [clsidTL] --  TypeLib GUID
  393. //              [clsidTI] --  TypeInfo GUID
  394. //              [ppTI]    --  Resulting typeInfo
  395. //
  396. //  Returns:    HRESULT
  397. //
  398. //-------------------------------------------------------------------------
  399.  
  400. HRESULT
  401. LoadTypeInfo(CLSID clsidTL, CLSID clsidTI, LPTYPEINFO *ppTI)
  402. {
  403.     HRESULT     hr;
  404.     ITypeLib *  pTL;
  405.  
  406.     ADsAssert(ppTI);
  407.     *ppTI = NULL;
  408.     hr = LoadRegTypeLib(clsidTL, 1, 0, LOCALE_SYSTEM_DEFAULT, &pTL);
  409.     if (hr)
  410.         RRETURN(hr);
  411.  
  412.     hr = pTL->GetTypeInfoOfGuid(clsidTI, ppTI);
  413.     pTL->Release();
  414.     RRETURN(hr);
  415. }
  416.  
  417.