Changeset 988 for vendor/current/lib/addns

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/lib/addns

Files:

• addns.h (deleted)
• dns.h (modified) (15 diffs)
• dnserr.h (modified) (1 diff)
• dnsgss.c (modified) (7 diffs)
• dnsmarshall.c (modified) (16 diffs)
• dnsquery.c (added)
• dnsquery.h (added)
• dnsrecord.c (modified) (17 diffs)
• dnssock.c (modified) (21 diffs)
• dnsutils.c (modified) (3 diffs)
• wscript_build (modified) (1 diff)

vendor/current/lib/addns/dns.h

@@ -28 +28 @@
 #include "../replace/replace.h"
 #include "system/network.h"
+#include "system/kerberos.h"
+#include "system/gssapi.h"
 
 /* make sure we have included the correct config.h */
@@ -37 +39 @@
 #endif /* NO_CONFIG_H */
 
-#include <stdio.h>
-#include <stdlib.h>
 #include <fcntl.h>
 #include <time.h>
-#include <string.h>
-#include <errno.h>
 #include <netdb.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <stdarg.h>
-
-#ifdef HAVE_UUID_UUID_H
-#include <uuid/uuid.h>
-#endif
-
-#ifdef HAVE_KRB5_H
-#include <krb5.h>
-#endif
-
-#ifdef HAVE_INTTYPES_H
-#include <inttypes.h>
-
-#ifndef int16
-#define int16 int16_t
-#endif
-
-#ifndef uint16
-#define uint16 uint16_t
-#endif
-
-#ifndef int32
-#define int32 int32_t
-#endif
-
-#ifndef uint32
-#define uint32 uint32_t
-#endif
-#endif
-
-#ifdef HAVE_KRB5_H
-#include <krb5.h>
-#endif
-
-#if HAVE_GSSAPI_GSSAPI_H
-#include <gssapi/gssapi.h>
-#elif HAVE_GSSAPI_GSSAPI_GENERIC_H
-#include <gssapi/gssapi_generic.h>
-#elif HAVE_GSSAPI_H
-#include <gssapi.h>
-#endif
-
-#if defined(HAVE_GSSAPI_H) || defined(HAVE_GSSAPI_GSSAPI_H) || defined(HAVE_GSSAPI_GSSAPI_GENERIC_H)
-#define HAVE_GSSAPI_SUPPORT    1
-#endif
 
 #include <talloc.h>
-
-#if 0
-
-Disable these now we have checked all code paths and ensured
-NULL returns on zero request. JRA.
-
-void *_talloc_zero_zeronull(const void *ctx, size_t size, const char *name);
-void *_talloc_memdup_zeronull(const void *t, const void *p, size_t size, const char *name);
-void *_talloc_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name);
-void *_talloc_zero_array_zeronull(const void *ctx, size_t el_size, unsigned count, const char *name);
-void *talloc_zeronull(const void *context, size_t size, const char *name);
-
-#define TALLOC(ctx, size) talloc_zeronull(ctx, size, __location__)
-#define TALLOC_P(ctx, type) (type *)talloc_zeronull(ctx, sizeof(type), #type)
-#define TALLOC_ARRAY(ctx, type, count) (type *)_talloc_array_zeronull(ctx, sizeof(type), count, #type)
-#define TALLOC_MEMDUP(ctx, ptr, size) _talloc_memdup_zeronull(ctx, ptr, size, __location__)
-#define TALLOC_ZERO(ctx, size) _talloc_zero_zeronull(ctx, size, __location__)
-#define TALLOC_ZERO_P(ctx, type) (type *)_talloc_zero_zeronull(ctx, sizeof(type), #type)
-#define TALLOC_ZERO_ARRAY(ctx, type, count) (type *)_talloc_zero_array_zeronull(ctx, sizeof(type), count, #type)
-#define TALLOC_SIZE(ctx, size) talloc_zeronull(ctx, size, __location__)
-#define TALLOC_ZERO_SIZE(ctx, size) _talloc_zero_zeronull(ctx, size, __location__)
-
-#else
-
-#define TALLOC(ctx, size) talloc_named_const(ctx, size, __location__)
-#define TALLOC_P(ctx, type) (type *)talloc_named_const(ctx, sizeof(type), #type)
-#define TALLOC_ARRAY(ctx, type, count) (type *)_talloc_array(ctx, sizeof(type), count, #type)
-#define TALLOC_MEMDUP(ctx, ptr, size) _talloc_memdup(ctx, ptr, size, __location__)
-#define TALLOC_ZERO(ctx, size) _talloc_zero(ctx, size, __location__)
-#define TALLOC_ZERO_P(ctx, type) (type *)_talloc_zero(ctx, sizeof(type), #type)
-#define TALLOC_ZERO_ARRAY(ctx, type, count) (type *)_talloc_zero_array(ctx, sizeof(type), count, #type)
-#define TALLOC_SIZE(ctx, size) talloc_named_const(ctx, size, __location__)
-#define TALLOC_ZERO_SIZE(ctx, size) _talloc_zero(ctx, size, __location__)
-
-#endif
-
-#define TALLOC_REALLOC(ctx, ptr, count) _talloc_realloc(ctx, ptr, count, __location__)
-#define TALLOC_REALLOC_ARRAY(ctx, ptr, type, count) (type *)_talloc_realloc_array(ctx, ptr, sizeof(type), count, #type)
-#define talloc_destroy(ctx) talloc_free(ctx)
-#ifndef TALLOC_FREE
-#define TALLOC_FREE(ctx) do { talloc_free(ctx); ctx=NULL; } while(0)
-#endif
-
-/*******************************************************************
-   Type definitions for int16, int32, uint16 and uint32.  Needed
-   for Samba coding style
-*******************************************************************/
-
-#ifndef uint8
-#  define uint8 unsigned char
-#endif
-
-#if !defined(int16) && !defined(HAVE_INT16_FROM_RPC_RPC_H)
-#  if (SIZEOF_SHORT == 4)
-#    define int16 __ERROR___CANNOT_DETERMINE_TYPE_FOR_INT16;
-#  else /* SIZEOF_SHORT != 4 */
-#    define int16 short
-#  endif /* SIZEOF_SHORT != 4 */
-   /* needed to work around compile issue on HP-UX 11.x */
-#  define _INT16        1
-#endif
-
-/*
- * Note we duplicate the size tests in the unsigned
- * case as int16 may be a typedef from rpc/rpc.h
- */
-
-#if !defined(uint16) && !defined(HAVE_UINT16_FROM_RPC_RPC_H)
-#  if (SIZEOF_SHORT == 4)
-#    define uint16 __ERROR___CANNOT_DETERMINE_TYPE_FOR_INT16;
-#  else /* SIZEOF_SHORT != 4 */
-#    define uint16 unsigned short
-#  endif /* SIZEOF_SHORT != 4 */
-#endif
-
-#if !defined(int32) && !defined(HAVE_INT32_FROM_RPC_RPC_H)
-#  if (SIZEOF_INT == 4)
-#    define int32 int
-#  elif (SIZEOF_LONG == 4)
-#    define int32 long
-#  elif (SIZEOF_SHORT == 4)
-#    define int32 short
-#  else
-     /* uggh - no 32 bit type?? probably a CRAY. just hope this works ... */
-#    define int32 int
-#  endif
-#  ifndef _INT32
-     /* needed to work around compile issue on HP-UX 11.x */
-#    define _INT32        1
-#  endif
-#endif
-
-/*
- * Note we duplicate the size tests in the unsigned
- * case as int32 may be a typedef from rpc/rpc.h
- */
-
-#if !defined(uint32) && !defined(HAVE_UINT32_FROM_RPC_RPC_H)
-#  if (SIZEOF_INT == 4)
-#    define uint32 unsigned int
-#  elif (SIZEOF_LONG == 4)
-#    define uint32 unsigned long
-#  elif (SIZEOF_SHORT == 4)
-#    define uint32 unsigned short
-#  else
-      /* uggh - no 32 bit type?? probably a CRAY. just hope this works ... */
-#    define uint32 unsigned
-#  endif
-#endif
-
-/*
- * check for 8 byte long long
- */
-
-#if !defined(uint64)
-#  if (SIZEOF_LONG == 8)
-#    define uint64 unsigned long
-#  elif (SIZEOF_LONG_LONG == 8)
-#    define uint64 unsigned long long
-#  endif /* don't lie.  If we don't have it, then don't use it */
-#endif
-
-/* needed on Sun boxes */
-#ifndef INADDR_NONE
-#define INADDR_NONE          0xFFFFFFFF
-#endif
 
 #include "dnserr.h"
