winpcap/Packet9x/VXD/Openclos.c

   1 /*
   2  * Copyright (c) 1999 - 2003
   3  * NetGroup, Politecnico di Torino (Italy)
   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
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  * notice, this list of conditions and the following disclaimer in the
  14  * documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the Politecnico di Torino nor the names of its
  16  * contributors may be used to endorse or promote products derived from
  17  * this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  */
  32
  33
  34 #include <basedef.h>
  35 #include <vmm.h>
  36 #include <ndis.h>
  37 #include <vwin32.h>
  38 #include "debug.h"
  39 #include "packet.h"
  40 #pragma VxD_LOCKED_CODE_SEG
  41 #pragma VxD_LOCKED_DATA_SEG
  42
  43
  44 void YieldExecution( void )
  45 {
  46         VMMCall(Release_Time_Slice);
  47         VMMCall(Begin_Nest_Exec);
  48         VMMCall(Resume_Exec);
  49         VMMCall(End_Nest_Exec);
  50 }
  51
  52 /************************************************************
  53 Function called when the user level application performs a open
  54 IOCTL. Opens the adapter.
  55 ************************************************************/
  56
  57 static NDIS_MEDIUM MediumArray[] = {
  58     NdisMedium802_3,
  59     NdisMediumWan,
  60     NdisMediumFddi,
  61     NdisMediumArcnet878_2,
  62     NdisMedium802_5
  63 };
  64
  65 #define NUM_NDIS_MEDIA  (sizeof MediumArray / sizeof MediumArray[0])
  66
  67 DWORD PacketOpen(PNDIS_STRING AdapterName,DWORD dwDDB,DWORD hDevice,PDIOCPARAMETERS pDiocParms)
  68 {
  69
  70         LARGE_INTEGER           SystemTime;
  71         __int64                         ltime1;
  72         PDEVICE_EXTENSION       pde;
  73         POPEN_INSTANCE          oiNew;
  74         NDIS_STATUS                     nsErrorStatus, nsOpenStatus;
  75         UINT            i;
  76         UINT            uiMedium;
  77         NDIS_STRING             NameStr;
  78         NDIS_STATUS     Status;
  79
  80
  81         pde = GlobalDeviceExtension;
  82         /*Allocate an element that describe an adapter*/
  83         NdisAllocateMemory( (PVOID *)&oiNew, sizeof( OPEN_INSTANCE ), 0, -1 );
  84         if ( oiNew == NULL )
  85         {
  86                 return NDIS_STATUS_FAILURE;
  87         }
  88         NdisZeroMemory( (PVOID)oiNew, sizeof( OPEN_INSTANCE ) );
  89         /*allocate a pool for the packet headers*/
  90
  91         NdisAllocatePacketPool( &nsErrorStatus,
  92                                                         &(oiNew->PacketPool),
  93                                                         TRANSMIT_PACKETS,
  94                                                         sizeof(PACKET_RESERVED) );
  95
  96         IF_TRACE_MSG( "PACKET_RESERVED_a :%lx",sizeof(PACKET_RESERVED));
  97         if ( nsErrorStatus != NDIS_STATUS_SUCCESS )
  98         {
  99                 IF_TRACE_MSG( "Failed to allocate packet pool AllocStatus=%x", nsErrorStatus );
 100                 NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) ,  0 );
 101                 TRACE_LEAVE( "BindAdapter" );
 102                 return NDIS_STATUS_FAILURE;
 103         }
 104
 105
 106         /*allocate a buffer pool for the packet data*/
 107         NdisAllocateBufferPool( &nsErrorStatus,
 108                                                         &(oiNew->BufferPool),
 109                                                         TRANSMIT_PACKETS );
 110         if ( nsErrorStatus != NDIS_STATUS_SUCCESS )
 111         {
 112                 IF_TRACE_MSG( "Failed to allocate packet pool AllocStatus=%x", nsErrorStatus );
 113                 NdisFreePacketPool( oiNew->PacketPool );
 114                 NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) ,  0 );
 115                 TRACE_LEAVE( "BindAdapter" );
 116                 return NDIS_STATUS_FAILURE;
 117         }
 118         NdisAllocateSpinLock( &(oiNew->ResetSpinLock) );
 119         InitializeListHead( &(oiNew->ResetIrpList) );
 120         NdisAllocateSpinLock( &(oiNew->RcvQSpinLock) );
 121         InitializeListHead( &(oiNew->RcvList) );
 122         NdisAllocateSpinLock( &(oiNew->RequestSpinLock) );
 123         InitializeListHead( &(oiNew->RequestList) );
 124
 125         for ( i=0;i<MAX_REQUESTS;i++ )
 126         {
 127                 InsertTailList( &(oiNew->RequestList), &(oiNew->Requests[i].Reserved.ListElement) );
 128         }
 129
 130         oiNew->Status = NDIS_STATUS_PENDING;
 131
 132         /*initialize the timer variables for this session*/
 133
 134         SystemTime=GetDate();
 135
 136         ltime1=((__int64)SystemTime.HighPart*86400);
 137         ltime1+=(__int64)(SystemTime.LowPart/1000);     //current time from 1980 in seconds
 138         ltime1+=(__int64)315532800;     //current time from 1970 (Unix format) in seconds
 139         ltime1*=1193182;
 140         ltime1+=(SystemTime.LowPart%1000)*1193182/1000; //current time from 1970 in ticks
 141         ltime1-=QuerySystemTime();      //boot time from 1970 in ticks
 142         oiNew->StartTime=ltime1;
 143
 144
 145         oiNew->Dropped=0;               //reset the dropped packets counter
 146         oiNew->Received=0;              //reset the received packets counter
 147         oiNew->bpfprogram=NULL; //set an accept-all filter
 148         oiNew->bpfprogramlen=0;
 149         oiNew->BufSize=0;               //set an empty buffer
 150         oiNew->Buffer=NULL;             //reset the buffer
 151         oiNew->Bhead=0;
 152         oiNew->Btail=0;
 153         oiNew->BLastByte=0;
 154         oiNew->TimeOut=0;               //reset the timeouts
 155         oiNew->ReadTimeoutTimer=0;
 156         oiNew->mode=0;                  //set capture mode
 157         oiNew->Nbytes=0;                //reset the counters
 158         oiNew->Npackets=0;
 159         oiNew->hDevice=hDevice;
 160         oiNew->tagProcess=pDiocParms->tagProcess;
 161         oiNew->ReadEvent=0;             //reset the read event
 162
 163         NdisAllocateSpinLock( &(oiNew->CountersLock) );
 164         /*open the MAC driver calling NDIS*/
 165         NdisOpenAdapter( &nsOpenStatus,
 166                                          &nsErrorStatus,
 167                                          &oiNew->AdapterHandle,
 168                                          &uiMedium,
 169                                          MediumArray,
 170                                          NUM_NDIS_MEDIA,
 171                                          pde->NdisProtocolHandle,
 172                                          oiNew,
 173                                          AdapterName,
 174                                          0,
 175                                          NULL );
 176
 177         IF_TRACE_MSG( "Open Status                   : %lx", nsOpenStatus );
 178         IF_TRACE_MSG( "Error Status                  : %lx", nsErrorStatus );
 179         IF_TRACE_MSG( "Completion Status             : %lx", oiNew->Status );
 180
 181         if ( nsOpenStatus == NDIS_STATUS_PENDING )
 182         {
 183                 while ( oiNew->Status == NDIS_STATUS_PENDING )
 184                         YieldExecution();
 185         }
 186         else
 187         {
 188                 PacketOpenAdapterComplete( oiNew, nsOpenStatus, nsErrorStatus );
 189         }
 190
 191         Status = oiNew->Status;
 192         if ( Status != NDIS_STATUS_SUCCESS )
 193         {
 194                 NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) ,  0 );
 195                 return NDIS_STATUS_FAILURE;
 196         }
 197         else
 198         {
 199
 200         }
 201
 202         TRACE_LEAVE( "BindAdapter" );
 203
 204         /*return succesfully*/
 205         return STATUS_SUCCESS;
 206
 207 }
 208
 209 /************************************************************
 210 Function called when the user level application performs a Close
 211 IOCTL. Closes the adapter and free the reources associated with it
 212 ************************************************************/
 213
 214 DWORD PacketClose(POPEN_INSTANCE Open,DWORD dwDDB,DWORD hDevice,PDIOCPARAMETERS pDiocParms)
 215 {
 216
 217         NDIS_STATUS                     Status;
 218         NDIS_STATUS                     nsErrorStatus;
 219         UINT                            to;
 220         DWORD                           TEvent;
 221
 222         TRACE_ENTER( "PacketClose" );
 223
 224         Open->BufSize=0;
 225
 226         to=Open->ReadTimeoutTimer;
 227         Open->ReadTimeoutTimer=0;
 228         if(to!=0){
 229                 _asm push esi;
 230                 _asm mov esi,to;
 231                 CancelReadTimeOut();
 232                 _asm pop esi;
 233         }
 234
 235         // Free the read event
 236         TEvent=Open->ReadEvent;
 237         _asm mov eax,TEvent;
 238         VxDCall(_VWIN32_CloseVxDHandle);
 239
 240         //close the adapter
 241         NdisCloseAdapter(&nsErrorStatus,Open->AdapterHandle);
 242         if ( nsErrorStatus == NDIS_STATUS_PENDING )
 243         {
 244                 while ( Open->Status == NDIS_STATUS_PENDING )
 245                         YieldExecution();
 246
 247                 if(Open->Status!=NDIS_STATUS_SUCCESS){
 248                         TRACE_LEAVE( "PacketClose" );
 249                         return NDIS_STATUS_FAILURE;
 250                 }
 251         }
 252         else
 253         {
 254                 PacketUnbindAdapterComplete( Open, nsErrorStatus );
 255                 if(nsErrorStatus!=NDIS_STATUS_SUCCESS){
 256                         TRACE_LEAVE( "PacketClose" );
 257                         return NDIS_STATUS_FAILURE;
 258                 }
 259         }
 260
 261         Status = Open->Status;
 262
 263         if(Open->Buffer!=NULL)NdisFreeMemory(Open->Buffer,Open->BufSize,0);
 264         Open->Buffer=NULL;
 265         if(Open->bpfprogram!=NULL)NdisFreeMemory(Open->bpfprogram,Open->bpfprogramlen,0);
 266
 267         //remove this adapter from the list of open adapters
 268         NdisAcquireSpinLock( &GlobalDeviceExtension->OpenSpinLock );
 269         RemoveEntryList(&(Open->ListElement));
 270         NdisReleaseSpinLock( &GlobalDeviceExtension->OpenSpinLock );
 271
 272         NdisFreeMemory( Open, sizeof( OPEN_INSTANCE ) ,  0 );
 273
 274         if(pDiocParms!=NULL)
 275                 *(DWORD *)(pDiocParms->lpcbBytesReturned) = 0;
 276
 277         TRACE_LEAVE( "PacketClose" );
 278         return Status;
 279
 280 }
 281
 282 /************************************************************
 283 Function used by NDIS to update the VXD when a new MAC driver
 284 is added
 285 ************************************************************/
 286 VOID NDIS_API PacketBindAdapter( OUT PNDIS_STATUS Status,
 287                                                  IN  NDIS_HANDLE  BindAdapterContext,
 288                                                  IN  PNDIS_STRING AdapterName,
 289                                                  IN  PVOID        SystemSpecific1,
 290                                                  IN  PVOID        SystemSpecific2 )
 291 {
 292         PDEVICE_EXTENSION       pde;
 293         POPEN_INSTANCE          oiNew;
 294         NDIS_STATUS                     nsErrorStatus, nsOpenStatus;
 295         UINT                    uiMedium;
 296         UINT                    i;
 297         PWRAPPER_PROTOCOL_BLOCK                         pWPBlock;
 298         PNDIS_PROTOCOL_CHARACTERISTICS  pNPChar;
 299         PADAPTER_NAME           AName;
 300         PWRAPPER_MAC_BLOCK      pWMBlock;
 301         PNDIS_MAC_CHARACTERISTICS         pNMChar;
 302     BYTE                *lpzName;
 303
 304
 305         TRACE_ENTER( "BindAdapter" );
 306         pde = GlobalDeviceExtension;
 307         /*Allocate an element that describe an adapter*/
 308         NdisAllocateMemory( (PVOID *)&AName, sizeof(ADAPTER_NAME), 0, -1 );
 309         if ( AName == NULL )
 310         {
 311                 *Status = NDIS_STATUS_RESOURCES;
 312                 return;
 313         }
 314
 315         NdisAllocateMemory( (PVOID *)&oiNew, sizeof( OPEN_INSTANCE ), 0, -1 );
 316         if ( oiNew == NULL )
 317         {
 318                 *Status = NDIS_STATUS_RESOURCES;
 319                 return;
 320         }
 321         NdisZeroMemory( (PVOID)oiNew, sizeof( OPEN_INSTANCE ) );
 322
 323         /*Save Binding Context*/
 324         oiNew->BindAdapterContext = BindAdapterContext;
 325
 326     /*Save the device handle*/
 327
 328     oiNew->hDevice = (DWORD) SystemSpecific1;
 329
 330         /*allocate a pool for the packet headers*/
 331
 332         NdisAllocatePacketPool( &nsErrorStatus,
 333                                                         &(oiNew->PacketPool),
 334                                                         TRANSMIT_PACKETS,
 335                                                         sizeof(PACKET_RESERVED) );
 336
 337         IF_TRACE_MSG( "PACKET_RESERVED_b :%lx",sizeof(PACKET_RESERVED));
 338         if ( nsErrorStatus != NDIS_STATUS_SUCCESS )
 339         {
 340                 IF_TRACE_MSG( "Failed to allocate packet pool AllocStatus=%x", nsErrorStatus );
 341                 NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) ,  0 );
 342                 *Status = NDIS_STATUS_RESOURCES;
 343                 TRACE_LEAVE( "BindAdapter" );
 344                 return;
 345         }
 346
 347
 348         /*allocate a pool for the packet data*/
 349
 350         NdisAllocateBufferPool( &nsErrorStatus,
 351                                                         &(oiNew->BufferPool),
 352                                                         TRANSMIT_PACKETS );
 353         if ( nsErrorStatus != NDIS_STATUS_SUCCESS )
 354         {
 355                 IF_TRACE_MSG( "Failed to allocate packet pool AllocStatus=%x", nsErrorStatus );
 356                 NdisFreePacketPool( oiNew->PacketPool );
 357                 NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) ,  0 );
 358                 *Status = NDIS_STATUS_RESOURCES;
 359                 TRACE_LEAVE( "BindAdapter" );
 360                 return;
 361         }
 362         NdisAllocateSpinLock( &(oiNew->ResetSpinLock) );
 363         InitializeListHead( &(oiNew->ResetIrpList) );
 364         NdisAllocateSpinLock( &(oiNew->RcvQSpinLock) );
 365         InitializeListHead( &(oiNew->RcvList) );
 366         NdisAllocateSpinLock( &(oiNew->RequestSpinLock) );
 367         InitializeListHead( &(oiNew->RequestList) );
 368
 369         for ( i=0;i<MAX_REQUESTS;i++ )
 370         {
 371                 InsertTailList( &(oiNew->RequestList), &(oiNew->Requests[i].Reserved.ListElement) );
 372         }
 373         oiNew->Status = NDIS_STATUS_PENDING;
 374         oiNew->BindAdapterContext = BindAdapterContext;
 375
 376         /*open the MAC driver calling NDIS*/
 377
 378         oiNew->hDevice=0;
 379         oiNew->tagProcess=0;
 380
 381         NdisOpenAdapter( &nsOpenStatus,
 382                                          &nsErrorStatus,
 383                                          &oiNew->AdapterHandle,
 384                                          &uiMedium,
 385                                          MediumArray,
 386                                          NUM_NDIS_MEDIA,
 387                                          pde->NdisProtocolHandle,
 388                                          oiNew,
 389                                          AdapterName,
 390                                          0,
 391                                          NULL );
 392         IF_TRACE_MSG( "Open Status                   : %lx", nsOpenStatus );
 393         IF_TRACE_MSG( "Error Status                  : %lx", nsErrorStatus );
 394         IF_TRACE_MSG( "Completion Status             : %lx", oiNew->Status );
 395         if ( nsOpenStatus == NDIS_STATUS_PENDING )
 396         {
 397                 while ( oiNew->Status == NDIS_STATUS_PENDING )
 398                         YieldExecution();
 399         }
 400         else
 401         {
 402                 PacketOpenAdapterComplete( oiNew, nsOpenStatus, nsErrorStatus );
 403         }
 404
 405         pWPBlock = ((PWRAPPER_OPEN_BLOCK)(oiNew->AdapterHandle))->ProtocolHandle;
 406         pNPChar  = &pWPBlock->ProtocolCharacteristics;
 407         IF_TRACE_MSG( "Protocol                      : %s",  pNPChar->Name.Buffer );
 408         IF_TRACE_MSG( "Protocol Handle               : %lx", pde->NdisProtocolHandle );
 409         IF_TRACE_MSG( "PWRAPPER_OPEN_BLOCK           : %lx", oiNew->AdapterHandle );
 410         IF_TRACE_MSG( "PWRAPPER_PROTOCOL_BLOCK       : %lx", pWPBlock );
 411         IF_TRACE_MSG( "NDIS_PROTOCOL_CHARACTERISTICS : %lx", pNPChar );
 412         IF_TRACE_MSG( "Name                          : %lx", &pNPChar->Name );
 413         IF_TRACE_MSG( "Adapter Name                  : %s",  AdapterName->Buffer );
 414         *Status = oiNew->Status;
 415
 416         if ( *Status != NDIS_STATUS_SUCCESS )
 417         {
 418                 NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) ,  0 );
 419                 IF_TRACE( "Bind Operation FAILED!" );
 420         }
 421         else
 422         {
 423                 AName->realnamestr.Length=AdapterName->Length;
 424                 AName->realnamestr.MaximumLength=AdapterName->MaximumLength;
 425                 AName->realnamestr.Buffer=AName->realname;
 426                 for(i=0;i<32;i++)AName->realname[i]=AdapterName->Buffer[i];
 427
 428                 pWMBlock = ((PWRAPPER_OPEN_BLOCK)(oiNew->AdapterHandle))->MacHandle;
 429                 pNMChar  = &pWMBlock->MacCharacteristics;
 430                 lpzName  = pNMChar->Name.Buffer;
 431                 for(i=0;i<32;i++)AName->devicename[i]=lpzName[i];
 432                 InsertTailList( &GlobalDeviceExtension->AdapterNames, &AName->ListElement);
 433
 434                 //close the adapter
 435                 NdisCloseAdapter(&nsErrorStatus,oiNew->AdapterHandle);
 436
 437                 if ( nsErrorStatus == NDIS_STATUS_PENDING )
 438                 {
 439                         while ( oiNew->Status == NDIS_STATUS_PENDING )
 440                                 YieldExecution();
 441                 }
 442                 else
 443                 {
 444                         PacketUnbindAdapterComplete( oiNew, nsErrorStatus );
 445                 }
 446                 *Status = oiNew->Status;
 447                 if ( *Status == NDIS_STATUS_SUCCESS )
 448                 {
 449                         //remove this adapter from the list of open adapters
 450                         RemoveEntryList(&(oiNew->ListElement));
 451                         //free the memory
 452                         NdisFreeMemory( oiNew, sizeof( OPEN_INSTANCE ) ,  0 );
 453                 }
 454                 else
 455                 {
 456                         IF_TRACE( "Close Operation FAILED!" );
 457                 }
 458
 459         }
 460
 461         TRACE_LEAVE( "BindAdapter" );
 462         return;
 463 }
 464
 465 /************************************************************
 466 Function called by NDIS to indicate the completion of a bind
 467 ************************************************************/
 468 VOID NDIS_API
 469 PacketOpenAdapterComplete(
 470    IN NDIS_HANDLE  ProtocolBindingContext,
 471    IN NDIS_STATUS  Status,
 472    IN NDIS_STATUS  OpenErrorStatus )
 473 {
 474         POPEN_INSTANCE  Open;
 475
 476         TRACE_ENTER( "BindAdapterComplete" );
 477         IF_TRACE_MSG2( "ErrorStatus=%x Status=%x", OpenErrorStatus, Status );
 478         Open = (POPEN_INSTANCE)ProtocolBindingContext;
 479         if ( Status == NDIS_STATUS_SUCCESS )
 480         {
 481                 /*Insert the just opened NIC in the list of initialized NICs*/
 482                 NdisAcquireSpinLock( &GlobalDeviceExtension->OpenSpinLock );
 483                 InsertHeadList( &GlobalDeviceExtension->OpenList, &Open->ListElement );
 484                 NdisReleaseSpinLock( &GlobalDeviceExtension->OpenSpinLock );
 485         }
 486         else
 487         {
 488                 /*free resources.*/
 489                 PacketFreeResources( Open );
 490                 return;
 491         }
 492         Open->Status = Status;
 493         /*complete the binding*/
 494         NdisCompleteBindAdapter( Open->BindAdapterContext, Status, OpenErrorStatus );
 495         TRACE_LEAVE( "BindAdapterComplete" );
 496         return;
 497 }
 498
 499 /************************************************************
 500 Start the unbind of a network driver from the protocol driver
 501 ************************************************************/
 502 VOID NDIS_API
 503 PacketUnbindAdapter( OUT PNDIS_STATUS   Status,
 504                                          IN  NDIS_HANDLE        ProtocolBindingContext,
 505                                          IN  NDIS_HANDLE        UnbindContext )
 506 {
 507         POPEN_INSTANCE  Open;
 508         NDIS_STATUS             nsCloseStatus;
 509
 510         TRACE_ENTER( "UnbindAdapter" );
 511
 512
 513         Open = (POPEN_INSTANCE)ProtocolBindingContext;
 514         Open->BindAdapterContext = UnbindContext;
 515         /*clean the pending requests*/
 516         PacketCleanUp( Status, Open );
 517         Open->Status = NDIS_STATUS_PENDING;
 518         /*Calls NDIS to close the selected adapter*/
 519
 520         NdisCloseAdapter( &nsCloseStatus, Open->AdapterHandle );
 521         if ( nsCloseStatus == NDIS_STATUS_PENDING )
 522         {
 523                 while ( Open->Status == NDIS_STATUS_PENDING )
 524                         YieldExecution();
 525         }
 526         else
 527         {
 528                 PacketUnbindAdapterComplete( Open, nsCloseStatus );
 529         }
 530         *Status = Open->Status;
 531         if ( *Status == NDIS_STATUS_SUCCESS )
 532         {
 533                 NdisFreeMemory( Open, sizeof( OPEN_INSTANCE ) ,  0 );
 534         }
 535         else
 536         {
 537                 IF_TRACE( "Unbind Operation FAILED!" );
 538         }
 539         TRACE_LEAVE( "CloseAdapter" );
 540
 541         return;
 542 }
 543
 544 /************************************************************
 545 Complete the unbind of a network driver from the protocol driver
 546 ************************************************************/
 547 VOID NDIS_API
 548 PacketUnbindAdapterComplete( IN NDIS_HANDLE ProtocolBindingContext,
 549                                                          IN NDIS_STATUS Status  )
 550 {
 551         POPEN_INSTANCE Open;
 552
 553         TRACE_ENTER( "UnbindAdapterComplete" );
 554         Open = (POPEN_INSTANCE)ProtocolBindingContext;
 555         if ( Status == NDIS_STATUS_SUCCESS )
 556         {
 557                 PacketFreeResources( Open );
 558         }
 559         Open->Status = Status;
 560
 561         TRACE_LEAVE( "UnbindAdapterComplete" );
 562         return;
 563 }
 564
 565 /************************************************************
 566 free the resources allocated by an adapter
 567 ************************************************************/
 568 VOID PacketFreeResources( POPEN_INSTANCE Open )
 569 {
 570         NdisFreeSpinLock( &Open->RequestSpinLock );
 571         NdisFreeSpinLock( &Open->RcvQSpinLock );
 572         NdisFreeSpinLock( &Open->ResetSpinLock );
 573         NdisFreeBufferPool( Open->BufferPool );
 574         NdisFreePacketPool( Open->PacketPool );
 575 }
 576
 577 /************************************************************
 578 Function that frees the pending requests
 579 ************************************************************/
 580 VOID
 581 PacketCleanUp(  PNDIS_STATUS    Status,
 582                                 POPEN_INSTANCE  Open )
 583 {
 584         PLIST_ENTRY                     PacketListEntry;
 585         PNDIS_PACKET    pPacket;
 586         PPACKET_RESERVED  Reserved;
 587
 588         TRACE_ENTER( "Cleanup" );
 589         /*clean all the pending requests*/
 590         NdisAcquireSpinLock( &(Open->RcvQSpinLock) );
 591         while( (PacketListEntry = PacketRemoveHeadList( &(Open->RcvList) )) != NULL )
 592         {
 593                 IF_VERY_LOUD( "CleanUp - Completing read" );
 594                 Reserved = CONTAINING_RECORD( PacketListEntry, PACKET_RESERVED, ListElement );
 595                 pPacket  = CONTAINING_RECORD( Reserved, NDIS_PACKET, ProtocolReserved );
 596                 /*emulate the end of a transfer to wake the processes that
 597                 are waiting on a request */
 598                 PacketTransferDataComplete( Open, pPacket, NDIS_STATUS_SUCCESS, 0 );
 599         }
 600         NdisReleaseSpinLock( &(Open->RcvQSpinLock) );
 601         TRACE_LEAVE( "Cleanup" );
 602         return;
 603 }
 604
 605 /************************************************************
 606 Start the reset of a instance of the driver
 607 ************************************************************/
 608 VOID
 609 PacketReset( PNDIS_STATUS       pStatus,
 610                          POPEN_INSTANCE pOpen )
 611 {
 612         PLIST_ENTRY     ResetListEntry;
 613
 614         TRACE_ENTER( "PacketReset" );
 615
 616         NdisAcquireSpinLock( &pOpen->RequestSpinLock );
 617         ResetListEntry = PacketRemoveHeadList( &pOpen->RequestList );
 618         NdisReleaseSpinLock( &pOpen->RequestSpinLock );
 619         if ( ResetListEntry == NULL )
 620         {
 621                 *pStatus = NDIS_STATUS_RESOURCES;
 622                 TRACE_LEAVE( "PacketReset" );
 623                 return;
 624         }
 625         NdisAcquireSpinLock( &pOpen->ResetSpinLock );
 626         InsertTailList( &pOpen->ResetIrpList, ResetListEntry );
 627         NdisReleaseSpinLock( &pOpen->ResetSpinLock );
 628
 629         /*Call NDIS to reset the adapter*/
 630         NdisReset( pStatus, pOpen->AdapterHandle );
 631         if ( *pStatus != NDIS_STATUS_PENDING )
 632         {
 633                 /*synchronous reset of the adapter*/
 634                 PacketResetComplete( pOpen, *pStatus );
 635         }
 636         TRACE_LEAVE( "PacketReset" );
 637         return;
 638 }
 639
 640 /************************************************************
 641 complete the reset of a instance of the driver
 642 ************************************************************/
 643 VOID NDIS_API
 644 PacketResetComplete( IN NDIS_HANDLE     ProtocolBindingContext,
 645                                          IN NDIS_STATUS Status   )
 646 {
 647         POPEN_INSTANCE          Open;
 648         PLIST_ENTRY                     ResetListEntry;
 649
 650         TRACE_ENTER( "PacketResetComplete" );
 651         Open = (POPEN_INSTANCE)ProtocolBindingContext;
 652
 653         NdisAcquireSpinLock( &Open->ResetSpinLock );
 654         ResetListEntry = PacketRemoveHeadList( &Open->ResetIrpList );
 655         NdisReleaseSpinLock( &Open->ResetSpinLock );
 656         if ( ResetListEntry == NULL )
 657         {
 658                 IF_VERY_LOUD( "Reset List Empty Error" );
 659                 TRACE_LEAVE( "PacketResetComplete" );
 660                 return;
 661         }
 662
 663         NdisAcquireSpinLock( &Open->RequestSpinLock );
 664         InsertTailList( &Open->RequestList, ResetListEntry );
 665         NdisReleaseSpinLock( &Open->RequestSpinLock );
 666         TRACE_LEAVE( "PacketResetComplete" );
 667         return;
 668 }