/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include "mdns_common.h"

static int _nss_mdns_queryrecord(const char *rrname, int rrclass, int rrtype,
                DNSServiceQueryRecordReply callback,
                struct mdns_querydata *data);
static void _nss_mdns_get_svcstatetimestamp(struct timeval *);
static void _nss_mdns_loadsmfcfg(mdns_backend_ptr_t);
static void _nss_mdns_freesmfcfg(mdns_backend_ptr_t);
static boolean_t cmpdmn(char *, char **, int);
static char *RDataToName(char *data, char *buffer, int datalen, int buflen);
static int searchdomain(mdns_backend_ptr_t, char *, int, char **);
static boolean_t validdomain(mdns_backend_ptr_t, char *, int);

/*
 * This file includes the functions to query for host name
 * information via Multicast DNS (mDNS). The function
 * _nss_mdns_queryrecord queries for the host information via
 * Multicast DNS. _nss_mdns_querybyname and _nss_mdns_querybyaddr
 * query for host IP address and hostname by querying for A/AAAA
 * and PTR DNS resource records respectively. DNSServiceQueryRecord
 * in libdns_sd sends a request to the mDNS daemon (mdnsd) to place
 * the DNS query via multicast and return the results.
 * mdnsd is managed by SMF (FMRI: svc:/network/dns/multicast:default).
 *
 * gethostent.c and gethostent6.c implement the nsswitch 'hosts'
 * backend module getXbyY functions: getbyname and getbyaddr.
 * getby* functions in gethostent.c  supports only IPv4 and
 * getby* functions in gethostent6.c returns both IPv4 and
 * IPv6 results. Functions in gethostent.c and gethostent6.c
 * call the _nss_mdns_queryby* functions in mdns_common.c to
 * query for host information via mDNS.
 *
 * Configuration for mdns is stored in SMF and is accessed using
 * the FMRI: svc:/network/dns/multicast:default. Configuration
 * includes the list of valid DNS domains checked before querying host
 * information via mDNS and the search list to use for host lookup via
 * mDNS. The default valid domain list in the mDNS service supports host
 * lookups for hostnames in the ".local" domain and hostname queries
 * for link-local IPv4 and IPv6 addresses. _nss_mdns_loadsmfcfg
 * loads the nss_mdns configuration from SMF and the function
 * _nss_mdns_updatecfg checks for any updates in nss_mdns configuration.
 */

static int
_nss_mdns_queryrecord(const char *rrname, int rrclass, int rrtype,
                DNSServiceQueryRecordReply callback,
                struct mdns_querydata *data)
{
        int sockfd;
        int flags = kDNSServiceFlagsForceMulticast;  /* Multicast only */
        int opinterface = kDNSServiceInterfaceIndexAny;
        DNSServiceErrorType err;
        DNSServiceRef ref = NULL;
        int ret;
        struct fd_set readfds;
        struct timeval tv;

        data->status = NSS_NOTFOUND;
#ifdef DEBUG
        syslog(LOG_DEBUG, "nss_mdns: query called rrname:%s rrtype:%d",
            rrname, rrtype);
#endif
        err = DNSServiceQueryRecord(&ref, flags, opinterface,
            rrname, rrtype, rrclass, callback, data);
        if (err != kDNSServiceErr_NoError || ref == NULL ||
            (sockfd = DNSServiceRefSockFD(ref)) == 0) {
                DNSServiceRefDeallocate(ref);
                data->status = NSS_UNAVAIL;
                return (NSS_UNAVAIL);
        }

        do {
                FD_ZERO(&readfds);
                FD_SET(sockfd, &readfds);
                tv.tv_sec = NSSMDNS_MAXQRYTMO;
                tv.tv_usec = 0;

                /* Wait until response received from mDNS daemon */
                ret = select(sockfd + 1, &readfds, NULL, NULL, &tv);
                if (!((ret > 0) && FD_ISSET(sockfd, &readfds) &&
                    (DNSServiceProcessResult(ref) == kDNSServiceErr_NoError))) {
                        data->status = NSS_NOTFOUND;
                        if (errno != EINTR)
                                data->qrydone = B_TRUE;
                }
        } while (data->qrydone != B_TRUE);

