1 | /* Copyright (C) 2003 Manuel Novoa III
|
---|
2 | *
|
---|
3 | * This library is free software; you can redistribute it and/or
|
---|
4 | * modify it under the terms of the GNU Library General Public
|
---|
5 | * License as published by the Free Software Foundation; either
|
---|
6 | * version 2 of the License, or (at your option) any later version.
|
---|
7 | *
|
---|
8 | * This library is distributed in the hope that it will be useful,
|
---|
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
11 | * Library General Public License for more details.
|
---|
12 | *
|
---|
13 | * You should have received a copy of the GNU Library General Public
|
---|
14 | * License along with this library; if not, write to the Free
|
---|
15 | * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
---|
16 | */
|
---|
17 |
|
---|
18 | /* Nov 6, 2003 Initial version.
|
---|
19 | *
|
---|
20 | * NOTE: This implementation is quite strict about requiring all
|
---|
21 | * field seperators. It also does not allow leading whitespace
|
---|
22 | * except when processing the numeric fields. glibc is more
|
---|
23 | * lenient. See the various glibc difference comments below.
|
---|
24 | *
|
---|
25 | * TODO:
|
---|
26 | * Move to dynamic allocation of (currently staticly allocated)
|
---|
27 | * buffers; especially for the group-related functions since
|
---|
28 | * large group member lists will cause error returns.
|
---|
29 | *
|
---|
30 | */
|
---|
31 |
|
---|
32 | /* Jul 20, 2004 Adapted for samhain. Rainer Wichmann.
|
---|
33 | *
|
---|
34 | * Stripped all unneeded code.
|
---|
35 | */
|
---|
36 |
|
---|
37 | #include "config_xor.h"
|
---|
38 |
|
---|
39 | #if defined(SH_COMPILE_STATIC) && defined(__linux__)
|
---|
40 |
|
---|
41 | #define _GNU_SOURCE
|
---|
42 | #include <features.h>
|
---|
43 | #include <stdio.h>
|
---|
44 | #include <stdlib.h>
|
---|
45 | #include <stdint.h>
|
---|
46 | #include <string.h>
|
---|
47 | #include <stddef.h>
|
---|
48 | #include <errno.h>
|
---|
49 | #include <assert.h>
|
---|
50 | #include <ctype.h>
|
---|
51 | #include <pwd.h>
|
---|
52 | #include <grp.h>
|
---|
53 |
|
---|
54 | #include "sh_pthread.h"
|
---|
55 |
|
---|
56 | extern int sl_close_fd (const char * file, int line, int fd);
|
---|
57 | extern int sl_fclose (const char * file, int line, FILE * fp);
|
---|
58 |
|
---|
59 |
|
---|
60 | #ifndef _PATH_PASSWD
|
---|
61 | #define _PATH_PASSWD "/etc/passwd"
|
---|
62 | #endif
|
---|
63 | #ifndef _PATH_GROUP
|
---|
64 | #define _PATH_GROUP "/etc/group"
|
---|
65 | #endif
|
---|
66 |
|
---|
67 | #undef FIL__
|
---|
68 | #define FIL__ _("sh_static.c")
|
---|
69 |
|
---|
70 | extern int sl_strlcpy(char * dst, /*@null@*/const char * src, size_t siz);
|
---|
71 | extern int sl_strlcat(char * dst, /*@null@*/const char * src, size_t siz);
|
---|
72 |
|
---|
73 |
|
---|
74 | /**********************************************************************/
|
---|
75 | /* Sizes for staticly allocated buffers. */
|
---|
76 |
|
---|
77 | #define PWD_BUFFER_SIZE 256
|
---|
78 | #define GRP_BUFFER_SIZE 3584
|
---|
79 | #define GRP_BUFFER_SIZE_MALLOC 32768
|
---|
80 |
|
---|
81 | /**********************************************************************/
|
---|
82 | /* Prototypes for internal functions. */
|
---|
83 |
|
---|
84 | static int __parsepwent(void *pw, char *line);
|
---|
85 | static int __parsegrent(void *gr, char *line);
|
---|
86 |
|
---|
87 | static int __pgsreader(int (*__parserfunc)(void *d, char *line), void *data,
|
---|
88 | char *__restrict line_buff,
|
---|
89 | size_t buflen, FILE *f);
|
---|
90 |
|
---|
91 | #undef GETXXKEY_R_FUNC
|
---|
92 | #undef GETXXKEY_R_PARSER
|
---|
93 | #undef GETXXKEY_R_ENTTYPE
|
---|
94 | #undef GETXXKEY_R_TEST
|
---|
95 | #undef DO_GETXXKEY_R_KEYTYPE
|
---|
96 | #undef DO_GETXXKEY_R_PATHNAME
|
---|
97 | #define GETXXKEY_R_FUNC sh_getpwnam_r
|
---|
98 | #define GETXXKEY_R_PARSER __parsepwent
|
---|
99 | #define GETXXKEY_R_ENTTYPE struct passwd
|
---|
100 | #define GETXXKEY_R_TEST(ENT) (!strcmp((ENT)->pw_name, key))
|
---|
101 | #define DO_GETXXKEY_R_KEYTYPE const char *__restrict
|
---|
102 | #define DO_GETXXKEY_R_PATHNAME _PATH_PASSWD
|
---|
103 |
|
---|
104 | int GETXXKEY_R_FUNC(DO_GETXXKEY_R_KEYTYPE key,
|
---|
105 | GETXXKEY_R_ENTTYPE *__restrict resultbuf,
|
---|
106 | char *__restrict buffer, size_t buflen,
|
---|
107 | GETXXKEY_R_ENTTYPE **__restrict result)
|
---|
108 | {
|
---|
109 | FILE *stream;
|
---|
110 | int rv;
|
---|
111 |
|
---|
112 | *result = NULL;
|
---|
113 |
|
---|
114 | if (!(stream = fopen(DO_GETXXKEY_R_PATHNAME, "r"))) {
|
---|
115 | rv = errno;
|
---|
116 | } else {
|
---|
117 | /* __STDIO_SET_USER_LOCKING(stream); */
|
---|
118 | do {
|
---|
119 | if (!(rv = __pgsreader(GETXXKEY_R_PARSER, resultbuf,
|
---|
120 | buffer, buflen, stream))
|
---|
121 | ) {
|
---|
122 | if (GETXXKEY_R_TEST(resultbuf)) { /* Found key? */
|
---|
123 | *result = resultbuf;
|
---|
124 | break;
|
---|
125 | }
|
---|
126 | } else {
|
---|
127 | if (rv == ENOENT) { /* end-of-file encountered. */
|
---|
128 | rv = 0;
|
---|
129 | }
|
---|
130 | break;
|
---|
131 | }
|
---|
132 | } while (1);
|
---|
133 | sl_fclose(FIL__, __LINE__, stream);
|
---|
134 | }
|
---|
135 |
|
---|
136 | return rv;
|
---|
137 | }
|
---|
138 |
|
---|
139 | #undef GETXXKEY_R_FUNC
|
---|
140 | #undef GETXXKEY_R_PARSER
|
---|
141 | #undef GETXXKEY_R_ENTTYPE
|
---|
142 | #undef GETXXKEY_R_TEST
|
---|
143 | #undef DO_GETXXKEY_R_KEYTYPE
|
---|
144 | #undef DO_GETXXKEY_R_PATHNAME
|
---|
145 | #define GETXXKEY_R_FUNC sh_getgrnam_r
|
---|
146 | #define GETXXKEY_R_PARSER __parsegrent
|
---|
147 | #define GETXXKEY_R_ENTTYPE struct group
|
---|
148 | #define GETXXKEY_R_TEST(ENT) (!strcmp((ENT)->gr_name, key))
|
---|
149 | #define DO_GETXXKEY_R_KEYTYPE const char *__restrict
|
---|
150 | #define DO_GETXXKEY_R_PATHNAME _PATH_GROUP
|
---|
151 |
|
---|
152 | int GETXXKEY_R_FUNC(DO_GETXXKEY_R_KEYTYPE key,
|
---|
153 | GETXXKEY_R_ENTTYPE *__restrict resultbuf,
|
---|
154 | char *__restrict buffer, size_t buflen,
|
---|
155 | GETXXKEY_R_ENTTYPE **__restrict result)
|
---|
156 | {
|
---|
157 | FILE *stream;
|
---|
158 | int rv;
|
---|
159 |
|
---|
160 | *result = NULL;
|
---|
161 |
|
---|
162 | if (!(stream = fopen(DO_GETXXKEY_R_PATHNAME, "r"))) {
|
---|
163 | rv = errno;
|
---|
164 | } else {
|
---|
165 | /* __STDIO_SET_USER_LOCKING(stream); */
|
---|
166 | do {
|
---|
167 | if (!(rv = __pgsreader(GETXXKEY_R_PARSER, resultbuf,
|
---|
168 | buffer, buflen, stream))
|
---|
169 | ) {
|
---|
170 | if (GETXXKEY_R_TEST(resultbuf)) { /* Found key? */
|
---|
171 | *result = resultbuf;
|
---|
172 | break;
|
---|
173 | }
|
---|
174 | } else {
|
---|
175 | if (rv == ENOENT) { /* end-of-file encountered. */
|
---|
176 | rv = 0;
|
---|
177 | }
|
---|
178 | break;
|
---|
179 | }
|
---|
180 | } while (1);
|
---|
181 | sl_fclose(FIL__, __LINE__, stream);
|
---|
182 | }
|
---|
183 |
|
---|
184 | return rv;
|
---|
185 | }
|
---|
186 |
|
---|
187 | #undef GETXXKEY_R_FUNC
|
---|
188 | #undef GETXXKEY_R_PARSER
|
---|
189 | #undef GETXXKEY_R_ENTTYPE
|
---|
190 | #undef GETXXKEY_R_TEST
|
---|
191 | #undef DO_GETXXKEY_R_KEYTYPE
|
---|
192 | #undef DO_GETXXKEY_R_PATHNAME
|
---|
193 | #define GETXXKEY_R_FUNC sh_getpwuid_r
|
---|
194 | #define GETXXKEY_R_PARSER __parsepwent
|
---|
195 | #define GETXXKEY_R_ENTTYPE struct passwd
|
---|
196 | #define GETXXKEY_R_TEST(ENT) ((ENT)->pw_uid == key)
|
---|
197 | #define DO_GETXXKEY_R_KEYTYPE uid_t
|
---|
198 | #define DO_GETXXKEY_R_PATHNAME _PATH_PASSWD
|
---|
199 |
|
---|
200 | int GETXXKEY_R_FUNC(DO_GETXXKEY_R_KEYTYPE key,
|
---|
201 | GETXXKEY_R_ENTTYPE *__restrict resultbuf,
|
---|
202 | char *__restrict buffer, size_t buflen,
|
---|
203 | GETXXKEY_R_ENTTYPE **__restrict result)
|
---|
204 | {
|
---|
205 | FILE *stream;
|
---|
206 | int rv;
|
---|
207 |
|
---|
208 | *result = NULL;
|
---|
209 |
|
---|
210 | if (!(stream = fopen(DO_GETXXKEY_R_PATHNAME, "r"))) {
|
---|
211 | rv = errno;
|
---|
212 | } else {
|
---|
213 | /* __STDIO_SET_USER_LOCKING(stream); */
|
---|
214 | do {
|
---|
215 | if (!(rv = __pgsreader(GETXXKEY_R_PARSER, resultbuf,
|
---|
216 | buffer, buflen, stream))
|
---|
217 | ) {
|
---|
218 | if (GETXXKEY_R_TEST(resultbuf)) { /* Found key? */
|
---|
219 | *result = resultbuf;
|
---|
220 | break;
|
---|
221 | }
|
---|
222 | } else {
|
---|
223 | if (rv == ENOENT) { /* end-of-file encountered. */
|
---|
224 | rv = 0;
|
---|
225 | }
|
---|
226 | break;
|
---|
227 | }
|
---|
228 | } while (1);
|
---|
229 | sl_fclose(FIL__, __LINE__, stream);
|
---|
230 | }
|
---|
231 |
|
---|
232 | return rv;
|
---|
233 | }
|
---|
234 |
|
---|
235 | #undef GETXXKEY_R_FUNC
|
---|
236 | #undef GETXXKEY_R_PARSER
|
---|
237 | #undef GETXXKEY_R_ENTTYPE
|
---|
238 | #undef GETXXKEY_R_TEST
|
---|
239 | #undef DO_GETXXKEY_R_KEYTYPE
|
---|
240 | #undef DO_GETXXKEY_R_PATHNAME
|
---|
241 | #define GETXXKEY_R_FUNC sh_getgrgid_r
|
---|
242 | #define GETXXKEY_R_PARSER __parsegrent
|
---|
243 | #define GETXXKEY_R_ENTTYPE struct group
|
---|
244 | #define GETXXKEY_R_TEST(ENT) ((ENT)->gr_gid == key)
|
---|
245 | #define DO_GETXXKEY_R_KEYTYPE gid_t
|
---|
246 | #define DO_GETXXKEY_R_PATHNAME _PATH_GROUP
|
---|
247 |
|
---|
248 | int GETXXKEY_R_FUNC(DO_GETXXKEY_R_KEYTYPE key,
|
---|
249 | GETXXKEY_R_ENTTYPE *__restrict resultbuf,
|
---|
250 | char *__restrict buffer, size_t buflen,
|
---|
251 | GETXXKEY_R_ENTTYPE **__restrict result)
|
---|
252 | {
|
---|
253 | FILE *stream;
|
---|
254 | int rv;
|
---|
255 |
|
---|
256 | *result = NULL;
|
---|
257 |
|
---|
258 | if (!(stream = fopen(DO_GETXXKEY_R_PATHNAME, "r"))) {
|
---|
259 | rv = errno;
|
---|
260 | } else {
|
---|
261 | /* __STDIO_SET_USER_LOCKING(stream); */
|
---|
262 | do {
|
---|
263 | if (!(rv = __pgsreader(GETXXKEY_R_PARSER, resultbuf,
|
---|
264 | buffer, buflen, stream))
|
---|
265 | ) {
|
---|
266 | if (GETXXKEY_R_TEST(resultbuf)) { /* Found key? */
|
---|
267 | *result = resultbuf;
|
---|
268 | break;
|
---|
269 | }
|
---|
270 | } else {
|
---|
271 | if (rv == ENOENT) { /* end-of-file encountered. */
|
---|
272 | rv = 0;
|
---|
273 | }
|
---|
274 | break;
|
---|
275 | }
|
---|
276 | } while (1);
|
---|
277 | sl_fclose(FIL__, __LINE__, stream);
|
---|
278 | }
|
---|
279 |
|
---|
280 | return rv;
|
---|
281 | }
|
---|
282 |
|
---|
283 | struct passwd * sh_getpwuid(uid_t uid)
|
---|
284 | {
|
---|
285 | static char buffer[PWD_BUFFER_SIZE];
|
---|
286 | static struct passwd resultbuf;
|
---|
287 | struct passwd *result;
|
---|
288 |
|
---|
289 | sh_getpwuid_r(uid, &resultbuf, buffer, sizeof(buffer), &result);
|
---|
290 | return result;
|
---|
291 | }
|
---|
292 |
|
---|
293 | struct passwd * getpwuid(uid_t uid)
|
---|
294 | {
|
---|
295 | return sh_getpwuid(uid);
|
---|
296 | }
|
---|
297 |
|
---|
298 | struct group * sh_getgrgid(gid_t gid)
|
---|
299 | {
|
---|
300 | static char buffer[GRP_BUFFER_SIZE];
|
---|
301 | static struct group resultbuf;
|
---|
302 | struct group *result;
|
---|
303 |
|
---|
304 | sh_getgrgid_r(gid, &resultbuf, buffer, sizeof(buffer), &result);
|
---|
305 | return result;
|
---|
306 | }
|
---|
307 |
|
---|
308 | struct group * getgrgid(gid_t gid)
|
---|
309 | {
|
---|
310 | return sh_getgrgid(gid);
|
---|
311 | }
|
---|
312 |
|
---|
313 | struct passwd * sh_getpwnam(const char *name)
|
---|
314 | {
|
---|
315 | static char buffer[PWD_BUFFER_SIZE];
|
---|
316 | static struct passwd resultbuf;
|
---|
317 | struct passwd *result;
|
---|
318 |
|
---|
319 | sh_getpwnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
|
---|
320 | return result;
|
---|
321 | }
|
---|
322 |
|
---|
323 | struct group * sh_getgrnam(const char *name)
|
---|
324 | {
|
---|
325 | static char buffer[GRP_BUFFER_SIZE];
|
---|
326 | static struct group resultbuf;
|
---|
327 | struct group *result;
|
---|
328 |
|
---|
329 | sh_getgrnam_r(name, &resultbuf, buffer, sizeof(buffer), &result);
|
---|
330 | return result;
|
---|
331 | }
|
---|
332 |
|
---|
333 | SH_MUTEX_STATIC(pwf_lock, PTHREAD_MUTEX_INITIALIZER);
|
---|
334 |
|
---|
335 |
|
---|
336 | static FILE *pwf = NULL;
|
---|
337 |
|
---|
338 | void sh_setpwent(void)
|
---|
339 | {
|
---|
340 | SH_MUTEX_LOCK(pwf_lock);
|
---|
341 | if (pwf) {
|
---|
342 | rewind(pwf);
|
---|
343 | }
|
---|
344 | SH_MUTEX_UNLOCK(pwf_lock);
|
---|
345 | }
|
---|
346 |
|
---|
347 | void sh_endpwent(void)
|
---|
348 | {
|
---|
349 | SH_MUTEX_LOCK(pwf_lock);
|
---|
350 | if (pwf) {
|
---|
351 | sl_fclose(FIL__, __LINE__, pwf);
|
---|
352 | pwf = NULL;
|
---|
353 | }
|
---|
354 | SH_MUTEX_UNLOCK(pwf_lock);
|
---|
355 | }
|
---|
356 |
|
---|
357 |
|
---|
358 | static int sh_getpwent_r(struct passwd *__restrict resultbuf,
|
---|
359 | char *__restrict buffer, size_t buflen,
|
---|
360 | struct passwd **__restrict result)
|
---|
361 | {
|
---|
362 | int rv;
|
---|
363 |
|
---|
364 | SH_MUTEX_LOCK(pwf_lock);
|
---|
365 |
|
---|
366 | *result = NULL; /* In case of error... */
|
---|
367 |
|
---|
368 | if (!pwf) {
|
---|
369 | if (!(pwf = fopen(_PATH_PASSWD, "r"))) {
|
---|
370 | rv = errno;
|
---|
371 | goto ERR;
|
---|
372 | }
|
---|
373 | /* __STDIO_SET_USER_LOCKING(pwf); */
|
---|
374 | }
|
---|
375 |
|
---|
376 | if (!(rv = __pgsreader(__parsepwent, resultbuf,
|
---|
377 | buffer, buflen, pwf))) {
|
---|
378 | *result = resultbuf;
|
---|
379 | }
|
---|
380 |
|
---|
381 | ERR:
|
---|
382 | ; /* 'label at end of compound statement' */
|
---|
383 | SH_MUTEX_UNLOCK(pwf_lock);
|
---|
384 |
|
---|
385 | return rv;
|
---|
386 | }
|
---|
387 |
|
---|
388 | SH_MUTEX_STATIC(grf_lock, PTHREAD_MUTEX_INITIALIZER);
|
---|
389 |
|
---|
390 | static FILE *grf = NULL;
|
---|
391 |
|
---|
392 | void sh_setgrent(void)
|
---|
393 | {
|
---|
394 | SH_MUTEX_LOCK(grf_lock);
|
---|
395 | if (grf) {
|
---|
396 | rewind(grf);
|
---|
397 | }
|
---|
398 | SH_MUTEX_UNLOCK(grf_lock);
|
---|
399 | }
|
---|
400 |
|
---|
401 | void sh_endgrent(void)
|
---|
402 | {
|
---|
403 | SH_MUTEX_LOCK(grf_lock);
|
---|
404 | if (grf) {
|
---|
405 | sl_fclose(FIL__, __LINE__, grf);
|
---|
406 | grf = NULL;
|
---|
407 | }
|
---|
408 | SH_MUTEX_UNLOCK(grf_lock);
|
---|
409 | }
|
---|
410 |
|
---|
411 | static int sh_getgrent_r(struct group *__restrict resultbuf,
|
---|
412 | char *__restrict buffer, size_t buflen,
|
---|
413 | struct group **__restrict result)
|
---|
414 | {
|
---|
415 | int rv;
|
---|
416 |
|
---|
417 | SH_MUTEX_LOCK(grf_lock);
|
---|
418 |
|
---|
419 | *result = NULL; /* In case of error... */
|
---|
420 |
|
---|
421 | if (!grf) {
|
---|
422 | if (!(grf = fopen(_PATH_GROUP, "r"))) {
|
---|
423 | rv = errno;
|
---|
424 | goto ERR;
|
---|
425 | }
|
---|
426 | /* __STDIO_SET_USER_LOCKING(grf); */
|
---|
427 | }
|
---|
428 |
|
---|
429 | if (!(rv = __pgsreader(__parsegrent, resultbuf,
|
---|
430 | buffer, buflen, grf))) {
|
---|
431 | *result = resultbuf;
|
---|
432 | }
|
---|
433 |
|
---|
434 | ERR:
|
---|
435 | ; /* 'label at end of compound statement' */
|
---|
436 | SH_MUTEX_UNLOCK(grf_lock);
|
---|
437 |
|
---|
438 | return rv;
|
---|
439 | }
|
---|
440 |
|
---|
441 |
|
---|
442 | struct passwd * sh_getpwent(void)
|
---|
443 | {
|
---|
444 | static char line_buff[PWD_BUFFER_SIZE];
|
---|
445 | static struct passwd pwd;
|
---|
446 | struct passwd *result;
|
---|
447 |
|
---|
448 | sh_getpwent_r(&pwd, line_buff, sizeof(line_buff), &result);
|
---|
449 | return result;
|
---|
450 | }
|
---|
451 |
|
---|
452 |
|
---|
453 | struct group * sh_getgrent(void)
|
---|
454 | {
|
---|
455 | static char line_buff[GRP_BUFFER_SIZE];
|
---|
456 | static struct group gr;
|
---|
457 | struct group *result;
|
---|
458 |
|
---|
459 | sh_getgrent_r(&gr, line_buff, sizeof(line_buff), &result);
|
---|
460 | return result;
|
---|
461 | }
|
---|
462 |
|
---|
463 | int sh_initgroups(const char *user, gid_t gid)
|
---|
464 | {
|
---|
465 | FILE *grf;
|
---|
466 | gid_t *group_list;
|
---|
467 | int num_groups, rv;
|
---|
468 | char **m;
|
---|
469 | struct group group;
|
---|
470 |
|
---|
471 | char * buff = malloc(GRP_BUFFER_SIZE_MALLOC);
|
---|
472 |
|
---|
473 | rv = -1;
|
---|
474 |
|
---|
475 | /* We alloc space for 8 gids at a time. */
|
---|
476 | if (((group_list = (gid_t *) malloc(8*sizeof(gid_t *))) != NULL)
|
---|
477 | && ((grf = fopen(_PATH_GROUP, "r")) != NULL)
|
---|
478 | ) {
|
---|
479 |
|
---|
480 | /* __STDIO_SET_USER_LOCKING(grf); */
|
---|
481 |
|
---|
482 | *group_list = gid;
|
---|
483 | num_groups = 1;
|
---|
484 |
|
---|
485 | while (!__pgsreader(__parsegrent, &group, buff, GRP_BUFFER_SIZE_MALLOC, grf)) {
|
---|
486 | assert(group.gr_mem); /* Must have at least a NULL terminator. */
|
---|
487 | if (group.gr_gid != gid) {
|
---|
488 | for (m=group.gr_mem ; *m ; m++) {
|
---|
489 | if (!strcmp(*m, user)) {
|
---|
490 | if (!(num_groups & 7)) {
|
---|
491 | gid_t *tmp = (gid_t *)
|
---|
492 | realloc(group_list,
|
---|
493 | (num_groups+8) * sizeof(gid_t *));
|
---|
494 | if (!tmp) {
|
---|
495 | rv = -1;
|
---|
496 | goto DO_CLOSE;
|
---|
497 | }
|
---|
498 | group_list = tmp;
|
---|
499 | }
|
---|
500 | group_list[num_groups++] = group.gr_gid;
|
---|
501 | break;
|
---|
502 | }
|
---|
503 | }
|
---|
504 | }
|
---|
505 | }
|
---|
506 |
|
---|
507 | rv = setgroups(num_groups, group_list);
|
---|
508 | DO_CLOSE:
|
---|
509 | sl_fclose(FIL__, __LINE__, grf);
|
---|
510 | }
|
---|
511 |
|
---|
512 | /* group_list will be NULL if initial malloc failed, which may trigger
|
---|
513 | * warnings from various malloc debuggers. */
|
---|
514 | free(group_list);
|
---|
515 | free(buff);
|
---|
516 | return rv;
|
---|
517 | }
|
---|
518 |
|
---|
519 |
|
---|
520 | /**********************************************************************/
|
---|
521 | /* Internal uClibc functions. */
|
---|
522 | /**********************************************************************/
|
---|
523 |
|
---|
524 | static const unsigned char pw_off[] = {
|
---|
525 | offsetof(struct passwd, pw_name), /* 0 */
|
---|
526 | offsetof(struct passwd, pw_passwd), /* 1 */
|
---|
527 | offsetof(struct passwd, pw_uid), /* 2 - not a char ptr */
|
---|
528 | offsetof(struct passwd, pw_gid), /* 3 - not a char ptr */
|
---|
529 | offsetof(struct passwd, pw_gecos), /* 4 */
|
---|
530 | offsetof(struct passwd, pw_dir), /* 5 */
|
---|
531 | offsetof(struct passwd, pw_shell) /* 6 */
|
---|
532 | };
|
---|
533 |
|
---|
534 | static int __parsepwent(void *data, char *line)
|
---|
535 | {
|
---|
536 | char *endptr;
|
---|
537 | char *p;
|
---|
538 | int i;
|
---|
539 |
|
---|
540 | i = 0;
|
---|
541 | do {
|
---|
542 | p = ((char *) ((struct passwd *) data)) + pw_off[i];
|
---|
543 |
|
---|
544 | if ((i & 6) ^ 2) { /* i!=2 and i!=3 */
|
---|
545 | *((char **) p) = line;
|
---|
546 | if (i==6) {
|
---|
547 | return 0;
|
---|
548 | }
|
---|
549 | /* NOTE: glibc difference - glibc allows omission of
|
---|
550 | * ':' seperators after the gid field if all remaining
|
---|
551 | * entries are empty. We require all separators. */
|
---|
552 | if (!(line = strchr(line, ':'))) {
|
---|
553 | break;
|
---|
554 | }
|
---|
555 | } else {
|
---|
556 | unsigned long t = strtoul(line, &endptr, 10);
|
---|
557 | /* Make sure we had at least one digit, and that the
|
---|
558 | * failing char is the next field seperator ':'. See
|
---|
559 | * glibc difference note above. */
|
---|
560 | /* TODO: Also check for leading whitespace? */
|
---|
561 | if ((endptr == line) || (*endptr != ':')) {
|
---|
562 | break;
|
---|
563 | }
|
---|
564 | line = endptr;
|
---|
565 | if (i & 1) { /* i == 3 -- gid */
|
---|
566 | *((gid_t *) p) = t;
|
---|
567 | } else { /* i == 2 -- uid */
|
---|
568 | *((uid_t *) p) = t;
|
---|
569 | }
|
---|
570 | }
|
---|
571 |
|
---|
572 | *line++ = 0;
|
---|
573 | ++i;
|
---|
574 | } while (1);
|
---|
575 |
|
---|
576 | return -1;
|
---|
577 | }
|
---|
578 |
|
---|
579 | static const unsigned char gr_off[] = {
|
---|
580 | offsetof(struct group, gr_name), /* 0 */
|
---|
581 | offsetof(struct group, gr_passwd), /* 1 */
|
---|
582 | offsetof(struct group, gr_gid) /* 2 - not a char ptr */
|
---|
583 | };
|
---|
584 |
|
---|
585 | static int __parsegrent(void *data, char *line)
|
---|
586 | {
|
---|
587 | char *endptr;
|
---|
588 | char *p;
|
---|
589 | int i;
|
---|
590 | char **members;
|
---|
591 | char *end_of_buf;
|
---|
592 |
|
---|
593 | end_of_buf = ((struct group *) data)->gr_name; /* Evil hack! */
|
---|
594 | i = 0;
|
---|
595 | do {
|
---|
596 | p = ((char *) ((struct group *) data)) + gr_off[i];
|
---|
597 |
|
---|
598 | if (i < 2) {
|
---|
599 | *((char **) p) = line;
|
---|
600 | if (!(line = strchr(line, ':'))) {
|
---|
601 | break;
|
---|
602 | }
|
---|
603 | *line++ = 0;
|
---|
604 | ++i;
|
---|
605 | } else {
|
---|
606 | *((gid_t *) p) = strtoul(line, &endptr, 10);
|
---|
607 |
|
---|
608 | /* NOTE: glibc difference - glibc allows omission of the
|
---|
609 | * trailing colon when there is no member list. We treat
|
---|
610 | * this as an error. */
|
---|
611 |
|
---|
612 | /* Make sure we had at least one digit, and that the
|
---|
613 | * failing char is the next field seperator ':'. See
|
---|
614 | * glibc difference note above. */
|
---|
615 | if ((endptr == line) || (*endptr != ':')) {
|
---|
616 | break;
|
---|
617 | }
|
---|
618 |
|
---|
619 | i = 1; /* Count terminating NULL ptr. */
|
---|
620 | p = endptr;
|
---|
621 |
|
---|
622 | if (p[1]) { /* We have a member list to process. */
|
---|
623 | /* Overwrite the last ':' with a ',' before counting.
|
---|
624 | * This allows us to test for initial ',' and adds
|
---|
625 | * one ',' so that the ',' count equals the member
|
---|
626 | * count. */
|
---|
627 | *p = ',';
|
---|
628 | do {
|
---|
629 | /* NOTE: glibc difference - glibc allows and trims leading
|
---|
630 | * (but not trailing) space. We treat this as an error. */
|
---|
631 | /* NOTE: glibc difference - glibc allows consecutive and
|
---|
632 | * trailing commas, and ignores "empty string" users. We
|
---|
633 | * treat this as an error. */
|
---|
634 | if (*p == ',') {
|
---|
635 | ++i;
|
---|
636 | *p = 0; /* nul-terminate each member string. */
|
---|
637 | if (!*++p || (*p == ',') || isspace(*p)) {
|
---|
638 | goto ERR;
|
---|
639 | }
|
---|
640 | }
|
---|
641 | } while (*++p);
|
---|
642 | }
|
---|
643 |
|
---|
644 | /* Now align (p+1), rounding up. */
|
---|
645 | /* Assumes sizeof(char **) is a power of 2. */
|
---|
646 | members = (char **)( (((intptr_t) p) + sizeof(char **))
|
---|
647 | & ~((intptr_t)(sizeof(char **) - 1)) );
|
---|
648 |
|
---|
649 | if (((char *)(members + i)) > end_of_buf) { /* No space. */
|
---|
650 | break;
|
---|
651 | }
|
---|
652 |
|
---|
653 | ((struct group *) data)->gr_mem = members;
|
---|
654 |
|
---|
655 | if (--i) {
|
---|
656 | p = endptr; /* Pointing to char prior to first member. */
|
---|
657 | do {
|
---|
658 | *members++ = ++p;
|
---|
659 | if (!--i) break;
|
---|
660 | while (*++p) {}
|
---|
661 | } while (1);
|
---|
662 | }
|
---|
663 | *members = NULL;
|
---|
664 |
|
---|
665 | return 0;
|
---|
666 | }
|
---|
667 | } while (1);
|
---|
668 |
|
---|
669 | ERR:
|
---|
670 | return -1;
|
---|
671 | }
|
---|
672 |
|
---|
673 | /* Reads until if EOF, or until if finds a line which fits in the buffer
|
---|
674 | * and for which the parser function succeeds.
|
---|
675 | *
|
---|
676 | * Returns 0 on success and ENOENT for end-of-file (glibc concession).
|
---|
677 | */
|
---|
678 |
|
---|
679 | static int __pgsreader(int (*__parserfunc)(void *d, char *line), void *data,
|
---|
680 | char *__restrict line_buff, size_t buflen, FILE *f)
|
---|
681 | {
|
---|
682 | size_t line_len; /* int -> size_t R.W. */
|
---|
683 | int skip;
|
---|
684 | int rv = ERANGE;
|
---|
685 |
|
---|
686 | if (buflen < PWD_BUFFER_SIZE) {
|
---|
687 | errno = rv;
|
---|
688 | } else {
|
---|
689 | /* __STDIO_THREADLOCK(f); */
|
---|
690 |
|
---|
691 | skip = 0;
|
---|
692 | do {
|
---|
693 | if (!fgets(line_buff, buflen, f)) {
|
---|
694 | if (feof(f)) {
|
---|
695 | rv = ENOENT;
|
---|
696 | }
|
---|
697 | break;
|
---|
698 | }
|
---|
699 |
|
---|
700 | line_len = strlen(line_buff) - 1; /* strlen() must be > 0. */
|
---|
701 | if (line_buff[line_len] == '\n') {
|
---|
702 | line_buff[line_len] = 0;
|
---|
703 | } else if (line_len + 2 == buflen) { /* line too long */
|
---|
704 | rv = ERANGE;
|
---|
705 | break;
|
---|
706 | /*
|
---|
707 | ++skip;
|
---|
708 | continue;
|
---|
709 | */
|
---|
710 | }
|
---|
711 |
|
---|
712 | if (skip) {
|
---|
713 | --skip;
|
---|
714 | continue;
|
---|
715 | }
|
---|
716 |
|
---|
717 | /* NOTE: glibc difference - glibc strips leading whitespace from
|
---|
718 | * records. We do not allow leading whitespace. */
|
---|
719 |
|
---|
720 | /* Skip empty lines, comment lines, and lines with leading
|
---|
721 | * whitespace. */
|
---|
722 | if (*line_buff && (*line_buff != '#') && !isspace(*line_buff)) {
|
---|
723 | if (__parserfunc == __parsegrent) { /* Do evil group hack. */
|
---|
724 | /* The group entry parsing function needs to know where
|
---|
725 | * the end of the buffer is so that it can construct the
|
---|
726 | * group member ptr table. */
|
---|
727 | ((struct group *) data)->gr_name = line_buff + buflen;
|
---|
728 | }
|
---|
729 |
|
---|
730 | if (!__parserfunc(data, line_buff)) {
|
---|
731 | rv = 0;
|
---|
732 | break;
|
---|
733 | }
|
---|
734 | }
|
---|
735 | } while (1);
|
---|
736 |
|
---|
737 | /* __STDIO_THREADUNLOCK(f); */
|
---|
738 | }
|
---|
739 |
|
---|
740 | return rv;
|
---|
741 | }
|
---|
742 |
|
---|
743 | /* resolv.c: DNS Resolver
|
---|
744 | *
|
---|
745 | * Copyright (C) 1998 Kenneth Albanowski <kjahds@kjahds.com>,
|
---|
746 | * The Silver Hammer Group, Ltd.
|
---|
747 | *
|
---|
748 | * This library is free software; you can redistribute it and/or
|
---|
749 | * modify it under the terms of the GNU Library General Public
|
---|
750 | * License as published by the Free Software Foundation; either
|
---|
751 | * version 2 of the License, or (at your option) any later version.
|
---|
752 | */
|
---|
753 |
|
---|
754 | /*
|
---|
755 | * Portions Copyright (c) 1985, 1993
|
---|
756 | * The Regents of the University of California. All rights reserved.
|
---|
757 | *
|
---|
758 | * Redistribution and use in source and binary forms, with or without
|
---|
759 | * modification, are permitted provided that the following conditions
|
---|
760 | * are met:
|
---|
761 | * 1. Redistributions of source code must retain the above copyright
|
---|
762 | * notice, this list of conditions and the following disclaimer.
|
---|
763 | * 2. Redistributions in binary form must reproduce the above copyright
|
---|
764 | * notice, this list of conditions and the following disclaimer in the
|
---|
765 | * documentation and/or other materials provided with the distribution.
|
---|
766 | * 4. Neither the name of the University nor the names of its contributors
|
---|
767 | * may be used to endorse or promote products derived from this software
|
---|
768 | * without specific prior written permission.
|
---|
769 | *
|
---|
770 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
---|
771 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
---|
772 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
---|
773 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
---|
774 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
---|
775 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
---|
776 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
---|
777 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
---|
778 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
---|
779 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
---|
780 | * SUCH DAMAGE.
|
---|
781 | */
|
---|
782 |
|
---|
783 | /*
|
---|
784 | * Portions Copyright (c) 1993 by Digital Equipment Corporation.
|
---|
785 | *
|
---|
786 | * Permission to use, copy, modify, and distribute this software for any
|
---|
787 | * purpose with or without fee is hereby granted, provided that the above
|
---|
788 | * copyright notice and this permission notice appear in all copies, and that
|
---|
789 | * the name of Digital Equipment Corporation not be used in advertising or
|
---|
790 | * publicity pertaining to distribution of the document or software without
|
---|
791 | * specific, written prior permission.
|
---|
792 | *
|
---|
793 | * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL
|
---|
794 | * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES
|
---|
795 | * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT
|
---|
796 | * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
---|
797 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
---|
798 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
|
---|
799 | * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
---|
800 | * SOFTWARE.
|
---|
801 | */
|
---|
802 |
|
---|
803 | /*
|
---|
804 | * Portions Copyright (c) 1996-1999 by Internet Software Consortium.
|
---|
805 | *
|
---|
806 | * Permission to use, copy, modify, and distribute this software for any
|
---|
807 | * purpose with or without fee is hereby granted, provided that the above
|
---|
808 | * copyright notice and this permission notice appear in all copies.
|
---|
809 | *
|
---|
810 | * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
|
---|
811 | * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
|
---|
812 | * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
|
---|
813 | * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
|
---|
814 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
|
---|
815 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
|
---|
816 | * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
---|
817 | * SOFTWARE.
|
---|
818 | */
|
---|
819 |
|
---|
820 | /*
|
---|
821 | *
|
---|
822 | * 5-Oct-2000 W. Greathouse wgreathouse@smva.com
|
---|
823 | * Fix memory leak and memory corruption.
|
---|
824 | * -- Every name resolution resulted in
|
---|
825 | * a new parse of resolv.conf and new
|
---|
826 | * copy of nameservers allocated by
|
---|
827 | * strdup.
|
---|
828 | * -- Every name resolution resulted in
|
---|
829 | * a new read of resolv.conf without
|
---|
830 | * resetting index from prior read...
|
---|
831 | * resulting in exceeding array bounds.
|
---|
832 | *
|
---|
833 | * Limit nameservers read from resolv.conf
|
---|
834 | *
|
---|
835 | * Add "search" domains from resolv.conf
|
---|
836 | *
|
---|
837 | * Some systems will return a security
|
---|
838 | * signature along with query answer for
|
---|
839 | * dynamic DNS entries.
|
---|
840 | * -- skip/ignore this answer
|
---|
841 | *
|
---|
842 | * Include arpa/nameser.h for defines.
|
---|
843 | *
|
---|
844 | * General cleanup
|
---|
845 | *
|
---|
846 | * 20-Jun-2001 Michal Moskal <malekith@pld.org.pl>
|
---|
847 | * partial IPv6 support (i.e. gethostbyname2() and resolve_address2()
|
---|
848 | * functions added), IPv6 nameservers are also supported.
|
---|
849 | *
|
---|
850 | * 6-Oct-2001 Jari Korva <jari.korva@iki.fi>
|
---|
851 | * more IPv6 support (IPv6 support for gethostbyaddr();
|
---|
852 | * address family parameter and improved IPv6 support for get_hosts_byname
|
---|
853 | * and read_etc_hosts; getnameinfo() port from glibc; defined
|
---|
854 | * defined ip6addr_any and in6addr_loopback)
|
---|
855 | *
|
---|
856 | * 2-Feb-2002 Erik Andersen <andersee@debian.org>
|
---|
857 | * Added gethostent(), sethostent(), and endhostent()
|
---|
858 | *
|
---|
859 | * 17-Aug-2002 Manuel Novoa III <mjn3@codepoet.org>
|
---|
860 | * Fixed __read_etc_hosts_r to return alias list, and modified buffer
|
---|
861 | * allocation accordingly. See MAX_ALIASES and ALIAS_DIM below.
|
---|
862 | * This fixes the segfault in the Python 2.2.1 socket test.
|
---|
863 | *
|
---|
864 | * 04-Jan-2003 Jay Kulpinski <jskulpin@berkshire.rr.com>
|
---|
865 | * Fixed __decode_dotted to count the terminating null character
|
---|
866 | * in a host name.
|
---|
867 | *
|
---|
868 | * 02-Oct-2003 Tony J. White <tjw@tjw.org>
|
---|
869 | * Lifted dn_expand() and dependent ns_name_uncompress(), ns_name_unpack(),
|
---|
870 | * and ns_name_ntop() from glibc 2.3.2 for compatibility with ipsec-tools
|
---|
871 | * and openldap.
|
---|
872 | *
|
---|
873 | */
|
---|
874 |
|
---|
875 | #include <sys/socket.h>
|
---|
876 | #include <netinet/in.h>
|
---|
877 | #include <arpa/inet.h>
|
---|
878 |
|
---|
879 | /* sl_close_fd(FIL__, __LINE__, )
|
---|
880 | */
|
---|
881 | #include <unistd.h>
|
---|
882 |
|
---|
883 | /* 'struct hostent'
|
---|
884 | */
|
---|
885 | #include <netdb.h>
|
---|
886 |
|
---|
887 | /* constanst like HFIXEDSZ
|
---|
888 | */
|
---|
889 | #include <arpa/nameser.h>
|
---|
890 |
|
---|
891 | SH_MUTEX_STATIC(resolv_lock, PTHREAD_MUTEX_INITIALIZER);
|
---|
892 |
|
---|
893 | #define __UCLIBC_HAS_IPV6__
|
---|
894 | #define MAX_RECURSE 5
|
---|
895 | #define REPLY_TIMEOUT 10
|
---|
896 | #define MAX_RETRIES 3
|
---|
897 | #define MAX_SERVERS 3
|
---|
898 | #define MAX_SEARCH 4
|
---|
899 | #define MAX_ALIASES 5
|
---|
900 |
|
---|
901 | /* 1:ip + 1:full + MAX_ALIASES:aliases + 1:NULL */
|
---|
902 | #define ALIAS_DIM (2 + MAX_ALIASES + 1)
|
---|
903 |
|
---|
904 | static int __nameservers;
|
---|
905 | static char * __nameserver[MAX_SERVERS];
|
---|
906 | static int __searchdomains;
|
---|
907 | static char * __searchdomain[MAX_SEARCH];
|
---|
908 |
|
---|
909 | #undef DEBUG
|
---|
910 | /*#define DEBUG*/
|
---|
911 |
|
---|
912 | #ifdef DEBUG
|
---|
913 | /* flawfinder: ignore *//* definition of debug macro */
|
---|
914 | #define DPRINTF(X,args...) fprintf(stderr, X, ##args)
|
---|
915 | #else
|
---|
916 | #define DPRINTF(X,args...)
|
---|
917 | #endif /* DEBUG */
|
---|
918 |
|
---|
919 | struct resolv_header {
|
---|
920 | int id;
|
---|
921 | int qr,opcode,aa,tc,rd,ra,rcode;
|
---|
922 | int qdcount;
|
---|
923 | int ancount;
|
---|
924 | int nscount;
|
---|
925 | int arcount;
|
---|
926 | };
|
---|
927 |
|
---|
928 | struct resolv_question {
|
---|
929 | char * dotted;
|
---|
930 | int qtype;
|
---|
931 | int qclass;
|
---|
932 | };
|
---|
933 |
|
---|
934 | struct resolv_answer {
|
---|
935 | char * dotted;
|
---|
936 | int atype;
|
---|
937 | int aclass;
|
---|
938 | int ttl;
|
---|
939 | int rdlength;
|
---|
940 | unsigned char * rdata;
|
---|
941 | int rdoffset;
|
---|
942 | };
|
---|
943 |
|
---|
944 | enum etc_hosts_action {
|
---|
945 | GET_HOSTS_BYNAME = 0,
|
---|
946 | GETHOSTENT,
|
---|
947 | GET_HOSTS_BYADDR,
|
---|
948 | };
|
---|
949 |
|
---|
950 | static int __encode_header(struct resolv_header *h, unsigned char *dest, int maxlen)
|
---|
951 | {
|
---|
952 | if (maxlen < HFIXEDSZ)
|
---|
953 | return -1;
|
---|
954 |
|
---|
955 | dest[0] = (h->id & 0xff00) >> 8;
|
---|
956 | dest[1] = (h->id & 0x00ff) >> 0;
|
---|
957 | dest[2] = (h->qr ? 0x80 : 0) |
|
---|
958 | ((h->opcode & 0x0f) << 3) |
|
---|
959 | (h->aa ? 0x04 : 0) |
|
---|
960 | (h->tc ? 0x02 : 0) |
|
---|
961 | (h->rd ? 0x01 : 0);
|
---|
962 | dest[3] = (h->ra ? 0x80 : 0) | (h->rcode & 0x0f);
|
---|
963 | dest[4] = (h->qdcount & 0xff00) >> 8;
|
---|
964 | dest[5] = (h->qdcount & 0x00ff) >> 0;
|
---|
965 | dest[6] = (h->ancount & 0xff00) >> 8;
|
---|
966 | dest[7] = (h->ancount & 0x00ff) >> 0;
|
---|
967 | dest[8] = (h->nscount & 0xff00) >> 8;
|
---|
968 | dest[9] = (h->nscount & 0x00ff) >> 0;
|
---|
969 | dest[10] = (h->arcount & 0xff00) >> 8;
|
---|
970 | dest[11] = (h->arcount & 0x00ff) >> 0;
|
---|
971 |
|
---|
972 | return HFIXEDSZ;
|
---|
973 | }
|
---|
974 |
|
---|
975 | static int __decode_header(unsigned char *data, struct resolv_header *h)
|
---|
976 | {
|
---|
977 | h->id = (data[0] << 8) | data[1];
|
---|
978 | h->qr = (data[2] & 0x80) ? 1 : 0;
|
---|
979 | h->opcode = (data[2] >> 3) & 0x0f;
|
---|
980 | h->aa = (data[2] & 0x04) ? 1 : 0;
|
---|
981 | h->tc = (data[2] & 0x02) ? 1 : 0;
|
---|
982 | h->rd = (data[2] & 0x01) ? 1 : 0;
|
---|
983 | h->ra = (data[3] & 0x80) ? 1 : 0;
|
---|
984 | h->rcode = data[3] & 0x0f;
|
---|
985 | h->qdcount = (data[4] << 8) | data[5];
|
---|
986 | h->ancount = (data[6] << 8) | data[7];
|
---|
987 | h->nscount = (data[8] << 8) | data[9];
|
---|
988 | h->arcount = (data[10] << 8) | data[11];
|
---|
989 |
|
---|
990 | return HFIXEDSZ;
|
---|
991 | }
|
---|
992 |
|
---|
993 | static int __length_dotted(const unsigned char *data, int offset)
|
---|
994 | {
|
---|
995 | int orig_offset = offset;
|
---|
996 | int l;
|
---|
997 |
|
---|
998 | if (!data)
|
---|
999 | return -1;
|
---|
1000 |
|
---|
1001 | while ((l = data[offset++])) {
|
---|
1002 |
|
---|
1003 | if ((l & 0xc0) == (0xc0)) {
|
---|
1004 | offset++;
|
---|
1005 | break;
|
---|
1006 | }
|
---|
1007 |
|
---|
1008 | offset += l;
|
---|
1009 | }
|
---|
1010 |
|
---|
1011 | return offset - orig_offset;
|
---|
1012 | }
|
---|
1013 |
|
---|
1014 | static int __length_question(unsigned char *message, int offset)
|
---|
1015 | {
|
---|
1016 | int i;
|
---|
1017 |
|
---|
1018 | i = __length_dotted(message, offset);
|
---|
1019 | if (i < 0)
|
---|
1020 | return i;
|
---|
1021 |
|
---|
1022 | return i + 4;
|
---|
1023 | }
|
---|
1024 |
|
---|
1025 | /* Decode a dotted string from nameserver transport-level encoding.
|
---|
1026 | This routine understands compressed data. */
|
---|
1027 |
|
---|
1028 | static int __decode_dotted(const unsigned char *data, int offset,
|
---|
1029 | char *dest, int maxlen)
|
---|
1030 | {
|
---|
1031 | int l;
|
---|
1032 | int measure = 1;
|
---|
1033 | int total = 0;
|
---|
1034 | int used = 0;
|
---|
1035 |
|
---|
1036 | if (!data)
|
---|
1037 | return -1;
|
---|
1038 |
|
---|
1039 | while ((l=data[offset++])) {
|
---|
1040 | if (measure)
|
---|
1041 | total++;
|
---|
1042 | if ((l & 0xc0) == (0xc0)) {
|
---|
1043 | if (measure)
|
---|
1044 | total++;
|
---|
1045 | /* compressed item, redirect */
|
---|
1046 | offset = ((l & 0x3f) << 8) | data[offset];
|
---|
1047 | measure = 0;
|
---|
1048 | continue;
|
---|
1049 | }
|
---|
1050 |
|
---|
1051 | if ((used + l + 1) >= maxlen)
|
---|
1052 | return -1;
|
---|
1053 |
|
---|
1054 | memcpy(dest + used, data + offset, l);
|
---|
1055 | offset += l;
|
---|
1056 | used += l;
|
---|
1057 | if (measure)
|
---|
1058 | total += l;
|
---|
1059 |
|
---|
1060 | if (data[offset] != 0)
|
---|
1061 | dest[used++] = '.';
|
---|
1062 | else
|
---|
1063 | dest[used++] = '\0';
|
---|
1064 | }
|
---|
1065 |
|
---|
1066 | /* The null byte must be counted too */
|
---|
1067 | if (measure) {
|
---|
1068 | total++;
|
---|
1069 | }
|
---|
1070 |
|
---|
1071 | DPRINTF("Total decode len = %d\n", total);
|
---|
1072 |
|
---|
1073 | return total;
|
---|
1074 | }
|
---|
1075 |
|
---|
1076 | static int __decode_answer(unsigned char *message, int offset,
|
---|
1077 | struct resolv_answer *a)
|
---|
1078 | {
|
---|
1079 | char temp[256];
|
---|
1080 | int i;
|
---|
1081 |
|
---|
1082 | i = __decode_dotted(message, offset, temp, sizeof(temp));
|
---|
1083 | if (i < 0)
|
---|
1084 | return i;
|
---|
1085 |
|
---|
1086 | message += offset + i;
|
---|
1087 |
|
---|
1088 | a->dotted = strdup(temp);
|
---|
1089 | a->atype = (message[0] << 8) | message[1];
|
---|
1090 | message += 2;
|
---|
1091 | a->aclass = (message[0] << 8) | message[1];
|
---|
1092 | message += 2;
|
---|
1093 | a->ttl = (message[0] << 24) |
|
---|
1094 | (message[1] << 16) | (message[2] << 8) | (message[3] << 0);
|
---|
1095 | message += 4;
|
---|
1096 | a->rdlength = (message[0] << 8) | message[1];
|
---|
1097 | message += 2;
|
---|
1098 | a->rdata = message;
|
---|
1099 | a->rdoffset = offset + i + RRFIXEDSZ;
|
---|
1100 |
|
---|
1101 | DPRINTF("i=%d,rdlength=%d\n", i, a->rdlength);
|
---|
1102 |
|
---|
1103 | return i + RRFIXEDSZ + a->rdlength;
|
---|
1104 | }
|
---|
1105 |
|
---|
1106 |
|
---|
1107 | /* Encode a dotted string into nameserver transport-level encoding.
|
---|
1108 | This routine is fairly dumb, and doesn't attempt to compress
|
---|
1109 | the data */
|
---|
1110 |
|
---|
1111 | static int __encode_dotted(const char *dotted, unsigned char *dest, int maxlen)
|
---|
1112 | {
|
---|
1113 | unsigned int used = 0;
|
---|
1114 |
|
---|
1115 | while (dotted && *dotted) {
|
---|
1116 | char *c = strchr(dotted, '.');
|
---|
1117 | unsigned int l = c ? (unsigned int)(c - dotted) : strlen(dotted);
|
---|
1118 |
|
---|
1119 | if (l >= ((unsigned int)maxlen - used - 1))
|
---|
1120 | return -1;
|
---|
1121 |
|
---|
1122 | dest[used++] = l;
|
---|
1123 | memcpy(dest + used, dotted, l);
|
---|
1124 | used += l;
|
---|
1125 |
|
---|
1126 | if (c)
|
---|
1127 | dotted = c + 1;
|
---|
1128 | else
|
---|
1129 | break;
|
---|
1130 | }
|
---|
1131 |
|
---|
1132 | if (maxlen < 1)
|
---|
1133 | return -1;
|
---|
1134 |
|
---|
1135 | dest[used++] = 0;
|
---|
1136 |
|
---|
1137 | return used;
|
---|
1138 | }
|
---|
1139 |
|
---|
1140 | static int __encode_question(struct resolv_question *q,
|
---|
1141 | unsigned char *dest, int maxlen)
|
---|
1142 | {
|
---|
1143 | int i;
|
---|
1144 |
|
---|
1145 | i = __encode_dotted(q->dotted, dest, maxlen);
|
---|
1146 | if (i < 0)
|
---|
1147 | return i;
|
---|
1148 |
|
---|
1149 | dest += i;
|
---|
1150 | maxlen -= i;
|
---|
1151 |
|
---|
1152 | if (maxlen < 4)
|
---|
1153 | return -1;
|
---|
1154 |
|
---|
1155 | dest[0] = (q->qtype & 0xff00) >> 8;
|
---|
1156 | dest[1] = (q->qtype & 0x00ff) >> 0;
|
---|
1157 | dest[2] = (q->qclass & 0xff00) >> 8;
|
---|
1158 | dest[3] = (q->qclass & 0x00ff) >> 0;
|
---|
1159 |
|
---|
1160 | return i + 4;
|
---|
1161 | }
|
---|
1162 |
|
---|
1163 |
|
---|
1164 | /* Just for the record, having to lock __dns_lookup() just for these two globals
|
---|
1165 | * is pretty lame. I think these two variables can probably be de-global-ized,
|
---|
1166 | * which should eliminate the need for doing locking here... Needs a closer
|
---|
1167 | * look anyways. */
|
---|
1168 | static int ns=0, id=1;
|
---|
1169 |
|
---|
1170 | static int __dns_lookup(const char *name, int type, int nscount, char **nsip,
|
---|
1171 | unsigned char **outpacket, struct resolv_answer *a)
|
---|
1172 | {
|
---|
1173 | int i, j, len, fd, pos, rc;
|
---|
1174 | struct timeval tv;
|
---|
1175 | fd_set fds;
|
---|
1176 | struct resolv_header h;
|
---|
1177 | struct resolv_question q;
|
---|
1178 | int retries = 0;
|
---|
1179 | unsigned char * packet = malloc(PACKETSZ);
|
---|
1180 | char *dns, *lookup = malloc(MAXDNAME);
|
---|
1181 | int variant = 0;
|
---|
1182 | struct sockaddr_in sa;
|
---|
1183 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1184 | int v6;
|
---|
1185 | struct sockaddr_in6 sa6;
|
---|
1186 | #endif
|
---|
1187 |
|
---|
1188 | fd = -1;
|
---|
1189 |
|
---|
1190 | if (!packet || !lookup || !nscount)
|
---|
1191 | goto fail;
|
---|
1192 |
|
---|
1193 | DPRINTF("Looking up type %d answer for '%s'\n", type, name);
|
---|
1194 |
|
---|
1195 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1196 | ns %= nscount;
|
---|
1197 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1198 |
|
---|
1199 | while (retries++ < MAX_RETRIES) {
|
---|
1200 | if (fd != -1)
|
---|
1201 | sl_close_fd(FIL__, __LINE__, fd);
|
---|
1202 |
|
---|
1203 | memset(packet, 0, PACKETSZ);
|
---|
1204 |
|
---|
1205 | memset(&h, 0, sizeof(h));
|
---|
1206 |
|
---|
1207 | /* Mess with globals while under lock */
|
---|
1208 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1209 | ++id;
|
---|
1210 | id &= 0xffff;
|
---|
1211 | h.id = id;
|
---|
1212 | dns = nsip[ns];
|
---|
1213 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1214 |
|
---|
1215 | h.qdcount = 1;
|
---|
1216 | h.rd = 1;
|
---|
1217 |
|
---|
1218 | DPRINTF("encoding header\n", h.rd);
|
---|
1219 |
|
---|
1220 | i = __encode_header(&h, packet, PACKETSZ);
|
---|
1221 | if (i < 0)
|
---|
1222 | goto fail;
|
---|
1223 |
|
---|
1224 | sl_strlcpy(lookup,name,MAXDNAME);
|
---|
1225 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1226 | if (variant < __searchdomains && strchr(lookup, '.') == NULL)
|
---|
1227 | {
|
---|
1228 | sl_strlcat(lookup,".", MAXDNAME);
|
---|
1229 | sl_strlcat(lookup,__searchdomain[variant], MAXDNAME);
|
---|
1230 | }
|
---|
1231 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1232 | DPRINTF("lookup name: %s\n", lookup);
|
---|
1233 | q.dotted = (char *)lookup;
|
---|
1234 | q.qtype = type;
|
---|
1235 | q.qclass = C_IN; /* CLASS_IN */
|
---|
1236 |
|
---|
1237 | j = __encode_question(&q, packet+i, PACKETSZ-i);
|
---|
1238 | if (j < 0)
|
---|
1239 | goto fail;
|
---|
1240 |
|
---|
1241 | len = i + j;
|
---|
1242 |
|
---|
1243 | DPRINTF("On try %d, sending query to port %d of machine %s\n",
|
---|
1244 | retries, NAMESERVER_PORT, dns);
|
---|
1245 |
|
---|
1246 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1247 | v6 = inet_pton(AF_INET6, dns, &sa6.sin6_addr) > 0;
|
---|
1248 | fd = socket(v6 ? AF_INET6 : AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
---|
1249 | #else
|
---|
1250 | fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
---|
1251 | #endif
|
---|
1252 | if (fd < 0) {
|
---|
1253 | continue;
|
---|
1254 | }
|
---|
1255 |
|
---|
1256 | /* Connect to the UDP socket so that asyncronous errors are returned */
|
---|
1257 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1258 | if (v6) {
|
---|
1259 | sa6.sin6_family = AF_INET6;
|
---|
1260 | sa6.sin6_port = htons(NAMESERVER_PORT);
|
---|
1261 | /* sa6.sin6_addr is already here */
|
---|
1262 | rc = connect(fd, (struct sockaddr *) &sa6, sizeof(sa6));
|
---|
1263 | } else {
|
---|
1264 | #endif
|
---|
1265 | sa.sin_family = AF_INET;
|
---|
1266 | sa.sin_port = htons(NAMESERVER_PORT);
|
---|
1267 | sa.sin_addr.s_addr = inet_addr(dns);
|
---|
1268 | rc = connect(fd, (struct sockaddr *) &sa, sizeof(sa));
|
---|
1269 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1270 | }
|
---|
1271 | #endif
|
---|
1272 | if (rc < 0) {
|
---|
1273 | if (errno == ENETUNREACH) {
|
---|
1274 | /* routing error, presume not transient */
|
---|
1275 | goto tryall;
|
---|
1276 | } else
|
---|
1277 | /* retry */
|
---|
1278 | continue;
|
---|
1279 | }
|
---|
1280 |
|
---|
1281 | DPRINTF("Transmitting packet of length %d, id=%d, qr=%d\n",
|
---|
1282 | len, h.id, h.qr);
|
---|
1283 |
|
---|
1284 | send(fd, packet, len, 0);
|
---|
1285 |
|
---|
1286 | FD_ZERO(&fds);
|
---|
1287 | FD_SET(fd, &fds);
|
---|
1288 | tv.tv_sec = REPLY_TIMEOUT;
|
---|
1289 | tv.tv_usec = 0;
|
---|
1290 | if (select(fd + 1, &fds, NULL, NULL, &tv) <= 0) {
|
---|
1291 | DPRINTF("Timeout\n");
|
---|
1292 |
|
---|
1293 | /* timed out, so retry send and receive,
|
---|
1294 | * to next nameserver on queue */
|
---|
1295 | goto again;
|
---|
1296 | }
|
---|
1297 |
|
---|
1298 | i = recv(fd, packet, 512, 0);
|
---|
1299 | if (i < HFIXEDSZ) {
|
---|
1300 | /* too short ! */
|
---|
1301 | goto again;
|
---|
1302 | }
|
---|
1303 |
|
---|
1304 | __decode_header(packet, &h);
|
---|
1305 |
|
---|
1306 | DPRINTF("id = %d, qr = %d\n", h.id, h.qr);
|
---|
1307 |
|
---|
1308 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1309 | if ((h.id != id) || (!h.qr)) {
|
---|
1310 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1311 | /* unsolicited */
|
---|
1312 | goto again;
|
---|
1313 | }
|
---|
1314 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1315 |
|
---|
1316 |
|
---|
1317 | DPRINTF("Got response %s\n", "(i think)!");
|
---|
1318 | DPRINTF("qrcount=%d,ancount=%d,nscount=%d,arcount=%d\n",
|
---|
1319 | h.qdcount, h.ancount, h.nscount, h.arcount);
|
---|
1320 | DPRINTF("opcode=%d,aa=%d,tc=%d,rd=%d,ra=%d,rcode=%d\n",
|
---|
1321 | h.opcode, h.aa, h.tc, h.rd, h.ra, h.rcode);
|
---|
1322 |
|
---|
1323 | if ((h.rcode) || (h.ancount < 1)) {
|
---|
1324 | /* negative result, not present */
|
---|
1325 | goto again;
|
---|
1326 | }
|
---|
1327 |
|
---|
1328 | pos = HFIXEDSZ;
|
---|
1329 |
|
---|
1330 | for (j = 0; j < h.qdcount; j++) {
|
---|
1331 | DPRINTF("Skipping question %d at %d\n", j, pos);
|
---|
1332 | i = __length_question(packet, pos);
|
---|
1333 | DPRINTF("Length of question %d is %d\n", j, i);
|
---|
1334 | if (i < 0)
|
---|
1335 | goto again;
|
---|
1336 | pos += i;
|
---|
1337 | }
|
---|
1338 | DPRINTF("Decoding answer at pos %d\n", pos);
|
---|
1339 |
|
---|
1340 | for (j=0;j<h.ancount;j++)
|
---|
1341 | {
|
---|
1342 | i = __decode_answer(packet, pos, a);
|
---|
1343 |
|
---|
1344 | if (i<0) {
|
---|
1345 | DPRINTF("failed decode %d\n", i);
|
---|
1346 | goto again;
|
---|
1347 | }
|
---|
1348 | /* For all but T_SIG, accept first answer */
|
---|
1349 | if (a->atype != T_SIG)
|
---|
1350 | break;
|
---|
1351 |
|
---|
1352 | DPRINTF("skipping T_SIG %d\n", i);
|
---|
1353 | free(a->dotted);
|
---|
1354 | pos += i;
|
---|
1355 | }
|
---|
1356 |
|
---|
1357 | DPRINTF("Answer name = |%s|\n", a->dotted);
|
---|
1358 | DPRINTF("Answer type = |%d|\n", a->atype);
|
---|
1359 |
|
---|
1360 | sl_close_fd(FIL__, __LINE__, fd);
|
---|
1361 |
|
---|
1362 | if (outpacket)
|
---|
1363 | *outpacket = packet;
|
---|
1364 | else
|
---|
1365 | free(packet);
|
---|
1366 | free(lookup);
|
---|
1367 | return (0); /* success! */
|
---|
1368 |
|
---|
1369 | tryall:
|
---|
1370 | /* if there are other nameservers, give them a go,
|
---|
1371 | otherwise return with error */
|
---|
1372 | {
|
---|
1373 | int sdomains;
|
---|
1374 |
|
---|
1375 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1376 | sdomains=__searchdomains;
|
---|
1377 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1378 | variant = 0;
|
---|
1379 | if (retries >= nscount*(sdomains+1))
|
---|
1380 | goto fail;
|
---|
1381 | }
|
---|
1382 |
|
---|
1383 | again:
|
---|
1384 | /* if there are searchdomains, try them or fallback as passed */
|
---|
1385 | {
|
---|
1386 | int sdomains;
|
---|
1387 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1388 | sdomains=__searchdomains;
|
---|
1389 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1390 |
|
---|
1391 | if (variant < sdomains) {
|
---|
1392 | /* next search */
|
---|
1393 | variant++;
|
---|
1394 | } else {
|
---|
1395 | /* next server, first search */
|
---|
1396 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1397 | ns = (ns + 1) % nscount;
|
---|
1398 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1399 | variant = 0;
|
---|
1400 | }
|
---|
1401 | }
|
---|
1402 | }
|
---|
1403 |
|
---|
1404 | fail:
|
---|
1405 | if (fd != -1)
|
---|
1406 | sl_close_fd(FIL__, __LINE__, fd);
|
---|
1407 | if (lookup)
|
---|
1408 | free(lookup);
|
---|
1409 | if (packet)
|
---|
1410 | free(packet);
|
---|
1411 | return -1;
|
---|
1412 | }
|
---|
1413 |
|
---|
1414 | static void __open_etc_hosts(FILE **fp)
|
---|
1415 | {
|
---|
1416 | if ((*fp = fopen("/etc/hosts", "r")) == NULL) {
|
---|
1417 | *fp = fopen("/etc/config/hosts", "r");
|
---|
1418 | }
|
---|
1419 | return;
|
---|
1420 | }
|
---|
1421 |
|
---|
1422 | static int __read_etc_hosts_r(FILE * fp, const char * name, int type,
|
---|
1423 | enum etc_hosts_action action,
|
---|
1424 | struct hostent * result_buf,
|
---|
1425 | char * buf, size_t buflen,
|
---|
1426 | struct hostent ** result,
|
---|
1427 | int * h_errnop)
|
---|
1428 | {
|
---|
1429 | struct in_addr *in=NULL;
|
---|
1430 | struct in_addr **addr_list=NULL;
|
---|
1431 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1432 | struct in6_addr *in6=NULL;
|
---|
1433 | struct in6_addr **addr_list6=NULL;
|
---|
1434 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1435 | char *cp;
|
---|
1436 | char **alias;
|
---|
1437 | int aliases, i;
|
---|
1438 | int ret=HOST_NOT_FOUND;
|
---|
1439 |
|
---|
1440 | if (buflen < sizeof(char *)*(ALIAS_DIM))
|
---|
1441 | return ERANGE;
|
---|
1442 | alias=(char **)buf;
|
---|
1443 | buf+=sizeof(char **)*(ALIAS_DIM);
|
---|
1444 | buflen-=sizeof(char **)*(ALIAS_DIM);
|
---|
1445 |
|
---|
1446 | if (action!=GETHOSTENT) {
|
---|
1447 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1448 | char *p=buf;
|
---|
1449 | size_t len=buflen;
|
---|
1450 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1451 | *h_errnop=NETDB_INTERNAL;
|
---|
1452 | if (buflen < sizeof(*in))
|
---|
1453 | return ERANGE;
|
---|
1454 | in=(struct in_addr*)buf;
|
---|
1455 | buf+=sizeof(*in);
|
---|
1456 | buflen-=sizeof(*in);
|
---|
1457 |
|
---|
1458 | if (buflen < sizeof(*addr_list)*2)
|
---|
1459 | return ERANGE;
|
---|
1460 | addr_list=(struct in_addr **)buf;
|
---|
1461 | buf+=sizeof(*addr_list)*2;
|
---|
1462 | buflen-=sizeof(*addr_list)*2;
|
---|
1463 |
|
---|
1464 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1465 | if (len < sizeof(*in6))
|
---|
1466 | return ERANGE;
|
---|
1467 | in6=(struct in6_addr*)p;
|
---|
1468 | p+=sizeof(*in6);
|
---|
1469 | len-=sizeof(*in6);
|
---|
1470 |
|
---|
1471 | if (len < sizeof(*addr_list6)*2)
|
---|
1472 | return ERANGE;
|
---|
1473 | addr_list6=(struct in6_addr**)p;
|
---|
1474 | p+=sizeof(*addr_list6)*2;
|
---|
1475 | len-=sizeof(*addr_list6)*2;
|
---|
1476 |
|
---|
1477 | if (len < buflen) {
|
---|
1478 | buflen=len;
|
---|
1479 | buf=p;
|
---|
1480 | }
|
---|
1481 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1482 |
|
---|
1483 | if (buflen < 80)
|
---|
1484 | return ERANGE;
|
---|
1485 |
|
---|
1486 | __open_etc_hosts(&fp);
|
---|
1487 | if (fp == NULL) {
|
---|
1488 | result=NULL;
|
---|
1489 | return errno;
|
---|
1490 | }
|
---|
1491 | }
|
---|
1492 |
|
---|
1493 | *h_errnop=HOST_NOT_FOUND;
|
---|
1494 | while (fgets(buf, buflen, fp)) {
|
---|
1495 | if ((cp = strchr(buf, '#')))
|
---|
1496 | *cp = '\0';
|
---|
1497 | DPRINTF("Looking at: %s\n", buf);
|
---|
1498 | aliases = 0;
|
---|
1499 |
|
---|
1500 | cp = buf;
|
---|
1501 | while (*cp) {
|
---|
1502 | while (*cp && isspace(*cp))
|
---|
1503 | *cp++ = '\0';
|
---|
1504 | if (!*cp)
|
---|
1505 | continue;
|
---|
1506 | if (aliases < (2+MAX_ALIASES))
|
---|
1507 | alias[aliases++] = cp;
|
---|
1508 | while (*cp && !isspace(*cp))
|
---|
1509 | cp++;
|
---|
1510 | }
|
---|
1511 | alias[aliases] = 0;
|
---|
1512 |
|
---|
1513 | if (aliases < 2)
|
---|
1514 | continue; /* syntax error really */
|
---|
1515 |
|
---|
1516 | if (action==GETHOSTENT) {
|
---|
1517 | /* Return whatever the next entry happens to be. */
|
---|
1518 | break;
|
---|
1519 | } else if (action==GET_HOSTS_BYADDR) {
|
---|
1520 | if (strcmp(name, alias[0]) != 0)
|
---|
1521 | continue;
|
---|
1522 | } else {
|
---|
1523 | /* GET_HOSTS_BYNAME */
|
---|
1524 | for (i = 1; i < aliases; i++)
|
---|
1525 | if (strcasecmp(name, alias[i]) == 0)
|
---|
1526 | break;
|
---|
1527 | if (i >= aliases)
|
---|
1528 | continue;
|
---|
1529 | }
|
---|
1530 |
|
---|
1531 | if (type == AF_INET && inet_pton(AF_INET, alias[0], in) > 0) {
|
---|
1532 | DPRINTF("Found INET\n");
|
---|
1533 | addr_list[0] = in;
|
---|
1534 | addr_list[1] = 0;
|
---|
1535 | result_buf->h_name = alias[1];
|
---|
1536 | result_buf->h_addrtype = AF_INET;
|
---|
1537 | result_buf->h_length = sizeof(*in);
|
---|
1538 | result_buf->h_addr_list = (char**) addr_list;
|
---|
1539 | result_buf->h_aliases = alias + 2;
|
---|
1540 | *result=result_buf;
|
---|
1541 | ret=NETDB_SUCCESS;
|
---|
1542 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1543 | } else if (type == AF_INET6 && inet_pton(AF_INET6, alias[0], in6) > 0) {
|
---|
1544 | DPRINTF("Found INET6\n");
|
---|
1545 | addr_list6[0] = in6;
|
---|
1546 | addr_list6[1] = 0;
|
---|
1547 | result_buf->h_name = alias[1];
|
---|
1548 | result_buf->h_addrtype = AF_INET6;
|
---|
1549 | result_buf->h_length = sizeof(*in6);
|
---|
1550 | result_buf->h_addr_list = (char**) addr_list6;
|
---|
1551 | result_buf->h_aliases = alias + 2;
|
---|
1552 | *result=result_buf;
|
---|
1553 | ret=NETDB_SUCCESS;
|
---|
1554 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1555 | } else {
|
---|
1556 | DPRINTF("Error\n");
|
---|
1557 | ret=TRY_AGAIN;
|
---|
1558 | break; /* bad ip address */
|
---|
1559 | }
|
---|
1560 |
|
---|
1561 | if (action!=GETHOSTENT) {
|
---|
1562 | sl_fclose(FIL__, __LINE__, fp);
|
---|
1563 | }
|
---|
1564 | return ret;
|
---|
1565 | }
|
---|
1566 | if (action!=GETHOSTENT) {
|
---|
1567 | sl_fclose(FIL__, __LINE__, fp);
|
---|
1568 | }
|
---|
1569 | return ret;
|
---|
1570 | }
|
---|
1571 |
|
---|
1572 | /*
|
---|
1573 | * we currently read formats not quite the same as that on normal
|
---|
1574 | * unix systems, we can have a list of nameservers after the keyword.
|
---|
1575 | */
|
---|
1576 | int __get_hosts_byname_r(const char * name, int type,
|
---|
1577 | struct hostent * result_buf,
|
---|
1578 | char * buf, size_t buflen,
|
---|
1579 | struct hostent ** result,
|
---|
1580 | int * h_errnop)
|
---|
1581 | {
|
---|
1582 | return(__read_etc_hosts_r(NULL, name, type, GET_HOSTS_BYNAME, result_buf, buf, buflen, result, h_errnop));
|
---|
1583 | }
|
---|
1584 |
|
---|
1585 | static int __open_nameservers(void)
|
---|
1586 | {
|
---|
1587 | FILE *fp;
|
---|
1588 | int i;
|
---|
1589 | #define RESOLV_ARGS 5
|
---|
1590 | char szBuffer[128], *p, *argv[RESOLV_ARGS];
|
---|
1591 | int argc;
|
---|
1592 |
|
---|
1593 | SH_MUTEX_LOCK(resolv_lock);
|
---|
1594 | if (__nameservers > 0) {
|
---|
1595 | goto the_end;
|
---|
1596 | }
|
---|
1597 |
|
---|
1598 | if ((fp = fopen("/etc/resolv.conf", "r")) ||
|
---|
1599 | (fp = fopen("/etc/config/resolv.conf", "r"))) {
|
---|
1600 |
|
---|
1601 | while (fgets(szBuffer, sizeof(szBuffer), fp) != NULL) {
|
---|
1602 |
|
---|
1603 | for (p = szBuffer; *p && isspace(*p); p++)
|
---|
1604 | /* skip white space */;
|
---|
1605 | if (*p == '\0' || *p == '\n' || *p == '#') /* skip comments etc */
|
---|
1606 | continue;
|
---|
1607 | argc = 0;
|
---|
1608 | while (*p && argc < RESOLV_ARGS) {
|
---|
1609 | argv[argc++] = p;
|
---|
1610 | while (*p && !isspace(*p) && *p != '\n')
|
---|
1611 | p++;
|
---|
1612 | while (*p && (isspace(*p) || *p == '\n')) /* remove spaces */
|
---|
1613 | *p++ = '\0';
|
---|
1614 | }
|
---|
1615 |
|
---|
1616 | if (strcmp(argv[0], "nameserver") == 0) {
|
---|
1617 | for (i = 1; i < argc && __nameservers < MAX_SERVERS; i++) {
|
---|
1618 | __nameserver[__nameservers++] = strdup(argv[i]);
|
---|
1619 | DPRINTF("adding nameserver %s\n", argv[i]);
|
---|
1620 | }
|
---|
1621 | }
|
---|
1622 |
|
---|
1623 | /* domain and search are mutually exclusive, the last one wins */
|
---|
1624 | if (strcmp(argv[0],"domain")==0 || strcmp(argv[0],"search")==0) {
|
---|
1625 | while (__searchdomains > 0) {
|
---|
1626 | free(__searchdomain[--__searchdomains]);
|
---|
1627 | __searchdomain[__searchdomains] = NULL;
|
---|
1628 | }
|
---|
1629 | for (i=1; i < argc && __searchdomains < MAX_SEARCH; i++) {
|
---|
1630 | __searchdomain[__searchdomains++] = strdup(argv[i]);
|
---|
1631 | DPRINTF("adding search %s\n", argv[i]);
|
---|
1632 | }
|
---|
1633 | }
|
---|
1634 | }
|
---|
1635 | sl_fclose(FIL__, __LINE__, fp);
|
---|
1636 | } else {
|
---|
1637 | DPRINTF("failed to open %s\n", "resolv.conf");
|
---|
1638 | }
|
---|
1639 | DPRINTF("nameservers = %d\n", __nameservers);
|
---|
1640 | the_end:
|
---|
1641 | ; /* 'label at end of compound statement' */
|
---|
1642 | SH_MUTEX_UNLOCK(resolv_lock);
|
---|
1643 | return 0;
|
---|
1644 | }
|
---|
1645 |
|
---|
1646 | static int sh_gethostbyname_r(const char * name,
|
---|
1647 | struct hostent * result_buf,
|
---|
1648 | char * buf, size_t buflen,
|
---|
1649 | struct hostent ** result,
|
---|
1650 | int * h_errnop)
|
---|
1651 | {
|
---|
1652 | struct in_addr *in;
|
---|
1653 | struct in_addr **addr_list;
|
---|
1654 | unsigned char *packet;
|
---|
1655 | struct resolv_answer a;
|
---|
1656 | int i;
|
---|
1657 | int nest = 0;
|
---|
1658 | int __nameserversXX;
|
---|
1659 | char ** __nameserverXX;
|
---|
1660 |
|
---|
1661 | __open_nameservers();
|
---|
1662 |
|
---|
1663 | *result=NULL;
|
---|
1664 | if (!name)
|
---|
1665 | return EINVAL;
|
---|
1666 |
|
---|
1667 | /* do /etc/hosts first */
|
---|
1668 | if ((i=__get_hosts_byname_r(name, AF_INET, result_buf,
|
---|
1669 | buf, buflen, result, h_errnop))==0)
|
---|
1670 | return i;
|
---|
1671 | switch (*h_errnop) {
|
---|
1672 | case HOST_NOT_FOUND:
|
---|
1673 | case NO_ADDRESS:
|
---|
1674 | break;
|
---|
1675 | case NETDB_INTERNAL:
|
---|
1676 | if (errno == ENOENT) {
|
---|
1677 | break;
|
---|
1678 | }
|
---|
1679 | /* else fall through */
|
---|
1680 | default:
|
---|
1681 | return i;
|
---|
1682 | }
|
---|
1683 |
|
---|
1684 | DPRINTF("Nothing found in /etc/hosts\n");
|
---|
1685 |
|
---|
1686 | *h_errnop = NETDB_INTERNAL;
|
---|
1687 | if (buflen < sizeof(*in))
|
---|
1688 | return ERANGE;
|
---|
1689 | in=(struct in_addr*)buf;
|
---|
1690 | buf+=sizeof(*in);
|
---|
1691 | buflen-=sizeof(*in);
|
---|
1692 |
|
---|
1693 | if (buflen < sizeof(*addr_list)*2)
|
---|
1694 | return ERANGE;
|
---|
1695 | addr_list=(struct in_addr**)buf;
|
---|
1696 | buf+=sizeof(*addr_list)*2;
|
---|
1697 | buflen-=sizeof(*addr_list)*2;
|
---|
1698 |
|
---|
1699 | addr_list[0] = in;
|
---|
1700 | addr_list[1] = 0;
|
---|
1701 |
|
---|
1702 | if (buflen<256)
|
---|
1703 | return ERANGE;
|
---|
1704 | strncpy(buf, name, buflen);
|
---|
1705 |
|
---|
1706 | /* First check if this is already an address */
|
---|
1707 | if (inet_aton(name, in)) {
|
---|
1708 | result_buf->h_name = buf;
|
---|
1709 | result_buf->h_addrtype = AF_INET;
|
---|
1710 | result_buf->h_length = sizeof(*in);
|
---|
1711 | result_buf->h_addr_list = (char **) addr_list;
|
---|
1712 | *result=result_buf;
|
---|
1713 | *h_errnop = NETDB_SUCCESS;
|
---|
1714 | return NETDB_SUCCESS;
|
---|
1715 | }
|
---|
1716 |
|
---|
1717 | for (;;) {
|
---|
1718 |
|
---|
1719 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1720 | __nameserversXX=__nameservers;
|
---|
1721 | __nameserverXX=__nameserver;
|
---|
1722 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1723 | i = __dns_lookup(buf, T_A, __nameserversXX, __nameserverXX, &packet, &a);
|
---|
1724 |
|
---|
1725 | if (i < 0) {
|
---|
1726 | *h_errnop = HOST_NOT_FOUND;
|
---|
1727 | DPRINTF("__dns_lookup\n");
|
---|
1728 | return TRY_AGAIN;
|
---|
1729 | }
|
---|
1730 |
|
---|
1731 | strncpy(buf, a.dotted, buflen);
|
---|
1732 | free(a.dotted);
|
---|
1733 |
|
---|
1734 | if (a.atype == T_CNAME) { /* CNAME */
|
---|
1735 | DPRINTF("Got a CNAME in gethostbyname()\n");
|
---|
1736 | i = __decode_dotted(packet, a.rdoffset, buf, buflen);
|
---|
1737 | free(packet);
|
---|
1738 |
|
---|
1739 | if (i < 0) {
|
---|
1740 | *h_errnop = NO_RECOVERY;
|
---|
1741 | DPRINTF("__decode_dotted\n");
|
---|
1742 | return -1;
|
---|
1743 | }
|
---|
1744 | if (++nest > MAX_RECURSE) {
|
---|
1745 | *h_errnop = NO_RECOVERY;
|
---|
1746 | DPRINTF("recursion\n");
|
---|
1747 | return -1;
|
---|
1748 | }
|
---|
1749 | continue;
|
---|
1750 | } else if (a.atype == T_A) { /* ADDRESS */
|
---|
1751 | memcpy(in, a.rdata, sizeof(*in));
|
---|
1752 | result_buf->h_name = buf;
|
---|
1753 | result_buf->h_addrtype = AF_INET;
|
---|
1754 | result_buf->h_length = sizeof(*in);
|
---|
1755 | result_buf->h_addr_list = (char **) addr_list;
|
---|
1756 | free(packet);
|
---|
1757 | break;
|
---|
1758 | } else {
|
---|
1759 | free(packet);
|
---|
1760 | *h_errnop=HOST_NOT_FOUND;
|
---|
1761 | return TRY_AGAIN;
|
---|
1762 | }
|
---|
1763 | }
|
---|
1764 |
|
---|
1765 | *result=result_buf;
|
---|
1766 | *h_errnop = NETDB_SUCCESS;
|
---|
1767 | return NETDB_SUCCESS;
|
---|
1768 | }
|
---|
1769 |
|
---|
1770 | struct hostent * sh_gethostbyname(const char *name)
|
---|
1771 | {
|
---|
1772 | static struct hostent h;
|
---|
1773 | static char buf[sizeof(struct in_addr) +
|
---|
1774 | sizeof(struct in_addr *)*2 +
|
---|
1775 | sizeof(char *)*(ALIAS_DIM) + 256/*namebuffer*/ + 32/* margin */];
|
---|
1776 | struct hostent *hp;
|
---|
1777 |
|
---|
1778 | sh_gethostbyname_r(name, &h, buf, sizeof(buf), &hp, &h_errno);
|
---|
1779 |
|
---|
1780 | return hp;
|
---|
1781 | }
|
---|
1782 |
|
---|
1783 | static int __get_hosts_byaddr_r(const char * addr, int len, int type,
|
---|
1784 | struct hostent * result_buf,
|
---|
1785 | char * buf, size_t buflen,
|
---|
1786 | struct hostent ** result,
|
---|
1787 | int * h_errnop)
|
---|
1788 | {
|
---|
1789 | #ifndef __UCLIBC_HAS_IPV6__
|
---|
1790 | char ipaddr[INET_ADDRSTRLEN];
|
---|
1791 | #else
|
---|
1792 | char ipaddr[INET6_ADDRSTRLEN];
|
---|
1793 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1794 |
|
---|
1795 | switch (type) {
|
---|
1796 | case AF_INET:
|
---|
1797 | if (len != sizeof(struct in_addr))
|
---|
1798 | return 0;
|
---|
1799 | break;
|
---|
1800 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1801 | case AF_INET6:
|
---|
1802 | if (len != sizeof(struct in6_addr))
|
---|
1803 | return 0;
|
---|
1804 | break;
|
---|
1805 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1806 | default:
|
---|
1807 | return 0;
|
---|
1808 | }
|
---|
1809 |
|
---|
1810 | inet_ntop(type, addr, ipaddr, sizeof(ipaddr));
|
---|
1811 |
|
---|
1812 | return(__read_etc_hosts_r(NULL, ipaddr, type, GET_HOSTS_BYADDR,
|
---|
1813 | result_buf, buf, buflen, result, h_errnop));
|
---|
1814 | }
|
---|
1815 |
|
---|
1816 | static int sh_gethostbyaddr_r (const void *addr, socklen_t len, int type,
|
---|
1817 | struct hostent * result_buf,
|
---|
1818 | char * buf, size_t buflen,
|
---|
1819 | struct hostent ** result,
|
---|
1820 | int * h_errnop)
|
---|
1821 |
|
---|
1822 | {
|
---|
1823 | struct in_addr *in;
|
---|
1824 | struct in_addr **addr_list;
|
---|
1825 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1826 | char *qp;
|
---|
1827 | size_t plen;
|
---|
1828 | struct in6_addr *in6;
|
---|
1829 | struct in6_addr **addr_list6;
|
---|
1830 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1831 | unsigned char *packet;
|
---|
1832 | struct resolv_answer a;
|
---|
1833 | int i;
|
---|
1834 | int nest = 0;
|
---|
1835 | int __nameserversXX;
|
---|
1836 | char ** __nameserverXX;
|
---|
1837 |
|
---|
1838 | *result=NULL;
|
---|
1839 | if (!addr)
|
---|
1840 | return EINVAL;
|
---|
1841 |
|
---|
1842 | switch (type) {
|
---|
1843 | case AF_INET:
|
---|
1844 | if (len != sizeof(struct in_addr))
|
---|
1845 | return EINVAL;
|
---|
1846 | break;
|
---|
1847 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1848 | case AF_INET6:
|
---|
1849 | if (len != sizeof(struct in6_addr))
|
---|
1850 | return EINVAL;
|
---|
1851 | break;
|
---|
1852 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1853 | default:
|
---|
1854 | return EINVAL;
|
---|
1855 | }
|
---|
1856 |
|
---|
1857 | /* do /etc/hosts first */
|
---|
1858 | if ((i=__get_hosts_byaddr_r(addr, len, type, result_buf,
|
---|
1859 | buf, buflen, result, h_errnop))==0)
|
---|
1860 | return i;
|
---|
1861 | switch (*h_errnop) {
|
---|
1862 | case HOST_NOT_FOUND:
|
---|
1863 | case NO_ADDRESS:
|
---|
1864 | break;
|
---|
1865 | default:
|
---|
1866 | return i;
|
---|
1867 | }
|
---|
1868 |
|
---|
1869 | __open_nameservers();
|
---|
1870 |
|
---|
1871 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1872 | qp=buf;
|
---|
1873 | plen=buflen;
|
---|
1874 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1875 |
|
---|
1876 | *h_errnop = NETDB_INTERNAL;
|
---|
1877 | if (buflen < sizeof(*in))
|
---|
1878 | return ERANGE;
|
---|
1879 | in=(struct in_addr*)buf;
|
---|
1880 | buf+=sizeof(*in);
|
---|
1881 | buflen-=sizeof(*in);
|
---|
1882 |
|
---|
1883 | if (buflen < sizeof(*addr_list)*2)
|
---|
1884 | return ERANGE;
|
---|
1885 | addr_list=(struct in_addr**)buf;
|
---|
1886 | buf+=sizeof(*addr_list)*2;
|
---|
1887 | buflen-=sizeof(*addr_list)*2;
|
---|
1888 |
|
---|
1889 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1890 | if (plen < sizeof(*in6))
|
---|
1891 | return ERANGE;
|
---|
1892 | in6=(struct in6_addr*)qp;
|
---|
1893 | qp+=sizeof(*in6);
|
---|
1894 | plen-=sizeof(*in6);
|
---|
1895 |
|
---|
1896 | if (plen < sizeof(*addr_list6)*2)
|
---|
1897 | return ERANGE;
|
---|
1898 | addr_list6=(struct in6_addr**)qp;
|
---|
1899 | qp+=sizeof(*addr_list6)*2;
|
---|
1900 | plen-=sizeof(*addr_list6)*2;
|
---|
1901 |
|
---|
1902 | if (plen < buflen) {
|
---|
1903 | buflen=plen;
|
---|
1904 | buf=qp;
|
---|
1905 | }
|
---|
1906 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1907 |
|
---|
1908 | if (buflen<256)
|
---|
1909 | return ERANGE;
|
---|
1910 |
|
---|
1911 | if(type == AF_INET) {
|
---|
1912 | const unsigned char *tmp_addr = (const unsigned char *)addr;
|
---|
1913 |
|
---|
1914 | memcpy(&in->s_addr, addr, len);
|
---|
1915 |
|
---|
1916 | addr_list[0] = in;
|
---|
1917 |
|
---|
1918 | sprintf(buf, "%u.%u.%u.%u.in-addr.arpa",
|
---|
1919 | tmp_addr[3], tmp_addr[2], tmp_addr[1], tmp_addr[0]);
|
---|
1920 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1921 | } else {
|
---|
1922 | memcpy(in6->s6_addr, addr, len);
|
---|
1923 |
|
---|
1924 | addr_list6[0] = in6;
|
---|
1925 | qp = buf;
|
---|
1926 |
|
---|
1927 | for (i = len - 1; i >= 0; i--) {
|
---|
1928 | qp += sprintf(qp, "%x.%x.", in6->s6_addr[i] & 0xf,
|
---|
1929 | (in6->s6_addr[i] >> 4) & 0xf);
|
---|
1930 | }
|
---|
1931 | strcpy(qp, "ip6.int");
|
---|
1932 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1933 | }
|
---|
1934 |
|
---|
1935 | addr_list[1] = 0;
|
---|
1936 |
|
---|
1937 | for (;;) {
|
---|
1938 |
|
---|
1939 | SH_MUTEX_LOCK_UNSAFE(resolv_lock);
|
---|
1940 | __nameserversXX=__nameservers;
|
---|
1941 | __nameserverXX=__nameserver;
|
---|
1942 | SH_MUTEX_UNLOCK_UNSAFE(resolv_lock);
|
---|
1943 | i = __dns_lookup(buf, T_PTR, __nameserversXX, __nameserverXX, &packet, &a);
|
---|
1944 |
|
---|
1945 | if (i < 0) {
|
---|
1946 | *h_errnop = HOST_NOT_FOUND;
|
---|
1947 | return TRY_AGAIN;
|
---|
1948 | }
|
---|
1949 |
|
---|
1950 | strncpy(buf, a.dotted, buflen);
|
---|
1951 | free(a.dotted);
|
---|
1952 |
|
---|
1953 | if (a.atype == T_CNAME) { /* CNAME */
|
---|
1954 | DPRINTF("Got a CNAME in gethostbyaddr()\n");
|
---|
1955 | i = __decode_dotted(packet, a.rdoffset, buf, buflen);
|
---|
1956 | free(packet);
|
---|
1957 |
|
---|
1958 | if (i < 0) {
|
---|
1959 | *h_errnop = NO_RECOVERY;
|
---|
1960 | return -1;
|
---|
1961 | }
|
---|
1962 | if (++nest > MAX_RECURSE) {
|
---|
1963 | *h_errnop = NO_RECOVERY;
|
---|
1964 | return -1;
|
---|
1965 | }
|
---|
1966 | continue;
|
---|
1967 | } else if (a.atype == T_PTR) { /* ADDRESS */
|
---|
1968 | i = __decode_dotted(packet, a.rdoffset, buf, buflen);
|
---|
1969 | free(packet);
|
---|
1970 |
|
---|
1971 | result_buf->h_name = buf;
|
---|
1972 | result_buf->h_addrtype = type;
|
---|
1973 |
|
---|
1974 | if(type == AF_INET) {
|
---|
1975 | result_buf->h_length = sizeof(*in);
|
---|
1976 | #ifdef __UCLIBC_HAS_IPV6__
|
---|
1977 | } else {
|
---|
1978 | result_buf->h_length = sizeof(*in6);
|
---|
1979 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
1980 | }
|
---|
1981 |
|
---|
1982 | result_buf->h_addr_list = (char **) addr_list;
|
---|
1983 | break;
|
---|
1984 | } else {
|
---|
1985 | free(packet);
|
---|
1986 | *h_errnop = NO_ADDRESS;
|
---|
1987 | return TRY_AGAIN;
|
---|
1988 | }
|
---|
1989 | }
|
---|
1990 |
|
---|
1991 | *result=result_buf;
|
---|
1992 | *h_errnop = NETDB_SUCCESS;
|
---|
1993 | return NETDB_SUCCESS;
|
---|
1994 | }
|
---|
1995 |
|
---|
1996 | struct hostent * sh_gethostbyaddr (const void *addr, socklen_t len, int type)
|
---|
1997 | {
|
---|
1998 | static struct hostent h;
|
---|
1999 | static char buf[
|
---|
2000 | #ifndef __UCLIBC_HAS_IPV6__
|
---|
2001 | sizeof(struct in_addr) + sizeof(struct in_addr *)*2 +
|
---|
2002 | #else
|
---|
2003 | sizeof(struct in6_addr) + sizeof(struct in6_addr *)*2 +
|
---|
2004 | #endif /* __UCLIBC_HAS_IPV6__ */
|
---|
2005 | sizeof(char *)*(ALIAS_DIM) + 256/*namebuffer*/ + 32/* margin */];
|
---|
2006 | struct hostent *hp;
|
---|
2007 |
|
---|
2008 | sh_gethostbyaddr_r(addr, len, type, &h, buf, sizeof(buf), &hp, &h_errno);
|
---|
2009 |
|
---|
2010 | return hp;
|
---|
2011 | }
|
---|
2012 |
|
---|
2013 | /* NEED_STATIC_LIBS */
|
---|
2014 | #else
|
---|
2015 |
|
---|
2016 | /* include something to avoid empty compilation unit */
|
---|
2017 | #include <stdio.h>
|
---|
2018 |
|
---|
2019 | #endif
|
---|
2020 |
|
---|