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->flush_cache = FALSE;
 379
 380     AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->response_jobs, rj);
 381
 382     return rj;
 383 }
 384
 385 gboolean avahi_packet_scheduler_post_response(AvahiPacketScheduler *s, AvahiRecord *record, gboolean flush_cache, gboolean immediately) {
 386     AvahiResponseJob *rj;
 387     GTimeVal tv;
 388
 389     g_assert(s);
 390     g_assert(record);
 391
 392     g_assert(!avahi_key_is_pattern(record->key));
 393
 394     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_RESPONSE_DEFER_MSEC, immediately ? 0 : AVAHI_RESPONSE_JITTER_MSEC);
 395
 396     /* Don't send out duplicates */
 397
 398     if ((rj = look_for_response(s, record))) {
 399         glong d;
 400
 401         d = avahi_timeval_diff(&tv, &rj->delivery);
 402
 403         /* If there's already a matching packet in our history or in
 404          * the schedule, we do nothing. */
 405         if (!!record->ttl == !!rj->record->ttl &&
 406             d >= 0 && d <= AVAHI_RESPONSE_HISTORY_MSEC*1000) {
 407             g_message("WARNING! DUPLICATE RESPONSE SUPPRESSION ACTIVE!");
 408
 409             rj->flush_cache = flush_cache;
 410
 411             return FALSE;
 412         }
 413
 414         /* Either one was a goodbye packet, but the other was not, so
 415          * let's drop the older one. */
 416         response_job_free(s, rj);
 417     }
 418
 419 /*     g_message("ACCEPTED NEW RESPONSE [%s]", t = avahi_record_to_string(record)); */
 420 /*     g_free(t); */
 421
 422     /* Create a new job and schedule it */
 423     rj = response_job_new(s, record);
 424     rj->flush_cache = flush_cache;
 425     rj->delivery = tv;
 426     rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &rj->delivery, response_elapse, rj);
 427
 428     return TRUE;
 429 }
 430
 431 void avahi_packet_scheduler_incoming_query(AvahiPacketScheduler *s, AvahiKey *key) {
 432     GTimeVal tv;
 433     AvahiQueryJob *qj;
 434
 435     g_assert(s);
 436     g_assert(key);
 437
 438     /* This function is called whenever an incoming query was
 439      * receieved. We drop all scheduled queries which match here. The
 440      * keyword is "DUPLICATE QUESTION SUPPRESION". */
 441
 442     for (qj = s->query_jobs; qj; qj = qj->jobs_next)
 443         if (avahi_key_equal(qj->key, key)) {
 444
 445             if (qj->done)
 446                 return;
 447
 448             goto mark_done;
 449         }
 450
 451
 452     /* No matching job was found. Add the query to the history */
 453     qj = query_job_new(s, key);
 454
 455 mark_done:
 456     qj->done = TRUE;
 457
 458     /* Drop the query after some time */
 459     avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
 460     qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, query_elapse, qj);
 461
 462     g_get_current_time(&qj->delivery);
 463 }
 464
 465 void response_job_set_elapse_time(AvahiPacketScheduler *s, AvahiResponseJob *rj, guint msec, guint jitter) {
 466     GTimeVal tv;
 467
 468     g_assert(s);
 469     g_assert(rj);
 470
 471     avahi_elapse_time(&tv, msec, jitter);
 472
 473     if (rj->time_event)
 474         avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
 475     else
 476         rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, response_elapse, rj);
 477 }
 478
 479 void avahi_packet_scheduler_incoming_response(AvahiPacketScheduler *s, AvahiRecord *record) {
 480     AvahiResponseJob *rj;
 481
 482     g_assert(s);
 483     g_assert(record);
 484
 485     /* This function is called whenever an incoming response was
 486      * receieved. We drop all scheduled responses which match
 487      * here. The keyword is "DUPLICATE ANSWER SUPPRESION". */
 488
 489     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
 490         if (avahi_record_equal_no_ttl(rj->record, record)) {
 491
 492             if (rj->done) {
 493
 494                 if (!!record->ttl == !!rj->record->ttl) {
 495                     /* An entry like this is already in our history,
 496                      * so let's get out of here! */
 497
 498                     return;
 499
 500                 } else {
 501                     /* Either one was a goodbye packet but other was
 502                      * none. We remove the history entry, and add a
 503                      * new one */
 504
 505                     response_job_free(s, rj);
 506                     break;
 507                 }
 508
 509             } else {
 510
 511                 if (!!record->ttl == !!rj->record->ttl) {
 512
 513                     /* The incoming packet matches our scheduled
 514                      * record, so let's mark that one as done */
 515
 516                     goto mark_done;
 517
 518                 } else {
 519
 520                     /* Either one was a goodbye packet but other was
 521                      * none. We ignore the incoming packet. */
 522
 523                     return;
 524                 }
 525             }
 526         }
 527
 528     /* No matching job was found. Add the query to the history */
 529     rj = response_job_new(s, record);
 530
 531 mark_done:
 532     rj->done = TRUE;
 533
 534     /* Drop response after 500ms from history */
 535     response_job_set_elapse_time(s, rj, AVAHI_RESPONSE_HISTORY_MSEC, 0);
 536
 537     g_get_current_time(&rj->delivery);
 538 }
 539
 540 void avahi_packet_scheduler_flush_responses(AvahiPacketScheduler *s) {
 541     AvahiResponseJob *rj;
 542
 543     g_assert(s);
 544
 545     /* Send all scheduled responses, ignoring the scheduled time */
 546
 547     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
 548         if (!rj->done)
 549             send_response_packet(s, rj);
 550 }
 551
 552 static AvahiProbeJob* probe_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
 553     AvahiProbeJob *pj;
 554
 555     g_assert(s);
 556     g_assert(record);
 557
 558     pj = g_new(AvahiProbeJob, 1);
 559     pj->scheduler = s;
 560     pj->record = avahi_record_ref(record);
 561     pj->time_event = NULL;
 562     pj->chosen = FALSE;
 563
 564     AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->probe_jobs, pj);
 565
 566     return pj;
 567 }
 568
 569 static guint8* packet_add_probe_query(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) {
 570     guint size;
 571     guint8 *ret;
 572     AvahiKey *k;
 573
 574     g_assert(s);
 575     g_assert(p);
 576     g_assert(pj);
 577
 578     g_assert(!pj->chosen);
 579
 580     /* Estimate the size for this record */
 581     size =
 582         avahi_key_get_estimate_size(pj->record->key) +
 583         avahi_record_get_estimate_size(pj->record);
 584
 585     /* Too large */
 586     if (size > avahi_dns_packet_space(p))
 587         return NULL;
 588
 589     /* Create the probe query */
 590     k = avahi_key_new(pj->record->key->name, pj->record->key->class, AVAHI_DNS_TYPE_ANY);
 591     ret = avahi_dns_packet_append_key(p, k, FALSE);
 592     g_assert(ret);
 593
 594     /* Mark this job for addition to the packet */
 595     pj->chosen = TRUE;
 596
 597     /* Scan for more jobs whith matching key pattern */
 598     for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
 599         if (pj->chosen)
 600             continue;
 601
 602         /* Does the record match the probe? */
 603         if (k->class != pj->record->key->class || !avahi_domain_equal(k->name, pj->record->key->name))
 604             continue;
 605
 606         /* This job wouldn't fit in */
 607         if (avahi_record_get_estimate_size(pj->record) > avahi_dns_packet_space(p))
 608             break;
 609
 610         /* Mark this job for addition to the packet */
 611         pj->chosen = TRUE;
 612     }
 613
 614     avahi_key_unref(k);
 615
 616     return ret;
 617 }
 618
 619 static void probe_elapse(AvahiTimeEvent *e, gpointer data) {
 620     AvahiProbeJob *pj = data, *next;
 621     AvahiPacketScheduler *s;
 622     AvahiDnsPacket *p;
 623     guint n;
 624
 625     g_assert(pj);
 626     s = pj->scheduler;
 627
 628     p = avahi_dns_packet_new_query(s->interface->hardware->mtu);
 629
 630     /* Add the import probe */
 631     if (!packet_add_probe_query(s, p, pj)) {
 632         g_warning("Record too large! ---");
 633         avahi_dns_packet_free(p);
 634         return;
 635     }
 636
 637     n = 1;
 638
 639     /* Try to fill up packet with more probes, if available */
 640     for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
 641
 642         if (pj->chosen)
 643             continue;
 644
 645         if (!packet_add_probe_query(s, p, pj))
 646             break;
 647
 648         n++;
 649     }
 650
 651     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
 652
 653     n = 0;
 654
 655     /* Now add the chosen records to the authorative section */
 656     for (pj = s->probe_jobs; pj; pj = next) {
 657
 658         next = pj->jobs_next;
 659
 660         if (!pj->chosen)
 661             continue;
 662
 663         if (!avahi_dns_packet_append_record(p, pj->record, TRUE, 0)) {
 664             g_warning("Bad probe size estimate!");
 665
 666             /* Unmark all following jobs */
 667             for (; pj; pj = pj->jobs_next)
 668                 pj->chosen = FALSE;
 669
 670             break;
 671         }
 672
 673         probe_job_free(s, pj);
 674
 675         n ++;
 676     }
 677
 678     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_NSCOUNT, n);
 679
 680     /* Send it now */
 681     avahi_interface_send_packet(s->interface, p);
 682     avahi_dns_packet_free(p);
 683 }
 684
 685 gboolean avahi_packet_scheduler_post_probe(AvahiPacketScheduler *s, AvahiRecord *record, gboolean immediately) {
 686     AvahiProbeJob *pj;
 687     GTimeVal tv;
 688
 689     g_assert(s);
 690     g_assert(record);
 691     g_assert(!avahi_key_is_pattern(record->key));
 692
 693     avahi_elapse_time(&tv, immediately ? 0 : AVAHI_PROBE_DEFER_MSEC, 0);
 694
 695     /* Create a new job and schedule it */
 696     pj = probe_job_new(s, record);
 697     pj->delivery = tv;
 698     pj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &pj->delivery, probe_elapse, pj);
 699
 700     return TRUE;
 701 }