        if (data->status == NSS_SUCCESS && (data->withttlbuffer == NULL)) {
                nss_XbyY_args_t *argp = data->argp;
                if (argp->buf.result != NULL) {
                        int stat;

                        if (data->buffer == NULL) {
                                data->status = NSS_NOTFOUND;
                                DNSServiceRefDeallocate(ref);
                                return (data->status);
                        }
                        stat = (*argp->str2ent)(data->buffer,
                            strlen(data->buffer),
                            argp->buf.result, argp->buf.buffer,
                            argp->buf.buflen);
                        if (stat == NSS_STR_PARSE_SUCCESS) {
                                argp->returnval = argp->buf.result;
                                argp->returnlen = 1;
                        } else {
                                data->status = NSS_NOTFOUND;
                                if (stat == NSS_STR_PARSE_ERANGE)
                                        argp->erange = 1;
                        }
                        free(data->buffer);
                } else {
                        argp->returnval = argp->buf.buffer;
                        argp->returnlen = strlen(argp->buf.buffer);
                }
                data->buffer = NULL;
                data->buflen = 0;
        }

        if (data->status != NSS_SUCCESS)
                data->argp->h_errno = HOST_NOT_FOUND;

        DNSServiceRefDeallocate(ref);
        return (data->status);
}

static void
/* LINTED E_FUNC_ARG_UNUSED */
_nss_mdns_querynamereply(DNSServiceRef sdRef, const DNSServiceFlags flags,
                /* LINTED E_FUNC_ARG_UNUSED */
                uint32_t ifIndex, DNSServiceErrorType errorCode,
                const char *fullname, uint16_t rrtype, uint16_t rrclass,
                /* LINTED E_FUNC_ARG_UNUSED */
                uint16_t rdlen, const void *rdata, uint32_t ttl,
                void *context)
{
        struct mdns_querydata *qdata;
        nss_XbyY_args_t *argp;
        int firstent = 0;
        int af;
        char addrstore[INET6_ADDRSTRLEN];
        char *buffer;
        int len;
        int remlen;

        qdata = (struct mdns_querydata *)context;
        argp = qdata->argp;

        if (errorCode != kDNSServiceErr_NoError) {
                qdata->qrydone = B_TRUE;
                return;
        }
        if ((flags & kDNSServiceFlagsMoreComing))
                qdata->qrydone = B_FALSE;
        else
                qdata->qrydone = B_TRUE;
        if (!(flags & kDNSServiceFlagsAdd))
                return;
        if (rrclass != kDNSServiceClass_IN)
                return;

        if (rrtype == kDNSServiceType_A)
                af = AF_INET;
        else if (rrtype == kDNSServiceType_AAAA)
                af = AF_INET6;
        else
                return;

        if (qdata->buffer == NULL) {
                if (qdata->withttlbsize > 0) {
                        remlen = qdata->buflen =
                            qdata->withttlbsize;
                        buffer = qdata->buffer =
                            qdata->withttlbuffer;
                        (void) memset(qdata->buffer, 0, remlen);
                } else {
                        remlen = qdata->buflen =
                            argp->buf.buflen;
                        if (argp->buf.result != NULL) {
                                buffer = qdata->buffer =
                                    calloc(1, remlen);
                        } else {
                                /* Return in file format */
                                (void) memset(argp->buf.buffer,
                                    0, remlen);
                                buffer = qdata->buffer = argp->buf.buffer;
                        }
                }
                firstent = 1;
        } else {
                buffer = qdata->buffer + strlen(qdata->buffer);
                remlen = qdata->buflen - strlen(qdata->buffer);
        }

#ifdef DEBUG
        syslog(LOG_DEBUG, "nss_mdns: querynamereply remlen:%d", remlen);
#endif
        if (inet_ntop(af, rdata, addrstore, INET6_ADDRSTRLEN) != NULL) {
                if (firstent)
                        len = snprintf(buffer, remlen, "%s %s",
                            addrstore, fullname);
                else
                        len = snprintf(buffer, remlen, "\n%s %s",
                            addrstore, fullname);
                if (len >= remlen || len < 0) {
                        qdata->status = NSS_NOTFOUND;
                        qdata->argp->erange = 1;
                        qdata->argp->h_errno = HOST_NOT_FOUND;
                        return;
                }
                qdata->ttl      = ttl;
                qdata->status   = NSS_SUCCESS;
#ifdef DEBUG
                syslog(LOG_DEBUG, "nss_mdns: querynamereply buffer:%s", buffer);
#endif
        } else {
                qdata->status = NSS_NOTFOUND;
                qdata->argp->h_errno = HOST_NOT_FOUND;
        }
}

