← Back to branch summary

~vorlon/ubuntu/natty/avahi/multiarch

« back to all changes in this revision

Viewing changes to avahi-core/dns.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2009-05-06 14:04:57 UTC
  • mfrom: (4.1.13 sid)
  • Revision ID: james.westby@ubuntu.com-20090506140457-72h3msg32nuc4j7v
Tags: 0.6.27-2ubuntu1
* Merge from Debian unstable, remaining Ubuntu changes:
* debian/control:
  - Remove linux-any as it is not yet supported by Soyuz
  - Add versioned dependency on the dbus that satisfies our upstart job
    dependency.
  - Add udebs corresponding to libavahi-common3 and libavahi-core6, so that
    we can use them for Eucalyptus integration in the installer.
  - Recommend dhcp3-client instead of isc-dhcp-client (not yet available in
    Ubuntu)
* debian/rules:
* debian/avahi-daemon.init:
* debian/avahi-dnsconfd.init:
  - Avahi init scripts (daemon or dnsconfd) do not need to
    be started before gdm, and do not need to be stopped specially on
    shutdown.
* debian/avahi-daemon.postinst:
* debian/avahi-dnsconfd.postinst:
  - Use Ubuntu versions for migration scripts
* debian/avahi-autoipd.preinst:
* debian/avahi-autoipd.install:
* debian/avahi-autoipd.postinst:
* debian/avahi-autoipd.postrm:
  - Disable DHCP 3 to 4 migration (not yet in Ubuntu)
* debian/avahi-daemon.upstart:
* debian/avahi-dnsconfd.upstart:
  - Add Upstart config
* debian/patches/03_gir_1.1.patch:
  - Compile with the latest Gobject introspection

Show diffs side-by-side

added added

removed removed

Lines of Context:
avahi-core/dns.c
1
 
/* $Id$ */
2
 
 
3
1
/***
4
2
  This file is part of avahi.
5
 
 
 
3
 
6
4
  avahi is free software; you can redistribute it and/or modify it
7
5
  under the terms of the GNU Lesser General Public License as
8
6
  published by the Free Software Foundation; either version 2.1 of the
9
7
  License, or (at your option) any later version.
10
 
 
 
8
 
11
9
  avahi is distributed in the hope that it will be useful, but WITHOUT
12
10
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13
11
  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
14
12
  Public License for more details.
15
 
 
 
13
 
16
14
  You should have received a copy of the GNU Lesser General Public
17
15
  License along with avahi; if not, write to the Free Software
18
16
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
51
49
 
52
50
    if (max_size < AVAHI_DNS_PACKET_HEADER_SIZE)
53
51
        max_size = AVAHI_DNS_PACKET_HEADER_SIZE;
54
 
    
 
52
 
55
53
    if (!(p = avahi_malloc(sizeof(AvahiDnsPacket) + max_size)))
56
54
        return p;
57
 
    
 
55
 
58
56
    p->size = p->rindex = AVAHI_DNS_PACKET_HEADER_SIZE;
59
57
    p->max_size = max_size;
60
58
    p->name_table = NULL;
69
67
 
70
68
    if (!(p = avahi_dns_packet_new(mtu)))
71
69
        return NULL;
72
 
    
 
70
 
73
71
    avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_FLAGS, AVAHI_DNS_FLAGS(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
74
72
    return p;
75
73
}
79
77
 
80
78
    if (!(p = avahi_dns_packet_new(mtu)))
81
79
        return NULL;
82
 
    
 
80
 
83
81
    avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_FLAGS, AVAHI_DNS_FLAGS(1, 0, aa, 0, 0, 0, 0, 0, 0, 0));
84
82
    return p;
85
83
}
97
95
 
98
96
        saved_rindex = p->rindex;
99
97
        p->rindex = AVAHI_DNS_PACKET_HEADER_SIZE;
100
 
        
 
98
 
101
99
        for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_QDCOUNT); n > 0; n--) {
102
100
            AvahiKey *k;
103
101
            int unicast_response;
120
118
                               (avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_OPCODE));
121
119
 
122
120
    return r;
123
 
} 
 
121
}
124
122
 
125
123
 
126
124
void avahi_dns_packet_free(AvahiDnsPacket *p) {
128
126
 
129
127
    if (p->name_table)
130
128
        avahi_hashmap_free(p->name_table);
131
 
    
 
129
 
132
130
    avahi_free(p);
133
131
}
134
132
 
135
133
void avahi_dns_packet_set_field(AvahiDnsPacket *p, unsigned idx, uint16_t v) {
136
134
    assert(p);
137
135
    assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE);
138
 
    
 
136
 
139
137
    ((uint16_t*) AVAHI_DNS_PACKET_DATA(p))[idx] = htons(v);
140
138
}
141
139
 
151
149
    assert(idx < AVAHI_DNS_PACKET_HEADER_SIZE);
152
150
 
153
151
    avahi_dns_packet_set_field(p, idx, avahi_dns_packet_get_field(p, idx) + 1);
154
 
}   
 
152
}
155
153
 
156
154
 
157
155
static void name_table_cleanup(void *key, void *value, void *user_data) {
158
156
    AvahiDnsPacket *p = user_data;
159
 
    
 
157
 
160
158
    if ((uint8_t*) value >= AVAHI_DNS_PACKET_DATA(p) + p->size)
161
159
        avahi_hashmap_remove(p->name_table, key);
162
160
}
169
167
uint8_t* avahi_dns_packet_append_name(AvahiDnsPacket *p, const char *name) {
170
168
    uint8_t *d, *saved_ptr = NULL;
171
169
    size_t saved_size;
172
 
    
 
170
 
173
171
    assert(p);
174
172
    assert(name);
175
173
 
176
174
    saved_size = p->size;
177
175
    saved_ptr = avahi_dns_packet_extend(p, 0);
178
 
    
 
176
 
179
177
    while (*name) {
180
178
        uint8_t* prev;
181
179
        const char *pname;
182
180
        char label[64], *u;
183
 
        
 
181
 
184
182
        /* Check whether we can compress this name. */
