src/WINNT/afsadmsvr/TaAfsAdmSvrClient.cpp

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <winsock2.h>
  11 #include <ws2tcpip.h>
  12
  13 extern "C" {
  14 #include <afs/param.h>
  15 #include <afs/stds.h>
  16 }
  17
  18 #include "TaAfsAdmSvrClientInternal.h"
  19
  20
  21 /*
  22  * VARIABLES __________________________________________________________________
  23  *
  24  */
  25
  26 static struct
  27    {
  28    BOOL fInitializedSockets;
  29    size_t cReqForAdminServer;
  30    } l;
  31
  32
  33 /*
  34  * ROUTINES ___________________________________________________________________
  35  *
  36  */
  37
  38 extern "C" void __RPC_FAR * __RPC_USER MIDL_user_allocate (size_t cbAllocate)
  39 {
  40    return (void __RPC_FAR *)Allocate (cbAllocate);
  41 }
  42
  43 extern "C" void __RPC_USER MIDL_user_free (void __RPC_FAR *pData)
  44 {
  45    Free (pData);
  46 }
  47
  48
  49 /*
  50  * DATA STRUCTURES ____________________________________________________________
  51  *
  52  */
  53
  54 BOOL ADMINAPI asc_AsidListCreate (LPASIDLIST *ppList)
  55 {
  56    return ((*ppList = AfsAdmSvr_CreateAsidList()) != NULL);
  57 }
  58
  59 BOOL ADMINAPI asc_AsidListCopy (LPASIDLIST *ppListTarget, LPASIDLIST *ppListSource)
  60 {
  61    return ((*ppListTarget = AfsAdmSvr_CopyAsidList (*ppListSource)) != NULL);
  62 }
  63
  64 BOOL ADMINAPI asc_AsidListAddEntry (LPASIDLIST *ppList, ASID idObject, LPARAM lp)
  65 {
  66    return AfsAdmSvr_AddToAsidList (ppList, idObject, lp);
  67 }
  68
  69 BOOL ADMINAPI asc_AsidListRemoveEntry (LPASIDLIST *ppList, ASID idObject)
  70 {
  71    return AfsAdmSvr_RemoveFromAsidList (ppList, idObject);
  72 }
  73
  74 BOOL ADMINAPI asc_AsidListRemoveEntryByIndex (LPASIDLIST *ppList, size_t iIndex)
  75 {
  76    return AfsAdmSvr_RemoveFromAsidListByIndex (ppList, iIndex);
  77 }
  78
  79 BOOL ADMINAPI asc_AsidListSetEntryParam (LPASIDLIST *ppList, ASID idObject, LPARAM lp)
  80 {
  81    return AfsAdmSvr_SetAsidListParam (ppList, idObject, lp);
  82 }
  83
  84 BOOL ADMINAPI asc_AsidListSetEntryParamByIndex (LPASIDLIST *ppList, size_t iIndex, LPARAM lp)
  85 {
  86    return AfsAdmSvr_SetAsidListParamByIndex (ppList, iIndex, lp);
  87 }
  88
  89 BOOL ADMINAPI asc_AsidListTest (LPASIDLIST *ppList, ASID idObject, LPARAM *pParam)
  90 {
  91    return AfsAdmSvr_IsInAsidList (ppList, idObject, pParam);
  92 }
  93
  94 BOOL ADMINAPI asc_AsidListFree (LPASIDLIST *ppList)
  95 {
  96    AfsAdmSvr_FreeAsidList (ppList);
  97    return TRUE;
  98 }
  99
 100
 101 BOOL ADMINAPI asc_ObjPropListCreate (LPASOBJPROPLIST *ppList)
 102 {
 103    return ((*ppList = AfsAdmSvr_CreateObjPropList()) != NULL);
 104 }
 105
 106 BOOL ADMINAPI asc_ObjPropListCopy (LPASOBJPROPLIST *ppListTarget, LPASOBJPROPLIST *ppListSource)
 107 {
 108    return ((*ppListTarget = AfsAdmSvr_CopyObjPropList (*ppListSource)) != NULL);
 109 }
 110
 111 BOOL ADMINAPI asc_ObjPropListAddEntry (LPASOBJPROPLIST *ppList, LPASOBJPROP pProperties, LPARAM lp)
 112 {
 113    return AfsAdmSvr_AddToObjPropList (ppList, pProperties, lp);
 114 }
 115
 116 BOOL ADMINAPI asc_ObjPropListRemoveEntry (LPASOBJPROPLIST *ppList, ASID idObject)
 117 {
 118    return AfsAdmSvr_RemoveFromObjPropList (ppList, idObject);
 119 }
 120
 121 BOOL ADMINAPI asc_ObjPropListTest (LPASOBJPROPLIST *ppList, ASID idObject, LPASOBJPROP pProperties, LPARAM *pParam)
 122 {
 123    return AfsAdmSvr_IsInObjPropList (ppList, idObject, pProperties, pParam);
 124 }
 125
 126 BOOL ADMINAPI asc_ObjPropListFree (LPASOBJPROPLIST *ppList)
 127 {
 128    AfsAdmSvr_FreeObjPropList (ppList);
 129    return TRUE;
 130 }
 131
 132
 133 BOOL ADMINAPI asc_ActionListCreate (LPASACTIONLIST *ppList)
 134 {
 135    return ((*ppList = AfsAdmSvr_CreateActionList()) != NULL);
 136 }
 137
 138 BOOL ADMINAPI asc_ActionListCopy (LPASACTIONLIST *ppListTarget, LPASACTIONLIST *ppListSource)
 139 {
 140    return ((*ppListTarget = AfsAdmSvr_CopyActionList (*ppListSource)) != NULL);
 141 }
 142
 143 BOOL ADMINAPI asc_ActionListAddEntry (LPASACTIONLIST *ppList, LPASACTION pAction)
 144 {
 145    return AfsAdmSvr_AddToActionList (ppList, pAction);
 146 }
 147
 148 BOOL ADMINAPI asc_ActionListRemoveEntry (LPASACTIONLIST *ppList, DWORD idAction)
 149 {
 150    return AfsAdmSvr_RemoveFromActionList (ppList, idAction);
 151 }
 152
 153 BOOL ADMINAPI asc_ActionListTest (LPASACTIONLIST *ppList, DWORD idAction, LPASACTION pAction)
 154 {
 155    return AfsAdmSvr_IsInActionList (ppList, idAction, pAction);
 156 }
 157
 158 BOOL ADMINAPI asc_ActionListFree (LPASACTIONLIST *ppList)
 159 {
 160    AfsAdmSvr_FreeActionList (ppList);
 161    return TRUE;
 162 }
 163
 164
 165 /*
 166  * ROUTINES ___________________________________________________________________
 167  *
 168  */
 169
 170 BOOL ADMINAPI asc_AdminServerOpen (LPCTSTR pszAddress, UINT_PTR *pidClient, ULONG *pStatus)
 171 {
 172    BOOL rc = TRUE;
 173    ULONG status = 0;
 174
 175    if (!l.fInitializedSockets)
 176       {
 177       WSADATA Data;
 178       WSAStartup (0x0101, &Data);
 179       l.fInitializedSockets = TRUE;
 180       }
 181
 182    if ((++l.cReqForAdminServer) == 1)
 183       {
 184       LPCTSTR pszResolvedAddress = ResolveAddress (pszAddress);
 185       if (!BindToAdminServer (pszResolvedAddress, FALSE, pidClient, &status))
 186          {
 187          if (status != RPC_S_CALL_FAILED_DNE) // server rejected us?
 188             rc = FALSE;
 189          else if (pszResolvedAddress || !ForkNewAdminServer (&status))
 190             rc = FALSE;
 191          else
 192             rc = BindToAdminServer (pszResolvedAddress, TRUE, pidClient, &status);
 193          }
 194       }
 195
 196    if (rc)
 197       StartPingThread (*pidClient);
 198    if (rc)
 199       StartCallbackThread();
 200    if (!rc && pStatus)
 201       *pStatus = status;
 202    return rc;
 203 }
 204
 205
 206 BOOL ADMINAPI asc_AdminServerClose (UINT_PTR idClient, ULONG *pStatus)
 207 {
 208    BOOL rc = TRUE;
 209    ULONG status = 0;
 210
 211    StopCallbackThread();
 212    StopPingThread (idClient);
 213
 214    if (l.cReqForAdminServer && ((--l.cReqForAdminServer) == 0))
 215       {
 216       UnbindFromAdminServer (idClient, &status);
 217       }
 218
 219    if (!rc && pStatus)
 220       *pStatus = status;
 221    return rc;
 222 }
 223
 224
 225
 226 BOOL ADMINAPI asc_CredentialsCrack (UINT_PTR idClient, PVOID hCreds, LPTSTR pszCell, LPTSTR pszUser, SYSTEMTIME *pstExpiration, ULONG *pStatus)
 227 {
 228    BOOL rc = FALSE;
 229    ULONG status = 0;
 230
 231    RpcTryExcept
 232       {
 233       STRING szCell = TEXT("");
 234       STRING szUser = TEXT("");
 235
 236       if ((rc = AfsAdmSvr_CrackCredentials (idClient, (UINT_PTR)hCreds, szCell, szUser, pstExpiration, &status)) != FALSE)
 237          {
 238          lstrcpy (pszCell, szCell);
 239          lstrcpy (pszUser, szUser);
 240          }
 241       }
 242    RpcExcept(1)
 243       {
 244       rc = FALSE;
 245       status = RPC_S_CALL_FAILED_DNE;
 246       }
 247    RpcEndExcept
 248
 249    if (!rc && pStatus)
 250       *pStatus = status;
 251    return rc;
 252 }
 253
 254
 255 UINT_PTR ADMINAPI asc_CredentialsGet (UINT_PTR idClient, LPCTSTR pszCell, ULONG *pStatus)
 256 {
 257    UINT_PTR rc = 0;
 258    ULONG status = 0;
 259
 260    RpcTryExcept
 261       {
 262       if (pszCell)
 263          {
 264          STRING szCell;
 265          lstrcpy (szCell, pszCell);
 266
 267          rc = AfsAdmSvr_GetCredentials (idClient, szCell, &status);
 268          }
 269       }
 270    RpcExcept(1)
 271       {
 272       rc = FALSE;
 273       status = RPC_S_CALL_FAILED_DNE;
 274       }
 275    RpcEndExcept
 276
 277    if (!rc && pStatus)
 278       *pStatus = status;
 279    return rc;
 280 }
 281
 282
 283 UINT_PTR ADMINAPI asc_CredentialsSet (UINT_PTR idClient, LPCTSTR pszCell, LPCTSTR pszUser, LPCTSTR pszPassword, ULONG *pStatus)
 284 {
 285    UINT_PTR rc = 0;
 286    ULONG status = 0;
 287
 288    RpcTryExcept
 289       {
 290       STRING szCell;
 291       lstrcpy (szCell, pszCell);
 292
 293       STRING szUser;
 294       lstrcpy (szUser, pszUser);
 295
 296       STRING szPassword;
 297       lstrcpy (szPassword, pszPassword);
 298
 299       // TODO: Ensure we do some encryption here, or using an
 300       // encrypted socket, or something... can't just be pushing
 301       // the user's unencrypted password across the wire.
 302
 303       rc = AfsAdmSvr_SetCredentials (idClient, szCell, szUser, szPassword, &status);
 304       }
 305    RpcExcept(1)
 306       {
 307       rc = FALSE;
 308       status = RPC_S_CALL_FAILED_DNE;
 309       }
 310    RpcEndExcept
 311
 312    if (!rc && pStatus)
 313       *pStatus = status;
 314    return rc;
 315 }
 316
 317
 318 BOOL ADMINAPI asc_CredentialsPush (UINT_PTR idClient, PVOID hCreds, ASID idCell, ULONG *pStatus)
 319 {
 320    BOOL rc = TRUE;
 321    ULONG status = 0;
 322
 323    RpcTryExcept
 324       {
 325       rc = (AfsAdmSvr_PushCredentials (idClient, PtrToUlong(hCreds), idCell, &status)?TRUE:FALSE);
 326       }
 327    RpcExcept(1)
 328       {
 329       rc = FALSE;
 330       status = RPC_S_CALL_FAILED_DNE;
 331       }
 332    RpcEndExcept
 333
 334    if (!rc && pStatus)
 335       *pStatus = status;
 336    return rc;
 337 }
 338
 339
 340 BOOL ADMINAPI asc_LocalCellGet (UINT_PTR idClient, LPTSTR pszCell, ULONG *pStatus)
 341 {
 342    BOOL rc = TRUE;
 343    ULONG status = 0;
 344
 345    RpcTryExcept
 346       {
 347       STRING szCell;
 348       if ((rc = AfsAdmSvr_GetLocalCell (idClient, szCell, &status)) != FALSE)
 349          {
 350          lstrcpy (pszCell, szCell);
 351          }
 352       }
 353    RpcExcept(1)
 354       {
 355       rc = FALSE;
 356       status = RPC_S_CALL_FAILED_DNE;
 357       }
 358    RpcEndExcept
 359
 360    if (!rc && pStatus)
 361       *pStatus = status;
 362    return rc;
 363 }
 364
 365
 366 BOOL ADMINAPI asc_ErrorCodeTranslate (UINT_PTR idClient, ULONG code, LANGID idLanguage, STRING pszErrorText, ULONG *pStatus)
 367 {
 368    BOOL rc = TRUE;
 369    ULONG status = 0;
 370
 371    RpcTryExcept
 372       {
 373       STRING szText;
 374       if ((rc = AfsAdmSvr_ErrorCodeTranslate (idClient, code, idLanguage, szText, &status)) != FALSE)
 375          {
 376          lstrcpy (pszErrorText, szText);
 377          }
 378       }
 379    RpcExcept(1)
 380       {
 381       rc = FALSE;
 382       status = RPC_S_CALL_FAILED_DNE;
 383       }
 384    RpcEndExcept
 385
 386    if (!rc && pStatus)
 387       *pStatus = status;
 388    return rc;
 389 }
 390
 391
 392 BOOL ADMINAPI asc_CellOpen (UINT_PTR idClient, PVOID hCreds, LPCTSTR pszCell, DWORD dwScope, ASID *pidCell, ULONG *pStatus)
 393 {
 394    BOOL rc = TRUE;
 395    ULONG status = 0;
 396
 397    RpcTryExcept
 398       {
 399       STRING szCell;
 400       lstrcpy (szCell, pszCell);
 401
 402       if ((rc = (AfsAdmSvr_OpenCell (idClient, PtrToUlong(hCreds), szCell, dwScope, pidCell, &status)?TRUE:FALSE)) != FALSE)
 403          {
 404          if (!CreateCellCache (*pidCell))
 405             {
 406             (void)AfsAdmSvr_CloseCell (idClient, *pidCell, &status);
 407             rc = FALSE;
 408             status = ERROR_NOT_ENOUGH_MEMORY;
 409             }
 410          else // get rudimentary properties about the cell
 411             {
 412             rc = RefreshCachedProperties (idClient, *pidCell, *pidCell, GET_RUDIMENTARY_DATA, &status);
 413             }
 414          }
 415       }
 416    RpcExcept(1)
 417       {
 418       rc = FALSE;
 419       status = RPC_S_CALL_FAILED_DNE;
 420       }
 421    RpcEndExcept
 422
 423    if (!rc && pStatus)
 424       *pStatus = status;
 425    return rc;
 426 }
 427
 428
 429 BOOL ADMINAPI asc_CellClose (UINT_PTR idClient, ASID idCell, ULONG *pStatus)
 430 {
 431    BOOL rc = TRUE;
 432    ULONG status = 0;
 433
 434    RpcTryExcept
 435       {
 436       rc = AfsAdmSvr_CloseCell (idClient, idCell, &status);
 437       DestroyCellCache (idCell);
 438       }
 439    RpcExcept(1)
 440       {
 441       rc = FALSE;
 442       status = RPC_S_CALL_FAILED_DNE;
 443       }
 444    RpcEndExcept
 445
 446    if (!rc && pStatus)
 447       *pStatus = status;
 448    return rc;
 449 }
 450
 451
 452 BOOL ADMINAPI asc_ObjectFind (UINT_PTR idClient, ASID idSearchScope, ASOBJTYPE ObjectType, LPCTSTR pszName, ASID *pidObject, ULONG *pStatus)
 453 {
 454    BOOL rc = TRUE;
 455    ULONG status = 0;
 456
 457    RpcTryExcept
 458       {
 459       STRING szName = TEXT("");
 460       if (pszName)
 461          lstrcpy (szName, pszName);
 462       rc = AfsAdmSvr_FindObject (idClient, idSearchScope, ObjectType, SEARCH_ALL_OBJECTS, szName, pidObject, &status);
 463       }
 464    RpcExcept(1)
 465       {
 466       rc = FALSE;
 467       status = RPC_S_CALL_FAILED_DNE;
 468       }
 469    RpcEndExcept
 470
 471    if (!rc && pStatus)
 472       *pStatus = status;
 473    return rc;
 474 }
 475
 476
 477 BOOL ADMINAPI asc_ObjectFindMultiple (UINT_PTR idClient, ASID idSearchScope, ASOBJTYPE ObjectType, LPCTSTR pszPattern, LPAFSADMSVR_SEARCH_PARAMS pSearchParams, LPASIDLIST *ppList, ULONG *pStatus)
 478 {
 479    BOOL rc = TRUE;
 480    ULONG status = 0;
 481
 482    RpcTryExcept
 483       {
 484       *ppList = NULL;
 485
 486       STRING szPattern = TEXT("");
 487       if (pszPattern)
 488          lstrcpy (szPattern, pszPattern);
 489
 490       AFSADMSVR_SEARCH_PARAMS SearchParams;
 491       if (pSearchParams)
 492          memcpy (&SearchParams, pSearchParams, sizeof(AFSADMSVR_SEARCH_PARAMS));
 493       else
 494          {
 495          memset (&SearchParams, 0x00, sizeof(AFSADMSVR_SEARCH_PARAMS));
 496          SearchParams.SearchType = SEARCH_NO_LIMITATIONS;
 497          }
 498
 499       rc = AfsAdmSvr_FindObjects (idClient, idSearchScope, ObjectType, SEARCH_ALL_OBJECTS, szPattern, &SearchParams, ppList, &status);
 500       }
 501    RpcExcept(1)
 502       {
 503       rc = FALSE;
 504       status = RPC_S_CALL_FAILED_DNE;
 505       }
 506    RpcEndExcept
 507
 508    if (!rc && pStatus)
 509       *pStatus = status;
 510    return rc;
 511 }
 512
 513
 514 BOOL ADMINAPI asc_ObjectPropertiesGet (UINT_PTR idClient, AFSADMSVR_GET_LEVEL GetLevel, ASID idCell, ASID idObject, LPASOBJPROP pProperties, ULONG *pStatus)
 515 {
 516    BOOL rc = TRUE;
 517    ULONG status = 0;
 518
 519    if (!RefreshCachedProperties (idClient, idCell, idObject, GetLevel, &status))
 520       {
 521       rc = FALSE;
 522       }
 523    else
 524       {
 525       LPASOBJPROP pFound;
 526       if ((pFound = GetCachedProperties (idCell, idObject)) == NULL)
 527          {
 528          status = ERROR_NOT_ENOUGH_MEMORY;
 529          rc = FALSE;
 530          }
 531       else
 532          {
 533          memcpy (pProperties, pFound, sizeof(ASOBJPROP));
 534          }
 535       }
 536
 537    if (!rc && pStatus)
 538       *pStatus = status;
 539    return rc;
 540 }
 541
 542
 543 BOOL ADMINAPI asc_ObjectPropertiesGetMultiple (UINT_PTR idClient, AFSADMSVR_GET_LEVEL GetLevel, ASID idCell, LPASIDLIST pAsidList, LPASOBJPROPLIST *ppPropertiesList, ULONG *pStatus)
 544 {
 545    BOOL rc = TRUE;
 546    ULONG status = 0;
 547
 548    if (!RefreshCachedProperties (idClient, idCell, pAsidList, GetLevel, &status))
 549       {
 550       rc = FALSE;
 551       }
 552    else
 553       {
 554       *ppPropertiesList = NULL;
 555       for (size_t iAsidList = 0; iAsidList < pAsidList->cEntries; ++iAsidList)
 556          {
 557          LPASOBJPROP pFound;
 558          if ((pFound = GetCachedProperties (idCell, pAsidList->aEntries[ iAsidList ].idObject)) != NULL)
 559             {
 560             if (!*ppPropertiesList)
 561                asc_ObjPropListCreate(ppPropertiesList);
 562             if (*ppPropertiesList)
 563                AfsAdmSvr_AddToObjPropList (ppPropertiesList, pFound, pAsidList->aEntries[ iAsidList ].lParam);
 564             }
 565          }
 566       }
 567
 568    if (!rc && *ppPropertiesList)
 569       AfsAdmSvr_FreeObjPropList (ppPropertiesList);
 570    if (!rc && pStatus)
 571       *pStatus = status;
 572    return rc;
 573 }
 574
 575
 576 BOOL ADMINAPI asc_ObjectListen (UINT_PTR idClient, ASID idCell, ASID idObject, HWND hNotify, ULONG *pStatus)
 577 {
 578    if (!idObject)
 579       {
 580       if (*pStatus)
 581          *pStatus = ERROR_INVALID_PARAMETER;
 582       return FALSE;
 583       }
 584
 585    if (!AddObjectNotification (hNotify, idCell, idObject))
 586       {
 587       if (*pStatus)
 588          *pStatus = ERROR_NOT_ENOUGH_MEMORY;
 589       return FALSE;
 590       }
 591
 592    TestForNotifications (idClient, idCell, idObject);
 593    return TRUE;
 594 }
 595
 596
 597 BOOL ADMINAPI asc_ObjectListenClear (UINT_PTR idClient, HWND hNotify, ULONG *pStatus)
 598 {
 599    ClearObjectNotifications (hNotify);
 600    return TRUE;
 601 }
 602
 603
 604 BOOL ADMINAPI asc_ObjectListenMultiple (UINT_PTR idClient, ASID idCell, LPASIDLIST pAsidList, HWND hNotify, ULONG *pStatus)
 605 {
 606    if (!pAsidList)
 607       {
 608       if (*pStatus)
 609          *pStatus = ERROR_INVALID_PARAMETER;
 610       return FALSE;
 611       }
 612
 613    for (size_t ii = 0; ii < pAsidList->cEntriesAllocated; ++ii)
 614       {
 615       if (!pAsidList->aEntries[ ii ].idObject)
 616          continue;
 617
 618       if (!AddObjectNotification (hNotify, idCell, pAsidList->aEntries[ ii ].idObject))
 619          {
 620          if (*pStatus)
 621             *pStatus = ERROR_NOT_ENOUGH_MEMORY;
 622          return FALSE;
 623          }
 624
 625       TestForNotifications (idClient, idCell, pAsidList->aEntries[ ii ].idObject);
 626       }
 627
 628    return TRUE;
 629 }
 630
 631
 632 BOOL ADMINAPI asc_ObjectRefresh (UINT_PTR idClient, ASID idCell, ASID idObject, ULONG *pStatus)
 633 {
 634    BOOL rc = TRUE;
 635    ULONG status = 0;
 636
 637    // First have the server invalidate its cache of information; regardless
 638    // of the name, this is actually just an Invalidate call, not a Refresh call
 639    //
 640    RpcTryExcept
 641       {
 642       rc = AfsAdmSvr_RefreshObject (idClient, idObject, &status);
 643       }
 644    RpcExcept(1)
 645       {
 646       rc = FALSE;
 647       status = RPC_S_CALL_FAILED_DNE;
 648       }
 649    RpcEndExcept
 650
 651    // If that suceeded, see if there is anyone listening for changes
 652    // in this object or any of its children. If so, this call
 653    // will requery the server for the latest properties for all
 654    // listened-for objects, which will make us post notifications if
 655    // we get new data back.
 656    //
 657    if (rc)
 658       {
 659       TestForNotifications (idClient, idCell);
 660       }
 661
 662    if (!rc && pStatus)
 663       *pStatus = status;
 664    return rc;
 665 }
 666
 667
 668 BOOL ADMINAPI asc_ObjectRefreshMultiple (UINT_PTR idClient, ASID idCell, LPASIDLIST pAsidList, ULONG *pStatus)
 669 {
 670    BOOL rc = TRUE;
 671    ULONG status = 0;
 672
 673    // First have the server invalidate its cache of information; regardless
 674    // of the name, this is actually just an Invalidate call, not a Refresh call
 675    //
 676    RpcTryExcept
 677       {
 678       rc = AfsAdmSvr_RefreshObjects (idClient, pAsidList, &status);
 679       }
 680    RpcExcept(1)
 681       {
 682       rc = FALSE;
 683       status = RPC_S_CALL_FAILED_DNE;
 684       }
 685    RpcEndExcept
 686
 687    // If that suceeded, see if there is anyone listening for changes
 688    // in any of these objects or their children. If so, this call
 689    // will requery the server for the latest properties for all
 690    // listened-for objects, which will make us post notifications if
 691    // we get new data back.
 692    //
 693    if (rc)
 694       {
 695       TestForNotifications (idClient, idCell);
 696       }
 697
 698    if (!rc && pStatus)
 699       *pStatus = status;
 700    return rc;
 701 }
 702
 703
 704 BOOL ADMINAPI asc_RandomKeyGet (UINT_PTR idClient, ASID idCell, PBYTE key, ULONG *pStatus)
 705 {
 706    BOOL rc = TRUE;
 707    ULONG status = 0;
 708
 709    RpcTryExcept
 710       {
 711       memset (key, 0x00, sizeof(BYTE) * ENCRYPTIONKEYLENGTH);
 712       rc = AfsAdmSvr_GetRandomKey (idClient, idCell, key, &status);
 713       }
 714    RpcExcept(1)
 715       {
 716       rc = FALSE;
 717       status = RPC_S_CALL_FAILED_DNE;
 718       }
 719    RpcEndExcept
 720
 721    if (!rc && pStatus)
 722       *pStatus = status;
 723    return rc;
 724 }
 725
 726
 727 BOOL ADMINAPI asc_CellNameGet_Fast (UINT_PTR idClient, ASID idCell, LPTSTR pszCell, ULONG *pStatus)
 728 {
 729    return asc_ObjectNameGet_Fast (idClient, idCell, idCell, pszCell, pStatus);
 730 }
 731
 732
 733 BOOL ADMINAPI asc_ObjectNameGet_Fast (UINT_PTR idClient, ASID idCell, ASID idObject, LPTSTR pszObject, ULONG *pStatus)
 734 {
 735    BOOL rc = TRUE;
 736    ULONG status = 0;
 737
 738    LPASOBJPROP pProperties;
 739    if ((pProperties = GetCachedProperties (idCell, idObject)) == NULL)
 740       {
 741       rc = FALSE;
 742       status = ERROR_NO_DATA;
 743       }
 744    else if (pProperties->verProperties == verPROP_NO_OBJECT)
 745       {
 746       rc = FALSE;
 747       status = ERROR_NO_DATA;
 748       }
 749    else
 750       {
 751       lstrcpy (pszObject, pProperties->szName);
 752       }
 753
 754    if (!rc && pStatus)
 755       *pStatus = status;
 756    return rc;
 757 }
 758
 759
 760 BOOL ADMINAPI asc_ObjectTypeGet_Fast (UINT_PTR idClient, ASID idCell, ASID idObject, ASOBJTYPE *pObjectType, ULONG *pStatus)
 761 {
 762    BOOL rc = TRUE;
 763    ULONG status = 0;
 764
 765    LPASOBJPROP pProperties;
 766    if ((pProperties = GetCachedProperties (idCell, idObject)) == NULL)
 767       {
 768       rc = FALSE;
 769       status = ERROR_NO_DATA;
 770       }
 771    else if (pProperties->verProperties == verPROP_NO_OBJECT)
 772       {
 773       rc = FALSE;
 774       status = ERROR_NO_DATA;
 775       }
 776    else
 777       {
 778       *pObjectType = pProperties->Type;
 779       }
 780
 781    if (!rc && pStatus)
 782       *pStatus = status;
 783    return rc;
 784 }
 785
 786
 787 BOOL ADMINAPI asc_ObjectPropertiesGet_Fast (UINT_PTR idClient, ASID idCell, ASID idObject, LPASOBJPROP pProperties, ULONG *pStatus)
 788 {
 789    BOOL rc = TRUE;
 790    ULONG status = 0;
 791
 792    LPASOBJPROP pPropFound;
 793    if ((pPropFound = GetCachedProperties (idCell, idObject)) == NULL)
 794       {
 795       rc = FALSE;
 796       status = ERROR_NO_DATA;
 797       }
 798    else if (pPropFound->verProperties == verPROP_NO_OBJECT)
 799       {
 800       rc = FALSE;
 801       status = ERROR_NO_DATA;
 802       }
 803    else if (pProperties)
 804       {
 805       memcpy (pProperties, pPropFound, sizeof(ASOBJPROP));
 806       }
 807
 808    if (!rc && pStatus)
 809       *pStatus = status;
 810    return rc;
 811 }
 812
 813
 814 BOOL ADMINAPI asc_ActionGet (UINT_PTR idClient, DWORD idAction, LPASACTION pAction, ULONG *pStatus)
 815 {
 816    BOOL rc = TRUE;
 817    ULONG status = 0;
 818
 819    RpcTryExcept
 820       {
 821       memset (pAction, 0x00, sizeof(ASACTION));
 822       rc = AfsAdmSvr_GetAction (idClient, idAction, pAction, &status);
 823       }
 824    RpcExcept(1)
 825       {
 826       rc = FALSE;
 827       status = RPC_S_CALL_FAILED_DNE;
 828       }
 829    RpcEndExcept
 830
 831    if (!rc && pStatus)
 832       *pStatus = status;
 833    return rc;
 834 }
 835
 836
 837 BOOL ADMINAPI asc_ActionGetMultiple (UINT_PTR idClient, UINT_PTR idClientSearch, ASID idCellSearch, LPASACTIONLIST *ppList, ULONG *pStatus)
 838 {
 839    BOOL rc = TRUE;
 840    ULONG status = 0;
 841
 842    RpcTryExcept
 843       {
 844       *ppList = NULL;
 845       rc = AfsAdmSvr_GetActions (idClient, idClientSearch, idCellSearch, ppList, &status);
 846       }
 847    RpcExcept(1)
 848       {
 849       rc = FALSE;
 850       status = RPC_S_CALL_FAILED_DNE;
 851       }
 852    RpcEndExcept
 853
 854    if (!rc && pStatus)
 855       *pStatus = status;
 856    return rc;
 857 }
 858
 859
 860 BOOL ADMINAPI asc_ActionListen (UINT_PTR idClient, HWND hNotify, ULONG *pStatus)
 861 {
 862    if (!SetActionNotification (hNotify, TRUE))
 863       {
 864       if (*pStatus)
 865          *pStatus = ERROR_NOT_ENOUGH_MEMORY;
 866       return FALSE;
 867       }
 868    return TRUE;
 869 }
 870
 871
 872 BOOL ADMINAPI asc_ActionListenClear (UINT_PTR idClient, HWND hNotify, ULONG *pStatus)
 873 {
 874    if (!SetActionNotification (hNotify, FALSE))
 875       {
 876       if (*pStatus)
 877          *pStatus = ERROR_NOT_ENOUGH_MEMORY;
 878       return FALSE;
 879       }
 880    return TRUE;
 881 }
 882
 883
 884       // AfsAdmSvrCallback_Action
 885       // ...called by the server in the context of the CallbackHost() routine;
 886       //    this routine is used to notify the client whenever an action is
 887       //    initiated or completed.
 888       //
 889 extern "C" void AfsAdmSvrCallback_Action (LPASACTION pAction, BOOL fFinished)
 890 {
 891    NotifyActionListeners (pAction, fFinished);
 892 }
 893