[autofs] * Fri Mar 18 2011 Ian Kent <ikent at redhat.com> - 1:5.0.5-37 - replace GPLv3 code with GPLv2 equivalen
Ian Kent
iankent at fedoraproject.org
Fri Mar 18 05:22:36 UTC 2011
commit e80f91ef5ebae4fdc5777b6e0adf6547b3bcdd51
Author: Ian Kent <raven at themaw.net>
Date: Fri Mar 18 13:21:54 2011 +0800
* Fri Mar 18 2011 Ian Kent <ikent at redhat.com> - 1:5.0.5-37
- replace GPLv3 code with GPLv2 equivalent.
autofs-5.0.5-replace-gplv3-code.patch | 791 +++++++++++++++++++++++++++++++++
autofs.spec | 7 +-
2 files changed, 797 insertions(+), 1 deletions(-)
---
diff --git a/autofs-5.0.5-replace-gplv3-code.patch b/autofs-5.0.5-replace-gplv3-code.patch
new file mode 100644
index 0000000..445ac8d
--- /dev/null
+++ b/autofs-5.0.5-replace-gplv3-code.patch
@@ -0,0 +1,791 @@
+autofs-5.0.5 - replace GPLv3 code
+
+From: Ian Kent <raven at themaw.net>
+
+The code to get SRV records from DNS was taken from Samba.
+Samba is a GPLv3 licensed work which forces autofs to GPLv3.
+
+I don't know enough about GPLv3 to know if that is a good thing
+but I also don't like autofs being forced to GPLv3 because one
+of the copyright holders won't grant permission to use the code
+under a GPLv2 license.
+---
+
+ CHANGELOG | 1
+ modules/dclist.c | 592 +++++++++++++++++--------------------------------------
+ 2 files changed, 193 insertions(+), 400 deletions(-)
+
+
+--- autofs-5.0.5.orig/CHANGELOG
++++ autofs-5.0.5/CHANGELOG
+@@ -60,6 +60,7 @@
+ - fix prune cache valid check.
+ - fix mountd vers retry.
+ - fix expire race.
++- replace GPLv3 code.
+
+ 03/09/2009 autofs-5.0.5
+ -----------------------
+--- autofs-5.0.5.orig/modules/dclist.c
++++ autofs-5.0.5/modules/dclist.c
+@@ -1,19 +1,10 @@
+ /*
+- * Copyright 2009 Ian Kent <raven at themaw.net>
+- * Copyright 2009 Red Hat, Inc.
+- *
+- * This module was apapted from code contained in the Samba distribution
+- * file source/libads/dns.c which contained the following copyright
+- * information:
+- *
+- * Unix SMB/CIFS implementation.
+- * DNS utility library
+- * Copyright (C) Gerald (Jerry) Carter 2006.
+- * Copyright (C) Jeremy Allison 2007.
++ * Copyright 2011 Ian Kent <raven at themaw.net>
++ * Copyright 2011 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+- * the Free Software Foundation; either version 3 of the License, or
++ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+@@ -25,7 +16,9 @@
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
++#include <sys/types.h>
+ #include <netinet/in.h>
++#include <arpa/inet.h>
+ #include <arpa/nameser.h>
+ #include <stdlib.h>
+ #include <string.h>
+@@ -39,80 +32,21 @@
+ #include "automount.h"
+ #include "dclist.h"
+
+-#define MAX_DNS_PACKET_SIZE 0xffff
+-#define MAX_DNS_NAME_LENGTH MAXHOSTNAMELEN
+-/* The longest time we will cache dns srv records */
+-#define MAX_TTL (60*60*1) /* 1 hours */
+-
+-#ifdef NS_HFIXEDSZ /* Bind 8/9 interface */
+-#if !defined(C_IN) /* AIX 5.3 already defines C_IN */
+-# define C_IN ns_c_in
+-#endif
+-#if !defined(T_A) /* AIX 5.3 already defines T_A */
+-# define T_A ns_t_a
+-#endif
+-
+-# define T_SRV ns_t_srv
+-#if !defined(T_NS) /* AIX 5.3 already defines T_NS */
+-# define T_NS ns_t_ns
+-#endif
+-#else
+-# ifdef HFIXEDSZ
+-# define NS_HFIXEDSZ HFIXEDSZ
+-# else
+-# define NS_HFIXEDSZ sizeof(HEADER)
+-# endif /* HFIXEDSZ */
+-# ifdef PACKETSZ
+-# define NS_PACKETSZ PACKETSZ
+-# else /* 512 is usually the default */
+-# define NS_PACKETSZ 512
+-# endif /* PACKETSZ */
+-# define T_SRV 33
+-#endif
+-
+-#define SVAL(buf, pos) (*(const uint16_t *)((const char *)(buf) + (pos)))
+-#define IVAL(buf, pos) (*(const uint32_t *)((const char *)(buf) + (pos)))
+-
+-#if __BYTE_ORDER == __LITTLE_ENDIAN
+-#define SREV(x) ((((x)&0xFF)<<8) | (((x)>>8)&0xFF))
+-#define IREV(x) ((SREV(x)<<16) | (SREV((x)>>16)))
+-#else
+-#define SREV(x) (x)
+-#define IREV(x) (x)
+-#endif
+-
+-#define RSVAL(buf, pos) SREV(SVAL(buf, pos))
+-#define RIVAL(buf, pos) IREV(IVAL(buf, pos))
+-
+-#define QSORT_CAST (int (*)(const void *, const void *))
+-
+-/* DNS query section in replies */
+-
+-struct dns_query {
+- const char *hostname;
+- uint16_t type;
+- uint16_t in_class;
+-};
+-
+-/* DNS RR record in reply */
++#define MAX_TTL (60*60) /* 1 hour */
+
+-struct dns_rr {
+- const char *hostname;
+- uint16_t type;
+- uint16_t in_class;
+- uint32_t ttl;
+- uint16_t rdatalen;
+- uint8_t *rdata;
++struct rr {
++ unsigned int type;
++ unsigned int class;
++ unsigned long ttl;
++ unsigned int len;
+ };
+
+-/* SRV records */
+-
+-struct dns_rr_srv {
+- const char *hostname;
+- uint16_t priority;
+- uint16_t weight;
+- uint16_t port;
+- uint32_t ttl;
++struct srv_rr {
++ const char *name;
++ unsigned int priority;
++ unsigned int weight;
++ unsigned int port;
++ unsigned long ttl;
+ };
+
+ static pthread_mutex_t dclist_mutex = PTHREAD_MUTEX_INITIALIZER;
+@@ -133,374 +67,224 @@ static void dclist_mutex_unlock(void)
+ return;
+ }
+
+-static int dns_parse_query(unsigned int logopt,
+- uint8_t *start, uint8_t *end,
+- uint8_t **ptr, struct dns_query *q)
++static int do_srv_query(unsigned int logopt, char *name, u_char **packet)
+ {
+- uint8_t *p = *ptr;
+- char hostname[MAX_DNS_NAME_LENGTH];
+- char buf[MAX_ERR_BUF];
+- int namelen;
+-
+- if (!start || !end || !q || !*ptr)
+- return 0;
++ unsigned int len = PACKETSZ;
++ unsigned int last_len = len;
++ char ebuf[MAX_ERR_BUF];
++ u_char *buf;
++
++ while (1) {
++ buf = malloc(last_len);
++ if (!buf) {
++ char *estr = strerror_r(errno, ebuf, MAX_ERR_BUF);
++ error(logopt, "malloc: %s", estr);
++ return -1;
++ }
+
+- memset(q, 0, sizeof(*q));
++ len = res_query(name, C_IN, T_SRV, buf, last_len);
++ if (len < 0) {
++ char *estr = strerror_r(errno, ebuf, MAX_ERR_BUF);
++ error(logopt, "Failed to resolve %s (%s)", name, estr);
++ free(buf);
++ return -1;
++ }
+
+- /* See RFC 1035 for details. If this fails, then return. */
++ if (len == last_len) {
++ /* These shouldn't too large, bump by PACKETSZ only */
++ last_len += PACKETSZ;
++ free(buf);
++ continue;
++ }
+
+- namelen = dn_expand(start, end, p, hostname, sizeof(hostname));
+- if (namelen < 0) {
+- error(logopt, "failed to expand query hostname");
+- return 0;
++ break;
+ }
+
+- p += namelen;
+- q->hostname = strdup(hostname);
+- if (!q) {
+- char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+- error(logopt, "strdup: %s", estr);
+- return 0;
+- }
++ *packet = buf;
+
+- /* check that we have space remaining */
++ return len;
++}
+
+- if (p + 4 > end) {
+- error(logopt, "insufficient buffer space for result");
+- free((void *) q->hostname);
+- return 0;
+- }
++static int get_name_len(u_char *buffer, u_char *start, u_char *end)
++{
++ char tmp[MAXDNAME];
++ return dn_expand(buffer, end, start, tmp, MAXDNAME);
++}
+
+- q->type = RSVAL(p, 0);
+- q->in_class = RSVAL(p, 2);
+- p += 4;
++static int get_data_offset(u_char *buffer,
++ u_char *start, u_char *end,
++ struct rr *rr)
++{
++ u_char *cp = start;
++ int name_len;
+
+- *ptr = p;
++ name_len = get_name_len(buffer, start, end);
++ if (name_len < 0)
++ return -1;
++ cp += name_len;
+
+- return 1;
++ GETSHORT(rr->type, cp);
++ GETSHORT(rr->class, cp);
++ GETLONG(rr->ttl, cp);
++ GETSHORT(rr->len, cp);
++
++ return (cp - start);
+ }
+
+-static int dns_parse_rr(unsigned int logopt,
+- uint8_t *start, uint8_t *end,
+- uint8_t **ptr, struct dns_rr *rr)
++static struct srv_rr *parse_srv_rr(unsigned int logopt,
++ u_char *buffer, u_char *start, u_char *end,
++ struct rr *rr, struct srv_rr *srv)
+ {
+- uint8_t *p = *ptr;
+- char hostname[MAX_DNS_NAME_LENGTH];
+- char buf[MAX_ERR_BUF];
+- int namelen;
+-
+- if (!start || !end || !rr || !*ptr)
+- return 0;
+-
+- memset(rr, 0, sizeof(*rr));
++ u_char *cp = start;
++ char ebuf[MAX_ERR_BUF];
++ char tmp[MAXDNAME];
++ int len;
+
+- /* pull the name from the answer */
++ GETSHORT(srv->priority, cp);
++ GETSHORT(srv->weight, cp);
++ GETSHORT(srv->port, cp);
++ srv->ttl = rr->ttl;
+
+- namelen = dn_expand(start, end, p, hostname, sizeof(hostname));
+- if (namelen < 0) {
+- error(logopt, "failed to expand query hostname");
+- return 0;
++ len = dn_expand(buffer, end, cp, tmp, MAXDNAME);
++ if (len < 0) {
++ error(logopt, "failed to expand name");
++ return NULL;
+ }
+- p += namelen;
+- rr->hostname = strdup(hostname);
+- if (!rr->hostname) {
+- char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
++ srv->name = strdup(tmp);
++ if (!srv->name) {
++ char *estr = strerror_r(errno, ebuf, MAX_ERR_BUF);
+ error(logopt, "strdup: %s", estr);
+- return 0;
+- }
+-
+- /* check that we have space remaining */
+-
+- if (p + 10 > end) {
+- error(logopt, "insufficient buffer space for result");
+- free((void *) rr->hostname);
+- return 0;
++ return NULL;
+ }
+
+- /* pull some values and then skip onto the string */
+-
+- rr->type = RSVAL(p, 0);
+- rr->in_class = RSVAL(p, 2);
+- rr->ttl = RIVAL(p, 4);
+- rr->rdatalen = RSVAL(p, 8);
++ return srv;
++}
+
+- p += 10;
++static int cmp(struct srv_rr *a, struct srv_rr *b)
++{
++ if (a->priority < b->priority)
++ return -1;
+
+- /* sanity check the available space */
++ if (a->priority > b->priority)
++ return 1;
+
+- if (p + rr->rdatalen > end) {
+- error(logopt, "insufficient buffer space for data");
+- free((void *) rr->hostname);
++ if (!a->weight || a->weight == b->weight)
+ return 0;
+- }
+
+- /* save a point to the rdata for this section */
+-
+- rr->rdata = p;
+- p += rr->rdatalen;
+-
+- *ptr = p;
++ if (a->weight > b->weight)
++ return -1;
+
+ return 1;
+ }
+
+-static int dns_parse_rr_srv(unsigned int logopt,
+- uint8_t *start, uint8_t *end,
+- uint8_t **ptr, struct dns_rr_srv *srv)
+-{
+- struct dns_rr rr;
+- uint8_t *p;
+- char dcname[MAX_DNS_NAME_LENGTH];
+- char buf[MAX_ERR_BUF];
+- int namelen;
+-
+- if (!start || !end || !srv || !*ptr)
+- return 0;
+-
+- /* Parse the RR entry. Coming out of the this, ptr is at the beginning
+- of the next record */
+-
+- if (!dns_parse_rr(logopt, start, end, ptr, &rr)) {
+- error(logopt, "Failed to parse RR record");
+- return 0;
+- }
++static void free_srv_rrs(struct srv_rr *dcs, unsigned int count)
++{
++ int i;
+
+- if (rr.type != T_SRV) {
+- error(logopt, "Bad answer type (%d)", rr.type);
+- return 0;
++ for (i = 0; i < count; i++) {
++ if (dcs[i].name)
++ free((void *) dcs[i].name);
+ }
++ free(dcs);
++}
+
+- p = rr.rdata;
++int get_srv_rrs(unsigned int logopt,
++ char *name, struct srv_rr **dcs, unsigned int *dcs_count)
++{
++ struct srv_rr *srvs;
++ unsigned int srv_num;
++ HEADER *header;
++ u_char *packet;
++ u_char *start;
++ u_char *end;
++ unsigned int count;
++ int i, len;
++ char ebuf[MAX_ERR_BUF];
+
+- srv->priority = RSVAL(p, 0);
+- srv->weight = RSVAL(p, 2);
+- srv->port = RSVAL(p, 4);
+- srv->ttl = rr.ttl;
+-
+- p += 6;
+-
+- namelen = dn_expand(start, end, p, dcname, sizeof(dcname));
+- if (namelen < 0) {
+- error(logopt, "Failed to expand dcname");
++ len = do_srv_query(logopt, name, &packet);
++ if (len < 0)
+ return 0;
+- }
+
+- srv->hostname = strdup(dcname);
+- if (!srv->hostname) {
+- char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+- error(logopt, "strdup: %s", estr);
+- return 0;
+- }
++ header = (HEADER *) packet;
++ start = packet + sizeof(HEADER);
++ end = packet + len;
+
+- debug(logopt, "Parsed %s [%u, %u, %u]",
+- srv->hostname, srv->priority, srv->weight, srv->port);
++ srvs = NULL;
++ srv_num = 0;
+
+- return 1;
+-}
+-
+-/*********************************************************************
+- Sort SRV record list based on weight and priority. See RFC 2782.
+-*********************************************************************/
+-
+-static int dnssrvcmp(struct dns_rr_srv *a, struct dns_rr_srv *b)
+-{
+- if (a->priority == b->priority) {
+- /* randomize entries with an equal weight and priority */
+- if (a->weight == b->weight)
+- return 0;
+-
+- /* higher weights should be sorted lower */
+- if (a->weight > b->weight)
+- return -1;
+- else
+- return 1;
++ /* Skip over question */
++ len = get_name_len(packet, start, end);
++ if (len < 0) {
++ error(logopt, "failed to get name length");
++ goto error_out;
+ }
+
+- if (a->priority < b->priority)
+- return -1;
++ start += len + QFIXEDSZ;
+
+- return 1;
+-}
++ count = ntohs(header->ancount);
+
+-#define DNS_FAILED_WAITTIME 30
++ debug(logopt, "%d records returned in the answer section", count);
+
+-static int dns_send_req(unsigned int logopt,
+- const char *name, int q_type, uint8_t **rbuf,
+- int *resp_length)
+-{
+- uint8_t *buffer = NULL;
+- size_t buf_len = 0;
+- int resp_len = NS_PACKETSZ;
+- static time_t last_dns_check = 0;
+- static unsigned int last_dns_status = 0;
+- time_t now = time(NULL);
+- char buf[MAX_ERR_BUF];
++ if (count <= 0) {
++ error(logopt, "no records found in answers section");
++ goto error_out;
++ }
+
+- /* Try to prevent bursts of DNS lookups if the server is down */
++ srvs = malloc(sizeof(struct srv_rr) * count);
++ if (!srvs) {
++ char *estr = strerror_r(errno, ebuf, MAX_ERR_BUF);
++ error(logopt, "malloc: %s", estr);
++ goto error_out;
++ }
++ memset(srvs, 0, sizeof(struct srv_rr) * count);
+
+- /* Protect against large clock changes */
++ srv_num = 0;
++ for (i = 0; i < count && (start < end); i++) {
++ unsigned int data_offset;
++ struct srv_rr srv;
++ struct srv_rr *psrv;
++ struct rr rr;
+
+- if (last_dns_check > now)
+- last_dns_check = 0;
++ memset(&rr, 0, sizeof(struct rr));
+
+- /* IF we had a DNS timeout or a bad server and we are still
+- in the 30 second cache window, just return the previous
+- status and save the network timeout. */
+-
+- if ((last_dns_status == ETIMEDOUT ||
+- last_dns_status == ECONNREFUSED) &&
+- ((last_dns_check + DNS_FAILED_WAITTIME) > now)) {
+- char *estr = strerror_r(last_dns_status, buf, MAX_ERR_BUF);
+- debug(logopt, "Returning cached status (%s)", estr);
+- return last_dns_status;
+- }
+-
+- /* Send the Query */
+- do {
+- if (buffer)
+- free(buffer);
+-
+- buf_len = resp_len * sizeof(uint8_t);
+-
+- if (buf_len) {
+- buffer = malloc(buf_len);
+- if (!buffer) {
+- char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+- error(logopt, "malloc: %s", estr);
+- last_dns_status = ENOMEM;
+- last_dns_check = time(NULL);
+- return last_dns_status;
+- }
++ data_offset = get_data_offset(packet, start, end, &rr);
++ if (data_offset <= 0) {
++ error(logopt, "failed to get start of data");
++ goto error_out;
+ }
++ start += data_offset;
+
+- resp_len = res_query(name, C_IN, q_type, buffer, buf_len);
+- if (resp_len < 0) {
+- char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+- error(logopt, "Failed to resolve %s (%s)", name, estr);
+- free(buffer);
+- last_dns_status = ENOENT;
+- last_dns_check = time(NULL);
+- return last_dns_status;
+- }
+-
+- /* On AIX, Solaris, and possibly some older glibc systems (e.g. SLES8)
+- truncated replies never give back a resp_len > buflen
+- which ends up causing DNS resolve failures on large tcp DNS replies */
+-
+- if (buf_len == resp_len) {
+- if (resp_len == MAX_DNS_PACKET_SIZE) {
+- error(logopt,
+- "DNS reply too large when resolving %s",
+- name);
+- free(buffer);
+- last_dns_status = EMSGSIZE;
+- last_dns_check = time(NULL);
+- return last_dns_status;
+- }
++ if (rr.type != T_SRV)
++ continue;
+
+- resp_len = MIN(resp_len * 2, MAX_DNS_PACKET_SIZE);
++ psrv = parse_srv_rr(logopt, packet, start, end, &rr, &srv);
++ if (psrv) {
++ memcpy(&srvs[srv_num], psrv, sizeof(struct srv_rr));
++ srv_num++;
+ }
+- } while (buf_len < resp_len && resp_len <= MAX_DNS_PACKET_SIZE);
+-
+- *rbuf = buffer;
+- *resp_length = resp_len;
+-
+- last_dns_check = time(NULL);
+- last_dns_status = 0;
+-
+- return 0;
+-}
+-
+-static int dns_lookup_srv(unsigned int logopt, const char *name,
+- struct dns_rr_srv **dclist, int *numdcs)
+-{
+- uint8_t *buffer = NULL;
+- int resp_len = 0;
+- struct dns_rr_srv *dcs = NULL;
+- int query_count, answer_count;
+- uint8_t *p = buffer;
+- int rrnum;
+- int idx = 0;
+- char buf[MAX_ERR_BUF];
+- int ret;
+-
+- if (!name || !dclist)
+- return -EINVAL;
+-
+- /* Send the request. May have to loop several times in case
+- of large replies */
+-
+- ret = dns_send_req(logopt, name, T_SRV, &buffer, &resp_len);
+- if (ret) {
+- error(logopt, "Failed to send DNS query");
+- return ret;
+- }
+- p = buffer;
+-
+- /* For some insane reason, the ns_initparse() et. al. routines are only
+- available in libresolv.a, and not the shared lib. Who knows why....
+- So we have to parse the DNS reply ourselves */
+-
+- /* Pull the answer RR's count from the header.
+- * Use the NMB ordering macros */
+-
+- query_count = RSVAL(p, 4);
+- answer_count = RSVAL(p, 6);
+-
+- debug(logopt,
+- "%d records returned in the answer section.",
+- answer_count);
+
+- if (answer_count) {
+- dcs = malloc(sizeof(struct dns_rr_srv) * answer_count);
+- if (!dcs) {
+- char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+- error(logopt, "malloc: %s", estr);
+- free(buffer);
+- return ENOMEM;
+- }
++ start += rr.len;
+ }
++ free(packet);
+
+- /* now skip the header */
+-
+- p += NS_HFIXEDSZ;
+-
+- /* parse the query section */
+-
+- for (rrnum = 0; rrnum < query_count; rrnum++) {
+- struct dns_query q;
+-
+- ret = dns_parse_query(logopt, buffer, buffer+resp_len, &p, &q);
+- if (!ret) {
+- error(logopt,
+- "Failed to parse query record [%d]", rrnum);
+- free(buffer);
+- free(dcs);
+- return EBADMSG;
+- }
++ if (!srv_num) {
++ error(logopt, "no srv resource records found");
++ goto error_srvs;
+ }
+
+- /* now we are at the answer section */
++ qsort(srvs, srv_num, sizeof(struct srv_rr),
++ (int (*)(const void *, const void *)) cmp);
+
+- for (rrnum = 0; rrnum < answer_count; rrnum++) {
+- ret = dns_parse_rr_srv(logopt,
+- buffer, buffer+resp_len,
+- &p, &dcs[rrnum]);
+- if (!ret) {
+- error(logopt,
+- "Failed to parse answer record [%d]", rrnum);
+- free(buffer);
+- free(dcs);
+- return EBADMSG;
+- }
+- }
+- idx = rrnum;
++ *dcs = srvs;
++ *dcs_count = srv_num;
+
+- qsort(dcs, idx, sizeof(struct dns_rr_srv), QSORT_CAST dnssrvcmp);
+-
+- *dclist = dcs;
+- *numdcs = idx;
++ return 1;
+
++error_out:
++ free(packet);
++error_srvs:
++ if (srvs)
++ free_srv_rrs(srvs, srv_num);
+ return 0;
+ }
+
+@@ -553,14 +337,14 @@ void free_dclist(struct dclist *dclist)
+ static char *getdnsdomainname(unsigned int logopt)
+ {
+ struct addrinfo hints, *ni;
+- char name[MAX_DNS_NAME_LENGTH + 1];
++ char name[MAXDNAME + 1];
+ char buf[MAX_ERR_BUF];
+ char *dnsdomain = NULL;
+ char *ptr;
+ int ret;
+
+ memset(name, 0, sizeof(name));
+- if (gethostname(name, MAX_DNS_NAME_LENGTH) == -1) {
++ if (gethostname(name, MAXDNAME) == -1) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ error(logopt, "gethostname: %s", estr);
+ return NULL;
+@@ -593,14 +377,12 @@ struct dclist *get_dc_list(unsigned int
+ {
+ LDAPURLDesc *ludlist = NULL;
+ LDAPURLDesc **ludp;
+- struct dns_rr_srv *dcs;
+ unsigned int min_ttl = MAX_TTL;
+ struct dclist *dclist = NULL;;
+ char buf[MAX_ERR_BUF];
+ char *dn_uri, *esc_uri;
+ char *domain;
+ char *list;
+- int numdcs;
+ int ret;
+
+ if (strcmp(uri, "ldap:///") && strcmp(uri, "ldaps:///")) {
+@@ -679,6 +461,8 @@ struct dclist *get_dc_list(unsigned int
+ list = NULL;
+ for (ludp = &ludlist; *ludp != NULL;) {
+ LDAPURLDesc *lud = *ludp;
++ struct srv_rr *dcs = NULL;
++ unsigned int numdcs = 0;
+ size_t req_len, len;
+ char *request = NULL;
+ char *tmp;
+@@ -716,7 +500,7 @@ struct dclist *get_dc_list(unsigned int
+ }
+
+ dclist_mutex_lock();
+- if (dns_lookup_srv(logopt, request, &dcs, &numdcs)) {
++ if (!get_srv_rrs(logopt, request, &dcs, &numdcs)) {
+ error(logopt,
+ "DNS SRV query failed for domain %s", domain);
+ dclist_mutex_unlock();
+@@ -733,7 +517,7 @@ struct dclist *get_dc_list(unsigned int
+ for (i = 0; i < numdcs; i++) {
+ if (dcs[i].ttl > 0 && dcs[i].ttl < min_ttl)
+ min_ttl = dcs[i].ttl;
+- len += strlen(dcs[i].hostname);
++ len += strlen(dcs[i].name);
+ if (dcs[i].port > 0)
+ len += sizeof(":65535");
+ }
+@@ -742,6 +526,8 @@ struct dclist *get_dc_list(unsigned int
+ if (!tmp) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ error(logopt, "realloc: %s", estr);
++ if (dcs)
++ free_srv_rrs(dcs, numdcs);
+ goto out_error;
+ }
+
+@@ -755,13 +541,15 @@ struct dclist *get_dc_list(unsigned int
+ strcat(tmp, " ");
+ strcat(tmp, lud->lud_scheme);
+ strcat(tmp, "://");
+- strcat(tmp, dcs[i].hostname);
++ strcat(tmp, dcs[i].name);
+ if (dcs[i].port > 0) {
+ char port[7];
+ ret = snprintf(port, 7, ":%d", dcs[i].port);
+ if (ret > 6) {
+ error(logopt,
+ "invalid port: %u", dcs[i].port);
++ if (dcs)
++ free_srv_rrs(dcs, numdcs);
+ goto out_error;
+ }
+ strcat(tmp, port);
+@@ -771,10 +559,14 @@ struct dclist *get_dc_list(unsigned int
+
+ *ludp = lud->lud_next;
+ ber_memfree(domain);
++ free_srv_rrs(dcs, numdcs);
+ }
+
+ ldap_free_urldesc(ludlist);
+
++ if (!list)
++ goto out_error;
++
+ dclist->expire = time(NULL) + min_ttl;
+ dclist->uri = list;
+
diff --git a/autofs.spec b/autofs.spec
index 9fc9a65..01d5add 100644
--- a/autofs.spec
+++ b/autofs.spec
@@ -4,7 +4,7 @@
Summary: A tool for automatically mounting and unmounting filesystems
Name: autofs
Version: 5.0.5
-Release: 36%{?dist}
+Release: 37%{?dist}
Epoch: 1
License: GPLv2+
Group: System Environment/Daemons
@@ -75,6 +75,7 @@ Patch63: autofs-5.0.5-fix-prune-cache-valid-check.patch
Patch64: autofs-5.0.5-fix-mountd-vers-retry.patch
Patch65: autofs-5.0.5-fix-expire-race.patch
Patch66: autofs-5.0.5-add-lsb-force-reload-and-try-restart.patch
+Patch67: autofs-5.0.5-replace-gplv3-code.patch
Buildroot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
BuildRequires: autoconf, hesiod-devel, openldap-devel, bison, flex, libxml2-devel, cyrus-sasl-devel, openssl-devel module-init-tools util-linux nfs-utils e2fsprogs libtirpc-devel
Conflicts: cyrus-sasl-lib < 2.1.23-9
@@ -183,6 +184,7 @@ echo %{version}-%{release} > .version
%patch64 -p1
%patch65 -p1
%patch66 -p1
+%patch67 -p1
%build
#CFLAGS="$RPM_OPT_FLAGS" ./configure --prefix=/usr --libdir=%{_libdir}
@@ -235,6 +237,9 @@ fi
%{_libdir}/autofs/
%changelog
+* Fri Mar 18 2011 Ian Kent <ikent at redhat.com> - 1:5.0.5-37
+- replace GPLv3 code with GPLv2 equivalent.
+
* Thu Mar 03 2011 Ian Kent <ikent at redhat.com> - 1:5.0.5-36
- use weight only for server selection.
- fix isspace() wild card substition.
More information about the scm-commits
mailing list