@@ -248 +71 @@
 #define QTYPE_CNAME     5
 #define QTYPE_SOA       6
+#define QTYPE_AAAA      28
 #define QTYPE_ANY       255
 #define QTYPE_TKEY      249
@@ -329 +153 @@
 struct dns_question {
         struct dns_domain_name *name;
-        uint16 q_type;
-        uint16 q_class;
+        uint16_t q_type;
+        uint16_t q_class;
 };
 
@@ -341 +165 @@
 struct dns_zone {
         struct dns_domain_name *name;
-        uint16 z_type;
-        uint16 z_class;
+        uint16_t z_type;
+        uint16_t z_class;
 };
 
 struct dns_rrec {
         struct dns_domain_name *name;
-        uint16 type;
-        uint16 r_class;
-        uint32 ttl;
-        uint16 data_length;
-        uint8 *data;
+        uint16_t type;
+        uint16_t r_class;
+        uint32_t ttl;
+        uint16_t data_length;
+        uint8_t *data;
 };
 
@@ -358 +182 @@
         time_t inception;
         time_t expiration;
-        uint16 mode;
-        uint16 error;
-        uint16 key_length;
-        uint8 *key;
+        uint16_t mode;
+        uint16_t error;
+        uint16_t key_length;
+        uint8_t *key;
 };
 
 struct dns_request {
-        uint16 id;
-        uint16 flags;
-        uint16 num_questions;
-        uint16 num_answers;
-        uint16 num_auths;
-        uint16 num_additionals;
+        uint16_t id;
+        uint16_t flags;
+        uint16_t num_questions;
+        uint16_t num_answers;
+        uint16_t num_auths;
+        uint16_t num_additionals;
         struct dns_question **questions;
         struct dns_rrec **answers;
@@ -384 +208 @@
 
 struct dns_update_request {
-        uint16 id;
-        uint16 flags;
-        uint16 num_zones;
-        uint16 num_preqs;
-        uint16 num_updates;
-        uint16 num_additionals;
+        uint16_t id;
+        uint16_t flags;
+        uint16_t num_zones;
+        uint16_t num_preqs;
+        uint16_t num_updates;
+        uint16_t num_additionals;
         struct dns_zone **zones;
         struct dns_rrec **preqs;
@@ -397 +221 @@
 
 struct dns_connection {
-        int32 hType;
+        int32_t hType;
         int s;
-        struct sockaddr RecvAddr;
+        struct sockaddr_storage RecvAddr;
 };
 
 struct dns_buffer {
-        uint8 *data;
+        uint8_t *data;
         size_t size;
         size_t offset;
@@ -419 +243 @@
 
 DNS_ERROR dns_create_query( TALLOC_CTX *mem_ctx, const char *name,
-                            uint16 q_type, uint16 q_class,
+                            uint16_t q_type, uint16_t q_class,
                             struct dns_request **preq );
 DNS_ERROR dns_create_update( TALLOC_CTX *mem_ctx, const char *name,
@@ -428 +252 @@
                            struct dns_update_request **preq);
 DNS_ERROR dns_create_rrec(TALLOC_CTX *mem_ctx, const char *name,
-                          uint16 type, uint16 r_class, uint32 ttl,
-                          uint16 data_length, uint8 *data,
+                          uint16_t type, uint16_t r_class, uint32_t ttl,
+                          uint16_t data_length, uint8_t *data,
                           struct dns_rrec **prec);
 DNS_ERROR dns_add_rrec(TALLOC_CTX *mem_ctx, struct dns_rrec *rec,
-                       uint16 *num_records, struct dns_rrec ***records);
+                       uint16_t *num_records, struct dns_rrec ***records);
 DNS_ERROR dns_create_tkey_record(TALLOC_CTX *mem_ctx, const char *keyname,
                                  const char *algorithm_name, time_t inception,
-                                 time_t expiration, uint16 mode, uint16 error,
-                                 uint16 key_length, const uint8 *key,
+                                 time_t expiration, uint16_t mode, uint16_t error,
+                                 uint16_t key_length, const uint8_t *key,
                                  struct dns_rrec **prec);
 DNS_ERROR dns_create_name_in_use_record(TALLOC_CTX *mem_ctx,
@@ -443 +267 @@
                                         struct dns_rrec **prec);
 DNS_ERROR dns_create_delete_record(TALLOC_CTX *mem_ctx, const char *name,
-                                   uint16 type, uint16 r_class,
+                                   uint16_t type, uint16_t r_class,
                                    struct dns_rrec **prec);
 DNS_ERROR dns_create_name_not_in_use_record(TALLOC_CTX *mem_ctx,
-                                            const char *name, uint32 type,
+                                            const char *name, uint32_t type,
                                             struct dns_rrec **prec);
 DNS_ERROR dns_create_a_record(TALLOC_CTX *mem_ctx, const char *host,
-                              uint32 ttl, const struct sockaddr_storage *pss,
+                              uint32_t ttl, const struct sockaddr_storage *pss,
                               struct dns_rrec **prec);
+DNS_ERROR dns_create_aaaa_record(TALLOC_CTX *mem_ctx, const char *host,
+                                 uint32_t ttl, const struct sockaddr_storage *pss,
+                                 struct dns_rrec **prec);
 DNS_ERROR dns_unmarshall_tkey_record(TALLOC_CTX *mem_ctx, struct dns_rrec *rec,
                                      struct dns_tkey_record **ptkey);
 DNS_ERROR dns_create_tsig_record(TALLOC_CTX *mem_ctx, const char *keyname,
                                  const char *algorithm_name,
-                                 time_t time_signed, uint16 fudge,
-                                 uint16 mac_length, const uint8 *mac,
-                                 uint16 original_id, uint16 error,
+                                 time_t time_signed, uint16_t fudge,
+                                 uint16_t mac_length, const uint8_t *mac,
+                                 uint16_t original_id, uint16_t error,
                                  struct dns_rrec **prec);
 DNS_ERROR dns_add_rrec(TALLOC_CTX *mem_ctx, struct dns_rrec *rec,
-                       uint16 *num_records, struct dns_rrec ***records);
+                       uint16_t *num_records, struct dns_rrec ***records);
 DNS_ERROR dns_create_update_request(TALLOC_CTX *mem_ctx,
                                     const char *domainname,
@@ -470 +297 @@
 /* from dnssock.c */
 
-DNS_ERROR dns_open_connection( const char *nameserver, int32 dwType,
+DNS_ERROR dns_open_connection( const char *nameserver, int32_t dwType,
                     TALLOC_CTX *mem_ctx,
                     struct dns_connection **conn );
@@ -487 +314 @@
 
 struct dns_buffer *dns_create_buffer(TALLOC_CTX *mem_ctx);
-void dns_marshall_buffer(struct dns_buffer *buf, const uint8 *data,
+void dns_marshall_buffer(struct dns_buffer *buf, const uint8_t *data,
                          size_t len);
-void dns_marshall_uint16(struct dns_buffer *buf, uint16 val);
-void dns_marshall_uint32(struct dns_buffer *buf, uint32 val);
-void dns_unmarshall_buffer(struct dns_buffer *buf, uint8 *data,
+void dns_marshall_uint16(struct dns_buffer *buf, uint16_t val);
+void dns_marshall_uint32(struct dns_buffer *buf, uint32_t val);
+void dns_unmarshall_buffer(struct dns_buffer *buf, uint8_t *data,
                            size_t len);
-void dns_unmarshall_uint16(struct dns_buffer *buf, uint16 *val);
-void dns_unmarshall_uint32(struct dns_buffer *buf, uint32 *val);
+void dns_unmarshall_uint16(struct dns_buffer *buf, uint16_t *val);
+void dns_unmarshall_uint32(struct dns_buffer *buf, uint32_t *val);
 void dns_unmarshall_domain_name(TALLOC_CTX *mem_ctx,
                                 struct dns_buffer *buf,
@@ -517 +344 @@
 struct dns_request *dns_update2request(struct dns_update_request *update);
 struct dns_update_request *dns_request2update(struct dns_request *request);
-uint16 dns_response_code(uint16 flags);
+uint16_t dns_response_code(uint16_t flags);
 const char *dns_errstr(DNS_ERROR err);
 
 /* from dnsgss.c */
 
-#ifdef HAVE_GSSAPI_SUPPORT
+#ifdef HAVE_GSSAPI
 
 void display_status( const char *msg, OM_uint32 maj_stat, OM_uint32 min_stat ); 
@@ -534 +361 @@
                           const char *keyname,
                           const char *algorithmname,
-                          time_t time_signed, uint16 fudge);
-
-#endif  /* HAVE_GSSAPI_SUPPORT */
+                          time_t time_signed, uint16_t fudge);
+
+#endif  /* HAVE_GSSAPI */
 
 #endif  /* _DNS_H */

vendor/current/lib/addns/dnserr.h

@@ -37 +37 @@
 
 #if defined(HAVE_IMMEDIATE_STRUCTURES)
-typedef struct {uint32 v;} DNS_ERROR;
+typedef struct {uint32_t v;} DNS_ERROR;
 #define ERROR_DNS(x) ((DNS_ERROR) { x })
 #define ERROR_DNS_V(x) ((x).v)
 #else
-typedef uint32 DNS_ERROR;
+typedef uint32_t DNS_ERROR;
 #define ERROR_DNS(x) (x)
 #define ERROR_DNS_V(x) (x)

vendor/current/lib/addns/dnsgss.c

@@ -27 +27 @@
 
 
-#ifdef HAVE_GSSAPI_SUPPORT
+#ifdef HAVE_GSSAPI
 
 /*********************************************************************
@@ -93 +93 @@
 
         gss_OID_desc krb5_oid_desc =
-                { 9, (char *)"\x2a\x86\x48\x86\xf7\x12\x01\x02\x02" };
+                { 9, discard_const("\x2a\x86\x48\x86\xf7\x12\x01\x02\x02") };
 
         *ctx = GSS_C_NO_CONTEXT;
@@ -126 +126 @@
                                 req, keyname, "gss.microsoft.com", t,
                                 t + 86400, DNS_TKEY_MODE_GSSAPI, 0,
-                                output_desc.length, (uint8 *)output_desc.value,
+                                output_desc.length, (uint8_t *)output_desc.value,
                                 &rec );
                         if (!ERR_DNS_IS_OK(err)) goto error;
@@ -231 +231 @@
 
         gss_OID_desc nt_host_oid_desc =
-                {10, (char *)"\x2a\x86\x48\x86\xf7\x12\x01\x02\x02\x01"};
+                {10, discard_const("\x2a\x86\x48\x86\xf7\x12\x01\x02\x02\x01")};
 
         TALLOC_CTX *mem_ctx;
@@ -281 +281 @@
                           const char *keyname,
                           const char *algorithmname,
-                          time_t time_signed, uint16 fudge)
+                          time_t time_signed, uint16_t fudge)
 {
         struct dns_buffer *buf;
@@ -328 +328 @@
 
         err = dns_create_tsig_record(buf, keyname, algorithmname, time_signed,
-                                     fudge, mic.length, (uint8 *)mic.value,
+                                     fudge, mic.length, (uint8_t *)mic.value,
                                      req->id, 0, &rec);
         gss_release_buffer(&minor, &mic);
@@ -340 +340 @@
 }
 
-#endif  /* HAVE_GSSAPI_SUPPORT */
+#endif  /* HAVE_GSSAPI */

vendor/current/lib/addns/dnsmarshall.c

@@ -40 +40 @@
         result->size = 2;
 
-        if (!(result->data = TALLOC_ZERO_ARRAY(result, uint8, result->size))) {
+        if (!(result->data = talloc_zero_array(result, uint8_t, result->size))) {
                 TALLOC_FREE(result);
                 return NULL;
@@ -48 +48 @@
 }
 
-void dns_marshall_buffer(struct dns_buffer *buf, const uint8 *data,
+void dns_marshall_buffer(struct dns_buffer *buf, const uint8_t *data,
                          size_t len)
 {
@@ -71 +71 @@
         if (buf->offset + len > buf->size) {
                 size_t new_size = buf->offset + len;
-                uint8 *new_data;
+                uint8_t *new_data;
 
                 /*
@@ -79 +79 @@
                 new_size += (64 - (new_size % 64));
 
-                if (!(new_data = TALLOC_REALLOC_ARRAY(buf, buf->data, uint8,
+                if (!(new_data = talloc_realloc(buf, buf->data, uint8_t,
                                                       new_size))) {
                         buf->error = ERROR_DNS_NO_MEMORY;
@@ -94 +94 @@
 }
 
-void dns_marshall_uint16(struct dns_buffer *buf, uint16 val)
-{
-        uint16 n_val = htons(val);
-        dns_marshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
-}
-
-void dns_marshall_uint32(struct dns_buffer *buf, uint32 val)
-{
-        uint32 n_val = htonl(val);
-        dns_marshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
-}
-
-void dns_unmarshall_buffer(struct dns_buffer *buf, uint8 *data,
+void dns_marshall_uint16(struct dns_buffer *buf, uint16_t val)
+{
+        uint16_t n_val = htons(val);
+        dns_marshall_buffer(buf, (uint8_t *)&n_val, sizeof(n_val));
+}
+
+void dns_marshall_uint32(struct dns_buffer *buf, uint32_t val)
+{
+        uint32_t n_val = htonl(val);
+        dns_marshall_buffer(buf, (uint8_t *)&n_val, sizeof(n_val));
+}
+
+void dns_unmarshall_buffer(struct dns_buffer *buf, uint8_t *data,
                            size_t len)
 {
@@ -122 +122 @@
 }
 
-void dns_unmarshall_uint16(struct dns_buffer *buf, uint16 *val)
-{
-        uint16 n_val;
-
-        dns_unmarshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
+void dns_unmarshall_uint16(struct dns_buffer *buf, uint16_t *val)
+{
+        uint16_t n_val;
+
+        dns_unmarshall_buffer(buf, (uint8_t *)&n_val, sizeof(n_val));
         if (!(ERR_DNS_IS_OK(buf->error))) return;
 
@@ -132 +132 @@
 }
 
-void dns_unmarshall_uint32(struct dns_buffer *buf, uint32 *val)
-{
-        uint32 n_val;
-
-        dns_unmarshall_buffer(buf, (uint8 *)&n_val, sizeof(n_val));
+void dns_unmarshall_uint32(struct dns_buffer *buf, uint32_t *val)
+{
+        uint32_t n_val;
+
+        dns_unmarshall_buffer(buf, (uint8_t *)&n_val, sizeof(n_val));
         if (!(ERR_DNS_IS_OK(buf->error))) return;
 
@@ -153 +153 @@
 
         for (label = name->pLabelList; label != NULL; label = label->next) {
-                uint8 len = label->len;
-
-                dns_marshall_buffer(buf, (uint8 *)&len, sizeof(len));
+                uint8_t len = label->len;
+
+                dns_marshall_buffer(buf, (uint8_t *)&len, sizeof(len));
                 if (!ERR_DNS_IS_OK(buf->error)) return;
 
-                dns_marshall_buffer(buf, (uint8 *)label->label, len);
+                dns_marshall_buffer(buf, (uint8_t *)label->label, len);
                 if (!ERR_DNS_IS_OK(buf->error)) return;
         }
 
-        dns_marshall_buffer(buf, (uint8 *)&end_char, 1);
+        dns_marshall_buffer(buf, (uint8_t *)&end_char, 1);
 }
 
@@ -171 +171 @@
 {
         struct dns_domain_label *label;
-        uint8 len;
+        uint8_t len;
 
         if (!ERR_DNS_IS_OK(buf->error)) return;
@@ -197 +197 @@
                  */
                 struct dns_buffer new_buf;
-                uint8 low;
+                uint8_t low;
 
                 dns_unmarshall_buffer(buf, &low, sizeof(low));
@@ -224 +224 @@
         label->len = len;
 
-        if (!(label->label = TALLOC_ZERO_ARRAY(label, char, len+1))) {
+        if (!(label->label = talloc_zero_array(label, char, len+1))) {
                 buf->error = ERROR_DNS_NO_MEMORY;
                 goto error;
         }
 
-        dns_unmarshall_buffer(buf, (uint8 *)label->label, len);
+        dns_unmarshall_buffer(buf, (uint8_t *)label->label, len);
         if (!ERR_DNS_IS_OK(buf->error)) goto error;
 
@@ -330 +330 @@
 
         if (r->data_length != 0) {
-                if (!(r->data = TALLOC_ZERO_ARRAY(r, uint8, r->data_length))) {
+                if (!(r->data = talloc_zero_array(r, uint8_t, r->data_length))) {
                         buf->error = ERROR_DNS_NO_MEMORY;
                         return;
@@ -347 +347 @@
 {
         struct dns_buffer *buf;
-        uint16 i;
+        uint16_t i;
 
         if (!(buf = dns_create_buffer(mem_ctx))) {
@@ -388 +388 @@
 {
         struct dns_request *req;
-        uint16 i;
+        uint16_t i;
         DNS_ERROR err;
 
-        if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_request))) {
+        if (!(req = talloc_zero(mem_ctx, struct dns_request))) {
                 return ERROR_DNS_NO_MEMORY;
         }
@@ -407 +407 @@
 
         if ((req->num_questions != 0) &&
-            !(req->questions = TALLOC_ZERO_ARRAY(req, struct dns_question *,
+            !(req->questions = talloc_zero_array(req, struct dns_question *,
                                             req->num_questions))) {
                 goto error;
         }
         if ((req->num_answers != 0) &&
-            !(req->answers = TALLOC_ZERO_ARRAY(req, struct dns_rrec *,
+            !(req->answers = talloc_zero_array(req, struct dns_rrec *,
                                           req->num_answers))) {
                 goto error;
         }
         if ((req->num_auths != 0) &&
-            !(req->auths = TALLOC_ZERO_ARRAY(req, struct dns_rrec *,
+            !(req->auths = talloc_zero_array(req, struct dns_rrec *,
                                         req->num_auths))) {
                 goto error;
         }
         if ((req->num_additionals != 0) &&
-            !(req->additionals = TALLOC_ZERO_ARRAY(req, struct dns_rrec *,
+            !(req->additionals = talloc_zero_array(req, struct dns_rrec *,
                                               req->num_additionals))) {
                 goto error;
@@ -525 +525 @@
 }
 
-uint16 dns_response_code(uint16 flags)
+uint16_t dns_response_code(uint16_t flags)
 {
         return flags & 0xF;

vendor/current/lib/addns/dnsrecord.c

@@ -23 +23 @@
 
 #include "dns.h"
+#include "lib/util/genrand.h"
 
 DNS_ERROR dns_create_query( TALLOC_CTX *mem_ctx, const char *name,
-                            uint16 q_type, uint16 q_class,
+                            uint16_t q_type, uint16_t q_class,
                             struct dns_request **preq )
 {
@@ -32 +33 @@
         DNS_ERROR err;
 
-        if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_request)) ||
-            !(req->questions = TALLOC_ARRAY(req, struct dns_question *, 1)) ||
+        if (!(req = talloc_zero(mem_ctx, struct dns_request)) ||
+            !(req->questions = talloc_array(req, struct dns_question *, 1)) ||
             !(req->questions[0] = talloc(req->questions,
                                          struct dns_question))) {
@@ -40 +41 @@
         }
 
-        req->id = random();
+        generate_random_buffer((uint8_t *)&req->id, sizeof(req->id));
 
         req->num_questions = 1;
@@ -65 +66 @@
         DNS_ERROR err;
 
-        if (!(req = TALLOC_ZERO_P(mem_ctx, struct dns_update_request)) ||
-            !(req->zones = TALLOC_ARRAY(req, struct dns_zone *, 1)) ||
+        if (!(req = talloc_zero(mem_ctx, struct dns_update_request)) ||
+            !(req->zones = talloc_array(req, struct dns_zone *, 1)) ||
             !(req->zones[0] = talloc(req->zones, struct dns_zone))) {
                 TALLOC_FREE(req);
@@ -92 +93 @@
 
 DNS_ERROR dns_create_rrec(TALLOC_CTX *mem_ctx, const char *name,
-                          uint16 type, uint16 r_class, uint32 ttl,
-                          uint16 data_length, uint8 *data,
+                          uint16_t type, uint16_t r_class, uint32_t ttl,
+                          uint16_t data_length, uint8_t *data,
                           struct dns_rrec **prec)
 {
@@ -120 +121 @@
 
 DNS_ERROR dns_create_a_record(TALLOC_CTX *mem_ctx, const char *host,
-                              uint32 ttl, const struct sockaddr_storage *pss,
+                              uint32_t ttl, const struct sockaddr_storage *pss,
                               struct dns_rrec **prec)
 {
-        uint8 *data;
+        uint8_t *data;
         DNS_ERROR err;
         struct in_addr ip;
 
         if (pss->ss_family != AF_INET) {
-                /* Silently ignore this. */
-                return ERROR_DNS_SUCCESS;
-        }
-
-        ip = ((struct sockaddr_in *)pss)->sin_addr;
-        if (!(data = (uint8 *)TALLOC_MEMDUP(mem_ctx, (const void *)&ip.s_addr,
+                return ERROR_DNS_INVALID_PARAMETER;
+        }
+
+        ip = ((const struct sockaddr_in *)pss)->sin_addr;
+        if (!(data = (uint8_t *)talloc_memdup(mem_ctx, (const void *)&ip.s_addr,
                                             sizeof(ip.s_addr)))) {
                 return ERROR_DNS_NO_MEMORY;
@@ -146 +146 @@
 
         return err;
+}
+
+DNS_ERROR dns_create_aaaa_record(TALLOC_CTX *mem_ctx, const char *host,
+                                 uint32_t ttl, const struct sockaddr_storage *pss,
+                                 struct dns_rrec **prec)
+{
+#ifdef HAVE_IPV6
+        uint8_t *data;
+        DNS_ERROR err;
+        struct in6_addr ip6;
+
+        if (pss->ss_family != AF_INET6) {
+                return ERROR_DNS_INVALID_PARAMETER;
+        }
+
+        ip6 = ((const struct sockaddr_in6 *)pss)->sin6_addr;
+        if (!(data = (uint8_t *)talloc_memdup(mem_ctx, (const void *)&ip6.s6_addr,
+                                            sizeof(ip6.s6_addr)))) {
+                return ERROR_DNS_NO_MEMORY;
+        }
+
+        err = dns_create_rrec(mem_ctx, host, QTYPE_AAAA, DNS_CLASS_IN, ttl,
+                              sizeof(ip6.s6_addr), data, prec);
+
+        if (!ERR_DNS_IS_OK(err)) {
+                TALLOC_FREE(data);
+        }
+
+        return err;
+#else
+        return ERROR_DNS_INVALID_PARAMETER;
+#endif
 }
 
@@ -154 +186 @@
 {
         if (ss != NULL) {
-                return dns_create_a_record(mem_ctx, name, 0, ss, prec);
+                switch (ss->ss_family) {
+                case AF_INET:
+                        return dns_create_a_record(mem_ctx, name, 0, ss, prec);
+#ifdef HAVE_IPV6
+                case AF_INET6:
+                        return dns_create_aaaa_record(mem_ctx, name, 0, ss, prec);
+#endif
+                default:
+                        return ERROR_DNS_INVALID_PARAMETER;
+                }
         }
 
@@ -162 +203 @@
 
 DNS_ERROR dns_create_name_not_in_use_record(TALLOC_CTX *mem_ctx,
-                                            const char *name, uint32 type,
+                                            const char *name, uint32_t type,
                                             struct dns_rrec **prec)
 {
@@ -170 +211 @@
 
 DNS_ERROR dns_create_delete_record(TALLOC_CTX *mem_ctx, const char *name,
-                                   uint16 type, uint16 r_class,
+                                   uint16_t type, uint16_t r_class,
                                    struct dns_rrec **prec)
 {
@@ -178 +219 @@
 DNS_ERROR dns_create_tkey_record(TALLOC_CTX *mem_ctx, const char *keyname,
                                  const char *algorithm_name, time_t inception,
-                                 time_t expiration, uint16 mode, uint16 error,
-                                 uint16 key_length, const uint8 *key,
+                                 time_t expiration, uint16_t mode, uint16_t error,
+                                 uint16_t key_length, const uint8_t *key,
                                  struct dns_rrec **prec)
 {
@@ -218 +259 @@
                                      struct dns_tkey_record **ptkey)
 {
-        struct dns_tkey_record *tkey = NULL;
+        struct dns_tkey_record *tkey;
         struct dns_buffer buf;
-        uint32 tmp_inception, tmp_expiration;
+        uint32_t tmp_inception, tmp_expiration;
         
         if (!(tkey = talloc(mem_ctx, struct dns_tkey_record))) {
@@ -241 +282 @@
 
         if (tkey->key_length) {
-                if (!(tkey->key = TALLOC_ARRAY(tkey, uint8, tkey->key_length))) {
+                if (!(tkey->key = talloc_array(tkey, uint8_t, tkey->key_length))) {
                         buf.error = ERROR_DNS_NO_MEMORY;
                         goto error;
@@ -265 +306 @@
 DNS_ERROR dns_create_tsig_record(TALLOC_CTX *mem_ctx, const char *keyname,
                                  const char *algorithm_name,
-                                 time_t time_signed, uint16 fudge,
-                                 uint16 mac_length, const uint8 *mac,
-                                 uint16 original_id, uint16 error,
+                                 time_t time_signed, uint16_t fudge,
+                                 uint16_t mac_length, const uint8_t *mac,
+                                 uint16_t original_id, uint16_t error,
                                  struct dns_rrec **prec)
 {
@@ -305 +346 @@
 
 DNS_ERROR dns_add_rrec(TALLOC_CTX *mem_ctx, struct dns_rrec *rec,
-                       uint16 *num_records, struct dns_rrec ***records)
+                       uint16_t *num_records, struct dns_rrec ***records)
 {
         struct dns_rrec **new_records;
 
-        if (!(new_records = TALLOC_REALLOC_ARRAY(mem_ctx, *records,
+        if (!(new_records = talloc_realloc(mem_ctx, *records,
                                                  struct dns_rrec *,
                                                  (*num_records)+1))) {
@@ -335 +376 @@
         struct dns_rrec *rec = NULL;
         DNS_ERROR err;
-        uint16 i;
+        uint16_t i;
 
         err = dns_create_update(mem_ctx, zone, &req);
-        if (!ERR_DNS_IS_OK(err)) goto error;
+        if (!ERR_DNS_IS_OK(err)) return err;
 
         err = dns_create_name_not_in_use_record(req, host, QTYPE_CNAME, &rec);
@@ -405 +446 @@
 
         for ( i=0; i<num_addrs; i++ ) {
-                err = dns_create_a_record(req, hostname, 3600, &ss_addrs[i], &rec);
+
+                switch(ss_addrs[i].ss_family) {
+                case AF_INET:
+                        err = dns_create_a_record(req, hostname, 3600, &ss_addrs[i], &rec);
+                        break;
+#ifdef HAVE_IPV6
+                case AF_INET6:
+                        err = dns_create_aaaa_record(req, hostname, 3600, &ss_addrs[i], &rec);
+                        break;
+#endif
+                default:
+                        continue;
+                }
                 if (!ERR_DNS_IS_OK(err))
                         goto error;

vendor/current/lib/addns/dnssock.c

@@ -28 +28 @@
 #include <unistd.h>
 #include "system/select.h"
+#include "../lib/util/debug.h"
 
 static int destroy_dns_connection(struct dns_connection *conn)
@@ -41 +42 @@
                                struct dns_connection **result )
 {
-        uint32_t ulAddress;
-        struct hostent *pHost;
-        struct sockaddr_in s_in;
+        struct addrinfo hints;
+        struct addrinfo *ai_result = NULL;
+        struct addrinfo *rp;
         struct dns_connection *conn;
-        int res;
+        int ret;
+        char service[16];
+
+        snprintf(service, sizeof(service), "%d", DNS_TCP_PORT);
 
         if (!(conn = talloc(mem_ctx, struct dns_connection))) {
@@ -51 +55 @@
         }
 
-        if ( (ulAddress = inet_addr( nameserver )) == INADDR_NONE ) {
-                if ( (pHost = gethostbyname( nameserver )) == NULL ) {
-                        TALLOC_FREE(conn);
-                        return ERROR_DNS_INVALID_NAME_SERVER;
-                }
-                memcpy( &ulAddress, pHost->h_addr, pHost->h_length );
-        }
-
-        conn->s = socket( PF_INET, SOCK_STREAM, 0 );
-        if (conn->s == -1) {
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_flags = 0;
+        hints.ai_protocol = IPPROTO_TCP;
+
+        ret = getaddrinfo(nameserver, service, &hints, &ai_result);
+        if (ret != 0) {
+                DEBUG(1,("dns_tcp_open: getaddrinfo: %s\n", gai_strerror(ret)));
+                TALLOC_FREE(conn);
+                return ERROR_DNS_INVALID_NAME_SERVER;
+        }
+
+        for (rp = ai_result; rp != NULL; rp = rp->ai_next) {
+                conn->s = socket(rp->ai_family,
+                                rp->ai_socktype,
+                                rp->ai_protocol);
+                if (conn->s == -1) {
+                        continue;
+                }
+                do {
+                        ret = connect(conn->s, rp->ai_addr, rp->ai_addrlen);
+                } while ((ret == -1) && (errno == EINTR));
+                if (ret != -1) {
+                        /* Successful connect */
+                        break;
+                }
+                close(conn->s);
+        }
+
+        freeaddrinfo(ai_result);
+
+        /* Failed to connect with any address */
+        if (rp == NULL) {
                 TALLOC_FREE(conn);
                 return ERROR_DNS_CONNECTION_FAILED;
@@ -67 +95 @@
         talloc_set_destructor(conn, destroy_dns_connection);
 
-        s_in.sin_family = AF_INET;
-        s_in.sin_addr.s_addr = ulAddress;
-        s_in.sin_port = htons( DNS_TCP_PORT );
-
-        res = connect(conn->s, (struct sockaddr*)&s_in, sizeof( s_in ));
-        if (res == -1) {
-                TALLOC_FREE(conn);
-                return ERROR_DNS_CONNECTION_FAILED;
-        }
-
         conn->hType = DNS_TCP;
-
         *result = conn;
         return ERROR_DNS_SUCCESS;
@@ -84 +101 @@
 
 /********************************************************************
-********************************************************************/
+ * ********************************************************************/
 
 static DNS_ERROR dns_udp_open( const char *nameserver,
@@ -90 +107 @@
                                struct dns_connection **result )
 {
-        unsigned long ulAddress;
-        struct hostent *pHost;
-        struct sockaddr_in RecvAddr;
+        struct addrinfo hints;
+        struct addrinfo *ai_result = NULL;
+        struct addrinfo *rp;
+        struct sockaddr_storage RecvAddr;
         struct dns_connection *conn;
+        int ret;
+        socklen_t RecvAddrLen;
+        char service[16];
+
+        snprintf(service, sizeof(service), "%d", DNS_UDP_PORT);
 
         if (!(conn = talloc(NULL, struct dns_connection))) {
@@ -99 +122 @@
         }
 
-        if ( (ulAddress = inet_addr( nameserver )) == INADDR_NONE ) {
-                if ( (pHost = gethostbyname( nameserver )) == NULL ) {
-                        TALLOC_FREE(conn);
-                        return ERROR_DNS_INVALID_NAME_SERVER;
-                }
-                memcpy( &ulAddress, pHost->h_addr, pHost->h_length );
-        }
-
-        /* Create a socket for sending data */
-
-        conn->s = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
-        if (conn->s == -1) {
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_DGRAM;
+        hints.ai_flags = 0;
+        hints.ai_protocol = IPPROTO_UDP;
+
+        ret = getaddrinfo(nameserver, service, &hints, &ai_result);
+        if (ret != 0) {
+                DEBUG(1,("dns_ucp_open:getaddrinfo: %s\n", gai_strerror(ret)));
+                TALLOC_FREE(conn);
+                return ERROR_DNS_INVALID_NAME_SERVER;
+        }
+
+        for (rp = ai_result; rp != NULL; rp = rp->ai_next) {
+                conn->s = socket(rp->ai_family,
+                                rp->ai_socktype,
+                                rp->ai_protocol);
+                if (conn->s == -1) {
+                        continue;
+                }
+                ret = connect(conn->s, rp->ai_addr, rp->ai_addrlen);
+                if (ret != -1) {
+                        /* Successful connect */
+                        break;
+                }
+                close(conn->s);
+        }
+
+        freeaddrinfo(ai_result);
+
+        /* Failed to connect with any address */
+        if (rp == NULL) {
                 TALLOC_FREE(conn);
                 return ERROR_DNS_CONNECTION_FAILED;
@@ -118 +161 @@
 
         /* Set up the RecvAddr structure with the IP address of
-           the receiver (in this example case "123.456.789.1")
-           and the specified port number. */
-
-        ZERO_STRUCT(RecvAddr);
-        RecvAddr.sin_family = AF_INET;
-        RecvAddr.sin_port = htons( DNS_UDP_PORT );
-        RecvAddr.sin_addr.s_addr = ulAddress;
+           the receiver and the specified port number. */
+
+        RecvAddrLen = sizeof(RecvAddr);
+        if (getpeername(conn->s,
+                        (struct sockaddr *)&RecvAddr,
+                        &RecvAddrLen) == -1) {
+                TALLOC_FREE(conn);
+                return ERROR_DNS_CONNECTION_FAILED;
+        }
 
         conn->hType = DNS_UDP;
-        memcpy( &conn->RecvAddr, &RecvAddr, sizeof( struct sockaddr_in ) );
+        memcpy(&conn->RecvAddr, &RecvAddr, sizeof(struct sockaddr_storage));
 
         *result = conn;
@@ -136 +181 @@
 ********************************************************************/
 
-DNS_ERROR dns_open_connection( const char *nameserver, int32 dwType,
+DNS_ERROR dns_open_connection( const char *nameserver, int32_t dwType,
                     TALLOC_CTX *mem_ctx,
                     struct dns_connection **conn )
@@ -150 +195 @@
 }
 
-static DNS_ERROR write_all(int fd, uint8 *data, size_t len)
+static DNS_ERROR write_all(int fd, uint8_t *data, size_t len)
 {
         size_t total = 0;
@@ -156 +201 @@
         while (total < len) {
 
-                ssize_t ret = write(fd, data + total, len - total);
+                ssize_t ret;
+
+                do {
+                        ret = write(fd, data + total, len - total);
+                } while ((ret == -1) && (errno == EINTR));
 
                 if (ret <= 0) {
@@ -174 +223 @@
                               const struct dns_buffer *buf)
 {
-        uint16 len = htons(buf->offset);
+        uint16_t len = htons(buf->offset);
         DNS_ERROR err;
 
-        err = write_all(conn->s, (uint8 *)&len, sizeof(len));
+        err = write_all(conn->s, (uint8_t *)&len, sizeof(len));
         if (!ERR_DNS_IS_OK(err)) return err;
 
@@ -188 +237 @@
         ssize_t ret;
 
-        ret = sendto(conn->s, buf->data, buf->offset, 0,
+        do {
+                ret = sendto(conn->s, buf->data, buf->offset, 0,
                      (struct sockaddr *)&conn->RecvAddr,
                      sizeof(conn->RecvAddr));
+        } while ((ret == -1) && (errno == EINTR));
 
         if (ret != buf->offset) {
@@ -212 +263 @@
 }
 
-static DNS_ERROR read_all(int fd, uint8 *data, size_t len)
+static DNS_ERROR read_all(int fd, uint8_t *data, size_t len)
 {
         size_t total = 0;
@@ -226 +277 @@
 
                 fd_ready = poll(&pfd, 1, 10000);
+                if (fd_ready == -1) {
+                        if (errno == EINTR) {
+                                continue;
+                        }
+                        return ERROR_DNS_SOCKET_ERROR;
+                }
                 if ( fd_ready == 0 ) {
                         /* read timeout */
@@ -231 +288 @@
                 }
 
-                ret = read(fd, data + total, len - total);
+                do {
+                        ret = read(fd, data + total, len - total);
+                } while ((ret == -1) && (errno == EINTR));
+
                 if (ret <= 0) {
                         /* EOF or error */
@@ -249 +309 @@
         struct dns_buffer *buf;
         DNS_ERROR err;
-        uint16 len;
-
-        if (!(buf = TALLOC_ZERO_P(mem_ctx, struct dns_buffer))) {
-                return ERROR_DNS_NO_MEMORY;
-        }
-
-        err = read_all(conn->s, (uint8 *)&len, sizeof(len));
+        uint16_t len;
+
+        if (!(buf = talloc_zero(mem_ctx, struct dns_buffer))) {
+                return ERROR_DNS_NO_MEMORY;
+        }
+
+        err = read_all(conn->s, (uint8_t *)&len, sizeof(len));
         if (!ERR_DNS_IS_OK(err)) {
                 return err;
@@ -262 +322 @@
         buf->size = ntohs(len);
 
-        if (buf->size) {
-                if (!(buf->data = TALLOC_ARRAY(buf, uint8, buf->size))) {
-                        TALLOC_FREE(buf);
-                        return ERROR_DNS_NO_MEMORY;
-                }
-        } else {
-                buf->data = NULL;
-        }
-
-        err = read_all(conn->s, buf->data, buf->size);
+        if (buf->size == 0) {
+                *presult = buf;
+                return ERROR_DNS_SUCCESS;
+        }
+
+        if (!(buf->data = talloc_array(buf, uint8_t, buf->size))) {
+                TALLOC_FREE(buf);
+                return ERROR_DNS_NO_MEMORY;
+        }
+
+        err = read_all(conn->s, buf->data, talloc_get_size(buf->data));
         if (!ERR_DNS_IS_OK(err)) {
                 TALLOC_FREE(buf);
@@ -288 +349 @@
         ssize_t received;
 
-        if (!(buf = TALLOC_ZERO_P(mem_ctx, struct dns_buffer))) {
+        if (!(buf = talloc_zero(mem_ctx, struct dns_buffer))) {
                 return ERROR_DNS_NO_MEMORY;
         }
@@ -296 +357 @@
          */
 
-        if (!(buf->data = TALLOC_ARRAY(buf, uint8, 512))) {
+        if (!(buf->data = talloc_array(buf, uint8_t, 512))) {
                 TALLOC_FREE(buf);
                 return ERROR_DNS_NO_MEMORY;
         }
 
-        received = recv(conn->s, (void *)buf->data, 512, 0);
+        do {
+                received = recv(conn->s, (void *)buf->data, 512, 0);
+        } while ((received == -1) && (errno == EINTR));
 
         if (received == -1) {
@@ -341 +404 @@
         DNS_ERROR err;
 
-        err = dns_marshall_request(conn, req, &buf);
+        err = dns_marshall_request(mem_ctx, req, &buf);
         if (!ERR_DNS_IS_OK(err)) goto error;
 

vendor/current/lib/addns/dnsutils.c

@@ -23 +23 @@
 */
 
+#include "includes.h"
+#include "librpc/ndr/libndr.h"
+#include "librpc/gen_ndr/ndr_misc.h"
+
 #include "dns.h"
 #include <ctype.h>
+
 
 static DNS_ERROR LabelList( TALLOC_CTX *mem_ctx,
@@ -54 +59 @@
         }
 
-        if (!(result = TALLOC_ZERO_P(mem_ctx, struct dns_domain_label))) {
+        if (!(result = talloc_zero(mem_ctx, struct dns_domain_label))) {
                 return ERROR_DNS_NO_MEMORY;
         }
@@ -134 +139 @@
 #if defined(WITH_DNS_UPDATES)
 
-        uuid_t uuid;
+        struct GUID guid;
 
-        /*
-         * uuid_unparse gives 36 bytes plus '\0'
-         */
-        if (!(result = TALLOC_ARRAY(mem_ctx, char, 37))) {
-                return NULL;
-        }
-
-        uuid_generate( uuid );
-        uuid_unparse( uuid, result );
+        guid = GUID_random();
+        result = GUID_string(mem_ctx, &guid);
 
 #endif

vendor/current/lib/addns/wscript_build

@@ -2 +2 @@
 
 bld.SAMBA_LIBRARY('addns',
-                   source='dnsrecord.c dnsutils.c dnssock.c dnsgss.c dnsmarshall.c error.c',
-                   public_deps='talloc krb5 k5crypto com_err gssapi gssapi_krb5 uuid',
+                   source='dnsquery.c dnsrecord.c dnsutils.c dnssock.c dnsgss.c dnsmarshall.c error.c',
+                   public_deps='samba-util gssapi ndr resolv',
                    private_library=True,
                    vars=locals())