185
183
 
186
184
        if (p->name_table && (prev = avahi_hashmap_lookup(p->name_table, name))) {
187
185
            unsigned idx;
188
 
            
 
186
 
189
187
            assert(prev >= AVAHI_DNS_PACKET_DATA(p));
190
188
            idx = (unsigned) (prev - AVAHI_DNS_PACKET_DATA(p));
191
189
 
203
201
        }
204
202
 
205
203
        pname = name;
206
 
        
 
204
 
207
205
        if (!(avahi_unescape_label(&name, label, sizeof(label))))
208
206
            goto fail;
209
207
 
222
220
 
223
221
    if (!(d = avahi_dns_packet_extend(p, 1)))
224
222
        goto fail;
225
 
    
 
223
 
226
224
    *d = 0;
227
225
 
228
226
    return saved_ptr;
237
235
uint8_t* avahi_dns_packet_append_uint16(AvahiDnsPacket *p, uint16_t v) {
238
236
    uint8_t *d;
239
237
    assert(p);
240
 
    
 
238
 
241
239
    if (!(d = avahi_dns_packet_extend(p, sizeof(uint16_t))))
242
240
        return NULL;
243
 
    
 
241
 
244
242
    d[0] = (uint8_t) (v >> 8);
245
243
    d[1] = (uint8_t) v;
246
244
    return d;
252
250
 
253
251
    if (!(d = avahi_dns_packet_extend(p, sizeof(uint32_t))))
254
252
        return NULL;
255
 
    
 
253
 
256
254
    d[0] = (uint8_t) (v >> 24);
257
255
    d[1] = (uint8_t) (v >> 16);
258
256
    d[2] = (uint8_t) (v >> 8);
278
276
uint8_t* avahi_dns_packet_append_string(AvahiDnsPacket *p, const char *s) {
279
277
    uint8_t* d;
280
278
    size_t k;
281
 
    
 
279
 
282
280
    assert(p);
283
281
    assert(s);
284
282
 
285
283
    if ((k = strlen(s)) >= 255)
286
284
        k = 255;
287
 
    
 
285
 
288
286
    if (!(d = avahi_dns_packet_extend(p, k+1)))
289
287
        return NULL;
290
288
 
296
294
 
297
295
uint8_t *avahi_dns_packet_extend(AvahiDnsPacket *p, size_t l) {
298
296
    uint8_t *d;
299
 
    
 
297
 
300
298
    assert(p);
301
299
 
302
300
    if (p->size+l > p->max_size)
303
301
        return NULL;
304
 
    
 
302
 
305
303
    d = AVAHI_DNS_PACKET_DATA(p) + p->size;
306
304
    p->size += l;
307
 
    
 
305
 
308
306
    return d;
309
307
}
310
308
 
316
314
        return -1;
317
315
 
318
316
    flags = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS);
319
 
    
 
317
 
320
318
    if (flags & AVAHI_DNS_FLAG_OPCODE)
321
319
        return -1;
322
320
 
329
327
 
330
328
    if (avahi_dns_packet_check_valid(p) < 0)
331
329
        return -1;
332
 
    
 
330
 
333
331
    flags = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS);
