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 static 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 static AvahiQueryJob* look_for_query(AvahiPacketScheduler *s, AvahiKey *key) {
 250     AvahiQueryJob *qj;
 251
 252     g_assert(s);
 253     g_assert(key);
 254
 255     for (qj = s->query_jobs; qj; qj = qj->jobs_next)
 256         if (avahi_key_equal(qj->key, key))
 257             return qj;
 258
 259     return NULL;
 260 }
 261
 262 gboolean avahi_packet_scheduler_post_query(AvahiPacketScheduler *s, AvahiKey *key, gboolean immediately) {
 263     GTimeVal tv;
 264     AvahiQueryJob *qj;
 265
 266     g_assert(s);
 267     g_assert(key);
 268
 269     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_QUERY_DEFER_MSEC, 0);
 270
 271     if ((qj = look_for_query(s, key))) {
 272         glong d = avahi_timeval_diff(&tv, &qj->delivery);
 273
 274         /* Duplicate questions suppression */
 275         if (!qj->done || d <= AVAHI_QUERY_HISTORY_MSEC*1000) {
 276             g_message("WARNING! DUPLICATE QUERY SUPPRESSION ACTIVE!");
 277
 278             if (!qj->done && d < 0) {
 279                 /* If the new entry should be scheduled earlier,
 280                  * update the old entry */
 281                 qj->delivery = tv;
 282                 avahi_time_event_queue_update(s->server->time_event_queue, qj->time_event, &qj->delivery);
 283             }
 284
 285             return FALSE;
 286         } else
 287             query_job_free(s, qj);
 288     }
 289
 290     qj = query_job_new(s, key);
 291     qj->delivery = tv;
 292     qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &qj->delivery, query_elapse, qj);
 293     return TRUE;
 294 }
 295
 296
 297 void avahi_packet_scheduler_incoming_query(AvahiPacketScheduler *s, AvahiKey *key) {
 298     AvahiQueryJob *qj;
 299     GTimeVal tv;
 300
 301     g_assert(s);
 302     g_assert(key);
 303
 304     /* This function is called whenever an incoming query was
 305      * receieved. We mark all matching queries that match as done. The
 306      * keyword is "DUPLICATE QUESTION SUPPRESION". */
 307
 308     if (!(qj = look_for_query(s, key)))
 309         qj = query_job_new(s, key);
 310
 311     qj->done = TRUE;
 312
 313     /* Drop the query after some time */
 314     avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
 315
 316     if (qj->time_event)
 317         avahi_time_event_queue_update(s->server->time_event_queue, qj->time_event, &tv);
 318     else
 319         qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, query_elapse, qj);
 320
 321     g_get_current_time(&qj->delivery);
 322 }
 323
 324 static guint8* packet_add_response_job(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiResponseJob *rj) {
 325     guint8 *d;
 326
 327     g_assert(s);
 328     g_assert(p);
 329     g_assert(rj);
 330
 331     if ((d = avahi_dns_packet_append_record(p, rj->record, rj->flush_cache, 0))) {
 332         GTimeVal tv;
 333
 334         rj->done = 1;
 335
 336         /* Drop response after some time from history */
 337         avahi_elapse_time(&tv, AVAHI_RESPONSE_HISTORY_MSEC, 0);
 338         avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
 339
 340         g_get_current_time(&rj->delivery);
 341     }
 342
 343     return d;
 344 }
 345
 346 static void send_response_packet(AvahiPacketScheduler *s, AvahiResponseJob *rj) {
 347     AvahiDnsPacket *p;
 348     guint n;
 349
 350     g_assert(s);
 351
 352     p = avahi_dns_packet_new_response(s->interface->hardware->mtu, TRUE);
 353     n = 0;
 354
 355     /* If a job was specified, put it in the packet. */
 356     if (rj) {
 357         guint8 *d;
 358         d = packet_add_response_job(s, p, rj);
 359         g_assert(d);
 360         n++;
 361     }
 362
 363     /* Try to fill up packet with more responses, if available */
 364     for (rj = s->response_jobs; rj; rj = rj->jobs_next) {
 365
 366         if (rj->done)
 367             continue;
 368
 369         if (!packet_add_response_job(s, p, rj))
 370             break;
 371
 372         n++;
 373     }
 374
 375     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
 376     avahi_interface_send_packet(s->interface, p);
 377     avahi_dns_packet_free(p);
 378 }
 379
 380 static void response_elapse(AvahiTimeEvent *e, gpointer data) {
 381     AvahiResponseJob *rj = data;
 382     AvahiPacketScheduler *s;
 383
 384     g_assert(rj);
 385     s = rj->scheduler;
 386
 387     if (rj->done) {
 388         /* Lets remove it  from the history */
 389         response_job_free(s, rj);
 390         return;
 391     }
 392
 393     send_response_packet(s, rj);
 394 }
 395
 396 static AvahiResponseJob* look_for_response(AvahiPacketScheduler *s, AvahiRecord *record) {
 397     AvahiResponseJob *rj;
 398
 399     g_assert(s);
 400     g_assert(record);
 401
 402     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
 403         if (avahi_record_equal_no_ttl(rj->record, record))
 404             return rj;
 405
 406     return NULL;
 407 }
 408
 409 static AvahiResponseJob* response_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
 410     AvahiResponseJob *rj;
 411
 412     g_assert(s);
 413     g_assert(record);
 414
 415     rj = g_new(AvahiResponseJob, 1);
 416     rj->scheduler = s;
 417     rj->record = avahi_record_ref(record);
 418     rj->done = FALSE;
 419     rj->time_event = NULL;
 420     rj->flush_cache = FALSE;
 421     rj->querier_valid = FALSE;
 422
 423     AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->response_jobs, rj);
 424
 425     return rj;
 426 }
 427
 428 gboolean avahi_packet_scheduler_post_response(AvahiPacketScheduler *s, AvahiRecord *record, gboolean flush_cache, gboolean immediately, const AvahiAddress *querier) {
 429     AvahiResponseJob *rj;
 430     GTimeVal tv;
 431
 432     g_assert(s);
 433     g_assert(record);
 434
 435     g_assert(!avahi_key_is_pattern(record->key));
 436
 437     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_RESPONSE_DEFER_MSEC, immediately ? 0 : AVAHI_RESPONSE_JITTER_MSEC);
 438
 439     /* Don't send out duplicates */
 440
 441     if ((rj = look_for_response(s, record))) {
 442
 443         glong d = avahi_timeval_diff(&tv, &rj->delivery);
 444
 445         /* If there's already a matching packet in our history or in
 446          * the schedule, we do nothing. */
 447
 448         if ((!!record->ttl == !!rj->record->ttl) &&
 449             (rj->flush_cache || !flush_cache) &&
 450             ((!rj->done && d >= 0) || (rj->done && d <= AVAHI_RESPONSE_HISTORY_MSEC*1000))) {
 451
 452             g_message("Duplicate suppresion active.");
 453             return FALSE;
 454         }
 455
 456         /* If the old job was not yet done but scheduled earlier than
 457          * our new one, we chedule our new job at the same time. */
 458         if (!rj->done && d > 0)
 459             tv = rj->delivery;
 460
 461         /* If the old job had the flush_cache bit enabled, we must
 462            enable it on our new one, too */
 463         if (!rj->done && rj->flush_cache)
 464             flush_cache = TRUE;
 465
 466         /* For known answer suppresion we have record for which host this data was intended */
 467         if (querier && !rj->done && (!rj->querier_valid || avahi_address_cmp(&rj->querier, querier) != 0))
 468             querier = NULL;
 469
 470         /* The old job wasn't good enough, so let's drop it */
 471         response_job_free(s, rj);
 472     }
 473
 474     /* Create a new job and schedule it */
 475     rj = response_job_new(s, record);
 476     rj->flush_cache = flush_cache;
 477     rj->delivery = tv;
 478     rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &rj->delivery, response_elapse, rj);
 479
 480     if ((rj->querier_valid = !!querier))
 481         rj->querier = *querier;
 482
 483     return TRUE;
 484 }
 485
 486 void response_job_set_elapse_time(AvahiPacketScheduler *s, AvahiResponseJob *rj, guint msec, guint jitter) {
 487     GTimeVal tv;
 488
 489     g_assert(s);
 490     g_assert(rj);
 491
 492     avahi_elapse_time(&tv, msec, jitter);
 493
 494     if (rj->time_event)
 495         avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
 496     else
 497         rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, response_elapse, rj);
 498 }
 499
 500 void avahi_packet_scheduler_incoming_response(AvahiPacketScheduler *s, AvahiRecord *record, gboolean flush_cache) {
 501     AvahiResponseJob *rj = NULL;
 502
 503     g_assert(s);
 504     g_assert(record);
 505
 506     /* This function is called whenever an incoming response was
 507      * receieved. We drop all scheduled responses which match
 508      * here. The keyword is "DUPLICATE ANSWER SUPPRESION". */
 509
 510     if ((rj = look_for_response(s, record))) {
 511
 512         if (!rj->done) {
 513
 514             if (rj->flush_cache && !flush_cache)
 515                 /* The incoming response didn't have flush_cache
 516                  * set, but our scheduled has => we still have to
 517                  * send our response */
 518                 return;
 519
 520
 521             if (!!record->ttl != !!rj->record->ttl) {
 522                 /* Either one was a goodbye packet but other was
 523                  * none => we still have to send our response */
 524                 return;
 525             }
 526         }
 527
 528         /* The two responses match, so let's mark the history
 529          * entry as done or update it */
 530     }
 531
 532     /* No matching job was found. Add the query to the history */
 533     if (!rj)
 534         rj = response_job_new(s, record);
 535     else {
 536         avahi_record_unref(rj->record);
 537         rj->record = avahi_record_ref(record);
 538     }
 539
 540     rj->done = TRUE;
 541     rj->flush_cache = rj->flush_cache || flush_cache;
 542
 543     /* Drop response after 500ms from history */
 544     response_job_set_elapse_time(s, rj, AVAHI_RESPONSE_HISTORY_MSEC, 0);
 545
 546     g_get_current_time(&rj->delivery);
 547 }
 548
 549
 550 void avahi_packet_scheduler_incoming_known_answer(AvahiPacketScheduler *s, AvahiRecord *record, const AvahiAddress *querier) {
 551     AvahiResponseJob *rj;
 552
 553     g_assert(s);
 554     g_assert(record);
 555     g_assert(querier);
 556
 557     /* Check whether a matching job has been scheduled */
 558     if (!(rj = look_for_response(s, record)) || rj->done)
 559         return;
 560
 561     /* Chech whether another querier demanded the original job */
 562     if (!rj->querier_valid || avahi_address_cmp(&rj->querier, querier) != 0)
 563         return;
 564
 565     /* Check whether one of them is a goodbye packet, while the other is not */
 566     if (!!record->ttl != !!rj->record->ttl)
 567         return;
 568
 569     /* Check whether the known answer has a good TTL */
 570     if (record->ttl <= rj->record->ttl/2)
 571         return;
 572
 573     g_message("Known answer suppression active!");
 574     response_job_free(s, rj);
 575 }
 576
 577 void avahi_packet_scheduler_flush_responses(AvahiPacketScheduler *s) {
 578     AvahiResponseJob *rj;
 579
 580     g_assert(s);
 581
 582     /* Send all scheduled responses, ignoring the scheduled time */
 583
 584     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
 585         if (!rj->done)
 586             send_response_packet(s, rj);
 587 }
 588
 589 static AvahiProbeJob* probe_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
 590     AvahiProbeJob *pj;
 591
 592     g_assert(s);
 593     g_assert(record);
 594
 595     pj = g_new(AvahiProbeJob, 1);
 596     pj->scheduler = s;
 597     pj->record = avahi_record_ref(record);
 598     pj->time_event = NULL;
 599     pj->chosen = FALSE;
 600
 601     AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->probe_jobs, pj);
 602
 603     return pj;
 604 }
 605
 606 static guint8* packet_add_probe_query(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) {
 607     guint size;
 608     guint8 *ret;
 609     AvahiKey *k;
 610
 611     g_assert(s);
 612     g_assert(p);
 613     g_assert(pj);
 614
 615     g_assert(!pj->chosen);
 616
 617     /* Estimate the size for this record */
 618     size =
 619         avahi_key_get_estimate_size(pj->record->key) +
 620         avahi_record_get_estimate_size(pj->record);
 621
 622     /* Too large */
 623     if (size > avahi_dns_packet_space(p))
 624         return NULL;
 625
 626     /* Create the probe query */
 627     k = avahi_key_new(pj->record->key->name, pj->record->key->class, AVAHI_DNS_TYPE_ANY);
 628     ret = avahi_dns_packet_append_key(p, k, FALSE);
 629     g_assert(ret);
 630
 631     /* Mark this job for addition to the packet */
 632     pj->chosen = TRUE;
 633
 634     /* Scan for more jobs whith matching key pattern */
 635     for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
 636         if (pj->chosen)
 637             continue;
 638
 639         /* Does the record match the probe? */
 640         if (k->class != pj->record->key->class || !avahi_domain_equal(k->name, pj->record->key->name))
 641             continue;
 642
 643         /* This job wouldn't fit in */
 644         if (avahi_record_get_estimate_size(pj->record) > avahi_dns_packet_space(p))
 645             break;
 646
 647         /* Mark this job for addition to the packet */
 648         pj->chosen = TRUE;
 649     }
 650
 651     avahi_key_unref(k);
 652
 653     return ret;
 654 }
 655
 656 static void probe_elapse(AvahiTimeEvent *e, gpointer data) {
 657     AvahiProbeJob *pj = data, *next;
 658     AvahiPacketScheduler *s;
 659     AvahiDnsPacket *p;
 660     guint n;
 661
 662     g_assert(pj);
 663     s = pj->scheduler;
 664
 665     p = avahi_dns_packet_new_query(s->interface->hardware->mtu);
 666
 667     /* Add the import probe */
 668     if (!packet_add_probe_query(s, p, pj)) {
 669         g_warning("Record too large! ---");
 670         avahi_dns_packet_free(p);
 671         return;
 672     }
 673
 674     n = 1;
 675
 676     /* Try to fill up packet with more probes, if available */
 677     for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
 678
 679         if (pj->chosen)
 680             continue;
 681
 682         if (!packet_add_probe_query(s, p, pj))
 683             break;
 684
 685         n++;
 686     }
 687
 688     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
 689
 690     n = 0;
 691
 692     /* Now add the chosen records to the authorative section */
 693     for (pj = s->probe_jobs; pj; pj = next) {
 694
 695         next = pj->jobs_next;
 696
 697         if (!pj->chosen)
 698             continue;
 699
 700         if (!avahi_dns_packet_append_record(p, pj->record, FALSE, 0)) {
 701             g_warning("Bad probe size estimate!");
 702
 703             /* Unmark all following jobs */
 704             for (; pj; pj = pj->jobs_next)
 705                 pj->chosen = FALSE;
 706
 707             break;
 708         }
 709
 710         probe_job_free(s, pj);
 711
 712         n ++;
 713     }
 714
 715     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_NSCOUNT, n);
 716
 717     /* Send it now */
 718     avahi_interface_send_packet(s->interface, p);
 719     avahi_dns_packet_free(p);
 720 }
 721
 722 gboolean avahi_packet_scheduler_post_probe(AvahiPacketScheduler *s, AvahiRecord *record, gboolean immediately) {
 723     AvahiProbeJob *pj;
 724     GTimeVal tv;
 725
 726     g_assert(s);
 727     g_assert(record);
 728     g_assert(!avahi_key_is_pattern(record->key));
 729
 730     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_PROBE_DEFER_MSEC, 0);
 731
 732     /* Create a new job and schedule it */
 733     pj = probe_job_new(s, record);
 734     pj->delivery = tv;
 735     pj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &pj->delivery, probe_elapse, pj);
 736
 737     return TRUE;
 738 }