int
_nss_mdns_querybyname(mdns_backend_ptr_t be, char *qname,
                int af, struct mdns_querydata *data)
{
        int rrtype;
        int rrclass;
        int srchidx = 0;
        int rc;
        char hname[MAXDNAME];
        char *name;
        char *sname;

        rrclass = kDNSServiceClass_IN;
        if (af == AF_INET6)
                rrtype = kDNSServiceType_ANY;
        else if (af == AF_INET)
                rrtype = kDNSServiceType_A;
        else
                return (NSS_NOTFOUND);

        name = strdup(qname);
        if (name == NULL)
                return (NSS_UNAVAIL);

        while ((srchidx = searchdomain(be, name, srchidx, &sname)) != -1) {
                if (sname != NULL)
                        (void) snprintf(hname, sizeof (hname), "%s.%s",
                            name, sname);
                else
                        (void) strlcpy(hname, name, sizeof (hname));
#ifdef DEBUG
        syslog(LOG_DEBUG, "nss_mdns: querybyname called" \
            " srchidx:%d af:%d hname:%s", srchidx, af, qname);
#endif
                rc = _nss_mdns_queryrecord(hname, rrclass, rrtype,
                    _nss_mdns_querynamereply, data);
                if ((rc == NSS_UNAVAIL) || (rc == NSS_SUCCESS)) {
                        free(name);
                        return (rc);
                }
        }
        free(name);
        return (NSS_NOTFOUND);
}

static void
/* LINTED E_FUNC_ARG_UNUSED */
_nss_mdns_queryaddrreply(DNSServiceRef sdRef, const DNSServiceFlags flags,
                /* LINTED E_FUNC_ARG_UNUSED */
                uint32_t ifIndex, DNSServiceErrorType errorCode,
                /* LINTED E_FUNC_ARG_UNUSED */
                const char *fullname, uint16_t rrtype, uint16_t rrclass,
                uint16_t rdlen, const void *rdata, uint32_t ttl,
                void *context)
{
        struct mdns_querydata *qdata;
        nss_XbyY_args_t *argp;
        char hostname[NI_MAXHOST];
        int firstent = 0;
        char *buffer;
        int len;
        int remlen;

        qdata = (struct mdns_querydata *)context;
        argp = qdata->argp;

        if (errorCode != kDNSServiceErr_NoError) {
                qdata->qrydone = B_TRUE;
                return;
        }
        if ((flags & kDNSServiceFlagsMoreComing))
                qdata->qrydone = B_FALSE;
        else
                qdata->qrydone = B_TRUE;
        if (!(flags & kDNSServiceFlagsAdd))
                return;
        if (rrclass != kDNSServiceClass_IN)
                return;
        if (rrtype != kDNSServiceType_PTR)
                return;

        if (qdata->buffer == NULL) {
                remlen = qdata->buflen = argp->buf.buflen;
                if (argp->buf.result != NULL) {
                        buffer = qdata->buffer = calloc(1, remlen);
                } else {
                        /* Return in file format */
                        (void) memset(argp->buf.buffer, 0, remlen);
                        buffer = qdata->buffer = argp->buf.buffer;
                }
                firstent = 1;
        } else {
                buffer = qdata->buffer + strlen(qdata->buffer);
                remlen = qdata->buflen - strlen(qdata->buffer);
        }

        if (RDataToName((char *)rdata, hostname, rdlen, NI_MAXHOST) == NULL) {
                qdata->status = NSS_NOTFOUND;
                qdata->argp->h_errno = HOST_NOT_FOUND;
                return;
        }

#ifdef DEBUG
        syslog(LOG_DEBUG, "nss_mdns: querynamereply remlen:%d", remlen);
#endif
        if (firstent)
                len = snprintf(buffer, remlen, "%s %s",
                    qdata->paddrbuf, hostname);
        else
                len = snprintf(buffer, remlen, "\n%s %s",
                    qdata->paddrbuf, hostname);
        if (len >= remlen || len < 0) {
                qdata->status = NSS_NOTFOUND;
                qdata->argp->erange = 1;
                qdata->argp->h_errno = HOST_NOT_FOUND;
                return;
        }
        qdata->status   = NSS_SUCCESS;
        qdata->ttl      = ttl;
}

