src/WINNT/afsrdr/user/RDRInit.cpp

   1 /*
   2  * Copyright (c) 2008 Secure Endpoints, Inc.
   3  * Copyright (c) 2009-2011 Your File System, Inc.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright notice,
  10  *   this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright notice,
  12  *   this list of conditions and the following disclaimer in the documentation
  13  *   and/or other materials provided with the distribution.
  14  * - Neither the name of Secure Endpoints Inc. nor the names of its contributors
  15  *   may be used to endorse or promote products derived from this software without
  16  *   specific prior written permission from Secure Endpoints, Inc. and
  17  *   Your File System, Inc.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  22  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
  23  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  24  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  26  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  27  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  28  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #ifndef _WIN32_WINNT
  33 #define _WIN32_WINNT 0x0500
  34 #endif
  35 #define _CRT_SECURE_NO_DEPRECATE
  36 #define _CRT_NON_CONFORMING_SWPRINTFS
  37 #define UNICODE 1
  38 #define STRSAFE_NO_DEPRECATE
  39
  40 #include <ntstatus.h>
  41 #define WIN32_NO_STATUS
  42 #include <windows.h>
  43 typedef LONG NTSTATUS, *PNTSTATUS;      // not declared in ntstatus.h
  44
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <stdarg.h>
  48 #include <errno.h>
  49
  50 #include <devioctl.h>
  51
  52 #include <tchar.h>
  53 #include <winbase.h>
  54 #include <winreg.h>
  55 #include <strsafe.h>
  56
  57 #include "..\\Common\\AFSUserDefines.h"
  58 #include "..\\Common\\AFSUserIoctl.h"
  59 #include "..\\Common\\AFSUserStructs.h"
  60
  61 extern "C" {
  62 #include <osilog.h>
  63 extern osi_log_t *afsd_logp;
  64
  65 #include <WINNT/afsreg.h>
  66 #include <afs/cm_config.h>
  67 #include <afs/cm_error.h>
  68 }
  69 #include <RDRPrototypes.h>
  70
  71 #ifndef FlagOn
  72 #define FlagOn(_F,_SF)        ((_F) & (_SF))
  73 #endif
  74
  75 #ifndef BooleanFlagOn
  76 #define BooleanFlagOn(F,SF)   ((BOOLEAN)(((F) & (SF)) != 0))
  77 #endif
  78
  79 #ifndef SetFlag
  80 #define SetFlag(_F,_SF)       ((_F) |= (_SF))
  81 #endif
  82
  83 #ifndef ClearFlag
  84 #define ClearFlag(_F,_SF)     ((_F) &= ~(_SF))
  85 #endif
  86
  87 #define QuadAlign(Ptr) (                \
  88     ((((ULONG)(Ptr)) + 7) & 0xfffffff8) \
  89     )
  90
  91 #define MIN_WORKER_THREADS 5
  92 #define MAX_WORKER_THREADS 512
  93
  94 typedef struct _worker_thread_info {
  95
  96     HANDLE hThread;
  97
  98     ULONG  Flags;
  99
 100     HANDLE hEvent;
 101
 102 } WorkerThreadInfo;
 103
 104 WorkerThreadInfo glWorkerThreadInfo[ MAX_WORKER_THREADS];
 105
 106 UINT   glThreadHandleIndex = 0;
 107
 108 HANDLE glDevHandle = INVALID_HANDLE_VALUE;
 109
 110 static DWORD Exit = false;
 111
 112 static DWORD ExitPending = false;
 113
 114 DWORD  dwOvEvIdx = 0;
 115
 116 extern "C" wchar_t RDR_UNCName[64]=L"AFS";
 117
 118 /* returns 0 on success */
 119 extern "C" DWORD
 120 RDR_Initialize(void)
 121 {
 122
 123     DWORD dwRet = 0;
 124     HKEY parmKey;
 125     DWORD dummyLen;
 126     DWORD numSvThreads = CM_CONFIGDEFAULT_SVTHREADS;
 127
 128     dwRet = RegOpenKeyEx(HKEY_LOCAL_MACHINE, AFSREG_CLT_SVC_PARAM_SUBKEY,
 129                          0, KEY_QUERY_VALUE, &parmKey);
 130     if (dwRet == ERROR_SUCCESS) {
 131         dummyLen = sizeof(numSvThreads);
 132         dwRet = RegQueryValueEx(parmKey, TEXT("ServerThreads"), NULL, NULL,
 133                                 (BYTE *) &numSvThreads, &dummyLen);
 134
 135         dummyLen = sizeof(RDR_UNCName);
 136         dwRet = RegQueryValueExW(parmKey, L"NetbiosName", NULL, NULL,
 137                                  (BYTE *) RDR_UNCName, &dummyLen);
 138
 139         RegCloseKey (parmKey);
 140     }
 141
 142     // Initialize the Thread local storage index for the overlapped i/o
 143     // Event Handle
 144     dwOvEvIdx = TlsAlloc();
 145
 146     Exit = false;
 147
 148     //
 149     // Launch our workers down to the
 150     // filters control device for processing requests
 151     //
 152
 153     dwRet = RDR_ProcessWorkerThreads(numSvThreads);
 154
 155     if (dwRet == ERROR_SUCCESS) {
 156
 157         RDR_InitIoctl();
 158     }
 159
 160     return dwRet;
 161 }
 162
 163 BOOL RDR_DeviceIoControl( HANDLE hDevice,
 164                           DWORD dwIoControlCode,
 165                           LPVOID lpInBuffer,
 166                           DWORD nInBufferSize,
 167                           LPVOID lpOutBuffer,
 168                           DWORD nOutBufferSize,
 169                           LPDWORD lpBytesReturned )
 170 {
 171     OVERLAPPED ov;
 172     HANDLE hEvent;
 173     BOOL rc = FALSE;
 174     DWORD gle;
 175
 176     ZeroMemory(&ov, sizeof(OVERLAPPED));
 177
 178     hEvent = (HANDLE)TlsGetValue(dwOvEvIdx);
 179     if (hEvent == NULL) {
 180         hEvent = CreateEvent( NULL, TRUE, TRUE, NULL );
 181         if (hEvent == INVALID_HANDLE_VALUE || hEvent == NULL)
 182             return FALSE;
 183         TlsSetValue( dwOvEvIdx, (LPVOID) hEvent );
 184     }
 185
 186     ResetEvent( hEvent);
 187     ov.hEvent = hEvent;
 188     *lpBytesReturned = 0;
 189
 190     rc = DeviceIoControl( hDevice,
 191                           dwIoControlCode,
 192                           lpInBuffer,
 193                           nInBufferSize,
 194                           lpOutBuffer,
 195                           nOutBufferSize,
 196                           lpBytesReturned,
 197                           &ov );
 198     if ( !rc ) {
 199         gle = GetLastError();
 200
 201         if ( gle == ERROR_IO_PENDING )
 202             rc = GetOverlappedResult( hDevice, &ov, lpBytesReturned, TRUE );
 203     }
 204
 205     return rc;
 206 }
 207
 208 extern "C" DWORD
 209 RDR_ShutdownFinal(void)
 210 {
 211
 212     DWORD dwIndex = 0;
 213
 214     Exit = true;
 215
 216     //
 217     // Close all the worker thread handles
 218     //
 219
 220     while( dwIndex < glThreadHandleIndex)
 221     {
 222
 223         CloseHandle( glWorkerThreadInfo[ dwIndex].hThread);
 224
 225         dwIndex++;
 226     }
 227
 228     if( glDevHandle != INVALID_HANDLE_VALUE)
 229     {
 230
 231         CloseHandle( glDevHandle);
 232     }
 233
 234     return 0;
 235 }
 236
 237 extern "C" DWORD
 238 RDR_ShutdownNotify(void)
 239 {
 240
 241     HANDLE hDevHandle = NULL;
 242     DWORD bytesReturned;
 243
 244     //
 245     // We use the global handle to the control device instance
 246     //
 247
 248     hDevHandle = glDevHandle;
 249
 250
 251     //
 252     // First, notify the file system driver that
 253     // we are shutting down.
 254     //
 255
 256     ExitPending = true;
 257
 258     if( !RDR_DeviceIoControl( hDevHandle,
 259                               IOCTL_AFS_SHUTDOWN,
 260                               NULL,
 261                               0,
 262                               NULL,
 263                               0,
 264                               &bytesReturned ))
 265     {
 266         // log the error, nothing to do
 267     }
 268
 269     return 0;
 270 }
 271
 272 //
 273 // Here we launch the worker threads for the given volume
 274 //
 275
 276 DWORD
 277 RDR_ProcessWorkerThreads(DWORD numThreads)
 278 {
 279     DWORD WorkerID;
 280     HANDLE hEvent;
 281     DWORD index = 0;
 282     DWORD bytesReturned = 0;
 283     DWORD dwRedirInitInfo;
 284     AFSRedirectorInitInfo * redirInitInfo = NULL;
 285     DWORD dwErr;
 286
 287     if (dwErr = RDR_SetInitParams(&redirInitInfo, &dwRedirInitInfo))
 288         return dwErr;
 289
 290     glDevHandle = CreateFile( AFS_SYMLINK_W,
 291                               GENERIC_READ | GENERIC_WRITE,
 292                               FILE_SHARE_READ | FILE_SHARE_WRITE,
 293                               NULL,
 294                               OPEN_EXISTING,
 295                               FILE_FLAG_OVERLAPPED,
 296                               NULL);
 297
 298     if( glDevHandle == INVALID_HANDLE_VALUE)
 299     {
 300         free(redirInitInfo);
 301         return GetLastError();
 302     }
 303
 304     //
 305     // Now call down to initialize the pool.
 306     //
 307
 308     if( !RDR_DeviceIoControl( glDevHandle,
 309                               IOCTL_AFS_INITIALIZE_CONTROL_DEVICE,
 310                               NULL,
 311                               0,
 312                               NULL,
 313                               0,
 314                               &bytesReturned ))
 315     {
 316
 317         CloseHandle( glDevHandle);
 318
 319         glDevHandle = NULL;
 320
 321         free(redirInitInfo);
 322
 323         return GetLastError();
 324     }
 325
 326     //
 327     // OK, now launch the workers
 328     //
 329
 330     hEvent = CreateEvent( NULL,
 331                           TRUE,
 332                           FALSE,
 333                           NULL);
 334
 335     //
 336     // Here we create a pool of worker threads but you can create the pool with as many requests
 337     // as you want
 338     //
 339
 340     if (numThreads < MIN_WORKER_THREADS)
 341         numThreads = MIN_WORKER_THREADS;
 342     else if (numThreads > MAX_WORKER_THREADS)
 343         numThreads = MAX_WORKER_THREADS;
 344
 345     for (index = 0; index < numThreads; index++)
 346     {
 347         //
 348         // 20% of worker threads should be reserved for release extent
 349         // event processing
 350         //
 351         glWorkerThreadInfo[ glThreadHandleIndex].Flags =
 352             (glThreadHandleIndex % 5) ? 0 : AFS_REQUEST_RELEASE_THREAD;
 353         glWorkerThreadInfo[ glThreadHandleIndex].hEvent = hEvent;
 354         glWorkerThreadInfo[ glThreadHandleIndex].hThread =
 355             CreateThread( NULL,
 356                           0,
 357                           RDR_RequestWorkerThread,
 358                           (void *)&glWorkerThreadInfo[ glThreadHandleIndex],
 359                           0,
 360                           &WorkerID);
 361
 362         if( glWorkerThreadInfo[ glThreadHandleIndex].hThread != NULL)
 363         {
 364
 365             //
 366             // Wait for the thread to signal it is ready for processing
 367             //
 368
 369             WaitForSingleObject( hEvent,
 370                                  INFINITE);
 371
 372             glThreadHandleIndex++;
 373
 374             ResetEvent( hEvent);
 375         }
 376         else
 377         {
 378
 379             //
 380             // Perform cleanup specific to your application
 381             //
 382
 383         }
 384     }
 385
 386     if( !RDR_DeviceIoControl( glDevHandle,
 387                               IOCTL_AFS_INITIALIZE_REDIRECTOR_DEVICE,
 388                               redirInitInfo,
 389                               dwRedirInitInfo,
 390                               NULL,
 391                               0,
 392                               &bytesReturned ))
 393     {
 394
 395         CloseHandle( glDevHandle);
 396
 397         glDevHandle = NULL;
 398
 399         free(redirInitInfo);
 400
 401         return GetLastError();
 402     }
 403
 404     free(redirInitInfo);
 405
 406     return 0;
 407 }
 408
 409 //
 410 // Entry point for the worker thread
 411 //
 412
 413 DWORD
 414 WINAPI
 415 RDR_RequestWorkerThread( LPVOID lpParameter)
 416 {
 417
 418     HANDLE hDevHandle = NULL;
 419     DWORD bytesReturned;
 420     AFSCommRequest *requestBuffer;
 421     bool bError = false;
 422     WorkerThreadInfo * pInfo = (WorkerThreadInfo *)lpParameter;
 423
 424     //
 425     // We use the global handle to the control device instance
 426     //
 427
 428     hDevHandle = glDevHandle;
 429
 430     //
 431     // Allocate a request buffer.
 432     //
 433
 434     requestBuffer = (AFSCommRequest *)malloc( sizeof( AFSCommRequest) + AFS_PAYLOAD_BUFFER_SIZE);
 435
 436     if( requestBuffer)
 437     {
 438
 439         //
 440         // Here we simply signal back to the main thread that we ahve started
 441         //
 442
 443         SetEvent( pInfo->hEvent);
 444
 445         //
 446         // Process requests until we are told to stop
 447         //
 448
 449         while( !Exit)
 450         {
 451
 452             memset( requestBuffer, '\0', sizeof( AFSCommRequest) + AFS_PAYLOAD_BUFFER_SIZE);
 453
 454             requestBuffer->RequestFlags = pInfo->Flags;
 455
 456             if( !RDR_DeviceIoControl( hDevHandle,
 457                                       IOCTL_AFS_PROCESS_IRP_REQUEST,
 458                                       (void *)requestBuffer,
 459                                       sizeof( AFSCommRequest),
 460                                       (void *)requestBuffer,
 461                                       sizeof( AFSCommRequest) + AFS_PAYLOAD_BUFFER_SIZE,
 462                                       &bytesReturned ))
 463             {
 464
 465                 //
 466                 // Error condition back from driver
 467                 //
 468
 469                 break;
 470             }
 471
 472             //
 473             // Go process the request
 474             //
 475
 476             if (!Exit)
 477                 RDR_ProcessRequest( requestBuffer);
 478         }
 479
 480         free( requestBuffer);
 481     }
 482
 483     ExitThread( 0);
 484
 485     return 0;
 486 }
 487
 488 //
 489 // This is the entry point for the worker threads to process the request from the TC Filter driver
 490 //
 491
 492 void
 493 RDR_ProcessRequest( AFSCommRequest *RequestBuffer)
 494 {
 495
 496     DWORD               bytesReturned;
 497     DWORD               result = 0;
 498     ULONG               ulIndex = 0;
 499     ULONG               ulCreateFlags = 0;
 500     AFSCommResult *     pResultCB = NULL;
 501     AFSCommResult       stResultCB;
 502     DWORD               dwResultBufferLength = 0;
 503     AFSSetFileExtentsCB * SetFileExtentsResultCB = NULL;
 504     AFSSetByteRangeLockResultCB *SetByteRangeLockResultCB = NULL;
 505     WCHAR               wchBuffer[1024];
 506     char *pBuffer = (char *)wchBuffer;
 507     DWORD gle;
 508     cm_user_t *         userp = NULL;
 509     BOOL                bWow64 = (RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_WOW64) ? TRUE : FALSE;
 510     BOOL                bFast  = (RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_FAST_REQUEST) ? TRUE : FALSE;
 511     BOOL                bHoldFid = (RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_HOLD_FID) ? TRUE : FALSE;
 512     BOOL                bFlushFile = (RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_FLUSH_FILE) ? TRUE : FALSE;
 513     BOOL                bDeleteFile = (RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_FILE_DELETED) ? TRUE : FALSE;
 514     BOOL                bUnlockFile = (RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_BYTE_RANGE_UNLOCK_ALL) ? TRUE : FALSE;
 515     BOOL                bCheckOnly = (RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_CHECK_ONLY) ? TRUE : FALSE;
 516     BOOL                bRetry = FALSE;
 517     BOOL                bUnsupported = FALSE;
 518     BOOL                bIsLocalSystem = (RequestBuffer->RequestFlags & AFS_REQUEST_LOCAL_SYSTEM_PAG) ? TRUE : FALSE;
 519
 520     userp = RDR_UserFromCommRequest(RequestBuffer);
 521
 522   retry:
 523     //
 524     // Build up the string to display based on the request type.
 525     //
 526
 527     switch( RequestBuffer->RequestType)
 528     {
 529
 530         case AFS_REQUEST_TYPE_DIR_ENUM:
 531         {
 532
 533             AFSDirQueryCB *pQueryCB = (AFSDirQueryCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 534
 535             if (afsd_logp->enabled) {
 536                 swprintf( wchBuffer,
 537                           L"ProcessRequest Processing AFS_REQUEST_TYPE_DIR_ENUM Index %08lX",
 538                           RequestBuffer->RequestIndex);
 539
 540                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 541             }
 542
 543             //
 544             // Here is where the content of the specific directory is enumerated.
 545             //
 546
 547             RDR_EnumerateDirectory( userp, RequestBuffer->FileId,
 548                                     pQueryCB, bWow64, bFast,
 549                                     RequestBuffer->ResultBufferLength,
 550                                     &pResultCB);
 551             break;
 552         }
 553
 554         case AFS_REQUEST_TYPE_EVAL_TARGET_BY_ID:
 555         {
 556             AFSEvalTargetCB *pEvalTargetCB = (AFSEvalTargetCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 557
 558             if (afsd_logp->enabled) {
 559                 swprintf( wchBuffer,
 560                           L"ProcessRequest Processing AFS_REQUEST_TYPE_EVAL_TARGET_BY_ID Index %08lX",
 561                           RequestBuffer->RequestIndex);
 562
 563                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 564             }
 565             //
 566             // Here is where the specified node is evaluated.
 567             //
 568
 569             RDR_EvaluateNodeByID( userp, pEvalTargetCB->ParentId,
 570                                   RequestBuffer->FileId,
 571                                   bWow64, bFast, bHoldFid,
 572                                   RequestBuffer->ResultBufferLength,
 573                                   &pResultCB);
 574             break;
 575         }
 576
 577         case AFS_REQUEST_TYPE_EVAL_TARGET_BY_NAME:
 578         {
 579             AFSEvalTargetCB *pEvalTargetCB = (AFSEvalTargetCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 580
 581             if (afsd_logp->enabled) {
 582                 swprintf( wchBuffer,
 583                           L"ProcessRequest Processing AFS_REQUEST_TYPE_EVAL_TARGET_BY_NAME Index %08lX",
 584                           RequestBuffer->RequestIndex);
 585
 586                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 587             }
 588             //
 589             // Here is where the specified node is evaluated.
 590             //
 591
 592             RDR_EvaluateNodeByName( userp, pEvalTargetCB->ParentId,
 593                                     RequestBuffer->Name,
 594                                     RequestBuffer->NameLength,
 595                                     RequestBuffer->RequestFlags & AFS_REQUEST_FLAG_CASE_SENSITIVE ? TRUE : FALSE,
 596                                     bWow64, bFast, bHoldFid,
 597                                     RequestBuffer->ResultBufferLength,
 598                                     &pResultCB);
 599             break;
 600         }
 601
 602         case AFS_REQUEST_TYPE_CREATE_FILE:
 603         {
 604
 605             AFSFileCreateCB *pCreateCB = (AFSFileCreateCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 606
 607             WCHAR wchFileName[ 256];
 608
 609             if (afsd_logp->enabled) {
 610                 memset( wchFileName, '\0', 256 * sizeof( WCHAR));
 611
 612                 memcpy( wchFileName,
 613                         RequestBuffer->Name,
 614                         RequestBuffer->NameLength);
 615
 616                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_CREATE_FILE Index %08lX File %S",
 617                           RequestBuffer->RequestIndex, wchFileName);
 618
 619                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 620             }
 621
 622             RDR_CreateFileEntry( userp,
 623                                  RequestBuffer->Name,
 624                                  RequestBuffer->NameLength,
 625                                  pCreateCB,
 626                                  bWow64,
 627                                  bHoldFid,
 628                                  RequestBuffer->ResultBufferLength,
 629                                  &pResultCB);
 630
 631             break;
 632         }
 633
 634         case AFS_REQUEST_TYPE_UPDATE_FILE:
 635         {
 636
 637             AFSFileUpdateCB *pUpdateCB = (AFSFileUpdateCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 638
 639             if (afsd_logp->enabled) {
 640                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_UPDATE_FILE Index %08lX File %08lX.%08lX.%08lX.%08lX",
 641                           RequestBuffer->RequestIndex,
 642                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 643                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 644
 645                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 646             }
 647
 648             RDR_UpdateFileEntry( userp, RequestBuffer->FileId,
 649                                  pUpdateCB,
 650                                  bWow64,
 651                                  RequestBuffer->ResultBufferLength,
 652                                  &pResultCB);
 653
 654             break;
 655         }
 656
 657         case AFS_REQUEST_TYPE_DELETE_FILE:
 658         {
 659
 660             AFSFileDeleteCB *pDeleteCB = (AFSFileDeleteCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 661
 662             if (afsd_logp->enabled) {
 663                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_DELETE_FILE Index %08lX %08lX.%08lX.%08lX.%08lX CheckOnly %X",
 664                           RequestBuffer->RequestIndex,
 665                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 666                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique,
 667                           bCheckOnly);
 668
 669                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 670             }
 671
 672             RDR_DeleteFileEntry( userp,
 673                                  pDeleteCB->ParentId,
 674                                  pDeleteCB->ProcessId,
 675                                  RequestBuffer->Name,
 676                                  RequestBuffer->NameLength,
 677                                  bWow64,
 678                                  bCheckOnly,
 679                                  RequestBuffer->ResultBufferLength,
 680                                  &pResultCB);
 681
 682             break;
 683         }
 684
 685         case AFS_REQUEST_TYPE_RENAME_FILE:
 686         {
 687
 688             AFSFileRenameCB *pFileRenameCB = (AFSFileRenameCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 689
 690             if (afsd_logp->enabled) {
 691                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_RENAME_FILE Index %08lX File %08lX.%08lX.%08lX.%08lX NameLength %08lX Name %*S",
 692                           RequestBuffer->RequestIndex,
 693                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 694                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique,
 695                           RequestBuffer->NameLength, (int)RequestBuffer->NameLength, RequestBuffer->Name);
 696
 697                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 698             }
 699
 700             RDR_RenameFileEntry( userp,
 701                                  RequestBuffer->Name,
 702                                  RequestBuffer->NameLength,
 703                                  RequestBuffer->FileId,
 704                                  pFileRenameCB,
 705                                  bWow64,
 706                                  RequestBuffer->ResultBufferLength,
 707                                  &pResultCB);
 708
 709             break;
 710         }
 711
 712         case AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS:
 713         {
 714
 715             AFSRequestExtentsCB *pFileRequestExtentsCB = (AFSRequestExtentsCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 716
 717             if (afsd_logp->enabled) {
 718                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS Index %08lX File %08lX.%08lX.%08lX.%08lX %S",
 719                           RequestBuffer->RequestIndex,
 720                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 721                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique,
 722                           BooleanFlagOn( RequestBuffer->RequestFlags, AFS_REQUEST_FLAG_SYNCHRONOUS) ? L"Sync" : L"Async");
 723
 724                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 725             }
 726
 727             if (BooleanFlagOn( RequestBuffer->RequestFlags, AFS_REQUEST_FLAG_SYNCHRONOUS))
 728                 osi_panic("SYNCHRONOUS AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS not supported",
 729                           __FILE__, __LINE__);
 730             else
 731                 bRetry = RDR_RequestFileExtentsAsync( userp, RequestBuffer->FileId,
 732                                                       pFileRequestExtentsCB,
 733                                                       bWow64,
 734                                                       &dwResultBufferLength,
 735                                                       &SetFileExtentsResultCB );
 736             break;
 737         }
 738
 739         case AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS:
 740         {
 741
 742             AFSReleaseExtentsCB *pFileReleaseExtentsCB = (AFSReleaseExtentsCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 743
 744             if (afsd_logp->enabled) {
 745                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_RELEASE_FILE_EXTENTS Index %08lX File %08lX.%08lX.%08lX.%08lX",
 746                           RequestBuffer->RequestIndex,
 747                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 748                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 749
 750                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 751             }
 752
 753             RDR_ReleaseFileExtents( userp, RequestBuffer->FileId,
 754                                     pFileReleaseExtentsCB,
 755                                     bWow64,
 756                                     RequestBuffer->ResultBufferLength,
 757                                     &pResultCB);
 758
 759             break;
 760         }
 761
 762         case AFS_REQUEST_TYPE_FLUSH_FILE:
 763         {
 764             if (afsd_logp->enabled) {
 765                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_FLUSH_FILE Index %08lX File %08lX.%08lX.%08lX.%08lX",
 766                           RequestBuffer->RequestIndex,
 767                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 768                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 769
 770                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 771             }
 772
 773             RDR_FlushFileEntry( userp, RequestBuffer->FileId,
 774                                 bWow64,
 775                                 RequestBuffer->ResultBufferLength,
 776                                 &pResultCB);
 777             break;
 778         }
 779
 780         case AFS_REQUEST_TYPE_OPEN_FILE:
 781         {
 782             AFSFileOpenCB *pFileOpenCB = (AFSFileOpenCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 783
 784             if (afsd_logp->enabled) {
 785                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_OPEN_FILE Index %08lX File %08lX.%08lX.%08lX.%08lX",
 786                           RequestBuffer->RequestIndex,
 787                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 788                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 789
 790                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 791             }
 792
 793             RDR_OpenFileEntry( userp, RequestBuffer->FileId,
 794                                pFileOpenCB,
 795                                bWow64,
 796                                bHoldFid,
 797                                RequestBuffer->ResultBufferLength,
 798                                &pResultCB);
 799
 800             break;
 801         }
 802
 803         case AFS_REQUEST_TYPE_RELEASE_FILE_ACCESS:
 804         {
 805             AFSFileAccessReleaseCB *pFileAccessReleaseCB = (AFSFileAccessReleaseCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 806
 807             if (afsd_logp->enabled) {
 808                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_RELEASE_FILE_ACCESS Index %08lX File %08lX.%08lX.%08lX.%08lX",
 809                           RequestBuffer->RequestIndex,
 810                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 811                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 812
 813                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 814             }
 815
 816             RDR_ReleaseFileAccess( userp,
 817                                    RequestBuffer->FileId,
 818                                    pFileAccessReleaseCB,
 819                                    bWow64,
 820                                    RequestBuffer->ResultBufferLength,
 821                                    &pResultCB);
 822
 823             break;
 824         }
 825
 826         case AFS_REQUEST_TYPE_PIOCTL_OPEN:
 827         {
 828             AFSPIOCtlOpenCloseRequestCB *pPioctlCB = (AFSPIOCtlOpenCloseRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 829
 830             if (afsd_logp->enabled) {
 831                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIOCTL_OPEN Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
 832                           RequestBuffer->RequestIndex,
 833                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 834                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 835
 836                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 837             }
 838
 839             RDR_PioctlOpen( userp,
 840                             RequestBuffer->FileId,
 841                             pPioctlCB,
 842                             bWow64,
 843                             RequestBuffer->ResultBufferLength,
 844                             &pResultCB);
 845             break;
 846         }
 847
 848         case AFS_REQUEST_TYPE_PIOCTL_WRITE:
 849         {
 850             AFSPIOCtlIORequestCB *pPioctlCB = (AFSPIOCtlIORequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 851
 852             if (afsd_logp->enabled) {
 853                 swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIOCTL_WRITE Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
 854                           RequestBuffer->RequestIndex,
 855                           RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 856                           RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 857
 858                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 859             }
 860
 861             RDR_PioctlWrite( userp,
 862                              RequestBuffer->FileId,
 863                              pPioctlCB,
 864                              bWow64,
 865                              RequestBuffer->ResultBufferLength,
 866                              &pResultCB);
 867             break;
 868         }
 869
 870     case AFS_REQUEST_TYPE_PIOCTL_READ:
 871             {
 872                 AFSPIOCtlIORequestCB *pPioctlCB = (AFSPIOCtlIORequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 873
 874                 if (afsd_logp->enabled) {
 875                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIOCTL_READ Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
 876                               RequestBuffer->RequestIndex,
 877                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 878                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 879
 880                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 881                 }
 882
 883                 RDR_PioctlRead( userp,
 884                                 RequestBuffer->FileId,
 885                                 pPioctlCB,
 886                                 bWow64,
 887                                 bIsLocalSystem,
 888                                 RequestBuffer->ResultBufferLength,
 889                                 &pResultCB);
 890                 break;
 891             }
 892
 893     case AFS_REQUEST_TYPE_PIOCTL_CLOSE:
 894             {
 895                 AFSPIOCtlOpenCloseRequestCB *pPioctlCB = (AFSPIOCtlOpenCloseRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 896
 897                 if (afsd_logp->enabled) {
 898                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIOCTL_CLOSE Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
 899                               RequestBuffer->RequestIndex,
 900                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 901                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 902
 903                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 904                 }
 905
 906                 RDR_PioctlClose( userp,
 907                                 RequestBuffer->FileId,
 908                                 pPioctlCB,
 909                                 bWow64,
 910                                 RequestBuffer->ResultBufferLength,
 911                                 &pResultCB);
 912                 break;
 913             }
 914
 915
 916     case AFS_REQUEST_TYPE_BYTE_RANGE_LOCK:
 917             {
 918                 if (afsd_logp->enabled) {
 919                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_BYTE_RANGE_LOCK Index %08lX File %08lX.%08lX.%08lX.%08lX %S",
 920                               RequestBuffer->RequestIndex,
 921                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 922                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique,
 923                               BooleanFlagOn( RequestBuffer->RequestFlags, AFS_REQUEST_FLAG_SYNCHRONOUS) ? L"Sync" : L"Async");
 924
 925                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 926                 }
 927
 928                 AFSByteRangeLockRequestCB *pBRLRequestCB = (AFSByteRangeLockRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 929
 930                 RDR_ByteRangeLockSync( userp,
 931                                        RequestBuffer->FileId,
 932                                        pBRLRequestCB,
 933                                        bWow64,
 934                                        RequestBuffer->ResultBufferLength,
 935                                        &pResultCB);
 936
 937                 break;
 938             }
 939
 940     case AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK:
 941             {
 942                 AFSByteRangeUnlockRequestCB *pBRURequestCB = (AFSByteRangeUnlockRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 943
 944                 if (afsd_logp->enabled) {
 945                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK Index %08lX File %08lX.%08lX.%08lX.%08lX",
 946                               RequestBuffer->RequestIndex,
 947                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 948                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 949
 950                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 951                 }
 952
 953                 RDR_ByteRangeUnlock( userp,
 954                                      RequestBuffer->FileId,
 955                                      pBRURequestCB,
 956                                      bWow64,
 957                                      RequestBuffer->ResultBufferLength,
 958                                      &pResultCB);
 959                 break;
 960             }
 961
 962     case AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK_ALL:
 963             {
 964                 AFSByteRangeUnlockRequestCB *pBRURequestCB = (AFSByteRangeUnlockRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
 965
 966                 if (afsd_logp->enabled) {
 967                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_BYTE_RANGE_UNLOCK_ALL Index %08lX File %08lX.%08lX.%08lX.%08lX",
 968                               RequestBuffer->RequestIndex,
 969                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 970                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 971
 972                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 973                 }
 974
 975                 RDR_ByteRangeUnlockAll( userp,
 976                                         RequestBuffer->FileId,
 977                                         pBRURequestCB,
 978                                         bWow64,
 979                                         RequestBuffer->ResultBufferLength,
 980                                         &pResultCB);
 981                 break;
 982             }
 983
 984     case AFS_REQUEST_TYPE_GET_VOLUME_INFO:
 985             {
 986                 if (afsd_logp->enabled) {
 987                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_GET_VOLUME_INFO Index %08lX File %08lX.%08lX.%08lX.%08lX",
 988                               RequestBuffer->RequestIndex,
 989                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
 990                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
 991
 992                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
 993                 }
 994
 995                 RDR_GetVolumeInfo( userp,
 996                                    RequestBuffer->FileId,
 997                                    bWow64,
 998                                    RequestBuffer->ResultBufferLength,
 999                                    &pResultCB);
1000                 break;
1001             }
1002
1003     case AFS_REQUEST_TYPE_HOLD_FID:
1004             {
1005
1006                 AFSHoldFidRequestCB *pHoldFidCB = (AFSHoldFidRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1007
1008                 if (afsd_logp->enabled) {
1009                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_HOLD_FID Index %08lX",
1010                               RequestBuffer->RequestIndex);
1011
1012                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1013                 }
1014
1015                 RDR_HoldFid( userp,
1016                              pHoldFidCB,
1017                              bFast,
1018                              RequestBuffer->ResultBufferLength,
1019                              &pResultCB);
1020
1021                 break;
1022             }
1023
1024     case AFS_REQUEST_TYPE_RELEASE_FID:
1025             {
1026
1027                 AFSReleaseFidRequestCB *pReleaseFidCB = (AFSReleaseFidRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1028
1029                 if (afsd_logp->enabled) {
1030                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_RELEASE_FID Index %08lX",
1031                               RequestBuffer->RequestIndex);
1032
1033                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1034                 }
1035
1036                 RDR_ReleaseFid( userp,
1037                                 pReleaseFidCB,
1038                                 bFast,
1039                                 RequestBuffer->ResultBufferLength,
1040                                 &pResultCB);
1041
1042                 break;
1043             }
1044
1045     case AFS_REQUEST_TYPE_CLEANUP_PROCESSING:
1046             {
1047
1048                 AFSFileCleanupCB *pCleanupCB = (AFSFileCleanupCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1049
1050                 if (afsd_logp->enabled) {
1051                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_CLEANUP_FILE Index %08lX File %08lX.%08lX.%08lX.%08lX",
1052                               RequestBuffer->RequestIndex,
1053                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
1054                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
1055
1056                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1057                 }
1058
1059                 RDR_CleanupFileEntry( userp,
1060                                       RequestBuffer->FileId,
1061                                       RequestBuffer->Name,
1062                                       RequestBuffer->NameLength,
1063                                       pCleanupCB,
1064                                       bWow64,
1065                                       bFlushFile,
1066                                       bDeleteFile,
1067                                       bUnlockFile,
1068                                       RequestBuffer->ResultBufferLength,
1069                                       &pResultCB);
1070
1071                 break;
1072             }
1073
1074     case AFS_REQUEST_TYPE_PIPE_OPEN:
1075             {
1076                 AFSPipeOpenCloseRequestCB *pPipeCB = (AFSPipeOpenCloseRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1077
1078                 if (afsd_logp->enabled) {
1079                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIPE_OPEN Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
1080                               RequestBuffer->RequestIndex,
1081                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
1082                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
1083
1084                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1085                 }
1086
1087                 RDR_PipeOpen( userp,
1088                               RequestBuffer->FileId,
1089                               RequestBuffer->Name,
1090                               RequestBuffer->NameLength,
1091                               pPipeCB,
1092                               bWow64,
1093                               RequestBuffer->ResultBufferLength,
1094                               &pResultCB);
1095                 break;
1096             }
1097
1098     case AFS_REQUEST_TYPE_PIPE_WRITE:
1099             {
1100                 AFSPipeIORequestCB *pPipeCB = (AFSPipeIORequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1101                 BYTE *pPipeData = ((BYTE *)RequestBuffer->Name + RequestBuffer->DataOffset + sizeof(AFSPipeIORequestCB));
1102
1103                 if (afsd_logp->enabled) {
1104                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIPE_WRITE Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
1105                               RequestBuffer->RequestIndex,
1106                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
1107                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
1108
1109                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1110                 }
1111
1112                 RDR_PipeWrite( userp,
1113                                RequestBuffer->FileId,
1114                                pPipeCB,
1115                                pPipeData,
1116                                bWow64,
1117                                RequestBuffer->ResultBufferLength,
1118                                &pResultCB);
1119                 break;
1120             }
1121
1122     case AFS_REQUEST_TYPE_PIPE_READ:
1123             {
1124                 AFSPipeIORequestCB *pPipeCB = (AFSPipeIORequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1125
1126                 if (afsd_logp->enabled) {
1127                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIPE_READ Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
1128                               RequestBuffer->RequestIndex,
1129                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
1130                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
1131
1132                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1133                 }
1134
1135                 RDR_PipeRead( userp,
1136                               RequestBuffer->FileId,
1137                               pPipeCB,
1138                               bWow64,
1139                               RequestBuffer->ResultBufferLength,
1140                               &pResultCB);
1141                 break;
1142             }
1143
1144     case AFS_REQUEST_TYPE_PIPE_CLOSE:
1145             {
1146                 AFSPipeOpenCloseRequestCB *pPipeCB = (AFSPipeOpenCloseRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1147
1148                 if (afsd_logp->enabled) {
1149                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIPE_CLOSE Index %08lX Parent %08lX.%08lX.%08lX.%08lX",
1150                               RequestBuffer->RequestIndex,
1151                               RequestBuffer->FileId.Cell, RequestBuffer->FileId.Volume,
1152                               RequestBuffer->FileId.Vnode, RequestBuffer->FileId.Unique);
1153
1154                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1155                 }
1156
1157                 RDR_PipeClose( userp,
1158                                 RequestBuffer->FileId,
1159                                 pPipeCB,
1160                                 bWow64,
1161                                 RequestBuffer->ResultBufferLength,
1162                                 &pResultCB);
1163                 break;
1164             }
1165
1166
1167     case AFS_REQUEST_TYPE_PIPE_TRANSCEIVE:
1168             {
1169                 AFSPipeIORequestCB *pPipeCB = (AFSPipeIORequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1170                 BYTE *pPipeData = ((BYTE *)RequestBuffer->Name + RequestBuffer->DataOffset + sizeof(AFSPipeIORequestCB));
1171
1172                 if (afsd_logp->enabled) {
1173                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIPE_TRANSCEIVE Index %08lX",
1174                               RequestBuffer->RequestIndex);
1175
1176                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1177                 }
1178
1179                 RDR_PipeTransceive( userp,
1180                                     RequestBuffer->FileId,
1181                                     pPipeCB,
1182                                     pPipeData,
1183                                     bWow64,
1184                                     RequestBuffer->ResultBufferLength,
1185                                     &pResultCB);
1186                 break;
1187             }
1188
1189     case AFS_REQUEST_TYPE_PIPE_QUERY_INFO:
1190             {
1191                 AFSPipeInfoRequestCB *pPipeInfoCB = (AFSPipeInfoRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1192
1193                 if (afsd_logp->enabled) {
1194                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIPE_QUERY_INFO Index %08lX",
1195                               RequestBuffer->RequestIndex);
1196
1197                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1198                 }
1199
1200                 RDR_PipeQueryInfo( userp,
1201                                    RequestBuffer->FileId,
1202                                    pPipeInfoCB,
1203                                    bWow64,
1204                                    RequestBuffer->ResultBufferLength,
1205                                    &pResultCB);
1206                 break;
1207             }
1208
1209     case AFS_REQUEST_TYPE_PIPE_SET_INFO:
1210             {
1211                 AFSPipeInfoRequestCB *pPipeInfoCB = (AFSPipeInfoRequestCB *)((char *)RequestBuffer->Name + RequestBuffer->DataOffset);
1212                 BYTE *pPipeData = ((BYTE *)RequestBuffer->Name + RequestBuffer->DataOffset + sizeof(AFSPipeInfoRequestCB));
1213
1214                 if (afsd_logp->enabled) {
1215                     swprintf( wchBuffer, L"ProcessRequest Processing AFS_REQUEST_TYPE_PIPE_SET_INFO Index %08lX",
1216                               RequestBuffer->RequestIndex);
1217
1218                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1219                 }
1220
1221                 RDR_PipeSetInfo( userp,
1222                                  RequestBuffer->FileId,
1223                                  pPipeInfoCB,
1224                                  pPipeData,
1225                                  bWow64,
1226                                  RequestBuffer->ResultBufferLength,
1227                                  &pResultCB);
1228
1229                 break;
1230             }
1231
1232     default:
1233             bUnsupported = TRUE;
1234
1235             if (afsd_logp->enabled) {
1236                 swprintf( wchBuffer, L"ProcessRequest Received unknown request type %08lX Index %08lX",
1237                           RequestBuffer->RequestType,
1238                           RequestBuffer->RequestIndex);
1239
1240                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1241             }
1242
1243             break;
1244     }
1245
1246     if( BooleanFlagOn( RequestBuffer->RequestFlags, AFS_REQUEST_FLAG_SYNCHRONOUS))
1247     {
1248         if (pResultCB == NULL) {
1249             // We failed probably due to a memory allocation error
1250             // unless the unsupported flag was set.
1251             pResultCB = &stResultCB;
1252             memset(&stResultCB, 0, sizeof(stResultCB));
1253             if ( bUnsupported )
1254                 pResultCB->ResultStatus = STATUS_NOT_IMPLEMENTED;
1255             else
1256                 pResultCB->ResultStatus = STATUS_NO_MEMORY;
1257         }
1258
1259         //
1260         // This is how the filter associates the response information passed in the IOCtl below to the
1261         // original call. This request index is setup by the filter and should not be modified, otherwise the
1262         // filter will not be able to locate the request in its internal queue and the blocking thread will
1263         // not be awakened
1264         //
1265
1266         pResultCB->RequestIndex = RequestBuffer->RequestIndex;
1267
1268         if (afsd_logp->enabled) {
1269             swprintf( wchBuffer,
1270                       L"ProcessRequest Responding to Index %08lX Length %08lX",
1271                       pResultCB->RequestIndex,
1272                       pResultCB->ResultBufferLength);
1273
1274             osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1275         }
1276
1277         //
1278         // Now post the result back to the driver.
1279         //
1280
1281         if( !RDR_DeviceIoControl( glDevHandle,
1282                                   IOCTL_AFS_PROCESS_IRP_RESULT,
1283                                   (void *)pResultCB,
1284                                   sizeof( AFSCommResult) + pResultCB->ResultBufferLength,
1285                                   (void *)NULL,
1286                                   0,
1287                                   &bytesReturned ))
1288         {
1289             char *pBuffer = (char *)wchBuffer;
1290             gle = GetLastError();
1291             if (afsd_logp->enabled) {
1292                 swprintf( wchBuffer,
1293                           L"Failed to post IOCTL_AFS_PROCESS_IRP_RESULT gle %X", gle);
1294                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1295             }
1296
1297             sprintf( pBuffer,
1298                      "Failed to post IOCTL_AFS_PROCESS_IRP_RESULT gle %X",
1299                      GetLastError());
1300             osi_panic(pBuffer, __FILE__, __LINE__);
1301         }
1302
1303     }
1304     else if (RequestBuffer->RequestType == AFS_REQUEST_TYPE_REQUEST_FILE_EXTENTS) {
1305
1306         if (SetFileExtentsResultCB) {
1307
1308             if (1 || afsd_logp->enabled) {
1309                 if (SetFileExtentsResultCB->ResultStatus != 0)
1310                     swprintf( wchBuffer,
1311                           L"ProcessRequest Responding Asynchronously with FAILURE to REQUEST_FILE_EXTENTS Index %08lX Count %08lX Status %08lX",
1312                           RequestBuffer->RequestIndex, SetFileExtentsResultCB->ExtentCount, SetFileExtentsResultCB->ResultStatus);
1313                 else
1314                     swprintf( wchBuffer,
1315                           L"ProcessRequest Responding Asynchronously with SUCCESS to REQUEST_FILE_EXTENTS Index %08lX Count %08lX",
1316                           RequestBuffer->RequestIndex, SetFileExtentsResultCB->ExtentCount);
1317
1318                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1319             }
1320
1321             if( (SetFileExtentsResultCB->ExtentCount != 0 ||
1322                  SetFileExtentsResultCB->ResultStatus != 0) &&
1323                 !RDR_DeviceIoControl( glDevHandle,
1324                                        IOCTL_AFS_SET_FILE_EXTENTS,
1325                                       (void *)SetFileExtentsResultCB,
1326                                       dwResultBufferLength,
1327                                       (void *)NULL,
1328                                       0,
1329                                       &bytesReturned ))
1330             {
1331                 gle = GetLastError();
1332                 if (afsd_logp->enabled) {
1333                     swprintf( wchBuffer,
1334                               L"Failed to post IOCTL_AFS_SET_FILE_EXTENTS gle %X",
1335                               gle);
1336                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1337                 }
1338
1339                 // The file system returns an error when it can't find the FID
1340                 // This is a bug in the file system but we should try to avoid
1341                 // the crash and clean up our own memory space.
1342                 //
1343                 // Since we couldn't deliver the extents to the file system
1344                 // we should release them.
1345                 if ( SetFileExtentsResultCB->ExtentCount != 0)
1346                 {
1347                     RDR_ReleaseFailedSetFileExtents( userp,
1348                                                  SetFileExtentsResultCB,
1349                                                  dwResultBufferLength);
1350                 }
1351
1352                 if (gle != ERROR_GEN_FAILURE) {
1353                     sprintf( pBuffer,
1354                              "Failed to post IOCTL_AFS_SET_FILE_EXTENTS gle %X",
1355                              gle);
1356                     osi_panic(pBuffer, __FILE__, __LINE__);
1357                 }
1358             }
1359
1360             free(SetFileExtentsResultCB);
1361
1362       } else {
1363           /* Must be out of memory */
1364           if (afsd_logp->enabled) {
1365               swprintf( wchBuffer,
1366                         L"ProcessRequest Responding Asynchronously STATUS_NO_MEMORY to REQUEST_FILE_EXTENTS Index %08lX",
1367                         RequestBuffer->RequestIndex);
1368
1369               osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1370           }
1371
1372           RDR_SetFileStatus( (cm_fid_t *)&RequestBuffer->FileId, STATUS_NO_MEMORY);
1373        }
1374     }
1375     else if (RequestBuffer->RequestType == AFS_REQUEST_TYPE_BYTE_RANGE_LOCK) {
1376
1377         if (afsd_logp->enabled) {
1378             swprintf( wchBuffer,
1379                       L"ProcessRequest Responding Asynchronously to REQUEST_TYPE_BYTE_RANGELOCK Index %08lX",
1380                       RequestBuffer->RequestIndex);
1381
1382             osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1383         }
1384
1385
1386         if (SetByteRangeLockResultCB) {
1387
1388             if( !RDR_DeviceIoControl( glDevHandle,
1389                                   IOCTL_AFS_SET_BYTE_RANGE_LOCKS,
1390                                   (void *)SetByteRangeLockResultCB,
1391                                   dwResultBufferLength,
1392                                   (void *)NULL,
1393                                   0,
1394                                   &bytesReturned ))
1395             {
1396                 gle = GetLastError();
1397
1398                 if (afsd_logp->enabled) {
1399                     swprintf( wchBuffer,
1400                               L"Failed to post IOCTL_AFS_SET_BYTE_RANGE_LOCKS gle 0x%x", gle);
1401                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1402                 }
1403
1404
1405                 // TODO - instead of a panic we should release the locks
1406                 sprintf( pBuffer,
1407                          "Failed to post IOCTL_AFS_SET_BYTE_RANGE_LOCKS gle %X", gle);
1408                 osi_panic(pBuffer, __FILE__, __LINE__);
1409             }
1410
1411             free(SetByteRangeLockResultCB);
1412         } else {
1413             /* Must be out of memory */
1414             AFSSetByteRangeLockResultCB SetByteRangeLockResultCB;
1415
1416             dwResultBufferLength = sizeof(AFSSetByteRangeLockResultCB);
1417             memset( &SetByteRangeLockResultCB, '\0', dwResultBufferLength );
1418             SetByteRangeLockResultCB.FileId = RequestBuffer->FileId;
1419             SetByteRangeLockResultCB.Result[0].Status = STATUS_NO_MEMORY;
1420
1421             if( !RDR_DeviceIoControl( glDevHandle,
1422                                       IOCTL_AFS_SET_BYTE_RANGE_LOCKS,
1423                                       (void *)&SetByteRangeLockResultCB,
1424                                       dwResultBufferLength,
1425                                       (void *)NULL,
1426                                       0,
1427                                       &bytesReturned ))
1428             {
1429                 gle = GetLastError();
1430
1431                 if (afsd_logp->enabled) {
1432                     swprintf( wchBuffer,
1433                               L"Failed to post IOCTL_AFS_SET_BYTE_RANGE_LOCKS gle 0x%x", gle);
1434                     osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1435                 }
1436
1437                 /* We were out of memory - nothing to do */
1438             }
1439         }
1440     }
1441     else {
1442
1443         if (afsd_logp->enabled) {
1444             swprintf( wchBuffer,
1445                       L"ProcessRequest Not responding to async Index %08lX",
1446                       RequestBuffer->RequestIndex);
1447
1448             osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1449         }
1450     }
1451
1452     if (bRetry)
1453         goto retry;
1454
1455     if (userp)
1456         RDR_ReleaseUser(userp);
1457
1458
1459     if( pResultCB && pResultCB != &stResultCB)
1460     {
1461
1462         free( pResultCB);
1463     }
1464     return;
1465 }
1466
1467
1468 extern "C" DWORD
1469 RDR_SetFileExtents( AFSSetFileExtentsCB *pSetFileExtentsResultCB,
1470                     DWORD dwResultBufferLength)
1471 {
1472     WCHAR wchBuffer[1024];
1473     DWORD bytesReturned;
1474     DWORD gle;
1475
1476     if (1 || afsd_logp->enabled) {
1477         if (pSetFileExtentsResultCB->ResultStatus != 0)
1478             swprintf( wchBuffer,
1479                L"RDR_SetFileExtents IOCTL_AFS_SET_FILE_EXTENTS FAILURE Count %08lX Status %08lX",
1480                pSetFileExtentsResultCB->ExtentCount, pSetFileExtentsResultCB->ResultStatus);
1481         else
1482             swprintf( wchBuffer,
1483                L"RDR_SetFileExtents IOCTL_AFS_SET_FILE_EXTENTS SUCCESS Count %08lX",
1484                pSetFileExtentsResultCB->ExtentCount);
1485
1486         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1487     }
1488
1489     if( !RDR_DeviceIoControl( glDevHandle,
1490                               IOCTL_AFS_SET_FILE_EXTENTS,
1491                               (void *)pSetFileExtentsResultCB,
1492                               dwResultBufferLength,
1493                               (void *)NULL,
1494                               0,
1495                               &bytesReturned ))
1496     {
1497         gle = GetLastError();
1498         return gle;
1499     }
1500
1501     return 0;
1502 }
1503
1504
1505 extern "C" DWORD
1506 RDR_SetFileStatus( cm_fid_t *fidp,
1507                    DWORD dwStatus)
1508 {
1509     WCHAR               wchBuffer[1024];
1510     AFSExtentFailureCB  SetFileStatusCB;
1511     DWORD               bytesReturned;
1512     DWORD               gle;
1513     AFSFileID          *pFileId = (AFSFileID *)fidp;
1514
1515     SetFileStatusCB.FileId = *pFileId;
1516     SetFileStatusCB.FailureStatus = dwStatus;
1517
1518     if (afsd_logp->enabled) {
1519         swprintf( wchBuffer, L"RDR_SetFileStatus IOCTL_AFS_EXTENT_FAILURE_CB Fid %08lX.%08lX.%08lX.%08lX Status 0x%lX",
1520                   pFileId->Cell, pFileId->Volume,
1521                   pFileId->Vnode, pFileId->Unique,
1522                   dwStatus);
1523
1524         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1525     }
1526
1527     if( !RDR_DeviceIoControl( glDevHandle,
1528                               IOCTL_AFS_SET_FILE_EXTENT_FAILURE,
1529                               (void *)&SetFileStatusCB,
1530                               sizeof(AFSExtentFailureCB),
1531                               (void *)NULL,
1532                               0,
1533                               &bytesReturned ))
1534     {
1535         gle = GetLastError();
1536         return gle;
1537     }
1538
1539     return 0;
1540 }
1541
1542
1543 extern "C" DWORD
1544 RDR_RequestExtentRelease(cm_fid_t *fidp, LARGE_INTEGER numOfHeldExtents, DWORD numOfExtents, AFSFileExtentCB *extentList)
1545 {
1546
1547     HANDLE hDevHandle = NULL;
1548     DWORD bytesReturned;
1549     AFSReleaseFileExtentsCB *requestBuffer = NULL;
1550     AFSReleaseFileExtentsResultCB *responseBuffer = NULL;
1551     DWORD requestBufferLen, responseBufferLen;
1552     bool bError = false;
1553     DWORD rc = 0;
1554     WCHAR wchBuffer[256];
1555     DWORD gle;
1556
1557     if (ExitPending) {
1558         if (afsd_logp->enabled) {
1559             swprintf( wchBuffer,
1560                       L"IOCTL_AFS_RELEASE_FILE_EXTENTS request ignored due to shutdown pending");
1561
1562             osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1563         }
1564
1565         OutputDebugString(L"RDR_RequestExtentRequest ignored - shutdown pending\n");
1566         return CM_ERROR_WOULDBLOCK;
1567     }
1568
1569     if (afsd_logp->enabled) {
1570         swprintf( wchBuffer,
1571                   L"IOCTL_AFS_RELEASE_FILE_EXTENTS request - number %08lX",
1572                   numOfExtents);
1573
1574         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1575     }
1576
1577     //
1578     // We use the global handle to the control device instance
1579     //
1580
1581     hDevHandle = glDevHandle;
1582
1583     //
1584     // Allocate a request buffer.
1585     //
1586
1587     requestBufferLen = sizeof( AFSReleaseFileExtentsCB) + sizeof(AFSFileExtentCB) * numOfExtents;
1588     requestBuffer = (AFSReleaseFileExtentsCB *)malloc( requestBufferLen);
1589     responseBufferLen = (sizeof( AFSReleaseFileExtentsResultCB) + sizeof( AFSReleaseFileExtentsResultFileCB)) * numOfExtents;
1590     responseBuffer = (AFSReleaseFileExtentsResultCB *)malloc( responseBufferLen);
1591
1592
1593     if( requestBuffer && responseBuffer)
1594     {
1595
1596         memset( requestBuffer, '\0', sizeof( AFSReleaseFileExtentsCB));
1597         memset( responseBuffer, '\0', responseBufferLen);
1598
1599         // If there is a FID provided, use it
1600         if (fidp && extentList)
1601         {
1602             RDR_fid2FID( fidp, &requestBuffer->FileId);
1603
1604             memcpy(&requestBuffer->FileExtents, extentList, numOfExtents * sizeof(AFSFileExtentCB));
1605
1606             requestBuffer->Flags = 0;
1607         } else {
1608
1609             requestBuffer->Flags = AFS_RELEASE_EXTENTS_FLAGS_RELEASE_ALL;
1610         }
1611
1612         // Set the number of extents to be freed
1613         // Leave the rest of the structure as zeros to indicate free anything
1614         requestBuffer->ExtentCount = numOfExtents;
1615
1616         requestBuffer->HeldExtentCount = numOfHeldExtents;
1617
1618         if( !RDR_DeviceIoControl( hDevHandle,
1619                                   IOCTL_AFS_RELEASE_FILE_EXTENTS,
1620                                   (void *)requestBuffer,
1621                                   requestBufferLen,
1622                                   (void *)responseBuffer,
1623                                   responseBufferLen,
1624                                   &bytesReturned ))
1625         {
1626             //
1627             // Error condition back from driver
1628             //
1629             if (afsd_logp->enabled) {
1630                 gle = GetLastError();
1631                 swprintf( wchBuffer,
1632                           L"Failed to post IOCTL_AFS_RELEASE_FILE_EXTENTS - gle 0x%x", gle);
1633                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1634             }
1635             rc = -1;
1636             goto cleanup;
1637         }
1638
1639         //
1640         // Go process the request
1641         //
1642
1643         if (afsd_logp->enabled) {
1644             swprintf( wchBuffer,
1645                       L"IOCTL_AFS_RELEASE_FILE_EXTENTS returns - serial number %08lX flags %lX FileCount %lX",
1646                       responseBuffer->SerialNumber, responseBuffer->Flags, responseBuffer->FileCount);
1647             osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1648         }
1649
1650         rc = RDR_ProcessReleaseFileExtentsResult( responseBuffer, bytesReturned);
1651     } else {
1652
1653         rc = ENOMEM;
1654     }
1655
1656   cleanup:
1657     if (requestBuffer)
1658         free( requestBuffer);
1659     if (responseBuffer)
1660         free( responseBuffer);
1661
1662     return rc;
1663 }
1664
1665
1666 extern "C" DWORD
1667 RDR_NetworkStatus(BOOLEAN status)
1668 {
1669
1670     HANDLE hDevHandle = NULL;
1671     DWORD bytesReturned;
1672     AFSNetworkStatusCB *requestBuffer = NULL;
1673     DWORD rc = 0;
1674     WCHAR wchBuffer[256];
1675     DWORD gle;
1676
1677     if (afsd_logp->enabled) {
1678         swprintf( wchBuffer,
1679                   L"IOCTL_AFS_NETWORK_STATUS request - status %d",
1680                   status);
1681
1682         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1683     }
1684
1685     //
1686     // We use the global handle to the control device instance
1687     //
1688
1689     hDevHandle = glDevHandle;
1690
1691     //
1692     // Allocate a request buffer.
1693     //
1694
1695     requestBuffer = (AFSNetworkStatusCB *)malloc( sizeof( AFSNetworkStatusCB));
1696
1697
1698     if( requestBuffer)
1699     {
1700
1701         memset( requestBuffer, '\0', sizeof( AFSNetworkStatusCB));
1702
1703         // Set the number of extents to be freed
1704         // Leave the rest of the structure as zeros to indicate free anything
1705         requestBuffer->Online = status;
1706
1707         if( !RDR_DeviceIoControl( hDevHandle,
1708                                   IOCTL_AFS_NETWORK_STATUS,
1709                                   (void *)requestBuffer,
1710                                   sizeof( AFSNetworkStatusCB),
1711                                   NULL,
1712                                   0,
1713                                   &bytesReturned ))
1714         {
1715             //
1716             // Error condition back from driver
1717             //
1718             if (afsd_logp->enabled) {
1719                 gle = GetLastError();
1720                 swprintf( wchBuffer,
1721                           L"Failed to post IOCTL_AFS_NETWORK_STATUS gle 0x%x",
1722                           gle);
1723                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1724             }
1725
1726             rc = -1;
1727             goto cleanup;
1728         }
1729     } else
1730         rc = ENOMEM;
1731
1732   cleanup:
1733     if (requestBuffer)
1734         free( requestBuffer);
1735
1736     return rc;
1737 }
1738
1739
1740
1741 extern "C" DWORD
1742 RDR_VolumeStatus(ULONG cellID, ULONG volID, BOOLEAN online)
1743 {
1744
1745     HANDLE hDevHandle = NULL;
1746     DWORD bytesReturned;
1747     AFSVolumeStatusCB *requestBuffer = NULL;
1748     DWORD rc = 0;
1749     WCHAR wchBuffer[256];
1750     DWORD gle;
1751
1752     if (afsd_logp->enabled) {
1753         swprintf( wchBuffer,
1754                   L"IOCTL_AFS_VOLUME_STATUS request - cell 0x%x vol 0x%x online %d",
1755                   cellID, volID, online);
1756
1757         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1758     }
1759
1760     //
1761     // We use the global handle to the control device instance
1762     //
1763
1764     hDevHandle = glDevHandle;
1765
1766     //
1767     // Allocate a request buffer.
1768     //
1769
1770     requestBuffer = (AFSVolumeStatusCB *)malloc( sizeof( AFSVolumeStatusCB));
1771
1772
1773     if( requestBuffer)
1774     {
1775
1776         memset( requestBuffer, '\0', sizeof( AFSVolumeStatusCB));
1777
1778         requestBuffer->FileID.Cell = cellID;
1779         requestBuffer->FileID.Volume = volID;
1780         requestBuffer->Online = online;
1781
1782         if( !RDR_DeviceIoControl( hDevHandle,
1783                                   IOCTL_AFS_VOLUME_STATUS,
1784                                   (void *)requestBuffer,
1785                                   sizeof( AFSVolumeStatusCB),
1786                                   NULL,
1787                                   0,
1788                                   &bytesReturned ))
1789         {
1790             //
1791             // Error condition back from driver
1792             //
1793
1794             if (afsd_logp->enabled) {
1795                 gle = GetLastError();
1796                 swprintf( wchBuffer,
1797                           L"Failed to post IOCTL_AFS_VOLUME_STATUS gle 0x%x", gle);
1798                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1799             }
1800
1801             rc = -1;
1802             goto cleanup;
1803         }
1804     } else
1805         rc = ENOMEM;
1806
1807   cleanup:
1808     if (requestBuffer)
1809         free( requestBuffer);
1810
1811     return rc;
1812 }
1813
1814 extern "C" DWORD
1815 RDR_NetworkAddrChange(void)
1816 {
1817     return 0;
1818 }
1819
1820
1821 extern "C" DWORD
1822 RDR_InvalidateVolume(ULONG cellID, ULONG volID, ULONG reason)
1823 {
1824
1825     HANDLE hDevHandle = NULL;
1826     DWORD bytesReturned;
1827     AFSInvalidateCacheCB *requestBuffer = NULL;
1828     DWORD rc = 0;
1829     WCHAR wchBuffer[256];
1830     DWORD gle;
1831
1832     if (afsd_logp->enabled) {
1833         swprintf( wchBuffer,
1834                   L"IOCTL_AFS_INVALIDATE_CACHE (vol) request - cell 0x%x vol 0x%x reason %d",
1835                   cellID, volID, reason);
1836
1837         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1838     }
1839
1840     //
1841     // We use the global handle to the control device instance
1842     //
1843
1844     hDevHandle = glDevHandle;
1845
1846     //
1847     // Allocate a request buffer.
1848     //
1849
1850     requestBuffer = (AFSInvalidateCacheCB *)malloc( sizeof( AFSInvalidateCacheCB));
1851
1852
1853     if( requestBuffer)
1854     {
1855
1856         memset( requestBuffer, '\0', sizeof( AFSInvalidateCacheCB));
1857
1858         requestBuffer->FileID.Cell = cellID;
1859         requestBuffer->FileID.Volume = volID;
1860         requestBuffer->WholeVolume = TRUE;
1861         requestBuffer->Reason = reason;
1862
1863         if( !RDR_DeviceIoControl( hDevHandle,
1864                                   IOCTL_AFS_INVALIDATE_CACHE,
1865                                   (void *)requestBuffer,
1866                                   sizeof( AFSInvalidateCacheCB),
1867                                   NULL,
1868                                   0,
1869                                   &bytesReturned ))
1870         {
1871             //
1872             // Error condition back from driver
1873             //
1874
1875             if (afsd_logp->enabled) {
1876                 gle = GetLastError();
1877                 swprintf( wchBuffer,
1878                           L"Failed to post IOCTL_AFS_INVALIDATE_VOLUME gle 0x%x", gle);
1879                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1880             }
1881
1882             rc = -1;
1883             goto cleanup;
1884         }
1885     } else
1886         rc = ENOMEM;
1887
1888   cleanup:
1889     if (requestBuffer)
1890         free( requestBuffer);
1891
1892     return rc;
1893 }
1894
1895
1896 extern "C" DWORD
1897 RDR_InvalidateObject(ULONG cellID, ULONG volID, ULONG vnode, ULONG uniq, ULONG hash, ULONG fileType, ULONG reason)
1898 {
1899
1900     HANDLE hDevHandle = NULL;
1901     DWORD bytesReturned;
1902     AFSInvalidateCacheCB *requestBuffer = NULL;
1903     DWORD rc = 0;
1904     WCHAR wchBuffer[256];
1905     DWORD gle;
1906
1907     if (afsd_logp->enabled) {
1908         swprintf( wchBuffer,
1909                   L"IOCTL_AFS_INVALIDATE_CACHE (obj) request - cell 0x%x vol 0x%x vn 0x%x uniq 0x%x hash 0x%x type 0x%x reason %d",
1910                   cellID, volID, vnode, uniq, hash, fileType, reason);
1911
1912         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1913     }
1914
1915     //
1916     // We use the global handle to the control device instance
1917     //
1918
1919     hDevHandle = glDevHandle;
1920
1921     //
1922     // Allocate a request buffer.
1923     //
1924
1925     requestBuffer = (AFSInvalidateCacheCB *)malloc( sizeof( AFSInvalidateCacheCB));
1926
1927
1928     if( requestBuffer)
1929     {
1930
1931         memset( requestBuffer, '\0', sizeof( AFSInvalidateCacheCB));
1932
1933         requestBuffer->FileID.Cell = cellID;
1934         requestBuffer->FileID.Volume = volID;
1935         requestBuffer->FileID.Vnode = vnode;
1936         requestBuffer->FileID.Unique = uniq;
1937         requestBuffer->FileID.Hash = hash;
1938         requestBuffer->FileType = fileType;
1939         requestBuffer->WholeVolume = FALSE;
1940         requestBuffer->Reason = reason;
1941
1942         if( !RDR_DeviceIoControl( hDevHandle,
1943                                   IOCTL_AFS_INVALIDATE_CACHE,
1944                                   (void *)requestBuffer,
1945                                   sizeof( AFSInvalidateCacheCB),
1946                                   NULL,
1947                                   0,
1948                                   &bytesReturned ))
1949         {
1950             //
1951             // Error condition back from driver
1952             //
1953             if (afsd_logp->enabled) {
1954                 gle = GetLastError();
1955                 swprintf( wchBuffer,
1956                           L"Failed to post IOCTL_AFS_INVALIDATE_CACHE gle 0x%x", gle);
1957                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1958             }
1959
1960             rc = -1;
1961             goto cleanup;
1962         }
1963     } else
1964         rc = ENOMEM;
1965
1966   cleanup:
1967     if (requestBuffer)
1968         free( requestBuffer);
1969
1970     return rc;
1971 }
1972
1973
1974
1975 extern "C" DWORD
1976 RDR_SysName(ULONG Architecture, ULONG Count, WCHAR **NameList)
1977 {
1978
1979     HANDLE hDevHandle = NULL;
1980     DWORD bytesReturned;
1981     AFSSysNameNotificationCB *requestBuffer = NULL;
1982     DWORD rc = 0;
1983     WCHAR wchBuffer[256];
1984     DWORD Length;
1985     DWORD gle;
1986
1987     if (afsd_logp->enabled) {
1988         swprintf( wchBuffer,
1989                   L"IOCTL_AFS_SYSNAME_NOTIFICATION request - Arch %d Count %d",
1990                   Architecture, Count);
1991
1992         osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
1993     }
1994
1995     if (Count <= 0 || NameList == NULL)
1996         return -1;
1997
1998     //
1999     // We use the global handle to the control device instance
2000     //
2001
2002     hDevHandle = glDevHandle;
2003
2004     //
2005     // Allocate a request buffer.
2006     //
2007
2008     Length = sizeof (AFSSysNameNotificationCB) + (Count - 1) * sizeof (AFSSysName);
2009     requestBuffer = (AFSSysNameNotificationCB *)malloc( Length );
2010
2011
2012     if( requestBuffer)
2013     {
2014         unsigned int i;
2015
2016         memset( requestBuffer, '\0', Length);
2017
2018         requestBuffer->Architecture = Architecture;
2019         requestBuffer->NumberOfNames = Count;
2020         for ( i=0 ; i<Count; i++) {
2021             size_t len = wcslen(NameList[i]);
2022             requestBuffer->SysNames[i].Length = (ULONG) (len * sizeof(WCHAR));
2023             StringCchCopyNW(requestBuffer->SysNames[i].String, AFS_MAX_SYSNAME_LENGTH,
2024                             NameList[i], len);
2025         }
2026
2027         if( !RDR_DeviceIoControl( hDevHandle,
2028                                   IOCTL_AFS_SYSNAME_NOTIFICATION,
2029                                   (void *)requestBuffer,
2030                                   Length,
2031                                   NULL,
2032                                   0,
2033                                   &bytesReturned ))
2034         {
2035             //
2036             // Error condition back from driver
2037             //
2038             if (afsd_logp->enabled) {
2039                 gle = GetLastError();
2040                 swprintf( wchBuffer,
2041                           L"Failed to post IOCTL_AFS_SYSNAME_NOTIFICATION gle 0x%x", gle);
2042                 osi_Log1(afsd_logp, "%S", osi_LogSaveStringW(afsd_logp, wchBuffer));
2043             }
2044
2045             rc = -1;
2046             goto cleanup;
2047         }
2048     } else
2049         rc = ENOMEM;
2050
2051   cleanup:
2052     if (requestBuffer)
2053         free( requestBuffer);
2054
2055     return rc;
2056 }