[BOOTDATA]
[reactos.git] / reactos / base / services / dhcpcsvc / dhcpcsvc.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: lib/dhcpcapi/dhcpcapi.c
5 * PURPOSE: Client API for DHCP
6 * COPYRIGHT: Copyright 2005 Art Yerkes <ayerkes@speakeasy.net>
7 */
8
9 #include <rosdhcp.h>
10 #include <winsvc.h>
11
12 #define NDEBUG
13 #include <debug.h>
14
15 static WCHAR ServiceName[] = L"DHCP";
16
17 SERVICE_STATUS_HANDLE ServiceStatusHandle = 0;
18 SERVICE_STATUS ServiceStatus;
19
20 static HANDLE PipeHandle = INVALID_HANDLE_VALUE;
21
22 DWORD APIENTRY
23 DhcpCApiInitialize(LPDWORD Version)
24 {
25 DWORD PipeMode;
26
27 /* Wait for the pipe to be available */
28 if (!WaitNamedPipeW(DHCP_PIPE_NAME, NMPWAIT_USE_DEFAULT_WAIT))
29 {
30 /* No good, we failed */
31 return GetLastError();
32 }
33
34 /* It's available, let's try to open it */
35 PipeHandle = CreateFileW(DHCP_PIPE_NAME,
36 GENERIC_READ | GENERIC_WRITE,
37 FILE_SHARE_READ | FILE_SHARE_WRITE,
38 NULL,
39 OPEN_EXISTING,
40 0,
41 NULL);
42
43 /* Check if we succeeded in opening the pipe */
44 if (PipeHandle == INVALID_HANDLE_VALUE)
45 {
46 /* We didn't */
47 return GetLastError();
48 }
49
50 /* Change the pipe into message mode */
51 PipeMode = PIPE_READMODE_MESSAGE;
52 if (!SetNamedPipeHandleState(PipeHandle, &PipeMode, NULL, NULL))
53 {
54 /* Mode change failed */
55 CloseHandle(PipeHandle);
56 PipeHandle = INVALID_HANDLE_VALUE;
57 return GetLastError();
58 }
59 else
60 {
61 /* We're good to go */
62 *Version = 2;
63 return NO_ERROR;
64 }
65 }
66
67 VOID APIENTRY
68 DhcpCApiCleanup(VOID)
69 {
70 CloseHandle(PipeHandle);
71 PipeHandle = INVALID_HANDLE_VALUE;
72 }
73
74 DWORD APIENTRY
75 DhcpQueryHWInfo(DWORD AdapterIndex,
76 PDWORD MediaType,
77 PDWORD Mtu,
78 PDWORD Speed)
79 {
80 COMM_DHCP_REQ Req;
81 COMM_DHCP_REPLY Reply;
82 DWORD BytesRead;
83 BOOL Result;
84
85 ASSERT(PipeHandle != INVALID_HANDLE_VALUE);
86
87 Req.Type = DhcpReqQueryHWInfo;
88 Req.AdapterIndex = AdapterIndex;
89
90 Result = TransactNamedPipe(PipeHandle,
91 &Req, sizeof(Req),
92 &Reply, sizeof(Reply),
93 &BytesRead, NULL);
94 if (!Result)
95 {
96 /* Pipe transaction failed */
97 return 0;
98 }
99
100 if (Reply.Reply == 0)
101 return 0;
102
103 *MediaType = Reply.QueryHWInfo.MediaType;
104 *Mtu = Reply.QueryHWInfo.Mtu;
105 *Speed = Reply.QueryHWInfo.Speed;
106 return 1;
107 }
108
109 DWORD APIENTRY
110 DhcpLeaseIpAddress(DWORD AdapterIndex)
111 {
112 COMM_DHCP_REQ Req;
113 COMM_DHCP_REPLY Reply;
114 DWORD BytesRead;
115 BOOL Result;
116
117 ASSERT(PipeHandle != INVALID_HANDLE_VALUE);
118
119 Req.Type = DhcpReqLeaseIpAddress;
120 Req.AdapterIndex = AdapterIndex;
121
122 Result = TransactNamedPipe(PipeHandle,
123 &Req, sizeof(Req),
124 &Reply, sizeof(Reply),
125 &BytesRead, NULL);
126 if (!Result)
127 {
128 /* Pipe transaction failed */
129 return 0;
130 }
131
132 return Reply.Reply;
133 }
134
135 DWORD APIENTRY
136 DhcpReleaseIpAddressLease(DWORD AdapterIndex)
137 {
138 COMM_DHCP_REQ Req;
139 COMM_DHCP_REPLY Reply;
140 DWORD BytesRead;
141 BOOL Result;
142
143 ASSERT(PipeHandle != INVALID_HANDLE_VALUE);
144
145 Req.Type = DhcpReqReleaseIpAddress;
146 Req.AdapterIndex = AdapterIndex;
147
148 Result = TransactNamedPipe(PipeHandle,
149 &Req, sizeof(Req),
150 &Reply, sizeof(Reply),
151 &BytesRead, NULL);
152 if (!Result)
153 {
154 /* Pipe transaction failed */
155 return 0;
156 }
157
158 return Reply.Reply;
159 }
160
161 DWORD APIENTRY
162 DhcpRenewIpAddressLease(DWORD AdapterIndex)
163 {
164 COMM_DHCP_REQ Req;
165 COMM_DHCP_REPLY Reply;
166 DWORD BytesRead;
167 BOOL Result;
168
169 ASSERT(PipeHandle != INVALID_HANDLE_VALUE);
170
171 Req.Type = DhcpReqRenewIpAddress;
172 Req.AdapterIndex = AdapterIndex;
173
174 Result = TransactNamedPipe(PipeHandle,
175 &Req, sizeof(Req),
176 &Reply, sizeof(Reply),
177 &BytesRead, NULL);
178 if (!Result)
179 {
180 /* Pipe transaction failed */
181 return 0;
182 }
183
184 return Reply.Reply;
185 }
186
187 DWORD APIENTRY
188 DhcpStaticRefreshParams(DWORD AdapterIndex,
189 DWORD Address,
190 DWORD Netmask)
191 {
192 COMM_DHCP_REQ Req;
193 COMM_DHCP_REPLY Reply;
194 DWORD BytesRead;
195 BOOL Result;
196
197 ASSERT(PipeHandle != INVALID_HANDLE_VALUE);
198
199 Req.Type = DhcpReqStaticRefreshParams;
200 Req.AdapterIndex = AdapterIndex;
201 Req.Body.StaticRefreshParams.IPAddress = Address;
202 Req.Body.StaticRefreshParams.Netmask = Netmask;
203
204 Result = TransactNamedPipe(PipeHandle,
205 &Req, sizeof(Req),
206 &Reply, sizeof(Reply),
207 &BytesRead, NULL);
208 if (!Result)
209 {
210 /* Pipe transaction failed */
211 return 0;
212 }
213
214 return Reply.Reply;
215 }
216
217 /*!
218 * Set new TCP/IP parameters and notify DHCP client service of this
219 *
220 * \param[in] ServerName
221 * NULL for local machine
222 *
223 * \param[in] AdapterName
224 * IPHLPAPI name of adapter to change
225 *
226 * \param[in] NewIpAddress
227 * TRUE if IP address changes
228 *
229 * \param[in] IpAddress
230 * New IP address (network byte order)
231 *
232 * \param[in] SubnetMask
233 * New subnet mask (network byte order)
234 *
235 * \param[in] DhcpAction
236 * 0 - don't modify
237 * 1 - enable DHCP
238 * 2 - disable DHCP
239 *
240 * \return non-zero on success
241 *
242 * \remarks Undocumented by Microsoft
243 */
244 DWORD APIENTRY
245 DhcpNotifyConfigChange(LPWSTR ServerName,
246 LPWSTR AdapterName,
247 BOOL NewIpAddress,
248 DWORD IpIndex,
249 DWORD IpAddress,
250 DWORD SubnetMask,
251 INT DhcpAction)
252 {
253 DPRINT1("DHCPCSVC: DhcpNotifyConfigChange not implemented yet\n");
254 return 0;
255 }
256
257 /*!
258 * Get DHCP info for an adapter
259 *
260 * \param[in] AdapterIndex
261 * Index of the adapter (iphlpapi-style) for which info is
262 * requested
263 *
264 * \param[out] DhcpEnabled
265 * Returns whether DHCP is enabled for the adapter
266 *
267 * \param[out] DhcpServer
268 * Returns DHCP server IP address (255.255.255.255 if no
269 * server reached yet), in network byte order
270 *
271 * \param[out] LeaseObtained
272 * Returns time at which the lease was obtained
273 *
274 * \param[out] LeaseExpires
275 * Returns time at which the lease will expire
276 *
277 * \return non-zero on success
278 *
279 * \remarks This is a ReactOS-only routine
280 */
281 DWORD APIENTRY
282 DhcpRosGetAdapterInfo(DWORD AdapterIndex,
283 PBOOL DhcpEnabled,
284 PDWORD DhcpServer,
285 time_t* LeaseObtained,
286 time_t* LeaseExpires)
287 {
288 COMM_DHCP_REQ Req;
289 COMM_DHCP_REPLY Reply;
290 DWORD BytesRead;
291 BOOL Result;
292
293 ASSERT(PipeHandle != INVALID_HANDLE_VALUE);
294
295 Req.Type = DhcpReqGetAdapterInfo;
296 Req.AdapterIndex = AdapterIndex;
297
298 Result = TransactNamedPipe(PipeHandle,
299 &Req, sizeof(Req),
300 &Reply, sizeof(Reply),
301 &BytesRead, NULL);
302
303 if (Result && Reply.Reply != 0)
304 *DhcpEnabled = Reply.GetAdapterInfo.DhcpEnabled;
305 else
306 *DhcpEnabled = FALSE;
307
308 if (*DhcpEnabled)
309 {
310 *DhcpServer = Reply.GetAdapterInfo.DhcpServer;
311 *LeaseObtained = Reply.GetAdapterInfo.LeaseObtained;
312 *LeaseExpires = Reply.GetAdapterInfo.LeaseExpires;
313 }
314 else
315 {
316 *DhcpServer = INADDR_NONE;
317 *LeaseObtained = 0;
318 *LeaseExpires = 0;
319 }
320
321 return Reply.Reply;
322 }
323
324
325 static VOID
326 UpdateServiceStatus(DWORD dwState)
327 {
328 ServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
329 ServiceStatus.dwCurrentState = dwState;
330
331 ServiceStatus.dwControlsAccepted = 0;
332
333 ServiceStatus.dwWin32ExitCode = 0;
334 ServiceStatus.dwServiceSpecificExitCode = 0;
335 ServiceStatus.dwCheckPoint = 0;
336
337 if (dwState == SERVICE_START_PENDING ||
338 dwState == SERVICE_STOP_PENDING ||
339 dwState == SERVICE_PAUSE_PENDING ||
340 dwState == SERVICE_CONTINUE_PENDING)
341 ServiceStatus.dwWaitHint = 10000;
342 else
343 ServiceStatus.dwWaitHint = 0;
344
345 SetServiceStatus(ServiceStatusHandle,
346 &ServiceStatus);
347 }
348
349 static DWORD WINAPI
350 ServiceControlHandler(DWORD dwControl,
351 DWORD dwEventType,
352 LPVOID lpEventData,
353 LPVOID lpContext)
354 {
355 switch (dwControl)
356 {
357 case SERVICE_CONTROL_STOP:
358 UpdateServiceStatus(SERVICE_STOP_PENDING);
359 UpdateServiceStatus(SERVICE_STOPPED);
360 return ERROR_SUCCESS;
361
362 case SERVICE_CONTROL_PAUSE:
363 UpdateServiceStatus(SERVICE_PAUSED);
364 return ERROR_SUCCESS;
365
366 case SERVICE_CONTROL_CONTINUE:
367 UpdateServiceStatus(SERVICE_START_PENDING);
368 UpdateServiceStatus(SERVICE_RUNNING);
369 return ERROR_SUCCESS;
370
371 case SERVICE_CONTROL_INTERROGATE:
372 SetServiceStatus(ServiceStatusHandle,
373 &ServiceStatus);
374 return ERROR_SUCCESS;
375
376 case SERVICE_CONTROL_SHUTDOWN:
377 UpdateServiceStatus(SERVICE_STOP_PENDING);
378 UpdateServiceStatus(SERVICE_STOPPED);
379 return ERROR_SUCCESS;
380
381 default :
382 return ERROR_CALL_NOT_IMPLEMENTED;
383 }
384 }
385
386 VOID WINAPI
387 ServiceMain(DWORD argc, LPWSTR* argv)
388 {
389 ServiceStatusHandle = RegisterServiceCtrlHandlerExW(ServiceName,
390 ServiceControlHandler,
391 NULL);
392 if (!ServiceStatusHandle)
393 {
394 DPRINT1("DHCPCSVC: Unable to register service control handler (%lx)\n", GetLastError());
395 return;
396 }
397
398 UpdateServiceStatus(SERVICE_START_PENDING);
399
400 if (!init_client())
401 {
402 DPRINT1("DHCPCSVC: init_client() failed!\n");
403 UpdateServiceStatus(SERVICE_STOPPED);
404 return;
405 }
406
407 DH_DbgPrint(MID_TRACE,("DHCP Service Started\n"));
408
409 UpdateServiceStatus(SERVICE_RUNNING);
410
411 DH_DbgPrint(MID_TRACE,("Going into dispatch()\n"));
412 DH_DbgPrint(MID_TRACE,("DHCPCSVC: DHCP service is starting up\n"));
413
414 dispatch();
415
416 DH_DbgPrint(MID_TRACE,("DHCPCSVC: DHCP service is shutting down\n"));
417 stop_client();
418
419 UpdateServiceStatus(SERVICE_STOPPED);
420 }
421
422 BOOL WINAPI
423 DllMain(HINSTANCE hinstDLL,
424 DWORD fdwReason,
425 LPVOID lpvReserved)
426 {
427 switch (fdwReason)
428 {
429 case DLL_PROCESS_ATTACH:
430 DisableThreadLibraryCalls(hinstDLL);
431 break;
432
433 case DLL_PROCESS_DETACH:
434 break;
435 }
436
437 return TRUE;
438 }
439
440 /* EOF */