int
/* LINTED E_FUNC_ARG_UNUSED */
_nss_mdns_querybyaddr(mdns_backend_ptr_t be, char *name, int af,
                struct mdns_querydata *data)
{
        int rrtype;
        int rrclass;

#ifdef DEBUG
        syslog(LOG_DEBUG, "nss_mdns: querybyaddr called" \
            " af:%d addr:%s", af, name);
#endif
        rrclass = kDNSServiceClass_IN;
        rrtype = kDNSServiceType_PTR;

        if (validdomain(be, name, 0) == B_FALSE) {
                data->status = NSS_NOTFOUND;
                return (NSS_NOTFOUND);
        }
        return (_nss_mdns_queryrecord(name, rrclass, rrtype,
            _nss_mdns_queryaddrreply, data));
}

/*
 * Converts the encoded name in RData returned
 * by mDNS query to name in file format
 */
static char *
RDataToName(char *data, char *buffer, int datalen, int buflen)
{
        char *src = data;
        char *srcend = data + datalen;
        char *ptr = buffer;
        char *end;
        char *bend = buffer + buflen - 1; /* terminal '\0' */
        int domainlen = 0;

        while ((src < srcend) && (*src != 0)) {

                /* first byte is len */
                domainlen = *src++;
                end = src + domainlen;

                while ((src < end) && (ptr < bend)) {
                        uint8_t ch = *src++;
                        if (ch == '.' || ch == '\\') {
                                *ptr++ = '\\';
                        }
                        *ptr++ = ch;
                }

                /*
                 * Check if we copied entire domain str. and
                 * if space is still remaining for '.' seperator
                 */
                if ((src != end) || (ptr == bend))
                        return (NULL);
                *ptr++ = '.';
        }
        *ptr = '\0';
        return (ptr);
}

nss_backend_t *
_nss_mdns_constr(mdns_backend_op_t ops[], int n_ops)
{
        mdns_backend_ptr_t      be;

        if ((be = (mdns_backend_ptr_t)calloc(1, sizeof (*be))) == NULL)
                return (NULL);
        be->ops = ops;
        be->n_ops = n_ops;
        _nss_mdns_updatecfg(be);
        return ((nss_backend_t *)be);
}

void
_nss_mdns_destr(mdns_backend_ptr_t be)
{
        if (be != NULL) {
                _nss_mdns_freesmfcfg(be);
                free(be);
        }
}

static int
searchdomain(mdns_backend_ptr_t be, char *name, int srchidx, char **sname)
{
        int trailing_dot = 0;
        char *ch;
        *sname = NULL;

        ch = name + strlen(name) - 1;
        if ((*ch) == '.')
                trailing_dot++;

        if (trailing_dot && srchidx > 0)
                /*
                 * If there is a trailing dot in the query
                 * name, do not perform any additional queries
                 * with search domains.
                 */
                return (-1);

        if (srchidx == 0) {
                /*
                 * If there is a trailing dot in the query
                 * or atleast one dot in the query name then
                 * perform a query as-is once first.
                 */
                ++srchidx;
                if ((trailing_dot || (strchr(name, '.') != NULL))) {
                        if (validdomain(be, name, 1) == B_TRUE)
                                return (srchidx);
                        else if (trailing_dot)
                                return (-1);
                }
        }

        if ((srchidx > NSSMDNS_MAXSRCHDMNS) ||
            (be->dmnsrchlist[srchidx-1] == NULL))
                return (-1);

        *sname = be->dmnsrchlist[srchidx-1];
        return (++srchidx);
}

/*
 * This function determines if the domain name in the query
 * matches any of the valid & search domains in the nss_mdns
 * configuration.
 */