334
 
    
 
332
 
335
333
    if (flags & AVAHI_DNS_FLAG_RCODE)
336
334
        return -1;
337
335
 
340
338
 
341
339
int avahi_dns_packet_is_query(AvahiDnsPacket *p) {
342
340
    assert(p);
343
 
    
 
341
 
344
342
    return !(avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_QR);
345
343
}
346
344
 
351
349
    unsigned label_ptr;
352
350
    int i;
353
351
    assert(p && ret_name && l);
354
 
    
 
352
 
355
353
    for (i = 0; i < AVAHI_DNS_LABELS_MAX; i++) {
356
354
        uint8_t n;
357
355
 
368
366
            if (l < 1)
369
367
                return -1;
370
368
            *ret_name = 0;
371
 
            
 
369
 
372
370
            return ret;
373
 
            
 
371
 
374
372
        } else if (n <= 63) {
375
373
            /* Uncompressed label */
376
374
            idx++;
377
375
            if (!compressed)
378
376
                ret++;
379
 
        
 
377
 
380
378
            if (idx + n > p->size)
381
379
                return -1;
382
380
 
393
391
                return -1;
394
392
 
395
393
            idx += n;
396
 
            
 
394
 
397
395
            if (!compressed)
398
396
                ret += n;
399
397
        } else if ((n & 0xC0) == 0xC0) {
411
409
 
412
410
            if (!compressed)
413
411
                ret += 2;
414
 
            
 
412
 
415
413
            compressed = 1;
416
414
        } else
417
415
            return -1;
422
420
 
423
421
int avahi_dns_packet_consume_name(AvahiDnsPacket *p, char *ret_name, size_t l) {
424
422
    int r;
425
 
    
 
423
 
426
424
    if ((r = consume_labels(p, p->rindex, ret_name, l)) < 0)
427
425
        return -1;
428
426
 
458
456
    d = (uint8_t*) (AVAHI_DNS_PACKET_DATA(p) + p->rindex);
459
457
    *ret_v = (d[0] << 24) | (d[1] << 16) | (d[2] << 8) | d[3];
460
458
    p->rindex += sizeof(uint32_t);
461
 
    
 
459
 
462
460
    return 0;
463
461
}
464
462
 
466
464
    assert(p);
467
465
    assert(ret_data);
468
466
    assert(l > 0);
469
 
    
 
467
 
470
468
    if (p->rindex + l > p->size)
471
469
        return -1;
472
470
 
478
476
 
