wined3d: Fix some checkGLcall() messages.
[wine] / dlls / dnsapi / record.c
1 /*
2  * DNS support
3  *
4  * Copyright (C) 2006 Hans Leidekker
5  * 
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23 #include "wine/debug.h"
24
25 #include <stdarg.h>
26 #include <string.h>
27 #include <sys/types.h>
28
29 #ifdef HAVE_NETINET_IN_H
30 # include <netinet/in.h>
31 #endif
32 #ifdef HAVE_ARPA_NAMESER_H
33 # include <arpa/nameser.h>
34 #endif
35 #ifdef HAVE_RESOLV_H
36 # include <resolv.h>
37 #endif
38
39 #include "windef.h"
40 #include "winbase.h"
41 #include "winnls.h"
42 #include "windns.h"
43
44 #include "dnsapi.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(dnsapi);
47
48 const char *dns_type_to_str( unsigned short type )
49 {
50     switch (type)
51     {
52 #define X(x)    case (x): return #x;
53     X(DNS_TYPE_ZERO)
54     X(DNS_TYPE_A)
55     X(DNS_TYPE_NS)
56     X(DNS_TYPE_MD)
57     X(DNS_TYPE_MF)
58     X(DNS_TYPE_CNAME)
59     X(DNS_TYPE_SOA)
60     X(DNS_TYPE_MB)
61     X(DNS_TYPE_MG)
62     X(DNS_TYPE_MR)
63     X(DNS_TYPE_NULL)
64     X(DNS_TYPE_WKS)
65     X(DNS_TYPE_PTR)
66     X(DNS_TYPE_HINFO)
67     X(DNS_TYPE_MINFO)
68     X(DNS_TYPE_MX)
69     X(DNS_TYPE_TEXT)
70     X(DNS_TYPE_RP)
71     X(DNS_TYPE_AFSDB)
72     X(DNS_TYPE_X25)
73     X(DNS_TYPE_ISDN)
74     X(DNS_TYPE_RT)
75     X(DNS_TYPE_NSAP)
76     X(DNS_TYPE_NSAPPTR)
77     X(DNS_TYPE_SIG)
78     X(DNS_TYPE_KEY)
79     X(DNS_TYPE_PX)
80     X(DNS_TYPE_GPOS)
81     X(DNS_TYPE_AAAA)
82     X(DNS_TYPE_LOC)
83     X(DNS_TYPE_NXT)
84     X(DNS_TYPE_EID)
85     X(DNS_TYPE_NIMLOC)
86     X(DNS_TYPE_SRV)
87     X(DNS_TYPE_ATMA)
88     X(DNS_TYPE_NAPTR)
89     X(DNS_TYPE_KX)
90     X(DNS_TYPE_CERT)
91     X(DNS_TYPE_A6)
92     X(DNS_TYPE_DNAME)
93     X(DNS_TYPE_SINK)
94     X(DNS_TYPE_OPT)
95     X(DNS_TYPE_UINFO)
96     X(DNS_TYPE_UID)
97     X(DNS_TYPE_GID)
98     X(DNS_TYPE_UNSPEC)
99     X(DNS_TYPE_ADDRS)
100     X(DNS_TYPE_TKEY)
101     X(DNS_TYPE_TSIG)
102     X(DNS_TYPE_IXFR)
103     X(DNS_TYPE_AXFR)
104     X(DNS_TYPE_MAILB)
105     X(DNS_TYPE_MAILA)
106     X(DNS_TYPE_ANY)
107     X(DNS_TYPE_WINS)
108     X(DNS_TYPE_WINSR)
109 #undef X
110     default: { static char tmp[7]; sprintf( tmp, "0x%04x", type ); return tmp; }
111     }
112 }
113
114 static int dns_strcmpX( LPCVOID str1, LPCVOID str2, BOOL wide )
115 {
116     if (wide)
117         return lstrcmpiW( str1, str2 );
118     else
119         return lstrcmpiA( str1, str2 );
120 }
121
122 /******************************************************************************
123  * DnsRecordCompare                        [DNSAPI.@]
124  *
125  */
126 BOOL WINAPI DnsRecordCompare( PDNS_RECORD r1, PDNS_RECORD r2 )
127 {
128     BOOL wide;
129     unsigned int i;
130
131     TRACE( "(%p,%p)\n", r1, r2 );
132
133     if (r1->wType       != r2->wType       ||
134         r1->wDataLength != r2->wDataLength ||
135         r1->Flags.DW    != r2->Flags.DW    ||
136         r1->dwReserved  != r2->dwReserved) return FALSE;
137
138     wide = (r1->Flags.S.CharSet == DnsCharSetUnicode) ? TRUE : FALSE;
139     if (dns_strcmpX( r1->pName, r2->pName, wide )) return FALSE;
140
141     switch (r1->wType)
142     {
143     case DNS_TYPE_A:
144     {
145         if (r1->Data.A.IpAddress != r2->Data.A.IpAddress) return FALSE;
146         break;
147     }
148     case DNS_TYPE_SOA:
149     {
150         if (r1->Data.SOA.dwSerialNo   != r2->Data.SOA.dwSerialNo ||
151             r1->Data.SOA.dwRefresh    != r2->Data.SOA.dwRefresh  ||
152             r1->Data.SOA.dwRetry      != r2->Data.SOA.dwRetry    ||
153             r1->Data.SOA.dwExpire     != r2->Data.SOA.dwExpire   ||
154             r1->Data.SOA.dwDefaultTtl != r2->Data.SOA.dwDefaultTtl)
155             return FALSE;
156         if (dns_strcmpX( r1->Data.SOA.pNamePrimaryServer,
157                          r2->Data.SOA.pNamePrimaryServer, wide ) ||
158             dns_strcmpX( r1->Data.SOA.pNameAdministrator,
159                          r2->Data.SOA.pNameAdministrator, wide ))
160             return FALSE;
161         break;
162     }
163     case DNS_TYPE_PTR:
164     case DNS_TYPE_NS:
165     case DNS_TYPE_CNAME:
166     case DNS_TYPE_MB:
167     case DNS_TYPE_MD:
168     case DNS_TYPE_MF:
169     case DNS_TYPE_MG:
170     case DNS_TYPE_MR:
171     {
172         if (dns_strcmpX( r1->Data.PTR.pNameHost,
173                          r2->Data.PTR.pNameHost, wide )) return FALSE;
174         break;
175     }
176     case DNS_TYPE_MINFO:
177     case DNS_TYPE_RP:
178     {
179         if (dns_strcmpX( r1->Data.MINFO.pNameMailbox,
180                          r2->Data.MINFO.pNameMailbox, wide ) ||
181             dns_strcmpX( r1->Data.MINFO.pNameErrorsMailbox,
182                          r2->Data.MINFO.pNameErrorsMailbox, wide ))
183             return FALSE;
184         break;
185     }
186     case DNS_TYPE_MX:
187     case DNS_TYPE_AFSDB:
188     case DNS_TYPE_RT:
189     {
190         if (r1->Data.MX.wPreference != r2->Data.MX.wPreference)
191             return FALSE;
192         if (dns_strcmpX( r1->Data.MX.pNameExchange,
193                          r2->Data.MX.pNameExchange, wide ))
194             return FALSE;
195         break;
196     }
197     case DNS_TYPE_HINFO:
198     case DNS_TYPE_ISDN:
199     case DNS_TYPE_TEXT:
200     case DNS_TYPE_X25:
201     {
202         if (r1->Data.TXT.dwStringCount != r2->Data.TXT.dwStringCount)
203             return FALSE;
204         for (i = 0; i < r1->Data.TXT.dwStringCount; i++)
205         {
206             if (dns_strcmpX( r1->Data.TXT.pStringArray[i],
207                              r2->Data.TXT.pStringArray[i], wide ))
208                 return FALSE;
209         }
210         break;
211     }
212     case DNS_TYPE_NULL:
213     {
214         if (r1->Data.Null.dwByteCount != r2->Data.Null.dwByteCount)
215             return FALSE;
216         if (memcmp( r1->Data.Null.Data,
217                     r2->Data.Null.Data, r1->Data.Null.dwByteCount ))
218             return FALSE;
219         break;
220     }
221     case DNS_TYPE_AAAA:
222     {
223         for (i = 0; i < sizeof(IP6_ADDRESS)/sizeof(DWORD); i++)
224         {
225             if (r1->Data.AAAA.Ip6Address.IP6Dword[i] !=
226                 r2->Data.AAAA.Ip6Address.IP6Dword[i]) return FALSE;
227         }
228         break;
229     }
230     case DNS_TYPE_KEY:
231     {
232         if (r1->Data.KEY.wFlags      != r2->Data.KEY.wFlags      ||
233             r1->Data.KEY.chProtocol  != r2->Data.KEY.chProtocol  ||
234             r1->Data.KEY.chAlgorithm != r2->Data.KEY.chAlgorithm)
235             return FALSE;
236         if (memcmp( r1->Data.KEY.Key, r2->Data.KEY.Key,
237                     r1->wDataLength - sizeof(DNS_KEY_DATA) + 1 ))
238             return FALSE;
239         break;
240     }
241     case DNS_TYPE_SIG:
242     {
243         if (dns_strcmpX( r1->Data.SIG.pNameSigner,
244                          r2->Data.SIG.pNameSigner, wide ))
245             return FALSE;
246         if (r1->Data.SIG.wTypeCovered  != r2->Data.SIG.wTypeCovered  ||
247             r1->Data.SIG.chAlgorithm   != r2->Data.SIG.chAlgorithm   ||
248             r1->Data.SIG.chLabelCount  != r2->Data.SIG.chLabelCount  ||
249             r1->Data.SIG.dwOriginalTtl != r2->Data.SIG.dwOriginalTtl ||
250             r1->Data.SIG.dwExpiration  != r2->Data.SIG.dwExpiration  ||
251             r1->Data.SIG.dwTimeSigned  != r2->Data.SIG.dwTimeSigned  ||
252             r1->Data.SIG.wKeyTag       != r2->Data.SIG.wKeyTag)
253             return FALSE;
254         if (memcmp( r1->Data.SIG.Signature, r2->Data.SIG.Signature,
255                     r1->wDataLength - sizeof(DNS_SIG_DATAA) + 1 ))
256             return FALSE;
257         break;
258     }
259     case DNS_TYPE_ATMA:
260     {
261         if (r1->Data.ATMA.AddressType != r2->Data.ATMA.AddressType)
262             return FALSE;
263         for (i = 0; i < DNS_ATMA_MAX_ADDR_LENGTH; i++)
264         {
265             if (r1->Data.ATMA.Address[i] != r2->Data.ATMA.Address[i])
266                 return FALSE;
267         }
268         break;
269     }
270     case DNS_TYPE_NXT:
271     {
272         if (dns_strcmpX( r1->Data.NXT.pNameNext,
273                          r2->Data.NXT.pNameNext, wide )) return FALSE;
274         if (r1->Data.NXT.wNumTypes != r2->Data.NXT.wNumTypes) return FALSE;
275         if (memcmp( r1->Data.NXT.wTypes, r2->Data.NXT.wTypes,
276                     r1->wDataLength - sizeof(DNS_NXT_DATAA) + sizeof(WORD) ))
277             return FALSE;
278         break;
279     }
280     case DNS_TYPE_SRV:
281     {
282         if (dns_strcmpX( r1->Data.SRV.pNameTarget,
283                          r2->Data.SRV.pNameTarget, wide )) return FALSE;
284         if (r1->Data.SRV.wPriority != r2->Data.SRV.wPriority ||
285             r1->Data.SRV.wWeight   != r2->Data.SRV.wWeight   ||
286             r1->Data.SRV.wPort     != r2->Data.SRV.wPort)
287             return FALSE;
288         break;
289     }
290     case DNS_TYPE_TKEY:
291     {
292         if (dns_strcmpX( r1->Data.TKEY.pNameAlgorithm,
293                          r2->Data.TKEY.pNameAlgorithm, wide ))
294             return FALSE;
295         if (r1->Data.TKEY.dwCreateTime    != r2->Data.TKEY.dwCreateTime     ||
296             r1->Data.TKEY.dwExpireTime    != r2->Data.TKEY.dwExpireTime     ||
297             r1->Data.TKEY.wMode           != r2->Data.TKEY.wMode            ||
298             r1->Data.TKEY.wError          != r2->Data.TKEY.wError           ||
299             r1->Data.TKEY.wKeyLength      != r2->Data.TKEY.wKeyLength       ||
300             r1->Data.TKEY.wOtherLength    != r2->Data.TKEY.wOtherLength     ||
301             r1->Data.TKEY.cAlgNameLength  != r2->Data.TKEY.cAlgNameLength   ||
302             r1->Data.TKEY.bPacketPointers != r2->Data.TKEY.bPacketPointers)
303             return FALSE;
304
305         /* FIXME: ignoring pAlgorithmPacket field */
306         if (memcmp( r1->Data.TKEY.pKey, r2->Data.TKEY.pKey,
307                     r1->Data.TKEY.wKeyLength ) ||
308             memcmp( r1->Data.TKEY.pOtherData, r2->Data.TKEY.pOtherData,
309                     r1->Data.TKEY.wOtherLength )) return FALSE;
310         break;
311     }
312     case DNS_TYPE_TSIG:
313     {
314         if (dns_strcmpX( r1->Data.TSIG.pNameAlgorithm,
315                          r2->Data.TSIG.pNameAlgorithm, wide ))
316             return FALSE;
317         if (r1->Data.TSIG.i64CreateTime   != r2->Data.TSIG.i64CreateTime    ||
318             r1->Data.TSIG.wFudgeTime      != r2->Data.TSIG.wFudgeTime       ||
319             r1->Data.TSIG.wOriginalXid    != r2->Data.TSIG.wOriginalXid     ||
320             r1->Data.TSIG.wError          != r2->Data.TSIG.wError           ||
321             r1->Data.TSIG.wSigLength      != r2->Data.TSIG.wSigLength       ||
322             r1->Data.TSIG.wOtherLength    != r2->Data.TSIG.wOtherLength     ||
323             r1->Data.TSIG.cAlgNameLength  != r2->Data.TSIG.cAlgNameLength   ||
324             r1->Data.TSIG.bPacketPointers != r2->Data.TSIG.bPacketPointers)
325             return FALSE;
326
327         /* FIXME: ignoring pAlgorithmPacket field */
328         if (memcmp( r1->Data.TSIG.pSignature, r2->Data.TSIG.pSignature,
329                     r1->Data.TSIG.wSigLength ) ||
330             memcmp( r1->Data.TSIG.pOtherData, r2->Data.TSIG.pOtherData,
331                     r1->Data.TSIG.wOtherLength )) return FALSE;
332         break;
333     }
334     case DNS_TYPE_WINS:
335     {
336         if (r1->Data.WINS.dwMappingFlag    != r2->Data.WINS.dwMappingFlag   ||
337             r1->Data.WINS.dwLookupTimeout  != r2->Data.WINS.dwLookupTimeout ||
338             r1->Data.WINS.dwCacheTimeout   != r2->Data.WINS.dwCacheTimeout  ||
339             r1->Data.WINS.cWinsServerCount != r2->Data.WINS.cWinsServerCount)
340             return FALSE;
341         if (memcmp( r1->Data.WINS.WinsServers, r2->Data.WINS.WinsServers,
342                     r1->wDataLength - sizeof(DNS_WINS_DATA) + sizeof(IP4_ADDRESS) ))
343             return FALSE;
344         break;
345     }
346     case DNS_TYPE_WINSR:
347     {
348         if (r1->Data.WINSR.dwMappingFlag   != r2->Data.WINSR.dwMappingFlag   ||
349             r1->Data.WINSR.dwLookupTimeout != r2->Data.WINSR.dwLookupTimeout ||
350             r1->Data.WINSR.dwCacheTimeout  != r2->Data.WINSR.dwCacheTimeout)
351             return FALSE;
352         if (dns_strcmpX( r1->Data.WINSR.pNameResultDomain,
353                          r2->Data.WINSR.pNameResultDomain, wide ))
354             return FALSE;
355         break;
356     }
357     default:
358         FIXME( "unknown type: %s\n", dns_type_to_str( r1->wType ) );
359         return FALSE;
360     }
361     return TRUE;
362 }
363
364 static LPVOID dns_strcpyX( LPCVOID src, DNS_CHARSET in, DNS_CHARSET out )
365 {
366     switch (in)
367     {
368     case DnsCharSetUnicode:
369     {
370         switch (out)
371         {
372         case DnsCharSetUnicode: return dns_strdup_w( src );
373         case DnsCharSetUtf8:    return dns_strdup_wu( src );
374         case DnsCharSetAnsi:    return dns_strdup_wa( src );
375         default:
376             WARN( "unhandled target charset: %d\n", out );
377             break;
378         }
379     }
380     case DnsCharSetUtf8:
381         switch (out)
382         {
383         case DnsCharSetUnicode: return dns_strdup_uw( src );
384         case DnsCharSetUtf8:    return dns_strdup_u( src );
385         case DnsCharSetAnsi:    return dns_strdup_ua( src );
386         default:
387             WARN( "unhandled target charset: %d\n", out );
388             break;
389         }
390     case DnsCharSetAnsi:
391         switch (out)
392         {
393         case DnsCharSetUnicode: return dns_strdup_aw( src );
394         case DnsCharSetUtf8:    return dns_strdup_au( src );
395         case DnsCharSetAnsi:    return dns_strdup_a( src );
396         default:
397             WARN( "unhandled target charset: %d\n", out );
398             break;
399         }
400     default:
401         WARN( "unhandled source charset: %d\n", in );
402         break;
403     }
404     return NULL;
405 }
406
407 /******************************************************************************
408  * DnsRecordCopyEx                         [DNSAPI.@]
409  *
410  */
411 PDNS_RECORD WINAPI DnsRecordCopyEx( PDNS_RECORD src, DNS_CHARSET in, DNS_CHARSET out )
412 {
413     DNS_RECORD *dst;
414     unsigned int i, size;
415
416     TRACE( "(%p,%d,%d)\n", src, in, out );
417
418     size = FIELD_OFFSET(DNS_RECORD, Data) + src->wDataLength;
419     dst = heap_alloc_zero( size );
420     if (!dst) return NULL;
421
422     memcpy( dst, src, size );
423
424     if (src->Flags.S.CharSet == DnsCharSetUtf8 ||
425         src->Flags.S.CharSet == DnsCharSetAnsi ||
426         src->Flags.S.CharSet == DnsCharSetUnicode) in = src->Flags.S.CharSet;
427
428     dst->Flags.S.CharSet = out;
429     dst->pName = dns_strcpyX( src->pName, in, out );
430     if (!dst->pName) goto error;
431
432     switch (src->wType)
433     {
434     case DNS_TYPE_HINFO:
435     case DNS_TYPE_ISDN:
436     case DNS_TYPE_TEXT:
437     case DNS_TYPE_X25:
438     {
439         for (i = 0; i < src->Data.TXT.dwStringCount; i++)
440         {
441             dst->Data.TXT.pStringArray[i] =
442                 dns_strcpyX( src->Data.TXT.pStringArray[i], in, out );
443
444             if (!dst->Data.TXT.pStringArray[i])
445             {
446                 while (i > 0) heap_free( dst->Data.TXT.pStringArray[--i] );
447                 goto error;
448             }
449         }
450         break;
451     }
452     case DNS_TYPE_MINFO:
453     case DNS_TYPE_RP:
454     {
455         dst->Data.MINFO.pNameMailbox =
456             dns_strcpyX( src->Data.MINFO.pNameMailbox, in, out );
457         if (!dst->Data.MINFO.pNameMailbox) goto error;
458
459         dst->Data.MINFO.pNameErrorsMailbox =
460             dns_strcpyX( src->Data.MINFO.pNameErrorsMailbox, in, out );
461         if (!dst->Data.MINFO.pNameErrorsMailbox)
462         {
463             heap_free( dst->Data.MINFO.pNameMailbox );
464             goto error;
465         }
466         break;
467     }
468     case DNS_TYPE_AFSDB:
469     case DNS_TYPE_RT:
470     case DNS_TYPE_MX:
471     {
472         dst->Data.MX.pNameExchange =
473             dns_strcpyX( src->Data.MX.pNameExchange, in, out );
474         if (!dst->Data.MX.pNameExchange) goto error;
475         break;
476     }
477     case DNS_TYPE_NXT:
478     {
479         dst->Data.NXT.pNameNext =
480             dns_strcpyX( src->Data.NXT.pNameNext, in, out );
481         if (!dst->Data.NXT.pNameNext) goto error;
482         break;
483     }
484     case DNS_TYPE_CNAME:
485     case DNS_TYPE_MB:
486     case DNS_TYPE_MD:
487     case DNS_TYPE_MF:
488     case DNS_TYPE_MG:
489     case DNS_TYPE_MR:
490     case DNS_TYPE_NS:
491     case DNS_TYPE_PTR:
492     {
493         dst->Data.PTR.pNameHost =
494             dns_strcpyX( src->Data.PTR.pNameHost, in, out );
495         if (!dst->Data.PTR.pNameHost) goto error;
496         break;
497     }
498     case DNS_TYPE_SIG:
499     {
500         dst->Data.SIG.pNameSigner =
501             dns_strcpyX( src->Data.SIG.pNameSigner, in, out );
502         if (!dst->Data.SIG.pNameSigner) goto error;
503         break;
504     }
505     case DNS_TYPE_SOA:
506     {
507         dst->Data.SOA.pNamePrimaryServer =
508             dns_strcpyX( src->Data.SOA.pNamePrimaryServer, in, out );
509         if (!dst->Data.SOA.pNamePrimaryServer) goto error;
510
511         dst->Data.SOA.pNameAdministrator =
512             dns_strcpyX( src->Data.SOA.pNameAdministrator, in, out );
513         if (!dst->Data.SOA.pNameAdministrator)
514         {
515             heap_free( dst->Data.SOA.pNamePrimaryServer );
516             goto error;
517         }
518         break;
519     }
520     case DNS_TYPE_SRV:
521     {
522         dst->Data.SRV.pNameTarget =
523             dns_strcpyX( src->Data.SRV.pNameTarget, in, out );
524         if (!dst->Data.SRV.pNameTarget) goto error;
525         break;
526     }
527     default:
528         break;
529     }
530     return dst;
531
532 error:
533     heap_free( dst->pName );
534     heap_free( dst );
535     return NULL;
536 }
537
538 /******************************************************************************
539  * DnsRecordListFree                       [DNSAPI.@]
540  *
541  */
542 VOID WINAPI DnsRecordListFree( PDNS_RECORD list, DNS_FREE_TYPE type )
543 {
544     DNS_RECORD *r, *next;
545     unsigned int i;
546
547     TRACE( "(%p,%d)\n", list, type );
548
549     if (!list) return;
550
551     switch (type)
552     {
553     case DnsFreeRecordList:
554     {
555         for (r = list; (list = r); r = next)
556         {
557             heap_free( r->pName );
558
559             switch (r->wType)
560             {
561             case DNS_TYPE_HINFO:
562             case DNS_TYPE_ISDN:
563             case DNS_TYPE_TEXT:
564             case DNS_TYPE_X25:
565             {
566                 for (i = 0; i < r->Data.TXT.dwStringCount; i++)
567                     heap_free( r->Data.TXT.pStringArray[i] );
568
569                 break;
570             }
571             case DNS_TYPE_MINFO:
572             case DNS_TYPE_RP:
573             {
574                 heap_free( r->Data.MINFO.pNameMailbox );
575                 heap_free( r->Data.MINFO.pNameErrorsMailbox );
576                 break;
577             }
578             case DNS_TYPE_AFSDB:
579             case DNS_TYPE_RT:
580             case DNS_TYPE_MX:
581             {
582                 heap_free( r->Data.MX.pNameExchange );
583                 break;
584             }
585             case DNS_TYPE_NXT:
586             {
587                 heap_free( r->Data.NXT.pNameNext );
588                 break;
589             }
590             case DNS_TYPE_CNAME:
591             case DNS_TYPE_MB:
592             case DNS_TYPE_MD:
593             case DNS_TYPE_MF:
594             case DNS_TYPE_MG:
595             case DNS_TYPE_MR:
596             case DNS_TYPE_NS:
597             case DNS_TYPE_PTR:
598             {
599                 heap_free( r->Data.PTR.pNameHost );
600                 break;
601             }
602             case DNS_TYPE_SIG:
603             {
604                 heap_free( r->Data.SIG.pNameSigner );
605                 break;
606             }
607             case DNS_TYPE_SOA:
608             {
609                 heap_free( r->Data.SOA.pNamePrimaryServer );
610                 heap_free( r->Data.SOA.pNameAdministrator );
611                 break;
612             }
613             case DNS_TYPE_SRV:
614             {
615                 heap_free( r->Data.SRV.pNameTarget );
616                 break;
617             }
618             default:
619                 break;
620             }
621
622             next = r->pNext;
623             heap_free( r );
624         }
625         break;
626     }
627     case DnsFreeFlat:
628     case DnsFreeParsedMessageFields:
629     {
630         FIXME( "unhandled free type: %d\n", type );
631         break;
632     }
633     default:
634         WARN( "unknown free type: %d\n", type );
635         break;
636     }
637 }
638
639 /******************************************************************************
640  * DnsRecordSetCompare                     [DNSAPI.@]
641  *
642  */
643 BOOL WINAPI DnsRecordSetCompare( PDNS_RECORD set1, PDNS_RECORD set2,
644                                  PDNS_RECORD *diff1, PDNS_RECORD *diff2 )
645 {
646     BOOL ret = TRUE;
647     DNS_RECORD *r, *t, *u;
648     DNS_RRSET rr1, rr2;
649
650     TRACE( "(%p,%p,%p,%p)\n", set1, set2, diff1, diff2 );
651
652     if (!set1 && !set2) return FALSE;
653
654     if (diff1) *diff1 = NULL;
655     if (diff2) *diff2 = NULL;
656
657     if (set1 && !set2)
658     {
659         if (diff1) *diff1 = DnsRecordSetCopyEx( set1, 0, set1->Flags.S.CharSet );
660         return FALSE;
661     }
662     if (!set1 && set2)
663     {
664         if (diff2) *diff2 = DnsRecordSetCopyEx( set2, 0, set2->Flags.S.CharSet );
665         return FALSE;
666     }
667
668     DNS_RRSET_INIT( rr1 );
669     DNS_RRSET_INIT( rr2 );
670
671     for (r = set1; r; r = r->pNext)
672     {
673         for (t = set2; t; t = t->pNext)
674         {
675             u = DnsRecordCopyEx( r, r->Flags.S.CharSet, t->Flags.S.CharSet );
676             if (!u) goto error;
677
678             if (!DnsRecordCompare( t, u ))
679             {
680                 DNS_RRSET_ADD( rr1, u );
681                 ret = FALSE;
682             }
683             else DnsRecordListFree( u, DnsFreeRecordList );
684         }
685     }
686
687     for (t = set2; t; t = t->pNext)
688     {
689         for (r = set1; r; r = r->pNext)
690         {
691             u = DnsRecordCopyEx( t, t->Flags.S.CharSet, r->Flags.S.CharSet );
692             if (!u) goto error;
693
694             if (!DnsRecordCompare( r, u ))
695             {
696                 DNS_RRSET_ADD( rr2, u );
697                 ret = FALSE;
698             }
699             else DnsRecordListFree( u, DnsFreeRecordList );
700         }
701     }
702
703     DNS_RRSET_TERMINATE( rr1 );
704     DNS_RRSET_TERMINATE( rr2 );
705     
706     if (diff1) *diff1 = rr1.pFirstRR;
707     else DnsRecordListFree( rr1.pFirstRR, DnsFreeRecordList );
708
709     if (diff2) *diff2 = rr2.pFirstRR;
710     else DnsRecordListFree( rr2.pFirstRR, DnsFreeRecordList );
711
712     return ret;
713
714 error:
715     DNS_RRSET_TERMINATE( rr1 );
716     DNS_RRSET_TERMINATE( rr2 );
717
718     DnsRecordListFree( rr1.pFirstRR, DnsFreeRecordList );
719     DnsRecordListFree( rr2.pFirstRR, DnsFreeRecordList );
720     
721     return FALSE;
722 }
723
724 /******************************************************************************
725  * DnsRecordSetCopyEx                      [DNSAPI.@]
726  *
727  */
728 PDNS_RECORD WINAPI DnsRecordSetCopyEx( PDNS_RECORD src_set, DNS_CHARSET in, DNS_CHARSET out )
729 {
730     DNS_RRSET dst_set;
731     DNS_RECORD *src, *dst;
732
733     TRACE( "(%p,%d,%d)\n", src_set, in, out );
734
735     DNS_RRSET_INIT( dst_set );
736
737     for (src = src_set; (src_set = src); src = src_set->pNext)
738     {
739         dst = DnsRecordCopyEx( src, in, out );
740         if (!dst)
741         {
742             DNS_RRSET_TERMINATE( dst_set );
743             DnsRecordListFree( dst_set.pFirstRR, DnsFreeRecordList );
744             return NULL;
745         }
746         DNS_RRSET_ADD( dst_set, dst );
747     }
748
749     DNS_RRSET_TERMINATE( dst_set );
750     return dst_set.pFirstRR;
751 }
752
753 /******************************************************************************
754  * DnsRecordSetDetach                      [DNSAPI.@]
755  *
756  */
757 PDNS_RECORD WINAPI DnsRecordSetDetach( PDNS_RECORD set )
758 {
759     DNS_RECORD *r, *s;
760
761     TRACE( "(%p)\n", set );
762
763     for (r = set; (set = r); r = set->pNext)
764     {
765         if (r->pNext && !r->pNext->pNext)
766         {
767             s = r->pNext;
768             r->pNext = NULL;
769             return s;
770         }
771     }
772     return NULL;
773 }