reactos/base/services/dhcpcsvc/dhcp/api.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             subsys/system/dhcp/api.c
   5  * PURPOSE:          DHCP client api handlers
   6  * PROGRAMMER:       arty
   7  */
   8
   9 #include <rosdhcp.h>
  10
  11 #define NDEBUG
  12 #include <reactos/debug.h>
  13
  14 static CRITICAL_SECTION ApiCriticalSection;
  15
  16 extern HANDLE AdapterStateChangedEvent;
  17
  18 VOID ApiInit() {
  19     InitializeCriticalSection( &ApiCriticalSection );
  20 }
  21
  22 VOID ApiLock() {
  23     EnterCriticalSection( &ApiCriticalSection );
  24 }
  25
  26 VOID ApiUnlock() {
  27     LeaveCriticalSection( &ApiCriticalSection );
  28 }
  29
  30 VOID ApiFree() {
  31     DeleteCriticalSection( &ApiCriticalSection );
  32 }
  33
  34 /* This represents the service portion of the DHCP client API */
  35
  36 DWORD DSLeaseIpAddress( PipeSendFunc Send, COMM_DHCP_REQ *Req ) {
  37     COMM_DHCP_REPLY Reply;
  38     PDHCP_ADAPTER Adapter;
  39     struct protocol* proto;
  40
  41     ApiLock();
  42
  43     Adapter = AdapterFindIndex( Req->AdapterIndex );
  44
  45     Reply.Reply = Adapter ? 1 : 0;
  46
  47     if( Adapter ) {
  48         proto = find_protocol_by_adapter( &Adapter->DhclientInfo );
  49         if (proto)
  50             remove_protocol(proto);
  51
  52         add_protocol( Adapter->DhclientInfo.name,
  53                       Adapter->DhclientInfo.rfdesc, got_one,
  54                       &Adapter->DhclientInfo );
  55
  56         Adapter->DhclientInfo.client->state = S_INIT;
  57         state_reboot(&Adapter->DhclientInfo);
  58
  59         if (AdapterStateChangedEvent != NULL)
  60             SetEvent(AdapterStateChangedEvent);
  61     }
  62
  63     ApiUnlock();
  64
  65     return Send( &Reply );
  66 }
  67
  68 DWORD DSQueryHWInfo( PipeSendFunc Send, COMM_DHCP_REQ *Req ) {
  69     COMM_DHCP_REPLY Reply;
  70     PDHCP_ADAPTER Adapter;
  71
  72     ApiLock();
  73
  74     Adapter = AdapterFindIndex( Req->AdapterIndex );
  75
  76     Reply.Reply = Adapter ? 1 : 0;
  77
  78     if (Adapter) {
  79         Reply.QueryHWInfo.AdapterIndex = Req->AdapterIndex;
  80         Reply.QueryHWInfo.MediaType = Adapter->IfMib.dwType;
  81         Reply.QueryHWInfo.Mtu = Adapter->IfMib.dwMtu;
  82         Reply.QueryHWInfo.Speed = Adapter->IfMib.dwSpeed;
  83     }
  84
  85     ApiUnlock();
  86
  87     return Send( &Reply );
  88 }
  89
  90 DWORD DSReleaseIpAddressLease( PipeSendFunc Send, COMM_DHCP_REQ *Req ) {
  91     COMM_DHCP_REPLY Reply;
  92     PDHCP_ADAPTER Adapter;
  93     struct protocol* proto;
  94
  95     ApiLock();
  96
  97     Adapter = AdapterFindIndex( Req->AdapterIndex );
  98
  99     Reply.Reply = Adapter ? 1 : 0;
 100
 101     if( Adapter ) {
 102         if (Adapter->NteContext)
 103         {
 104             DeleteIPAddress( Adapter->NteContext );
 105             Adapter->NteContext = 0;
 106         }
 107         if (Adapter->RouterMib.dwForwardNextHop)
 108         {
 109             DeleteIpForwardEntry( &Adapter->RouterMib );
 110             Adapter->RouterMib.dwForwardNextHop = 0;
 111         }
 112
 113         proto = find_protocol_by_adapter( &Adapter->DhclientInfo );
 114         if (proto)
 115            remove_protocol(proto);
 116
 117         Adapter->DhclientInfo.client->active = NULL;
 118         Adapter->DhclientInfo.client->state = S_INIT;
 119
 120         if (AdapterStateChangedEvent != NULL)
 121             SetEvent(AdapterStateChangedEvent);
 122     }
 123
 124     ApiUnlock();
 125
 126     return Send( &Reply );
 127 }
 128
 129 DWORD DSRenewIpAddressLease( PipeSendFunc Send, COMM_DHCP_REQ *Req ) {
 130     COMM_DHCP_REPLY Reply;
 131     PDHCP_ADAPTER Adapter;
 132     struct protocol* proto;
 133
 134     ApiLock();
 135
 136     Adapter = AdapterFindIndex( Req->AdapterIndex );
 137
 138     if( !Adapter || Adapter->DhclientState.state == S_STATIC ) {
 139         Reply.Reply = 0;
 140         ApiUnlock();
 141         return Send( &Reply );
 142     }
 143
 144     Reply.Reply = 1;
 145
 146     proto = find_protocol_by_adapter( &Adapter->DhclientInfo );
 147     if (proto)
 148         remove_protocol(proto);
 149
 150     add_protocol( Adapter->DhclientInfo.name,
 151                   Adapter->DhclientInfo.rfdesc, got_one,
 152                   &Adapter->DhclientInfo );
 153
 154     Adapter->DhclientInfo.client->state = S_INIT;
 155     state_reboot(&Adapter->DhclientInfo);
 156
 157     if (AdapterStateChangedEvent != NULL)
 158         SetEvent(AdapterStateChangedEvent);
 159
 160     ApiUnlock();
 161
 162     return Send( &Reply );
 163 }
 164
 165 DWORD DSStaticRefreshParams( PipeSendFunc Send, COMM_DHCP_REQ *Req ) {
 166     NTSTATUS Status;
 167     COMM_DHCP_REPLY Reply;
 168     PDHCP_ADAPTER Adapter;
 169     struct protocol* proto;
 170
 171     ApiLock();
 172
 173     Adapter = AdapterFindIndex( Req->AdapterIndex );
 174
 175     Reply.Reply = Adapter ? 1 : 0;
 176
 177     if( Adapter ) {
 178         if (Adapter->NteContext)
 179         {
 180             DeleteIPAddress( Adapter->NteContext );
 181             Adapter->NteContext = 0;
 182         }
 183         if (Adapter->RouterMib.dwForwardNextHop)
 184         {
 185             DeleteIpForwardEntry( &Adapter->RouterMib );
 186             Adapter->RouterMib.dwForwardNextHop = 0;
 187         }
 188
 189         Adapter->DhclientState.state = S_STATIC;
 190         proto = find_protocol_by_adapter( &Adapter->DhclientInfo );
 191         if (proto)
 192             remove_protocol(proto);
 193         Status = AddIPAddress( Req->Body.StaticRefreshParams.IPAddress,
 194                                Req->Body.StaticRefreshParams.Netmask,
 195                                Req->AdapterIndex,
 196                                &Adapter->NteContext,
 197                                &Adapter->NteInstance );
 198         Reply.Reply = NT_SUCCESS(Status);
 199
 200         if (AdapterStateChangedEvent != NULL)
 201             SetEvent(AdapterStateChangedEvent);
 202     }
 203
 204     ApiUnlock();
 205
 206     return Send( &Reply );
 207 }
 208
 209 DWORD DSGetAdapterInfo( PipeSendFunc Send, COMM_DHCP_REQ *Req ) {
 210     COMM_DHCP_REPLY Reply;
 211     PDHCP_ADAPTER Adapter;
 212
 213     ApiLock();
 214
 215     Adapter = AdapterFindIndex( Req->AdapterIndex );
 216
 217     Reply.Reply = Adapter ? 1 : 0;
 218
 219     if( Adapter ) {
 220         Reply.GetAdapterInfo.DhcpEnabled = (S_STATIC != Adapter->DhclientState.state);
 221         if (S_BOUND == Adapter->DhclientState.state) {
 222             if (sizeof(Reply.GetAdapterInfo.DhcpServer) ==
 223                 Adapter->DhclientState.active->serveraddress.len) {
 224                 memcpy(&Reply.GetAdapterInfo.DhcpServer,
 225                        Adapter->DhclientState.active->serveraddress.iabuf,
 226                        Adapter->DhclientState.active->serveraddress.len);
 227             } else {
 228                 DPRINT1("Unexpected server address len %d\n",
 229                         Adapter->DhclientState.active->serveraddress.len);
 230                 Reply.GetAdapterInfo.DhcpServer = htonl(INADDR_NONE);
 231             }
 232             Reply.GetAdapterInfo.LeaseObtained = Adapter->DhclientState.active->obtained;
 233             Reply.GetAdapterInfo.LeaseExpires = Adapter->DhclientState.active->expiry;
 234         } else {
 235             Reply.GetAdapterInfo.DhcpServer = htonl(INADDR_NONE);
 236             Reply.GetAdapterInfo.LeaseObtained = 0;
 237             Reply.GetAdapterInfo.LeaseExpires = 0;
 238         }
 239     }
 240
 241     ApiUnlock();
 242
 243     return Send( &Reply );
 244 }