static boolean_t
validdomain(mdns_backend_ptr_t be, char *name, int chksrchdmns)
{
        char *nameptr;

        /* Remove any trailing and leading dots in the name  */
        nameptr = name + strlen(name) - 1;
        while (*nameptr && (nameptr != name) && (*nameptr == '.'))
                nameptr--;
        *(++nameptr) = '\0';
        nameptr = name;
        while (*nameptr && (*nameptr == '.'))
                nameptr++;
        if (*nameptr == '\0')
                return (B_FALSE);

        /* Compare with search domains */
        if (chksrchdmns && (cmpdmn(nameptr, be->dmnsrchlist,
            NSSMDNS_MAXSRCHDMNS) == B_TRUE))
                return (B_TRUE);

        /* Compare with valid domains */
        return (cmpdmn(nameptr, be->validdmnlist, NSSMDNS_MAXVALIDDMNS));
}

static boolean_t
cmpdmn(char *name, char **dmnlist, int maxdmns)
{
        char *vptr;
        int vdlen;
        char *cptr;
        int nlen;
        int i;

        nlen = strlen(name);
        for (i = 0; (i < maxdmns) &&
            ((vptr = dmnlist[i]) != NULL); i++) {
                vdlen = strlen(vptr);
                if (vdlen > nlen)
                        continue;
                cptr = name + nlen - vdlen;
                if (strncasecmp(cptr, vptr, vdlen) == 0)
                        return (B_TRUE);
        }
        return (B_FALSE);
}

static void
_nss_mdns_get_svcstatetimestamp(struct timeval *ptv)
{
        scf_handle_t *h;
        scf_simple_prop_t *sprop;
        int32_t nsec;

        (void) memset(ptv, 0, sizeof (struct timeval));

        h = scf_handle_create(SCF_VERSION);
        if (h == NULL)
                return;

        if (scf_handle_bind(h) == -1) {
                scf_handle_destroy(h);
                return;
        }

        if ((sprop = scf_simple_prop_get(h, SMF_MDNS_FMRI,
            SCF_PG_RESTARTER, SCF_PROPERTY_STATE_TIMESTAMP)) != NULL) {
                ptv->tv_sec = *(time_t *)(scf_simple_prop_next_time(sprop,
                    &nsec));
                ptv->tv_usec = nsec / 1000;
                scf_simple_prop_free(sprop);
        }

        if (h != NULL)
                scf_handle_destroy(h);
}

void
_nss_mdns_updatecfg(mdns_backend_ptr_t be)
{
        struct timeval statetimestamp;

        /*
         * Update configuration if current svc state timestamp
         * is different from last known svc state timestamp
         */
        _nss_mdns_get_svcstatetimestamp(&statetimestamp);
        if ((statetimestamp.tv_sec == 0) && (statetimestamp.tv_usec == 0)) {
                syslog(LOG_ERR, "nss_mdns: error checking " \
                    "svc:/network/dns/multicast:default" \
                    " service timestamp");
        } else if ((be->conftimestamp.tv_sec == statetimestamp.tv_sec) &&
            (be->conftimestamp.tv_usec == statetimestamp.tv_usec)) {
                return;
        }

        _nss_mdns_freesmfcfg(be);
        _nss_mdns_loadsmfcfg(be);
        be->conftimestamp.tv_sec = statetimestamp.tv_sec;
        be->conftimestamp.tv_usec = statetimestamp.tv_usec;
}

static void
load_mdns_domaincfg(scf_handle_t *h, char **storelist,
                        const char *scfprop, int maxprops)
{
        scf_simple_prop_t *sprop;
        char *tchr;
        char *pchr;
        int tlen;
        int cnt = 0;

        if ((sprop = scf_simple_prop_get(h, SMF_MDNS_FMRI,
            SMF_NSSMDNSCFG_PROPGRP, scfprop)) == NULL)
                        return;

        while ((cnt < maxprops) &&
            (tchr = scf_simple_prop_next_astring(sprop)) != NULL) {

                /* Remove beginning & trailing '.' chars */
                while (*tchr && (*tchr == '.'))
                        tchr++;

                if (*tchr && ((tlen = strlen(tchr)) < MAXDNAME)) {
                        pchr = &tchr[tlen-1];
                        while ((pchr != tchr) && (*pchr == '.'))
                                pchr--;
                        *(++pchr) = '\0';
                        storelist[cnt] = strdup(tchr);
                        cnt++;
                }
        }
        scf_simple_prop_free(sprop);
}

