Changeset 7d33d36 in rtems-libbsd


Ignore:
Timestamp:
Sep 19, 2018, 6:54:52 AM (8 months ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
a87e0f4f5c4795f77dc3956c7d1543f90f7d7710, 16fa6a4651faaa77ef72c7e03d285c143d6e54fa
Children:
a814950
Parents:
fc605b3
git-author:
Sebastian Huber <sebastian.huber@…> (09/19/18 06:54:52)
git-committer:
Sebastian Huber <sebastian.huber@…> (09/20/18 09:23:33)
Message:

mDNSResponder: Update to v765.30.11

The sources can be obtained via:

https://opensource.apple.com/tarballs/mDNSResponder/mDNSResponder-765.30.11.tar.gz

Update #3522.

Location:
mDNSResponder
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • mDNSResponder/Makefile

    rfc605b3 r7d33d36  
    1717include $(MAKEFILEPATH)/pb_makefiles/platform.make
    1818
    19 MVERS = "mDNSResponder-765.20.4"
     19MVERS = "mDNSResponder-765.30.11"
    2020
    2121DDNSWRITECONFIG = "$(DSTROOT)/Library/Application Support/Bonjour/ddnswriteconfig"
  • mDNSResponder/mDNSCore/dnsproxy.c

    rfc605b3 r7d33d36  
    196196    CacheRecord *cname = mDNSNULL;
    197197    mDNSu8 *limit;
     198    domainname tempQName;
     199    mDNSu32 tempQNameHash;
    198200
    199201    *error = mStatus_NoError;
     
    223225    LogInfo("AddResourceRecords: Limit is %d", limit - m->omsg.data);
    224226
    225     if (!SameDomainName(&pc->qname, &pc->q.qname))
    226     {
    227         AssignDomainName(&pc->q.qname, &pc->qname);
    228         pc->q.qnamehash = DomainNameHashValue(&pc->q.qname);
    229     }
     227    AssignDomainName(&tempQName, &pc->qname);
     228    tempQNameHash = DomainNameHashValue(&tempQName);
    230229
    231230again:
    232231    nsec = soa = cname = mDNSNULL;
    233     slot = HashSlot(&pc->q.qname);
    234        
    235     cg = CacheGroupForName(m, slot, pc->q.qnamehash, &pc->q.qname);
     232    slot = HashSlot(&tempQName);
     233
     234    cg = CacheGroupForName(m, slot, tempQNameHash, &tempQName);
    236235    if (!cg)
    237236    {
    238         LogInfo("AddResourceRecords: CacheGroup not found");
     237        LogInfo("AddResourceRecords: CacheGroup not found for %##s", tempQName.c);
    239238        *error = mStatus_NoSuchRecord;
    240239        return mDNSNULL;
     
    345344    if (cname)
    346345    {
    347         AssignDomainName(&pc->q.qname, &cname->resrec.rdata->u.name);
    348         pc->q.qnamehash = DomainNameHashValue(&pc->q.qname);
     346        AssignDomainName(&tempQName, &cname->resrec.rdata->u.name);
     347        tempQNameHash = DomainNameHashValue(&tempQName);
    349348        goto again;
    350349    }
  • mDNSResponder/mDNSCore/mDNSEmbeddedAPI.h

    rfc605b3 r7d33d36  
    33773377extern void mDNSPlatformGetDNSRoutePolicy(mDNS *const m, DNSQuestion *q, mDNSBool *isBlocked);
    33783378#endif
    3379 extern void mDNSPlatformSetSocktOpt(void *sock, mDNSTransport_Type transType, mDNSAddr_Type addrType, DNSQuestion *q);
     3379extern void mDNSPlatformSetSocktOpt(void *sock, mDNSTransport_Type transType, mDNSAddr_Type addrType, const DNSQuestion *q);
    33803380extern mDNSs32 mDNSPlatformGetPID(void);
    33813381extern mDNSBool mDNSValidKeepAliveRecord(AuthRecord *rr);
  • mDNSResponder/mDNSCore/uDNS.c

    rfc605b3 r7d33d36  
    47384738                        q->LocalSocket = mDNSPlatformUDPSocket(m, zeroIPPort);
    47394739                        if (q->LocalSocket)
    4740                             mDNSPlatformSetSocktOpt(q->LocalSocket, mDNSTransport_UDP, q->qDNSServer->addr.type, q);
     4740                        {
     4741                            mDNSPlatformSetSocktOpt(q->LocalSocket, mDNSTransport_UDP, mDNSAddrType_IPv4, q);
     4742                            mDNSPlatformSetSocktOpt(q->LocalSocket, mDNSTransport_UDP, mDNSAddrType_IPv6, q);
     4743                        }
    47414744                    }
    47424745                    if (!q->LocalSocket) err = mStatus_NoMemoryErr; // If failed to make socket (should be very rare), we'll try again next time
  • mDNSResponder/mDNSMacOSX/Metrics.m

    rfc605b3 r7d33d36  
    100100    { "icloud.com.",    (domainname *)"\x6" "icloud"    "\x3" "com", 2 },
    101101    { "mzstatic.com.",  (domainname *)"\x8" "mzstatic"  "\x3" "com", 2 },
    102     { "me.com.",        (domainname *)"\x2" "me"        "\x3" "com", 2 },
    103102    { "google.com.",    (domainname *)"\x6" "google"    "\x3" "com", 2 },
    104     { "youtube.com.",   (domainname *)"\x7" "youtube"   "\x3" "com", 2 },
    105103    { "facebook.com.",  (domainname *)"\x8" "facebook"  "\x3" "com", 2 },
    106104    { "baidu.com.",     (domainname *)"\x5" "baidu"     "\x3" "com", 2 },
     
    109107};
    110108
    111 check_compile_time(countof(kQueryStatsDomains) == 11);
     109check_compile_time(countof(kQueryStatsDomains) == 9);
    112110
    113111// DNSHist contains the per domain per network type histogram data that goes in a DNSDomainStats protobuf message. See
     
    169167typedef struct
    170168{
    171     DNSHist *       histAny;    // Histogram data for queries of any resource record type.
    172169    DNSHist *       histA;      // Histogram data for queries for A resource records.
    173170    DNSHist *       histAAAA;   // Histogram data for queries for AAAA resource records.
     
    314311mDNSlocal void      DNSDomainStatsFree(DNSDomainStats *inStats);
    315312mDNSlocal void      DNSDomainStatsFreeList(DNSDomainStats *inList);
    316 mDNSlocal mStatus   DNSDomainStatsUpdate(DNSDomainStats *inStats, uint16_t inType, const ResourceRecord *inRR, mDNSu32 inQuerySendCount, mDNSu32 inLatencyMs, mDNSBool inForCell);
     313mDNSlocal mStatus   DNSDomainStatsUpdate(DNSDomainStats *inStats, int inType, const ResourceRecord *inRR, mDNSu32 inQuerySendCount, mDNSu32 inLatencyMs, mDNSBool inForCell);
    317314
    318315mDNSlocal mStatus   ResolveStatsDomainCreate(const Domain *inDomain, ResolveStatsDomain **outDomain);
     
    363360mStatus MetricsInit(void)
    364361{
    365     mStatus     err;
    366 
    367362#if (METRICS_VALIDATE_DNS_STATS_DOMAINS)
    368363    ValidateDNSStatsDomains();
    369364#endif
    370 
    371     err = CreateDomainStatsList(&gDomainStatsList);
    372     require_noerr_quiet(err, exit);
    373 
    374     err = CreateResolveStatsList(&gResolveStatsList);
    375     require_noerr_quiet(err, exit);
    376365
    377366    @autoreleasepool
     
    396385                }
    397386                forIdentifier: (UInt32)AWDMetricId_MDNSResponder_ResolveStats];
    398            
     387
    399388            [gAWDServerConnection
    400389                registerQueriableMetricCallback: ^(UInt32 inMetricID)
     
    409398        }
    410399    }
    411 exit:
    412     return (err);
     400
     401    if( gAWDServerConnection )
     402    {
     403        CreateDomainStatsList(&gDomainStatsList);
     404        CreateResolveStatsList(&gResolveStatsList);
     405    }
     406
     407    return (mStatus_NoError);
    413408}
    414409
     
    425420    int                     skipCount;
    426421    int                     skipCountLast = -1;
     422
     423    require_quiet(gAWDServerConnection, exit);
     424    require_quiet((inType == kDNSType_A) || (inType == kDNSType_AAAA), exit);
    427425
    428426    queryLabelCount = CountLabels(inQueryName);
     
    456454    }
    457455
     456exit:
     457    return;
    458458}
    459459
     
    474474    Response                    response;
    475475
     476    require_quiet(gAWDServerConnection, exit);
    476477    require_quiet((inRR->rrtype == kDNSType_A) || (inRR->rrtype == kDNSType_AAAA), exit);
    477478    require_quiet(inRR->rDNSServer, exit);
     
    537538    int                                 addrObjCount     = 0;
    538539
     540    LogMsgNoIdent("gAWDServerConnection %p", gAWDServerConnection);
    539541    LogMsgNoIdent("---- DNS query stats by domain -----");
    540542
     
    658660    if (inStats->nonCellular)
    659661    {
    660         ForgetMem(&inStats->nonCellular->histAny);
    661662        ForgetMem(&inStats->nonCellular->histA);
    662663        ForgetMem(&inStats->nonCellular->histAAAA);
     
    666667    if (inStats->cellular)
    667668    {
    668         ForgetMem(&inStats->cellular->histAny);
    669669        ForgetMem(&inStats->cellular->histA);
    670670        ForgetMem(&inStats->cellular->histAAAA);
     
    694694//===========================================================================================================================
    695695
    696 mDNSlocal mStatus DNSDomainStatsUpdate(DNSDomainStats *inStats, uint16_t inType, const ResourceRecord *inRR, mDNSu32 inQuerySendCount, mDNSu32 inLatencyMs, mDNSBool inForCell)
     696mDNSlocal mStatus DNSDomainStatsUpdate(DNSDomainStats *inStats, int inType, const ResourceRecord *inRR, mDNSu32 inQuerySendCount, mDNSu32 inLatencyMs, mDNSBool inForCell)
    697697{
    698698    mStatus             err;
    699     DNSHistSet **       p;
    700699    DNSHistSet *        set;
    701     DNSHist *           histAny;
     700    DNSHistSet **       pSet;
    702701    DNSHist *           hist;
     702    DNSHist **          pHist;
    703703    int                 i;
    704704
    705705    require_action_quiet(inRR || (inQuerySendCount > 0), exit, err = mStatus_NoError);
    706 
    707     p = inForCell ? &inStats->cellular : &inStats->nonCellular;
    708     if ((set = *p) == NULL)
     706    require_action_quiet((inType == kDNSType_A) || (inType == kDNSType_AAAA), exit, err = mStatus_NoError);
     707
     708    pSet = inForCell ? &inStats->cellular : &inStats->nonCellular;
     709    if ((set = *pSet) == NULL)
    709710    {
    710711        set = (DNSHistSet *)calloc(1, sizeof(*set));
    711712        require_action_quiet(set, exit, err = mStatus_NoMemoryErr);
    712         *p = set;
    713     }
    714     if ((histAny = set->histAny) == NULL)
    715     {
    716         histAny = (DNSHist *)calloc(1, sizeof(*histAny));
    717         require_action_quiet(histAny, exit, err = mStatus_NoMemoryErr);
    718         set->histAny = histAny;
    719     }
    720     if (inType == kDNSType_A)
    721     {
    722         if ((hist = set->histA) == NULL)
    723         {
    724             hist = (DNSHist *)calloc(1, sizeof(*hist));
    725             require_action_quiet(hist, exit, err = mStatus_NoMemoryErr);
    726             set->histA = hist;
    727         }
    728     }
    729     else if (inType == kDNSType_AAAA)
    730     {
    731         if ((hist = set->histAAAA) == NULL)
    732         {
    733             hist = (DNSHist *)calloc(1, sizeof(*hist));
    734             require_action_quiet(hist, exit, err = mStatus_NoMemoryErr);
    735             set->histAAAA = hist;
    736         }
    737     }
    738     else
    739     {
    740         hist = NULL;
     713        *pSet = set;
     714    }
     715    pHist = (inType == kDNSType_A) ? &set->histA : &set->histAAAA;
     716    if ((hist = *pHist) == NULL)
     717    {
     718        hist = (DNSHist *)calloc(1, sizeof(*hist));
     719        require_action_quiet(hist, exit, err = mStatus_NoMemoryErr);
     720        *pHist = hist;
    741721    }
    742722
     
    749729        i = Min(inQuerySendCount, kQueryStatsMaxQuerySendCount);
    750730
    751         sendCountBins = isNegative ? histAny->negAnsweredQuerySendCountBins : histAny->answeredQuerySendCountBins;
     731        sendCountBins = isNegative ? hist->negAnsweredQuerySendCountBins : hist->answeredQuerySendCountBins;
    752732        increment_saturate(sendCountBins[i], UINT16_MAX);
    753         if (hist)
    754         {
    755             sendCountBins = isNegative ? hist->negAnsweredQuerySendCountBins : hist->answeredQuerySendCountBins;
    756             increment_saturate(sendCountBins[i], UINT16_MAX);
    757         }
    758733
    759734        if (inQuerySendCount > 0)
    760735        {
    761736            for (i = 0; (i < (int)countof(kResponseLatencyMsLimits)) && (inLatencyMs >= kResponseLatencyMsLimits[i]); ++i) {}
    762             latencyBins = isNegative ? histAny->negResponseLatencyBins : histAny->responseLatencyBins;
     737            latencyBins = isNegative ? hist->negResponseLatencyBins : hist->responseLatencyBins;
    763738            increment_saturate(latencyBins[i], UINT16_MAX);
    764             if (hist)
    765             {
    766                 latencyBins = isNegative ? hist->negResponseLatencyBins : hist->responseLatencyBins;
    767                 increment_saturate(latencyBins[i], UINT16_MAX);
    768             }
    769739        }
    770740    }
     
    772742    {
    773743        i = Min(inQuerySendCount, kQueryStatsMaxQuerySendCount);
    774         increment_saturate(histAny->unansweredQuerySendCountBins[i], UINT16_MAX);
    775         if (hist) increment_saturate(hist->unansweredQuerySendCountBins[i], UINT16_MAX);
     744        increment_saturate(hist->unansweredQuerySendCountBins[i], UINT16_MAX);
    776745
    777746        for (i = 0; (i < (int)countof(kResponseLatencyMsLimits)) && (inLatencyMs >= kResponseLatencyMsLimits[i]); ++i) {}
    778         increment_saturate(histAny->unansweredQueryDurationBins[i], UINT16_MAX);
    779         if (hist) increment_saturate(hist->unansweredQueryDurationBins[i], UINT16_MAX);
     747        increment_saturate(hist->unansweredQueryDurationBins[i], UINT16_MAX);
    780748    }
    781749    err = mStatus_NoError;
     
    15061474mDNSlocal mStatus SubmitAWDMetric(UInt32 inMetricID)
    15071475{
    1508     mStatus     err = mStatus_NoError;
     1476    mStatus     err;
    15091477
    15101478    switch (inMetricID)
     
    15191487
    15201488        case AWDMetricId_MDNSResponder_ServicesStats:
    1521             [AWDMetricManagerSoft postMetricWithId:AWDMetricId_MDNSResponder_ServicesStats integerValue:max_num_regservices];
     1489            [AWDMetricManagerSoft postMetricWithId:AWDMetricId_MDNSResponder_ServicesStats unsignedIntegerValue:max_num_regservices];
    15221490            KQueueLock(&mDNSStorage);
    15231491            // reset the no of max services since we want to collect the max no of services registered per AWD submission period
    15241492            max_num_regservices = curr_num_regservices;
    15251493            KQueueUnlock(&mDNSStorage, "SubmitAWDSimpleMetricServiceStats");
     1494            err = mStatus_NoError;
    15261495            break;
    15271496           
     
    15311500    }
    15321501
    1533     if (err)
    1534         LogMsg("SubmitAWDMetric for metric ID 0x%08X failed with error %d", inMetricID, err);
     1502    if (err) LogMsg("SubmitAWDMetric for metric ID 0x%08X failed with error %d", inMetricID, err);
    15351503    return (err);
    15361504}
     
    15531521    require_noerr_quiet(err, exit);
    15541522
     1523    KQueueLock(&mDNSStorage);
    15551524    domainStatsList = gDomainStatsList;
    1556 
    1557     KQueueLock(&mDNSStorage);
    15581525    gDomainStatsList = newDomainStatsList;
    15591526    KQueueUnlock(&mDNSStorage, "SubmitAWDMetricQueryStats");
     
    16121579    require_noerr_quiet(err, exit);
    16131580
     1581    KQueueLock(&mDNSStorage);
    16141582    domainList = gResolveStatsList;
    16151583    serverList = gResolveStatsServerList;
    1616 
    1617     KQueueLock(&mDNSStorage);
    16181584    gResolveStatsList           = newResolveStatsList;
    16191585    gResolveStatsServerList     = NULL;
     
    17631729    AWDDNSDomainStats *     awdStats;
    17641730
    1765     if (inSet->histAny)
    1766     {
    1767         err = CreateAWDDNSDomainStats(inSet->histAny, inDomain, inForCell, AWDDNSDomainStats_RecordType_Any, &awdStats);
     1731    if (inSet->histA)
     1732    {
     1733        err = CreateAWDDNSDomainStats(inSet->histA, inDomain, inForCell, AWDDNSDomainStats_RecordType_A, &awdStats);
    17681734        require_noerr_quiet(err, exit);
    17691735
     
    17711737        [awdStats release];
    17721738    }
    1773     if (inSet->histA)
    1774     {
    1775         err = CreateAWDDNSDomainStats(inSet->histA, inDomain, inForCell, AWDDNSDomainStats_RecordType_A, &awdStats);
     1739    if (inSet->histAAAA)
     1740    {
     1741        err = CreateAWDDNSDomainStats(inSet->histAAAA, inDomain, inForCell, AWDDNSDomainStats_RecordType_AAAA, &awdStats);
    17761742        require_noerr_quiet(err, exit);
    17771743
     
    17791745        [awdStats release];
    17801746    }
    1781     if (inSet->histAAAA)
    1782     {
    1783         err = CreateAWDDNSDomainStats(inSet->histAAAA, inDomain, inForCell, AWDDNSDomainStats_RecordType_AAAA, &awdStats);
    1784         require_noerr_quiet(err, exit);
    1785 
    1786         [inMetric addStats:awdStats];
    1787         [awdStats release];
    1788     }
    17891747    err = mStatus_NoError;
    17901748
     
    17991757mDNSlocal void LogDNSHistSet(const DNSHistSet *inSet, const char *inDomain, mDNSBool inForCell)
    18001758{
    1801     if (inSet->histAny)     LogDNSHist(inSet->histAny,  inDomain, inForCell, "Any");
    18021759    if (inSet->histA)       LogDNSHist(inSet->histA,    inDomain, inForCell, "A");
    18031760    if (inSet->histAAAA)    LogDNSHist(inSet->histAAAA, inDomain, inForCell, "AAAA");
  • mDNSResponder/mDNSMacOSX/mDNSMacOSX.c

    rfc605b3 r7d33d36  
    18361836}
    18371837
    1838 mDNSexport void mDNSPlatformSetSocktOpt(void *sockCxt, mDNSTransport_Type transType, mDNSAddr_Type addrType, DNSQuestion *q)
     1838mDNSexport void mDNSPlatformSetSocktOpt(void *sockCxt, mDNSTransport_Type transType, mDNSAddr_Type addrType, const DNSQuestion *q)
    18391839{
    18401840    int sockfd;
     
    69676967        {
    69686968            LogInfo("mDNSPlatformSetDNSConfig: config->n_resolver = %d, generation %llu, last %llu", config->n_resolver, config->generation, m->p->LastConfigGeneration);
    6969             if (m->p->LastConfigGeneration == config->generation)
     6969
     6970            // For every network change, the search domain list is updated.
     6971            // This update is done without regard for generation number because it is
     6972            // not an expensive update and it keeps the search domain list in sync (even when
     6973            // a network change occurs, while currently processing a network
     6974            // change).
     6975            //
     6976            // For every DNS configuration change, the DNS server list is updated.
     6977            // This update is NOT done every network change because it may involve
     6978            // updating cache entries which worst-case is expensive. Setting the generation
     6979            // per DNS server list change keeps the list in sync with configd.
     6980
     6981            if (setservers &&  m->p->LastConfigGeneration == config->generation)
    69706982            {
    69716983                LogInfo("mDNSPlatformSetDNSConfig: generation number %llu same, not processing", config->generation);
     
    69937005            ConfigResolvers(m, config, kScopeServiceID, setsearch, setservers, &sdc, resolverGroupID);
    69947006
    6995             // Acking provides a hint that we processed this current configuration and
    6996             // we will use that from now on, assuming we don't get another one immediately
    6997             // after we return from here.
     7007            // Acking provides a hint to other processes that the current DNS configuration has completed
     7008            // its update.  When configd receives the ack, it publishes a notification.
     7009            // Applications monitoring the notification then know when to re-issue their DNS queries
     7010            // after a network change occurs.
    69987011            if (ackConfig)
    69997012            {
    70007013                // Note: We have to set the generation number here when we are acking.
    7001                 // For every DNS configuration change, we do the following:
    7002                 //
    7003                 // 1) Copy dns configuration, handle search domains change
    7004                 // 2) Copy dns configuration, handle dns server change
    7005                 //
    7006                 // If we update the generation number at step (1), we won't process the
    7007                 // DNS servers the second time because generation number would be the same.
    7008                 // As we ack only when we process dns servers, we set the generation number
    7009                 // during acking.
    70107014                m->p->LastConfigGeneration = config->generation;
    70117015                LogInfo("mDNSPlatformSetDNSConfig: Acking configuration setservers %d, setsearch %d", setservers, setsearch);
  • mDNSResponder/mDNSPosix/Responder.c

    rfc605b3 r7d33d36  
    504504    mStatus status = mStatus_NoError;
    505505    FILE *      fp = fopen(filePath, "r");
     506    int rv;
    506507
    507508    if (fp == NULL) {
     
    604605    }
    605606
    606     assert(0 == fclose(fp));
     607    rv = fclose(fp);
     608    assert(rv == 0);
    607609
    608610    return status;
  • mDNSResponder/mDNSPosix/mDNSPosix.c

    rfc605b3 r7d33d36  
    585585mDNSlocal void FreePosixNetworkInterface(PosixNetworkInterface *intf)
    586586{
     587    int rv;
    587588    assert(intf != NULL);
    588589    if (intf->intfName != NULL) free((void *)intf->intfName);
    589     if (intf->multicastSocket4 != -1) assert(close(intf->multicastSocket4) == 0);
     590    if (intf->multicastSocket4 != -1)
     591    {
     592        rv = close(intf->multicastSocket4);
     593        assert(rv == 0);
     594    }
    590595#if HAVE_IPV6
    591     if (intf->multicastSocket6 != -1) assert(close(intf->multicastSocket6) == 0);
     596    if (intf->multicastSocket6 != -1)
     597    {
     598        rv = close(intf->multicastSocket6);
     599        assert(rv == 0);
     600    }
    592601#endif
    593602
     
    852861
    853862    // Clean up
    854     if (err != 0 && *sktPtr != -1) { assert(close(*sktPtr) == 0); *sktPtr = -1; }
     863    if (err != 0 && *sktPtr != -1)
     864    {
     865        int rv;
     866        rv = close(*sktPtr);
     867        assert(rv == 0);
     868        *sktPtr = -1;
     869    }
    855870    assert((err == 0) == (*sktPtr != -1));
    856871    return err;
     
    13541369mDNSexport void mDNSPlatformClose(mDNS *const m)
    13551370{
     1371    int rv;
    13561372    assert(m != NULL);
    13571373    ClearInterfaceList(m);
    1358     if (m->p->unicastSocket4 != -1) assert(close(m->p->unicastSocket4) == 0);
     1374    if (m->p->unicastSocket4 != -1)
     1375    {
     1376        rv = close(m->p->unicastSocket4);
     1377        assert(rv == 0);
     1378    }
    13591379#if HAVE_IPV6
    1360     if (m->p->unicastSocket6 != -1) assert(close(m->p->unicastSocket6) == 0);
     1380    if (m->p->unicastSocket6 != -1)
     1381    {
     1382        rv = close(m->p->unicastSocket6);
     1383        assert(rv == 0);
     1384    }
    13611385#endif
    13621386}
     
    16631687}
    16641688
    1665 mDNSexport void mDNSPlatformSetSocktOpt(void *sock, mDNSTransport_Type transType, mDNSAddr_Type addrType, DNSQuestion *q)
     1689mDNSexport void mDNSPlatformSetSocktOpt(void *sock, mDNSTransport_Type transType, mDNSAddr_Type addrType, const DNSQuestion *q)
    16661690{
    16671691    (void) sock;
  • mDNSResponder/mDNSPosix/mDNSUNP.c

    rfc605b3 r7d33d36  
    200200done:
    201201    if (sockfd != -1) {
    202         assert(close(sockfd) == 0);
     202        int rv;
     203        rv = close(sockfd);
     204        assert(rv == 0);
    203205    }
    204206    if (fp != NULL) {
  • mDNSResponder/mDNSShared/dns_sd.h

    rfc605b3 r7d33d36  
    6767
    6868#ifndef _DNS_SD_H
    69 #define _DNS_SD_H 7652004
     69#define _DNS_SD_H 7653011
    7070
    7171#ifdef  __cplusplus
  • mDNSResponder/mDNSWindows/mDNSWin32.c

    rfc605b3 r7d33d36  
    21532153}
    21542154
    2155 mDNSexport void mDNSPlatformSetSocktOpt(void *sock, mDNSTransport_Type transType, mDNSAddr_Type addrType, DNSQuestion *q)
     2155mDNSexport void mDNSPlatformSetSocktOpt(void *sock, mDNSTransport_Type transType, mDNSAddr_Type addrType, const DNSQuestion *q)
    21562156    {
    21572157    (void) sock;
Note: See TracChangeset for help on using the changeset viewer.