[CMAKE]: Make cross-build work on all systems. RosBE Already is nice and adds itself...
[reactos.git] / lib / dnslib / sablob.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS DNS Shared Library
4 * FILE: lib/dnslib/sablob.c
5 * PURPOSE: Functions for the Saved Answer Blob Implementation
6 */
7
8 /* INCLUDES ******************************************************************/
9 #include "precomp.h"
10
11 /* DATA **********************************************************************/
12
13 /* FUNCTIONS *****************************************************************/
14
15 PVOID
16 WINAPI
17 FlatBuf_Arg_ReserveAlignPointer(IN PVOID Position,
18 IN PSIZE_T FreeSize,
19 IN SIZE_T Size)
20 {
21 /* Just a little helper that we use */
22 return FlatBuf_Arg_Reserve(Position, FreeSize, Size, sizeof(PVOID));
23 }
24
25 PDNS_BLOB
26 WINAPI
27 SaBlob_Create(IN ULONG Count)
28 {
29 PDNS_BLOB Blob;
30 PDNS_ARRAY DnsAddrArray;
31
32 /* Allocate the blob */
33 Blob = Dns_AllocZero(sizeof(DNS_BLOB));
34 if (Blob)
35 {
36 /* Check if it'll hold any addresses */
37 if (Count)
38 {
39 /* Create the DNS Address Array */
40 DnsAddrArray = DnsAddrArray_Create(Count);
41 if (!DnsAddrArray)
42 {
43 /* Failure, free the blob */
44 SaBlob_Free(Blob);
45 SetLastError(ERROR_OUTOFMEMORY);
46 }
47 else
48 {
49 /* Link it with the blob */
50 Blob->DnsAddrArray = DnsAddrArray;
51 }
52 }
53 }
54
55 /* Return the blob */
56 return Blob;
57 }
58
59 PDNS_BLOB
60 WINAPI
61 SaBlob_CreateFromIp4(IN LPWSTR Name,
62 IN ULONG Count,
63 IN PIN_ADDR AddressArray)
64 {
65 PDNS_BLOB Blob;
66 LPWSTR NameCopy;
67 ULONG i;
68
69 /* Create the blob */
70 Blob = SaBlob_Create(Count);
71 if (!Blob) goto Quickie;
72
73 /* If we have a name */
74 if (Name)
75 {
76 /* Create a copy of it */
77 NameCopy = Dns_CreateStringCopy_W(Name);
78 if (!NameCopy) goto Quickie;
79
80 /* Save the pointer to the name */
81 Blob->Name = NameCopy;
82 }
83
84 /* Loop all the addresses */
85 for (i = 0; i < Count; i++)
86 {
87 /* Add an entry for this address */
88 DnsAddrArray_AddIp4(Blob->DnsAddrArray, AddressArray[i], IpV4Address);
89 }
90
91 /* Return the blob */
92 return Blob;
93
94 Quickie:
95 /* Free the blob, set error and fail */
96 SaBlob_Free(Blob);
97 SetLastError(ERROR_OUTOFMEMORY);
98 return NULL;
99 }
100
101 VOID
102 WINAPI
103 SaBlob_Free(IN PDNS_BLOB Blob)
104 {
105 /* Make sure we got a blob */
106 if (Blob)
107 {
108 /* Free the name */
109 Dns_Free(Blob->Name);
110
111 /* Loop the aliases */
112 while (Blob->AliasCount)
113 {
114 /* Free the alias */
115 Dns_Free(Blob->Aliases[Blob->AliasCount]);
116
117 /* Decrease number of aliases */
118 Blob->AliasCount--;
119 }
120
121 /* Free the DNS Address Array */
122 DnsAddrArray_Free(Blob->DnsAddrArray);
123
124 /* Free the blob itself */
125 Dns_Free(Blob);
126 }
127 }
128
129 PHOSTENT
130 WINAPI
131 SaBlob_CreateHostent(IN OUT PULONG_PTR BufferPosition,
132 IN OUT PSIZE_T FreeBufferSpace,
133 IN OUT PSIZE_T HostEntrySize,
134 IN PDNS_BLOB Blob,
135 IN DWORD StringType,
136 IN BOOLEAN Relative,
137 IN BOOLEAN BufferAllocated)
138 {
139 PDNS_ARRAY DnsAddrArray = Blob->DnsAddrArray;
140 ULONG AliasCount = Blob->AliasCount;
141 WORD AddressFamily = AF_UNSPEC;
142 ULONG AddressCount = 0, AddressSize = 0, TotalSize, NamePointerSize;
143 ULONG AliasPointerSize;
144 PDNS_FAMILY_INFO FamilyInfo = NULL;
145 ULONG StringLength = 0;
146 ULONG i;
147 ULONG HostentSize = 0;
148 PHOSTENT Hostent = NULL;
149 ULONG_PTR HostentPtr;
150 PVOID CurrentAddress;
151
152 /* Check if we actually have any addresses */
153 if (DnsAddrArray)
154 {
155 /* Get the address family */
156 AddressFamily = DnsAddrArray->Addresses[0].AddressFamily;
157
158 /* Get family information */
159 FamilyInfo = FamilyInfo_GetForFamily(AddressFamily);
160
161 /* Save the current address count and their size */
162 AddressCount = DnsAddrArray->UsedAddresses;
163 AddressSize = FamilyInfo->AddressSize;
164 }
165
166 /* Calculate total size for all the addresses, and their pointers */
167 TotalSize = AddressSize * AddressCount;
168 NamePointerSize = AddressCount * sizeof(PVOID) + sizeof(PVOID);
169
170 /* Check if we have a name */
171 if (Blob->Name)
172 {
173 /* Find out the size we'll need for a copy */
174 StringLength = (Dns_GetBufferLengthForStringCopy(Blob->Name,
175 0,
176 UnicodeString,
177 StringType) + 1) & ~1;
178 }
179
180 /* Now do the same for the aliases */
181 for (i = AliasCount; i; i--)
182 {
183 /* Find out the size we'll need for a copy */
184 HostentSize += (Dns_GetBufferLengthForStringCopy(Blob->Aliases[i],
185 0,
186 UnicodeString,
187 StringType) + 1) & ~1;
188 }
189
190 /* Find out how much the pointers will take */
191 AliasPointerSize = AliasCount * sizeof(PVOID) + sizeof(PVOID);
192
193 /* Calculate Hostent Size */
194 HostentSize += TotalSize +
195 NamePointerSize +
196 AliasPointerSize +
197 StringLength +
198 sizeof(HOSTENT);
199
200 /* Check if we already have a buffer */
201 if (!BufferAllocated)
202 {
203 /* We don't, allocate space ourselves */
204 HostentPtr = (ULONG_PTR)Dns_AllocZero(HostentSize);
205 }
206 else
207 {
208 /* We do, so allocate space in the buffer */
209 HostentPtr = (ULONG_PTR)FlatBuf_Arg_ReserveAlignPointer(BufferPosition,
210 FreeBufferSpace,
211 HostentSize);
212 }
213
214 /* Make sure we got space */
215 if (HostentPtr)
216 {
217 /* Initialize it */
218 Hostent = Hostent_Init((PVOID)&HostentPtr,
219 AddressFamily,
220 AddressSize,
221 AddressCount,
222 AliasCount);
223 }
224
225 /* Loop the addresses */
226 for (i = 0; i < AddressCount; i++)
227 {
228 /* Get the pointer of the current address */
229 CurrentAddress = (PVOID)((ULONG_PTR)&DnsAddrArray->Addresses[i] +
230 FamilyInfo->AddressOffset);
231
232 /* Write the pointer */
233 Hostent->h_addr_list[i] = (PCHAR)HostentPtr;
234
235 /* Copy the address */
236 RtlCopyMemory((PVOID)HostentPtr, CurrentAddress, AddressSize);
237
238 /* Advance the buffer */
239 HostentPtr += AddressSize;
240 }
241
242 /* Check if we have a name */
243 if (Blob->Name)
244 {
245 /* Align our current position */
246 HostentPtr += 1 & ~1;
247
248 /* Save our name here */
249 Hostent->h_name = (LPSTR)HostentPtr;
250
251 /* Now copy it in the blob */
252 HostentPtr += Dns_StringCopy((PVOID)HostentPtr,
253 NULL,
254 Blob->Name,
255 0,
256 UnicodeString,
257 StringType);
258 }
259
260 /* Loop the Aliases */
261 for (i = AliasCount; i; i--)
262 {
263 /* Align our current position */
264 HostentPtr += 1 & ~1;
265
266 /* Save our alias here */
267 Hostent->h_aliases[i] = (LPSTR)HostentPtr;
268
269 /* Now copy it in the blob */
270 HostentPtr += Dns_StringCopy((PVOID)HostentPtr,
271 NULL,
272 Blob->Aliases[i],
273 0,
274 UnicodeString,
275 StringType);
276 }
277
278 /* Check if the caller didn't have a buffer */
279 if (!BufferAllocated)
280 {
281 /* Return the size; not needed if we had a blob, since it's internal */
282 *HostEntrySize = *BufferPosition - (ULONG_PTR)HostentPtr;
283 }
284
285 /* Convert to Offsets if requested */
286 if(Relative) Hostent_ConvertToOffsets(Hostent);
287
288 /* Return the full, complete, hostent */
289 return Hostent;
290 }
291
292 INT
293 WINAPI
294 SaBlob_WriteNameOrAlias(IN PDNS_BLOB Blob,
295 IN LPWSTR String,
296 IN BOOLEAN IsAlias)
297 {
298 /* Check if this is an alias */
299 if (!IsAlias)
300 {
301 /* It's not. Simply create a copy of the string */
302 Blob->Name = Dns_CreateStringCopy_W(String);
303 if (!Blob->Name) return GetLastError();
304 }
305 else
306 {
307 /* Does it have a name, and less then 8 aliases? */
308 if ((Blob->Name) && (Blob->AliasCount <= 8))
309 {
310 /* Yup, create a copy of the string and increase the alias count */
311 Blob->Aliases[Blob->AliasCount] = Dns_CreateStringCopy_W(String);
312 Blob->AliasCount++;
313 }
314 else
315 {
316 /* Invalid request! */
317 return ERROR_MORE_DATA;
318 }
319 }
320
321 /* Return Success */
322 return ERROR_SUCCESS;
323 }
324
325 INT
326 WINAPI
327 SaBlob_WriteAddress(IN PDNS_BLOB Blob,
328 OUT PDNS_ADDRESS DnsAddr)
329 {
330 /* Check if we have an array yet */
331 if (!Blob->DnsAddrArray)
332 {
333 /* Allocate one! */
334 Blob->DnsAddrArray = DnsAddrArray_Create(1);
335 if (!Blob->DnsAddrArray) return ERROR_OUTOFMEMORY;
336 }
337
338 /* Add this address */
339 return DnsAddrArray_AddAddr(Blob->DnsAddrArray, DnsAddr, AF_UNSPEC, 0) ?
340 ERROR_SUCCESS:
341 ERROR_MORE_DATA;
342 }
343
344 BOOLEAN
345 WINAPI
346 SaBlob_IsSupportedAddrType(WORD DnsType)
347 {
348 /* Check for valid Types that we support */
349 return (DnsType == DNS_TYPE_A ||
350 DnsType == DNS_TYPE_ATMA ||
351 DnsType == DNS_TYPE_AAAA);
352 }
353
354 INT
355 WINAPI
356 SaBlob_WriteRecords(OUT PDNS_BLOB Blob,
357 IN PDNS_RECORD DnsRecord,
358 IN BOOLEAN DoAlias)
359 {
360 DNS_ADDRESS DnsAddress;
361 INT ErrorCode = STATUS_INVALID_PARAMETER;
362 BOOLEAN WroteOnce = FALSE;
363
364 /* Zero out the Address */
365 RtlZeroMemory(&DnsAddress, sizeof(DnsAddress));
366
367 /* Loop through all the Records */
368 while (DnsRecord)
369 {
370 /* Is this not an answer? */
371 if (DnsRecord->Flags.S.Section != DNSREC_ANSWER)
372 {
373 /* Then simply move on to the next DNS Record */
374 DnsRecord = DnsRecord->pNext;
375 continue;
376 }
377
378 /* Check the type of thsi record */
379 switch(DnsRecord->wType)
380 {
381 /* Regular IPv4, v6 or ATM Record */
382 case DNS_TYPE_A:
383 case DNS_TYPE_AAAA:
384 case DNS_TYPE_ATMA:
385
386 /* Create a DNS Address from the record */
387 DnsAddr_BuildFromDnsRecord(DnsRecord, &DnsAddress);
388
389 /* Add it to the DNS Blob */
390 ErrorCode = SaBlob_WriteAddress(Blob, &DnsAddress);
391
392 /* Add the name, if needed */
393 if ((DoAlias) &&
394 (!WroteOnce) &&
395 (!Blob->Name) &&
396 (DnsRecord->pName))
397 {
398 /* Write the name from the DNS Record */
399 ErrorCode = SaBlob_WriteNameOrAlias(Blob,
400 DnsRecord->pName,
401 FALSE);
402 WroteOnce = TRUE;
403 }
404 break;
405
406 case DNS_TYPE_CNAME:
407
408 /* Just write the alias name */
409 ErrorCode = SaBlob_WriteNameOrAlias(Blob,
410 DnsRecord->pName,
411 TRUE);
412 break;
413
414 case DNS_TYPE_PTR:
415
416 /* Check if we already have a name */
417 if (Blob->Name)
418 {
419 /* We don't, so add this as a name */
420 ErrorCode = SaBlob_WriteNameOrAlias(Blob,
421 DnsRecord->pName,
422 FALSE);
423 }
424 else
425 {
426 /* We do, so add it as an alias */
427 ErrorCode = SaBlob_WriteNameOrAlias(Blob,
428 DnsRecord->pName,
429 TRUE);
430 }
431 break;
432 default:
433 break;
434 }
435
436 /* Next record */
437 DnsRecord = DnsRecord->pNext;
438 }
439
440 /* Return error code */
441 return ErrorCode;
442 }
443
444 PDNS_BLOB
445 WINAPI
446 SaBlob_CreateFromRecords(IN PDNS_RECORD DnsRecord,
447 IN BOOLEAN DoAliases,
448 IN DWORD DnsType)
449 {
450 PDNS_RECORD LocalDnsRecord;
451 ULONG ProcessedCount = 0;
452 PDNS_BLOB DnsBlob;
453 INT ErrorCode;
454 DNS_ADDRESS DnsAddress;
455
456 /* Find out how many DNS Addresses to allocate */
457 LocalDnsRecord = DnsRecord;
458 while (LocalDnsRecord)
459 {
460 /* Make sure this record is an answer */
461 if ((LocalDnsRecord->Flags.S.Section == DNSREC_ANSWER) &&
462 (SaBlob_IsSupportedAddrType(LocalDnsRecord->wType)))
463 {
464 /* Increase number of records to process */
465 ProcessedCount++;
466 }
467
468 /* Move to the next record */
469 LocalDnsRecord = LocalDnsRecord->pNext;
470 }
471
472 /* Create the DNS Blob */
473 DnsBlob = SaBlob_Create(ProcessedCount);
474 if (!DnsBlob)
475 {
476 /* Fail */
477 ErrorCode = GetLastError();
478 goto Quickie;
479 }
480
481 /* Write the record to the DNS Blob */
482 ErrorCode = SaBlob_WriteRecords(DnsBlob, DnsRecord, TRUE);
483 if (ErrorCode != NO_ERROR)
484 {
485 /* We failed... but do we still have valid data? */
486 if ((DnsBlob->Name) || (DnsBlob->AliasCount))
487 {
488 /* We'll just assume success then */
489 ErrorCode = NO_ERROR;
490 }
491 else
492 {
493 /* Ok, last chance..do you have a DNS Address Array? */
494 if ((DnsBlob->DnsAddrArray) &&
495 (DnsBlob->DnsAddrArray->UsedAddresses))
496 {
497 /* Boy are you lucky! */
498 ErrorCode = NO_ERROR;
499 }
500 }
501
502 /* Buh-bye! */
503 goto Quickie;
504 }
505
506 /* Check if this is a PTR record */
507 if ((DnsRecord->wType == DNS_TYPE_PTR) ||
508 ((DnsType == DNS_TYPE_PTR) &&
509 (DnsRecord->wType == DNS_TYPE_CNAME) &&
510 (DnsRecord->Flags.S.Section == DNSREC_ANSWER)))
511 {
512 /* Get a DNS Address Structure */
513 if (Dns_ReverseNameToDnsAddr_W(&DnsAddress, DnsRecord->pName))
514 {
515 /* Add it to the Blob */
516 if (SaBlob_WriteAddress(DnsBlob, &DnsAddress)) ErrorCode = NO_ERROR;
517 }
518 }
519
520 /* Ok...do we still not have a name? */
521 if (!(DnsBlob->Name) && (DoAliases) && (LocalDnsRecord))
522 {
523 /* We have an local DNS Record, so just use it to write the name */
524 ErrorCode = SaBlob_WriteNameOrAlias(DnsBlob,
525 LocalDnsRecord->pName,
526 FALSE);
527 }
528
529 Quickie:
530 /* Check error code */
531 if (ErrorCode != NO_ERROR)
532 {
533 /* Free the blob and set the error */
534 SaBlob_Free(DnsBlob);
535 DnsBlob = NULL;
536 SetLastError(ErrorCode);
537 }
538
539 /* Return */
540 return DnsBlob;
541 }
542
543 PDNS_BLOB
544 WINAPI
545 SaBlob_Query(IN LPWSTR Name,
546 IN WORD DnsType,
547 IN ULONG Flags,
548 IN PVOID *Reserved,
549 IN DWORD AddressFamily)
550 {
551 PDNS_RECORD DnsRecord = NULL;
552 INT ErrorCode;
553 PDNS_BLOB DnsBlob = NULL;
554 LPWSTR LocalName, LocalNameCopy;
555
556 /* If they want reserved data back, clear it out in case we fail */
557 if (Reserved) *Reserved = NULL;
558
559 /* Query DNS */
560 ErrorCode = DnsQuery_W(Name,
561 DnsType,
562 Flags,
563 NULL,
564 &DnsRecord,
565 Reserved);
566 if (ErrorCode != ERROR_SUCCESS)
567 {
568 /* We failed... did the caller use reserved data? */
569 if (Reserved && *Reserved)
570 {
571 /* He did, and it was valid. Free it */
572 DnsApiFree(*Reserved);
573 *Reserved = NULL;
574 }
575
576 /* Normalize error code */
577 if (ErrorCode == RPC_S_SERVER_UNAVAILABLE) ErrorCode = WSATRY_AGAIN;
578 goto Quickie;
579 }
580
581 /* Now create the Blob from the DNS Records */
582 DnsBlob = SaBlob_CreateFromRecords(DnsRecord, TRUE, DnsType);
583 if (!DnsBlob)
584 {
585 /* Failed, get error code */
586 ErrorCode = GetLastError();
587 goto Quickie;
588 }
589
590 /* Make sure it has a name */
591 if (!DnsBlob->Name)
592 {
593 /* It doesn't, fail */
594 ErrorCode = DNS_INFO_NO_RECORDS;
595 goto Quickie;
596 }
597
598 /* Check if the name is local or loopback */
599 if (!(DnsNameCompare_W(DnsBlob->Name, L"localhost")) &&
600 !(DnsNameCompare_W(DnsBlob->Name, L"loopback")))
601 {
602 /* Nothing left to do, exit! */
603 goto Quickie;
604 }
605
606 /* This is a local name...query it */
607 LocalName = DnsQueryConfigAllocEx(DnsConfigFullHostName_W, NULL, NULL);
608 if (LocalName)
609 {
610 /* Create a copy for the caller */
611 LocalNameCopy = Dns_CreateStringCopy_W(LocalName);
612 if (LocalNameCopy)
613 {
614 /* Overwrite the one in the blob */
615 DnsBlob->Name = LocalNameCopy;
616 }
617 else
618 {
619 /* We failed to make a copy, free memory */
620 DnsApiFree(LocalName);
621 }
622 }
623
624 Quickie:
625 /* Free the DNS Record if we have one */
626 if (DnsRecord) DnsRecordListFree(DnsRecord, DnsFreeRecordList);
627
628 /* Check if this is a failure path with an active blob */
629 if ((ErrorCode != ERROR_SUCCESS) && (DnsBlob))
630 {
631 /* Free the blob */
632 SaBlob_Free(DnsBlob);
633 DnsBlob = NULL;
634 }
635
636 /* Set the last error and return */
637 SetLastError(ErrorCode);
638 return DnsBlob;
639 }
640