479
477
int avahi_dns_packet_consume_string(AvahiDnsPacket *p, char *ret_string, size_t l) {
480
478
    size_t k;
481
 
    
 
479
 
482
480
    assert(p);
483
481
    assert(ret_string);
484
482
    assert(l > 0);
496
494
 
497
495
    memcpy(ret_string, AVAHI_DNS_PACKET_DATA(p)+p->rindex+1, l-1);
498
496
    ret_string[l-1] = 0;
499
 
    
 
497
 
500
498
    p->rindex += 1+k;
501
499
 
502
500
    return 0;
504
502
 
505
503
const void* avahi_dns_packet_get_rptr(AvahiDnsPacket *p) {
506
504
    assert(p);
507
 
    
 
505
 
508
506
    if (p->rindex > p->size)
509
507
        return NULL;
510
508
 
524
522
static int parse_rdata(AvahiDnsPacket *p, AvahiRecord *r, uint16_t rdlength) {
525
523
    char buf[AVAHI_DOMAIN_NAME_MAX];
526
524
    const void* start;
527
 
    
 
525
 
528
526
    assert(p);
529
527
    assert(r);
530
528
 
531
529
    start = avahi_dns_packet_get_rptr(p);
532
 
 
 
530
 
533
531
    switch (r->key->type) {
534
532
        case AVAHI_DNS_TYPE_PTR:
535
533
        case AVAHI_DNS_TYPE_CNAME:
536
534
        case AVAHI_DNS_TYPE_NS:
537
 
            
 
535
 
538
536
            if (avahi_dns_packet_consume_name(p, buf, sizeof(buf)) < 0)
539
537
                return -1;
540
538
 
541
539
            r->data.ptr.name = avahi_strdup(buf);
542
540
            break;
543
541
 
544
 
            
 
542
 
545
543
        case AVAHI_DNS_TYPE_SRV:
546
 
            
 
544
 
547
545
            if (avahi_dns_packet_consume_uint16(p, &r->data.srv.priority) < 0 ||
548
546
                avahi_dns_packet_consume_uint16(p, &r->data.srv.weight) < 0 ||
549
547
                avahi_dns_packet_consume_uint16(p, &r->data.srv.port) < 0 ||
550
548
                avahi_dns_packet_consume_name(p, buf, sizeof(buf)) < 0)
551
549
                return -1;
552
 
            
 
550
 
553
551
            r->data.srv.name = avahi_strdup(buf);
554
552
            break;
555
553
 
557
555
 
558
556
            if (avahi_dns_packet_consume_string(p, buf, sizeof(buf)) < 0)
559
557
                return -1;
560
 
            
 
558
 
561
559
            r->data.hinfo.cpu = avahi_strdup(buf);
562
 
            
 
560
 
563
561
            if (avahi_dns_packet_consume_string(p, buf, sizeof(buf)) < 0)
564
562
                return -1;
565
 
            
 
563
 
566
564
            r->data.hinfo.os = avahi_strdup(buf);
567
565
            break;
568
566
 
571
569
            if (rdlength > 0) {
572
570
                if (avahi_string_list_parse(avahi_dns_packet_get_rptr(p), rdlength, &r->data.txt.string_list) < 0)
573
571
                    return -1;
574
 
                
 
572
 
575
573
                if (avahi_dns_packet_skip(p, rdlength) < 0)
576
574
                    return -1;
577
575
            } else
578
576
                r->data.txt.string_list = NULL;
579
 
            
 
577
 
580
578
            break;
581
579
 
582
580
        case AVAHI_DNS_TYPE_A:
585
583
 
586
584
            if (avahi_dns_packet_consume_bytes(p, &r->data.a.address, sizeof(AvahiIPv4Address)) < 0)
587
585
                return -1;
588
 
            
 
586
 
589
587
            break;
590
588
 
591
589
        case AVAHI_DNS_TYPE_AAAA:
592
590
 
593
591
/*             avahi_log_debug("aaaa"); */
594
 
            
 
592
 
595
593
            if (avahi_dns_packet_consume_bytes(p, &r->data.aaaa.address, sizeof(AvahiIPv6Address)) < 0)
596
594
                return -1;
597
 
            
 
595
 
598
596
            break;
599
 
            
 
597
 
600
598
        default:
601
599
 
602
600
/*             avahi_log_debug("generic"); */
603
 
            
 
601
 
604
602
            if (rdlength > 0) {
605
603
 
606
604
                r->data.generic.data = avahi_memdup(avahi_dns_packet_get_rptr(p), rdlength);
607
 
                r->data.generic.size = rdlength; 
608
 
                
 
605
                r->data.generic.size = rdlength;
 
606
 
609
607
                if (avahi_dns_packet_skip(p, rdlength) < 0)
610
608
                    return -1;
611
609
            }
616
614
    /* Check if we read enough data */
617
615
    if ((const uint8_t*) avahi_dns_packet_get_rptr(p) - (const uint8_t*) start != rdlength)
618
616
        return -1;
619
 
    
 
617
 
620
618
    return 0;
621
619
}
622
620
 
640
638
    if (ret_cache_flush)
641
639
        *ret_cache_flush = !!(class & AVAHI_DNS_CACHE_FLUSH);
642
640
    class &= ~AVAHI_DNS_CACHE_FLUSH;
643
 
    
 
641
 
644
642
    if (!(r = avahi_record_new_full(name, class, type, ttl)))
645
643
        goto fail;
646
 
    
 
644
 
647
645
    if (parse_rdata(p, r, rdlength) < 0)
648
646
        goto fail;
649
647
 
650
648
    if (!avahi_record_is_valid(r))
651
649
        goto fail;
652
 
    
 
650
 
653
651
    return r;
654
652
 
655
653
fail:
675
673
        *ret_unicast_response = !!(class & AVAHI_DNS_UNICAST_RESPONSE);
676
674
 
677
675
    class &= ~AVAHI_DNS_UNICAST_RESPONSE;
678
 
    
 
676
 
679
677
    if (!(k = avahi_key_new(name, class, type)))
680
678
        return NULL;
681
679
 
690
688
uint8_t* avahi_dns_packet_append_key(AvahiDnsPacket *p, AvahiKey *k, int unicast_response) {
691
689
    uint8_t *t;
692
690
    size_t size;
693
 
    
 
691
 
694
692
    assert(p);
695
693
    assert(k);
696
694
 
697
695
    size = p->size;
698
 
    
 
696
 
699
697
    if (!(t = avahi_dns_packet_append_name(p, k->name)) ||
700
698
        !avahi_dns_packet_append_uint16(p, k->type) ||
701
699
        !avahi_dns_packet_append_uint16(p, k->clazz | (unicast_response ? AVAHI_DNS_UNICAST_RESPONSE : 0))) {
711
709
static int append_rdata(AvahiDnsPacket *p, AvahiRecord *r) {
712
710
    assert(p);
713
711
    assert(r);
714
 
    
 
712
 
715
713
    switch (r->key->type) {
716
 
        
 
714
 
717
715
        case AVAHI_DNS_TYPE_PTR:
718
716
        case AVAHI_DNS_TYPE_CNAME:
719
717
        case AVAHI_DNS_TYPE_NS:
720
 
            
 
718
 
721
719
            if (!(avahi_dns_packet_append_name(p, r->data.ptr.name)))
722
720
                return -1;
723
 
            
 
721
 
724
722
            break;
725
723
 
726
724
        case AVAHI_DNS_TYPE_SRV:
759
757
 
760
758
            if (!avahi_dns_packet_append_bytes(p, &r->data.a.address, sizeof(r->data.a.address)))
761
759
                return -1;
762
 
            
 
760
 
763
761
            break;
764
762
 
765
763
        case AVAHI_DNS_TYPE_AAAA:
766
 
            
 
764
 
767
765
            if (!avahi_dns_packet_append_bytes(p, &r->data.aaaa.address, sizeof(r->data.aaaa.address)))
768
766
                return -1;
769
 
            
 
767
 
770
768
            break;
771
 
            
 
769
 
772
770
        default:
773
771
 
774
772
            if (r->data.generic.size)
802
800
 
803
801
    if (append_rdata(p, r) < 0)
804
802
        goto fail;
805
 
    
 
803
 
806
804
    size = avahi_dns_packet_extend(p, 0) - start;
807
805
    assert(size <= AVAHI_DNS_RDATA_MAX);
808
806
 
810
808
 
811
809
    l[0] = (uint8_t) ((uint16_t) size >> 8);
812
810
    l[1] = (uint8_t) ((uint16_t) size);
813
 
    
 
811
 
814
812
    return t;
815
813
 
816
814
 
831
829
    assert(p);
832
830
 
833
831
    assert(p->size <= p->max_size);
834
 
    
 
832
 
835
833
    return p->max_size - p->size;
836
834
}
837
835
 
838
836
int avahi_rdata_parse(AvahiRecord *record, const void* rdata, size_t size) {
839
837
    int ret;
840
838
    AvahiDnsPacket p;
841
 
    
 
839
 
842
840
    assert(record);
843
841
    assert(rdata);
844
 
    
 
842
 
845
843
    p.data = (void*) rdata;
846
844
    p.max_size = p.size = size;
847
845
    p.rindex = 0;
850
848
    ret = parse_rdata(&p, record, size);
851
849
 
852
850
    assert(!p.name_table);
853
 
    
 
851
 
854
852
    return ret;
855
853
}
856
854
 
857
855
size_t avahi_rdata_serialize(AvahiRecord *record, void *rdata, size_t max_size) {
858
856
    int ret;
859
857
    AvahiDnsPacket p;
860
 
    
 
858
 
861
859
    assert(record);
862
860
    assert(rdata);
863
861
    assert(max_size > 0);
874
872
 
875
873
    if (ret < 0)
876
874
        return (size_t) -1;
877
 
    
 
875
 
878
876
    return p.size;
879
877
}