2005-08-26 Kevin Coffman <kwc@citi.umich.edu>
[nfs-utils.git] / support / export / hostname.c
1 /*
2  * support/export/hostname.c
3  *
4  * Functions for hostname.
5  *
6  */
7
8 #include "config.h"
9
10 /*
11 #define TEST
12 */
13
14 #include <string.h>
15 #include <netdb.h>
16 #include <netinet/in.h>
17 #include <arpa/inet.h>
18 #include <stdlib.h>
19 #include <xlog.h>
20 #ifdef TEST
21 #define xmalloc malloc
22 #else
23 #include "xmalloc.h"
24 #include "misc.h"
25 #endif
26
27 #define ALIGNMENT       sizeof (char *)
28
29 static int
30 align (int len, int al)
31 {
32   int i;
33   i = len % al;
34   if (i)
35     len += al - i;
36   return len;
37 }
38
39 struct hostent *
40 get_hostent (const char *addr, int len, int type)
41 {
42   struct hostent *cp;
43   int len_ent;
44   const char *name;
45   int len_name;
46   int num_aliases = 1;
47   int len_aliases = sizeof (char *);
48   int num_addr_list = 1;
49   int len_addr_list = sizeof (char *);
50   int pos;
51   struct in_addr *ipv4;
52
53   switch (type)
54     {
55     case AF_INET:
56       ipv4 = (struct in_addr *) addr;
57       name = inet_ntoa (*ipv4);
58       break;
59
60     default:
61       return NULL;
62     }
63
64   len_ent = align (sizeof (*cp), ALIGNMENT);
65   len_name = align (strlen (name) + 1, ALIGNMENT);
66
67   num_addr_list++;
68   len_addr_list += align (len, ALIGNMENT) + sizeof (char *);
69
70   cp = (struct hostent *) xmalloc (len_ent + len_name + len_aliases
71                                    + len_addr_list);
72
73   cp->h_addrtype = type;
74   cp->h_length = len;
75   pos = len_ent;
76   cp->h_name = (char *) &(((char *) cp) [pos]);
77   strcpy (cp->h_name, name);
78
79   pos += len_name;
80   cp->h_aliases = (char **) &(((char *) cp) [pos]);
81   pos += num_aliases * sizeof (char *);
82   cp->h_aliases [0] = NULL;
83
84   pos = len_ent + len_name + len_aliases;
85   cp->h_addr_list = (char **) &(((char *) cp) [pos]);
86   pos += num_addr_list * sizeof (char *);
87   cp->h_addr_list [0] = (char *) &(((char *) cp) [pos]);
88   memcpy (cp->h_addr_list [0], addr, cp->h_length);
89   pos += align (cp->h_length, ALIGNMENT);
90   cp->h_addr_list [1] = NULL;
91
92   return cp;
93 }
94
95 struct hostent *
96 hostent_dup (struct hostent *hp)
97 {
98   int len_ent = align (sizeof (*hp), ALIGNMENT);
99   int len_name = align (strlen (hp->h_name) + 1, ALIGNMENT);
100   int num_aliases = 1;
101   int len_aliases = sizeof (char *);
102   int num_addr_list = 1;
103   int len_addr_list = sizeof (char *);
104   int pos, i;
105   char **sp;
106   struct hostent *cp;
107
108   for (sp = hp->h_aliases; sp && *sp; sp++)
109     {
110       num_aliases++;
111       len_aliases += align (strlen (*sp) + 1, ALIGNMENT)
112                      + sizeof (char *);
113     }
114
115   for (sp = hp->h_addr_list; *sp; sp++)
116     {
117       num_addr_list++;
118       len_addr_list += align (hp->h_length, ALIGNMENT)
119                        + sizeof (char *);
120     }
121   
122   cp = (struct hostent *) xmalloc (len_ent + len_name + len_aliases
123                                    + len_addr_list);
124
125   *cp = *hp;
126   pos = len_ent;
127   cp->h_name = (char *) &(((char *) cp) [pos]);
128   strcpy (cp->h_name, hp->h_name);
129
130   pos += len_name;
131   cp->h_aliases = (char **) &(((char *) cp) [pos]);
132   pos += num_aliases * sizeof (char *);
133   for (sp = hp->h_aliases, i = 0; i < num_aliases; i++, sp++)
134     if (sp && *sp)
135       {
136         cp->h_aliases [i] = (char *) &(((char *) cp) [pos]);
137         strcpy (cp->h_aliases [i], *sp);
138         pos += align (strlen (*sp) + 1, ALIGNMENT);
139       }
140     else
141       cp->h_aliases [i] = NULL;
142
143   pos = len_ent + len_name + len_aliases;
144   cp->h_addr_list = (char **) &(((char *) cp) [pos]);
145   pos += num_addr_list * sizeof (char *);
146   for (sp = hp->h_addr_list, i = 0; i < num_addr_list; i++, sp++)
147     if (*sp)
148       {
149         cp->h_addr_list [i] = (char *) &(((char *) cp) [pos]);
150         memcpy (cp->h_addr_list [i], *sp, hp->h_length);
151         pos += align (hp->h_length, ALIGNMENT);
152       }
153     else
154       cp->h_addr_list [i] = *sp;
155
156   return cp;
157 }
158
159 static int
160 is_hostname(const char *sp)
161 {
162   if (*sp == '\0' || *sp == '@')
163     return 0;
164
165   for (; *sp; sp++)
166     {
167       if (*sp == '*' || *sp == '?' || *sp == '[' || *sp == '/')
168         return 0;
169       if (*sp == '\\' && sp[1])
170         sp++;
171     }
172
173   return 1;
174 }
175
176 int
177 matchhostname (const char *h1, const char *h2)
178 {
179   struct hostent *hp1, *hp2;
180   int status;
181
182   if (strcasecmp (h1, h2) == 0)
183     return 1;
184
185   if (!is_hostname (h1) || !is_hostname (h2))
186     return 0;
187
188   hp1 = gethostbyname (h1);
189   if (hp1 == NULL)
190     return 0;
191
192   hp1 = hostent_dup (hp1);
193
194   hp2 = gethostbyname (h2);
195   if (hp2)
196     {
197       if (strcasecmp (hp1->h_name, hp2->h_name) == 0)
198         status = 1;
199       else
200         {
201           char **ap1, **ap2;
202
203           status = 0;
204           for (ap1 = hp1->h_addr_list; *ap1 && status == 0; ap1++)
205             for (ap2 = hp2->h_addr_list; *ap2; ap2++)
206               if (memcmp (*ap1, *ap2, sizeof (struct in_addr)) == 0)
207                 {
208                   status = 1;
209                   break;
210                 }
211         }
212     }
213   else
214     status = 0;
215
216   free (hp1);
217   return status;
218 }
219
220
221 /* Map IP to hostname, and then map back to addr to make sure it is a
222  * reliable hostname 
223  */
224 struct hostent *
225 get_reliable_hostbyaddr(const char *addr, int len, int type)
226 {
227         struct hostent *hp = NULL;
228
229         struct hostent *reverse;
230         struct hostent *forward;
231         char **sp;
232
233         reverse = gethostbyaddr (addr, len, type);
234         if (!reverse)
235                 return NULL;
236
237         /* must make sure the hostent is authorative. */
238
239         reverse = hostent_dup (reverse);
240         forward = gethostbyname (reverse->h_name);
241
242         if (forward) {
243                 /* now make sure the "addr" is in the list */
244                 for (sp = forward->h_addr_list ; *sp ; sp++) {
245                         if (memcmp (*sp, addr, forward->h_length) == 0)
246                                 break;
247                 }
248
249                 if (*sp) {
250                         /* it's valid */
251                         hp = hostent_dup (forward);
252                 }
253                 else {
254                         /* it was a FAKE */
255                         xlog (L_WARNING, "Fake hostname %s for %s - forward lookup doesn't match reverse",
256                               reverse->h_name, inet_ntoa(*(struct in_addr*)addr));
257                 }
258         }
259         else {
260                 /* never heard of it. misconfigured DNS? */
261                 xlog (L_WARNING, "Fake hostname %s for %s - forward lookup doesn't exist",
262                       reverse->h_name, inet_ntoa(*(struct in_addr*)addr));
263         }
264
265         free (reverse);
266         return hp;
267 }
268
269
270 #ifdef TEST
271 void
272 print_host (struct hostent *hp)
273 {
274   char **sp;
275
276   if (hp)
277     {
278       printf ("official hostname: %s\n", hp->h_name); 
279       printf ("aliases:\n");
280       for (sp = hp->h_aliases; *sp; sp++)
281         printf ("  %s\n", *sp);
282       printf ("IP addresses:\n");
283       for (sp = hp->h_addr_list; *sp; sp++)
284         printf ("  %s\n", inet_ntoa (*(struct in_addr *) *sp));
285     }
286   else
287     printf ("Not host information\n");
288 }
289
290 int
291 main (int argc, char **argv)
292 {
293   struct hostent *hp = gethostbyname (argv [1]);
294   struct hostent *cp;
295   struct in_addr addr;
296
297   print_host (hp);
298
299   if (hp)
300     {
301       cp = hostent_dup (hp);
302       print_host (cp);
303       free (cp);
304     }
305   printf ("127.0.0.1 == %s: %d\n", argv [1],
306           matchhostname ("127.0.0.1", argv [1]));
307   addr.s_addr = inet_addr(argv [2]);
308   printf ("%s\n", inet_ntoa (addr));
309   cp = get_hostent ((const char *)&addr, sizeof(addr), AF_INET);
310   print_host (cp);
311   return 0;
312 }
313 #endif