← Back to branch summary

~ubuntu-branches/ubuntu/vivid/cctools/vivid

« back to all changes in this revision

Viewing changes to dttools/src/domain_name_cache.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Hanke
  • Date: 2011-05-07 09:05:00 UTC
  • Revision ID: james.westby@ubuntu.com-20110507090500-lqpmdtwndor6e7os
Tags: upstream-3.3.2
Import upstream version 3.3.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
dttools/src/domain_name_cache.c
 
1
/*
 
2
Copyright (C) 2003-2004 Douglas Thain and the University of Wisconsin
 
3
Copyright (C) 2005- The University of Notre Dame
 
4
This software is distributed under the GNU General Public License.
 
5
See the file COPYING for details.
 
6
*/
 
7
 
 
8
#include "domain_name_cache.h"
 
9
#include "hash_cache.h"
 
10
#include "debug.h"
 
11
 
 
12
#include <stdlib.h>
 
13
#include <string.h>
 
14
#include <errno.h>
 
15
#include <stdio.h>
 
16
#include <string.h>
 
17
#include <sys/utsname.h>
 
18
 
 
19
/* cache domain names for up to five minutes */
 
20
#define DOMAIN_NAME_CACHE_LIFETIME 300
 
21
 
 
22
static struct hash_cache *name_to_addr=0;
 
23
static struct hash_cache *addr_to_name=0;
 
24
 
 
25
static int domain_name_cache_init()
 
26
{
 
27
        if(!name_to_addr) {
 
28
                name_to_addr = hash_cache_create(127,hash_string,free);
 
29
                if(!name_to_addr) {
 
30
                        return 0;
 
31
                }
 
32
        }
 
33
 
 
34
        if(!addr_to_name) {
 
35
                addr_to_name = hash_cache_create(127,hash_string,free);
 
36
                if(!addr_to_name) {
 
37
                        return 0;
 
38
                }
 
39
        }
 
40
 
 
41
        return 1;
 
42
}
 
43
 
 
44
int domain_name_cache_canonical( const char *name_or_addr, char *cname )
 
45
{
 
46
        char addr[DOMAIN_NAME_MAX];
 
47
        return domain_name_cache_lookup(name_or_addr,addr) &&
 
48
        domain_name_cache_lookup_reverse(addr,cname);
 
49
}
 
50
 
 
51
int domain_name_cache_lookup( const char *name, char *addr )
 
52
{
 
53
        char *found, *copy;
 
54
        int success;
 
55
 
 
56
        if(!domain_name_cache_init()) return 0;
 
57
 
 
58
        found = hash_cache_lookup(name_to_addr,name);
 
59
        if(found) {
 
60
                strcpy(addr,found);
 
61
                return 1;
 
62
        }
 
63
 
 
64
        success = domain_name_lookup(name,addr);
 
65
        if(!success) return 0;
 
66
 
 
67
        copy = strdup(addr);
 
68
        if(!copy) return 1;
 
69
 
 
70
        success = hash_cache_insert(name_to_addr,name,copy,DOMAIN_NAME_CACHE_LIFETIME);
 
71
 
 
72
        return 1;
 
73
}
 
74
 
 
75
int domain_name_cache_lookup_reverse( const char *addr, char *name )
 
76
{
 
77
        char *found, *copy;
 
78
        int success;
 
79
 
 
80
        if(!domain_name_cache_init()) return 0;
 
81
 
 
82
        found = hash_cache_lookup(addr_to_name,addr);
 
83
        if(found) {
 
84
                strcpy(name,found);
 
85
                return 1;
 
86
        }
 
87
 
 
88
        success = domain_name_lookup_reverse(addr,name);
 
89
        if(!success) return 0;
 
90
 
 
91
        copy = strdup(name);
 
92
        if(!copy) return 1;
 
93
 
 
94
        success = hash_cache_insert(addr_to_name,addr,copy,DOMAIN_NAME_CACHE_LIFETIME);
 
95
 
 
96
        return 1;
 
97
}
 
98
 
 
99
static int guess_dns_domain( char *domain )
 
100
{
 
101
        char line[DOMAIN_NAME_MAX];
 
102
        FILE *file;
 
103
 
 
104
        file = fopen("/etc/resolv.conf","r");
 
105
        if(!file) return 0;
 
106
 
 
107
        while(fgets(line,sizeof(line),file)) {
 
108
                if(sscanf(line,"search %[^ \t\n]",domain)==1) {
 
109
                        fclose(file);
 
110
                        return 1;
 
111
                }
 
112
                if(sscanf(line,"domain %[^ \t\n]",domain)==1) {
 
113
                        fclose(file);
 
114
                        return 1;
 
115
                }
 
116
        }
 
117
 
 
118
        fclose(file);
 
119
        return 0;       
 
120
}
 
121
 
 
122
int domain_name_cache_guess( char *name )
 
123
{
 
124
        struct utsname n;
 
125
        char addr[DOMAIN_NAME_MAX];
 
126
        char domain[DOMAIN_NAME_MAX];
 
127
 
 
128
        if(uname(&n)<0) return 0;
 
129
 
 
130
        if(!domain_name_cache_lookup(n.nodename,addr)) return 0;
 
131
        if(!domain_name_cache_lookup_reverse(addr,name)) return 0;
 
132
 
 
133
        debug(D_DNS,"finding my hostname: uname = %s, address = %s, hostname = %s",n.nodename,addr,name);
 
134
 
 
135
        if(!strncmp(name,"localhost",9) || !strcmp(addr,"127.0.0.1") ) {
 
136
                debug(D_DNS,"local address of '%s' (%s) is not very useful.",name,addr);
 
137
                if(guess_dns_domain(domain)) {
 
138
                        sprintf(name,"%s.%s",n.nodename,domain);
 
139
                        debug(D_DNS,"but /etc/resolv.conf says domain = %s so hostname = %s",domain,name);
 
140
                        if (!domain_name_cache_lookup(name,addr)) {
 
141
                                debug(D_DNS,"unfortunately %s is meaningless, so going back to %s",name,n.nodename);
 
142
                                sprintf(name,"%s",n.nodename);
 
143
                        }
 
144
                } else {
 
145
                        strcpy(name,n.nodename);
 
146
                        debug(D_DNS,"cannot find any more info, so use hostname = %s",n.nodename);
 
147
                }
 
148
        }
 
149
 
 
150
        return 1;
 
151
}
 
152
 
 
153
static char shortname[DOMAIN_NAME_MAX];
 
154
static int got_shortname = 0;
 
155
 
 
156
int domain_name_cache_guess_short( char *name )
 
157
{
 
158
        struct utsname n;
 
159
 
 
160
        if(got_shortname) {
 
161
                strcpy(name,shortname);
 
162
                return 1;
 
163
        }
 
164
 
 
165
        if(uname(&n)<0) return 0;
 
166
 
 
167
        strcpy(shortname,n.nodename);
 
168
 
 
169
        char *p = strchr(shortname,'.');
 
170
        if(p) *p = 0;
 
171
 
 
172
        strcpy(name,shortname);
 
173
        got_shortname = 1;
 
174
 
 
175
        return 1;
 
176
}