static void
_nss_mdns_loadsmfcfg(mdns_backend_ptr_t be)
{
        scf_handle_t *h;

        h = scf_handle_create(SCF_VERSION);
        if (h == NULL)
                return;

        if (scf_handle_bind(h) == -1) {
                scf_handle_destroy(h);
                return;
        }

        load_mdns_domaincfg(h, &(be->dmnsrchlist[0]),
            SMF_NSSMDNSCFG_SRCHPROP, NSSMDNS_MAXSRCHDMNS);

        load_mdns_domaincfg(h, &(be->validdmnlist[0]),
            SMF_NSSMDNSCFG_DMNPROP, NSSMDNS_MAXVALIDDMNS);

        if (h != NULL)
                scf_handle_destroy(h);
}

static void
_nss_mdns_freesmfcfg(mdns_backend_ptr_t be)
{
        int idx;
        if (be == NULL)
                return;
        for (idx = 0; idx < NSSMDNS_MAXSRCHDMNS; idx++) {
                if (be->dmnsrchlist[idx] != NULL) {
                        free(be->dmnsrchlist[idx]);
                        be->dmnsrchlist[idx] = NULL;
                }
        }
        for (idx = 0; idx < NSSMDNS_MAXVALIDDMNS; idx++) {
                if (be->validdmnlist[idx] != NULL) {
                        free(be->validdmnlist[idx]);
                        be->validdmnlist[idx] = NULL;
                }
        }
}

/*
 * Performs lookup for IP address by hostname via mDNS and returns
 * results along with the TTL value from the mDNS resource records.
 * Called by nscd wth a ptr to packed bufer and packed buffer size.
 */
nss_status_t
_nss_mdns_gethost_withttl(void *buffer, size_t bufsize, int ipnode)
{
        nss_pheader_t *pbuf = (nss_pheader_t *)buffer;
        nss_XbyY_args_t arg;
        int dbop;
        int af;
        int len;
        int blen;
        char *dbname;
        nss_status_t sret;
        char *hname;
        struct mdns_querydata qdata;
        nssuint_t *pttl;
        mdns_backend_ptr_t be = NULL;

        (void) memset(&qdata, 0, sizeof (struct mdns_querydata));

        qdata.argp = &arg;

        /*
         * Retrieve withttl buffer and size from the passed packed buffer.
         * Results are returned along with ttl in this buffer.
         */
        qdata.withttlbsize = pbuf->data_len - sizeof (nssuint_t);
        qdata.withttlbuffer = (char *)buffer + pbuf->data_off;

        sret = nss_packed_getkey(buffer, bufsize, &dbname, &dbop, &arg);
        if (sret != NSS_SUCCESS)
                return (NSS_ERROR);

        if (ipnode) {
                if (arg.key.ipnode.flags != 0)
                        return (NSS_ERROR);
                hname = (char *)arg.key.ipnode.name;
                af = arg.key.ipnode.af_family;
        } else {
                af = AF_INET;
                hname = (char *)arg.key.name;
        }

        if ((be = (mdns_backend_ptr_t)calloc(1, sizeof (*be))) == NULL)
                return (NSS_ERROR);
        _nss_mdns_updatecfg(be);

        /* Zero out the withttl buffer prior to use */
        (void) memset(qdata.withttlbuffer, 0, qdata.withttlbsize);

#ifdef DEBUG
        syslog(LOG_DEBUG, "nss_mdns: querybyname withttl called" \
            " af:%d hname:%s", af, hname);
#endif
        if (_nss_mdns_querybyname(be, hname, af, &qdata) == NSS_SUCCESS) {
                blen = strlen(qdata.buffer);
                len = ROUND_UP(blen, sizeof (nssuint_t));

                if (len + sizeof (nssuint_t) > pbuf->data_len) {
                        _nss_mdns_freesmfcfg(be);
                        free(be);
                        return (NSS_ERROR);
                }

                pbuf->ext_off = pbuf->data_off + len;
                pbuf->ext_len = sizeof (nssuint_t);
                pbuf->data_len = blen;

                /* Return ttl in the packed buffer at ext_off */
                pttl = (nssuint_t *)((void *)((char *)pbuf + pbuf->ext_off));
                *pttl = qdata.ttl;

                _nss_mdns_freesmfcfg(be);
                free(be);
                return (NSS_SUCCESS);
        }
        _nss_mdns_freesmfcfg(be);
        free(be);
        return (NSS_ERROR);
}