git.meshlink.io Git - catta/blob - avahi-core/psched.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <string.h>
  27
  28 #include "util.h"
  29 #include "psched.h"
  30
  31 #define AVAHI_QUERY_HISTORY_MSEC 100
  32 #define AVAHI_QUERY_DEFER_MSEC 100
  33 #define AVAHI_RESPONSE_HISTORY_MSEC 700
  34 #define AVAHI_RESPONSE_DEFER_MSEC 20
  35 #define AVAHI_RESPONSE_JITTER_MSEC 100
  36 #define AVAHI_PROBE_DEFER_MSEC 70
  37
  38 AvahiPacketScheduler *avahi_packet_scheduler_new(AvahiServer *server, AvahiInterface *i) {
  39     AvahiPacketScheduler *s;
  40
  41     g_assert(server);
  42     g_assert(i);
  43
  44     s = g_new(AvahiPacketScheduler, 1);
  45     s->server = server;
  46     s->interface = i;
  47
  48     AVAHI_LLIST_HEAD_INIT(AvahiQueryJob, s->query_jobs);
  49     AVAHI_LLIST_HEAD_INIT(AvahiResponseJob, s->response_jobs);
  50     AVAHI_LLIST_HEAD_INIT(AvahiKnownAnswer, s->known_answers);
  51     AVAHI_LLIST_HEAD_INIT(AvahiProbeJob, s->probe_jobs);
  52
  53     return s;
  54 }
  55
  56 static void query_job_free(AvahiPacketScheduler *s, AvahiQueryJob *qj) {
  57     g_assert(qj);
  58
  59     if (qj->time_event)
  60         avahi_time_event_queue_remove(qj->scheduler->server->time_event_queue, qj->time_event);
  61
  62     AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->query_jobs, qj);
  63
  64     avahi_key_unref(qj->key);
  65     g_free(qj);
  66 }
  67
  68 static void response_job_free(AvahiPacketScheduler *s, AvahiResponseJob *rj) {
  69     g_assert(rj);
  70
  71     if (rj->time_event)
  72         avahi_time_event_queue_remove(rj->scheduler->server->time_event_queue, rj->time_event);
  73
  74     AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->response_jobs, rj);
  75
  76     avahi_record_unref(rj->record);
  77     g_free(rj);
  78 }
  79
  80 static void probe_job_free(AvahiPacketScheduler *s, AvahiProbeJob *pj) {
  81     g_assert(pj);
  82
  83     if (pj->time_event)
  84         avahi_time_event_queue_remove(pj->scheduler->server->time_event_queue, pj->time_event);
  85
  86     AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->probe_jobs, pj);
  87
  88     avahi_record_unref(pj->record);
  89     g_free(pj);
  90 }
  91
  92 void avahi_packet_scheduler_free(AvahiPacketScheduler *s) {
  93     AvahiQueryJob *qj;
  94     AvahiResponseJob *rj;
  95     AvahiProbeJob *pj;
  96
  97     g_assert(s);
  98
  99     g_assert(!s->known_answers);
 100
 101     while ((qj = s->query_jobs))
 102         query_job_free(s, qj);
 103     while ((rj = s->response_jobs))
 104         response_job_free(s, rj);
 105     while ((pj = s->probe_jobs))
 106         probe_job_free(s, pj);
 107
 108     g_free(s);
 109 }
 110
 111 static gpointer known_answer_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata) {
 112     AvahiPacketScheduler *s = userdata;
 113     AvahiKnownAnswer *ka;
 114
 115     g_assert(c);
 116     g_assert(pattern);
 117     g_assert(e);
 118     g_assert(s);
 119
 120     if (avahi_cache_entry_half_ttl(c, e))
 121         return NULL;
 122
 123     ka = g_new0(AvahiKnownAnswer, 1);
 124     ka->scheduler = s;
 125     ka->record = avahi_record_ref(e->record);
 126
 127     AVAHI_LLIST_PREPEND(AvahiKnownAnswer, known_answer, s->known_answers, ka);
 128     return NULL;
 129 }
 130
 131 static guint8* packet_add_query_job(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiQueryJob *qj) {
 132     guint8 *d;
 133
 134     g_assert(s);
 135     g_assert(p);
 136     g_assert(qj);
 137
 138     if ((d = avahi_dns_packet_append_key(p, qj->key, FALSE))) {
 139         GTimeVal tv;
 140
 141         qj->done = 1;
 142
 143         /* Drop query after some time from history */
 144         avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
 145         avahi_time_event_queue_update(s->server->time_event_queue, qj->time_event, &tv);
 146
 147         g_get_current_time(&qj->delivery);
 148
 149         /* Add all matching known answers to the list */
 150         avahi_cache_walk(s->interface->cache, qj->key, known_answer_walk_callback, s);
 151     }
 152
 153     return d;
 154 }
 155
 156 static void append_known_answers_and_send(AvahiPacketScheduler *s, AvahiDnsPacket *p) {
 157     AvahiKnownAnswer *ka;
 158     guint n;
 159     g_assert(s);
 160     g_assert(p);
 161
 162     n = 0;
 163
 164     while ((ka = s->known_answers)) {
 165
 166         while (!avahi_dns_packet_append_record(p, ka->record, FALSE, 0)) {
 167
 168             g_assert(!avahi_dns_packet_is_empty(p));
 169
 170             avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_FLAGS, avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) | AVAHI_DNS_FLAG_TC);
 171             avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
 172             avahi_interface_send_packet(s->interface, p);
 173             avahi_dns_packet_free(p);
 174
 175             p = avahi_dns_packet_new_query(s->interface->hardware->mtu);
 176             n = 0;
 177         }
 178
 179         AVAHI_LLIST_REMOVE(AvahiKnownAnswer, known_answer, s->known_answers, ka);
 180         avahi_record_unref(ka->record);
 181         g_free(ka);
 182
 183         n++;
 184     }
 185
 186     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
 187     avahi_interface_send_packet(s->interface, p);
 188     avahi_dns_packet_free(p);
 189 }
 190
 191 static void query_elapse(AvahiTimeEvent *e, gpointer data) {
 192     AvahiQueryJob *qj = data;
 193     AvahiPacketScheduler *s;
 194     AvahiDnsPacket *p;
 195     guint n;
 196     guint8 *d;
 197
 198     g_assert(qj);
 199     s = qj->scheduler;
 200
 201     if (qj->done) {
 202         /* Lets remove it  from the history */
 203         query_job_free(s, qj);
 204         return;
 205     }
 206
 207     g_assert(!s->known_answers);
 208
 209     p = avahi_dns_packet_new_query(s->interface->hardware->mtu);
 210     d = packet_add_query_job(s, p, qj);
 211     g_assert(d);
 212     n = 1;
 213
 214     /* Try to fill up packet with more queries, if available */
 215     for (qj = s->query_jobs; qj; qj = qj->jobs_next) {
 216
 217         if (qj->done)
 218             continue;
 219
 220         if (!packet_add_query_job(s, p, qj))
 221             break;
 222
 223         n++;
 224     }
 225
 226     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
 227
 228     /* Now add known answers */
 229     append_known_answers_and_send(s, p);
 230 }
 231
 232 AvahiQueryJob* query_job_new(AvahiPacketScheduler *s, AvahiKey *key) {
 233     AvahiQueryJob *qj;
 234
 235     g_assert(s);
 236     g_assert(key);
 237
 238     qj = g_new(AvahiQueryJob, 1);
 239     qj->scheduler = s;
 240     qj->key = avahi_key_ref(key);
 241     qj->done = FALSE;
 242     qj->time_event = NULL;
 243
 244     AVAHI_LLIST_PREPEND(AvahiQueryJob, jobs, s->query_jobs, qj);
 245
 246     return qj;
 247 }
 248
 249 gboolean avahi_packet_scheduler_post_query(AvahiPacketScheduler *s, AvahiKey *key, gboolean immediately) {
 250     GTimeVal tv;
 251     AvahiQueryJob *qj;
 252
 253     g_assert(s);
 254     g_assert(key);
 255
 256     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_QUERY_DEFER_MSEC, 0);
 257
 258     for (qj = s->query_jobs; qj; qj = qj->jobs_next) {
 259
 260         if (avahi_key_equal(qj->key, key)) {
 261
 262             glong d = avahi_timeval_diff(&tv, &qj->delivery);
 263
 264             /* Duplicate questions suppression */
 265             if (d >= 0 && d <= AVAHI_QUERY_HISTORY_MSEC*1000) {
 266                 g_message("WARNING! DUPLICATE QUERY SUPPRESSION ACTIVE!");
 267                 return FALSE;
 268             }
 269
 270             query_job_free(s, qj);
 271             break;
 272         }
 273
 274     }
 275
 276     qj = query_job_new(s, key);
 277     qj->delivery = tv;
 278     qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &qj->delivery, query_elapse, qj);
 279     return TRUE;
 280 }
 281
 282 static guint8* packet_add_response_job(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiResponseJob *rj) {
 283     guint8 *d;
 284
 285     g_assert(s);
 286     g_assert(p);
 287     g_assert(rj);
 288
 289     if ((d = avahi_dns_packet_append_record(p, rj->record, rj->flush_cache, 0))) {
 290         GTimeVal tv;
 291
 292         rj->done = 1;
 293
 294         /* Drop response after some time from history */
 295         avahi_elapse_time(&tv, AVAHI_RESPONSE_HISTORY_MSEC, 0);
 296         avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
 297
 298         g_get_current_time(&rj->delivery);
 299     }
 300
 301     return d;
 302 }
 303
 304 static void send_response_packet(AvahiPacketScheduler *s, AvahiResponseJob *rj) {
 305     AvahiDnsPacket *p;
 306     guint n;
 307
 308     g_assert(s);
 309
 310     p = avahi_dns_packet_new_response(s->interface->hardware->mtu, TRUE);
 311     n = 0;
 312
 313     /* If a job was specified, put it in the packet. */
 314     if (rj) {
 315         guint8 *d;
 316         d = packet_add_response_job(s, p, rj);
 317         g_assert(d);
 318         n++;
 319     }
 320
 321     /* Try to fill up packet with more responses, if available */
 322     for (rj = s->response_jobs; rj; rj = rj->jobs_next) {
 323
 324         if (rj->done)
 325             continue;
 326
 327         if (!packet_add_response_job(s, p, rj))
 328             break;
 329
 330         n++;
 331     }
 332
 333     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
 334     avahi_interface_send_packet(s->interface, p);
 335     avahi_dns_packet_free(p);
 336 }
 337
 338 static void response_elapse(AvahiTimeEvent *e, gpointer data) {
 339     AvahiResponseJob *rj = data;
 340     AvahiPacketScheduler *s;
 341
 342     g_assert(rj);
 343     s = rj->scheduler;
 344
 345     if (rj->done) {
 346         /* Lets remove it  from the history */
 347         response_job_free(s, rj);
 348         return;
 349     }
 350
 351     send_response_packet(s, rj);
 352 }
 353
 354 static AvahiResponseJob* look_for_response(AvahiPacketScheduler *s, AvahiRecord *record) {
 355     AvahiResponseJob *rj;
 356
 357     g_assert(s);
 358     g_assert(record);
 359
 360     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
 361         if (avahi_record_equal_no_ttl(rj->record, record))
 362             return rj;
 363
 364     return NULL;
 365 }
 366
 367 static AvahiResponseJob* response_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
 368     AvahiResponseJob *rj;
 369
 370     g_assert(s);
 371     g_assert(record);
 372
 373     rj = g_new(AvahiResponseJob, 1);
 374     rj->scheduler = s;
 375     rj->record = avahi_record_ref(record);
 376     rj->done = FALSE;
 377     rj->time_event = NULL;
 378     rj->address_valid = FALSE;
 379     rj->flush_cache = FALSE;
 380
 381     AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->response_jobs, rj);
 382
 383     return rj;
 384 }
 385
 386 gboolean avahi_packet_scheduler_post_response(AvahiPacketScheduler *s, const AvahiAddress *a, AvahiRecord *record, gboolean flush_cache, gboolean immediately) {
 387     AvahiResponseJob *rj;
 388     GTimeVal tv;
 389
 390     g_assert(s);
 391     g_assert(record);
 392
 393     g_assert(!avahi_key_is_pattern(record->key));
 394
 395     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_RESPONSE_DEFER_MSEC, immediately ? 0 : AVAHI_RESPONSE_JITTER_MSEC);
 396
 397     /* Don't send out duplicates */
 398
 399     if ((rj = look_for_response(s, record))) {
 400         glong d;
 401
 402         d = avahi_timeval_diff(&tv, &rj->delivery);
 403
 404         /* If there's already a matching packet in our history or in
 405          * the schedule, we do nothing. */
 406         if (!!record->ttl == !!rj->record->ttl &&
 407             d >= 0 && d <= AVAHI_RESPONSE_HISTORY_MSEC*1000) {
 408             g_message("WARNING! DUPLICATE RESPONSE SUPPRESSION ACTIVE!");
 409
 410             /* This job is no longer specific to a single querier, so
 411              * make sure it isn't suppressed by known answer
 412              * suppresion */
 413
 414             if (rj->address_valid && (!a || avahi_address_cmp(a, &rj->address) != 0))
 415                 rj->address_valid = FALSE;
 416
 417             rj->flush_cache = flush_cache;
 418
 419             return FALSE;
 420         }
 421
 422         /* Either one was a goodbye packet, but the other was not, so
 423          * let's drop the older one. */
 424         response_job_free(s, rj);
 425     }
 426
 427 /*     g_message("ACCEPTED NEW RESPONSE [%s]", t = avahi_record_to_string(record)); */
 428 /*     g_free(t); */
 429
 430     /* Create a new job and schedule it */
 431     rj = response_job_new(s, record);
 432     rj->flush_cache = flush_cache;
 433     rj->delivery = tv;
 434     rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &rj->delivery, response_elapse, rj);
 435
 436     /* Store the address of the host this messages is intended to, so
 437        that we can drop this job in case a truncated message with
 438        known answer suppresion entries is recieved */
 439
 440     if ((rj->address_valid = !!a))
 441         rj->address = *a;
 442
 443     return TRUE;
 444 }
 445
 446 void avahi_packet_scheduler_incoming_query(AvahiPacketScheduler *s, AvahiKey *key) {
 447     GTimeVal tv;
 448     AvahiQueryJob *qj;
 449
 450     g_assert(s);
 451     g_assert(key);
 452
 453     /* This function is called whenever an incoming query was
 454      * receieved. We drop all scheduled queries which match here. The
 455      * keyword is "DUPLICATE QUESTION SUPPRESION". */
 456
 457     for (qj = s->query_jobs; qj; qj = qj->jobs_next)
 458         if (avahi_key_equal(qj->key, key)) {
 459
 460             if (qj->done)
 461                 return;
 462
 463             goto mark_done;
 464         }
 465
 466
 467     /* No matching job was found. Add the query to the history */
 468     qj = query_job_new(s, key);
 469
 470 mark_done:
 471     qj->done = TRUE;
 472
 473     /* Drop the query after some time */
 474     avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
 475     qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, query_elapse, qj);
 476
 477     g_get_current_time(&qj->delivery);
 478 }
 479
 480 void response_job_set_elapse_time(AvahiPacketScheduler *s, AvahiResponseJob *rj, guint msec, guint jitter) {
 481     GTimeVal tv;
 482
 483     g_assert(s);
 484     g_assert(rj);
 485
 486     avahi_elapse_time(&tv, msec, jitter);
 487
 488     if (rj->time_event)
 489         avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
 490     else
 491         rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, response_elapse, rj);
 492
 493 }
 494
 495 void avahi_packet_scheduler_incoming_response(AvahiPacketScheduler *s, AvahiRecord *record) {
 496     AvahiResponseJob *rj;
 497
 498     g_assert(s);
 499     g_assert(record);
 500
 501     /* This function is called whenever an incoming response was
 502      * receieved. We drop all scheduled responses which match
 503      * here. The keyword is "DUPLICATE ANSWER SUPPRESION". */
 504
 505     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
 506         if (avahi_record_equal_no_ttl(rj->record, record)) {
 507
 508             if (rj->done) {
 509
 510                 if (!!record->ttl == !!rj->record->ttl) {
 511                     /* An entry like this is already in our history,
 512                      * so let's get out of here! */
 513
 514                     return;
 515
 516                 } else {
 517                     /* Either one was a goodbye packet but other was
 518                      * none. We remove the history entry, and add a
 519                      * new one */
 520
 521                     response_job_free(s, rj);
 522                     break;
 523                 }
 524
 525             } else {
 526
 527                 if (!!record->ttl == !!rj->record->ttl) {
 528
 529                     /* The incoming packet matches our scheduled
 530                      * record, so let's mark that one as done */
 531
 532                     goto mark_done;
 533
 534                 } else {
 535
 536                     /* Either one was a goodbye packet but other was
 537                      * none. We ignore the incoming packet. */
 538
 539                     return;
 540                 }
 541             }
 542         }
 543
 544     /* No matching job was found. Add the query to the history */
 545     rj = response_job_new(s, record);
 546
 547 mark_done:
 548     rj->done = TRUE;
 549
 550     /* Drop response after 500ms from history */
 551     response_job_set_elapse_time(s, rj, AVAHI_RESPONSE_HISTORY_MSEC, 0);
 552
 553     g_get_current_time(&rj->delivery);
 554 }
 555
 556 void avahi_packet_scheduler_incoming_known_answer(AvahiPacketScheduler *s, AvahiRecord *record, const AvahiAddress *a) {
 557     AvahiResponseJob *rj;
 558
 559     g_assert(s);
 560     g_assert(record);
 561     g_assert(a);
 562
 563     for (rj = s->response_jobs; rj; rj = rj->jobs_next) {
 564
 565         g_assert(record->ttl > 0);
 566         g_assert(rj->record->ttl/2);
 567
 568         if (avahi_record_equal_no_ttl(rj->record, record))
 569             if (rj->address_valid)
 570                 if (avahi_address_cmp(&rj->address, a))
 571                     if (record->ttl >= rj->record->ttl/2) {
 572
 573             /* Let's suppress it */
 574
 575             response_job_free(s, rj);
 576             break;
 577         }
 578     }
 579 }
 580
 581 void avahi_packet_scheduler_flush_responses(AvahiPacketScheduler *s) {
 582     AvahiResponseJob *rj;
 583
 584     g_assert(s);
 585
 586     /* Send all scheduled responses, ignoring the scheduled time */
 587
 588     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
 589         if (!rj->done)
 590             send_response_packet(s, rj);
 591 }
 592
 593 static AvahiProbeJob* probe_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
 594     AvahiProbeJob *pj;
 595
 596     g_assert(s);
 597     g_assert(record);
 598
 599     pj = g_new(AvahiProbeJob, 1);
 600     pj->scheduler = s;
 601     pj->record = avahi_record_ref(record);
 602     pj->time_event = NULL;
 603     pj->chosen = FALSE;
 604
 605     AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->probe_jobs, pj);
 606
 607     return pj;
 608 }
 609
 610 static guint8* packet_add_probe_query(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) {
 611     guint size;
 612     guint8 *ret;
 613     AvahiKey *k;
 614
 615     g_assert(s);
 616     g_assert(p);
 617     g_assert(pj);
 618
 619     g_assert(!pj->chosen);
 620
 621     /* Estimate the size for this record */
 622     size =
 623         avahi_key_get_estimate_size(pj->record->key) +
 624         avahi_record_get_estimate_size(pj->record);
 625
 626     /* Too large */
 627     if (size > avahi_dns_packet_space(p))
 628         return NULL;
 629
 630     /* Create the probe query */
 631     k = avahi_key_new(pj->record->key->name, pj->record->key->class, AVAHI_DNS_TYPE_ANY);
 632     ret = avahi_dns_packet_append_key(p, k, FALSE);
 633     g_assert(ret);
 634
 635     /* Mark this job for addition to the packet */
 636     pj->chosen = TRUE;
 637
 638     /* Scan for more jobs whith matching key pattern */
 639     for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
 640         if (pj->chosen)
 641             continue;
 642
 643         /* Does the record match the probe? */
 644         if (k->class != pj->record->key->class || !avahi_domain_equal(k->name, pj->record->key->name))
 645             continue;
 646
 647         /* This job wouldn't fit in */
 648         if (avahi_record_get_estimate_size(pj->record) > avahi_dns_packet_space(p))
 649             break;
 650
 651         /* Mark this job for addition to the packet */
 652         pj->chosen = TRUE;
 653     }
 654
 655     avahi_key_unref(k);
 656
 657     return ret;
 658 }
 659
 660 static void probe_elapse(AvahiTimeEvent *e, gpointer data) {
 661     AvahiProbeJob *pj = data, *next;
 662     AvahiPacketScheduler *s;
 663     AvahiDnsPacket *p;
 664     guint n;
 665
 666     g_assert(pj);
 667     s = pj->scheduler;
 668
 669     p = avahi_dns_packet_new_query(s->interface->hardware->mtu);
 670
 671     /* Add the import probe */
 672     if (!packet_add_probe_query(s, p, pj)) {
 673         g_warning("Record too large! ---");
 674         avahi_dns_packet_free(p);
 675         return;
 676     }
 677
 678     n = 1;
 679
 680     /* Try to fill up packet with more probes, if available */
 681     for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
 682
 683         if (pj->chosen)
 684             continue;
 685
 686         if (!packet_add_probe_query(s, p, pj))
 687             break;
 688
 689         n++;
 690     }
 691
 692     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
 693
 694     n = 0;
 695
 696     /* Now add the chosen records to the authorative section */
 697     for (pj = s->probe_jobs; pj; pj = next) {
 698
 699         next = pj->jobs_next;
 700
 701         if (!pj->chosen)
 702             continue;
 703
 704         if (!avahi_dns_packet_append_record(p, pj->record, TRUE, 0)) {
 705             g_warning("Bad probe size estimate!");
 706
 707             /* Unmark all following jobs */
 708             for (; pj; pj = pj->jobs_next)
 709                 pj->chosen = FALSE;
 710
 711             break;
 712         }
 713
 714         probe_job_free(s, pj);
 715
 716         n ++;
 717     }
 718
 719     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_NSCOUNT, n);
 720
 721     /* Send it now */
 722     avahi_interface_send_packet(s->interface, p);
 723     avahi_dns_packet_free(p);
 724 }
 725
 726 gboolean avahi_packet_scheduler_post_probe(AvahiPacketScheduler *s, AvahiRecord *record, gboolean immediately) {
 727     AvahiProbeJob *pj;
 728     GTimeVal tv;
 729
 730     g_assert(s);
 731     g_assert(record);
 732     g_assert(!avahi_key_is_pattern(record->key));
 733
 734     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_PROBE_DEFER_MSEC, 0);
 735
 736     /* Create a new job and schedule it */
 737     pj = probe_job_new(s, record);
 738     pj->delivery = tv;
 739     pj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &pj->delivery, probe_elapse, pj);
 740
 741     return TRUE;
 742 }