← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/nis/oneiric-proposed

« back to all changes in this revision

Viewing changes to ypserv-2.17/ypserv/server.c

  • Committer: Bazaar Package Importer
  • Author(s): Scott James Remnant
  • Date: 2005-11-16 23:42:06 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20051116234206-p00omaw5ji5q0qhr
Tags: 3.15-3ubuntu1
Resynchronise with Debian.  (me)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ypserv-2.17/ypserv/server.c
1
 
/* Copyright (c) 2000, 2001, 2002, 2003, 2005  Thorsten Kukuk
2
 
   Author: Thorsten Kukuk <kukuk@suse.de>
3
 
 
4
 
   The YP Server is free software; you can redistribute it and/or
5
 
   modify it under the terms of the GNU General Public License
6
 
   version 2 as published by the Free Software Foundation.
7
 
 
8
 
   The YP Server 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
 
   General Public License for more details.
12
 
 
13
 
   You should have received a copy of the GNU General Public
14
 
   License along with the YP Server; see the file COPYING. If
15
 
   not, write to the Free Software Foundation, Inc., 675 Mass Ave,
16
 
   Cambridge, MA 02139, USA. */
17
 
 
18
 
#ifdef HAVE_CONFIG_H
19
 
#include "config.h"
20
 
#endif
21
 
 
22
 
#define _GNU_SOURCE
23
 
 
24
 
#include <string.h>
25
 
#include <sys/types.h>
26
 
#include <sys/socket.h>
27
 
#include <netinet/in.h>
28
 
#include <arpa/inet.h>
29
 
#include <sys/stat.h>
30
 
#ifdef HAVE_ALLOCA_H
31
 
#include <alloca.h>
32
 
#endif /* HAVE_ALLOCA_H */
33
 
#include <unistd.h>
34
 
#include <stdlib.h>
35
 
#include <dirent.h>
36
 
#include <errno.h>
37
 
#include <fcntl.h>
38
 
#include <time.h>
39
 
#include "yp.h"
40
 
#include "yp_db.h"
41
 
#include "access.h"
42
 
#include "ypserv_conf.h"
43
 
#include "log_msg.h"
44
 
#include "compat.h"
45
 
 
46
 
 
47
 
static void
48
 
mangle(datum *val, int vcode)
49
 
{
50
 
        char *s, *p, *q;
51
 
        int field;
52
 
        int newsize;
53
 
        int i, n = 1;
54
 
 
55
 
        if (vcode < 201) return;
56
 
        field = vcode - 200;
57
 
 
58
 
        for (i = 0, s = val->dptr; i < val->dsize && *s; i++, s++) {
59
 
                if (n == field) break;
60
 
                if (*s == ':') n++;
61
 
        }
62
 
        if (n != field) return;
63
 
 
64
 
        if ((p = malloc(val->dsize + 1)) == NULL) return;
65
 
        memcpy(p, val->dptr, i);
66
 
        memcpy(p + i, "x", 1);
67
 
        newsize = i + 1;
68
 
        q = p + newsize;
69
 
 
70
 
        for (; i < val->dsize; i++, s++)
71
 
                if (*s == ':') break;
72
 
        memcpy(q, s, val->dsize - i);
73
 
        newsize += val->dsize - i;
74
 
 
75
 
        free(val->dptr);
76
 
        val->dptr = p;
77
 
        val->dsize = newsize;
78
 
}
79
 
 
80
 
bool_t
81
 
ypproc_null_2_svc (void *argp UNUSED, void *result UNUSED,
82
 
                   struct svc_req *rqstp)
83
 
{
84
 
  if (debug_flag)
85
 
    {
86
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
87
 
      log_msg ("ypproc_null() [From: %s:%d]",
88
 
               inet_ntoa (rqhost->sin_addr),
89
 
               ntohs (rqhost->sin_port));
90
 
    }
91
 
 
92
 
  if (is_valid (rqstp, NULL, NULL) < 1)
93
 
    return FALSE;
94
 
 
95
 
  return TRUE;
96
 
}
97
 
 
98
 
 
99
 
bool_t
100
 
ypproc_domain_2_svc (domainname *argp, bool_t *result,
101
 
                     struct svc_req *rqstp)
102
 
{
103
 
  if (debug_flag)
104
 
    {
105
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
106
 
      log_msg ("ypproc_domain(\"%s\") [From: %s:%d]",
107
 
               *argp, inet_ntoa (rqhost->sin_addr),
108
 
               ntohs (rqhost->sin_port));
109
 
    }
110
 
 
111
 
  switch (is_valid (rqstp, NULL, *argp))
112
 
    {
113
 
    case -3:
114
 
    case -2: /* -2 should not happen */
115
 
      *result = FALSE;
116
 
      break;
117
 
    case -1:
118
 
      if (debug_flag)
119
 
        log_msg ("\t-> Ignored (not a valid source host)");
120
 
      *result = FALSE;
121
 
      break;
122
 
    case 0:
123
 
      if (debug_flag)
124
 
        log_msg ("\t-> Ignored (forbidden by securenets)");
125
 
      *result = FALSE;
126
 
      break;
127
 
    default:
128
 
      *result = TRUE;
129
 
    }
130
 
 
131
 
  if (debug_flag)
132
 
    log_msg ("\t-> %s.",
133
 
             (*result == TRUE ? "Ok" : "Not served by us"));
134
 
 
135
 
  return TRUE;
136
 
}
137
 
 
138
 
 
139
 
bool_t
140
 
ypproc_domain_nonack_2_svc (domainname *argp, bool_t *result,
141
 
                            struct svc_req *rqstp)
142
 
{
143
 
  if (debug_flag)
144
 
    {
145
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
146
 
      log_msg ("ypproc_domain_nonack(\"%s\") [From: %s:%d]",
147
 
               *argp, inet_ntoa (rqhost->sin_addr),
148
 
               ntohs (rqhost->sin_port));
149
 
    }
150
 
 
151
 
  switch (is_valid (rqstp, NULL, *argp))
152
 
    {
153
 
    case -3:
154
 
      if (debug_flag)
155
 
        log_msg ("\t-> Ignored (not a valid domain)");
156
 
      /* Bail out and don't return any RPC value */
157
 
      return FALSE;
158
 
    case -2: /* Should not happen */
159
 
      log_msg ("Map name not valid, this cannot happen???");
160
 
      return FALSE;
161
 
    case -1:
162
 
      if (debug_flag)
163
 
        log_msg ("\t-> Ignored (not a valid source host)");
164
 
      return FALSE;
165
 
    case 0:
166
 
      if (debug_flag)
167
 
        log_msg ("\t-> Ignored (forbidden by securenets)");
168
 
      return FALSE;
169
 
    default:
170
 
      *result = TRUE;
171
 
      break;
172
 
    }
173
 
 
174
 
  if (debug_flag)
175
 
    log_msg ("\t-> OK.");
176
 
 
177
 
  return TRUE;
178
 
}
179
 
 
180
 
 
181
 
bool_t
182
 
ypproc_match_2_svc (ypreq_key *argp, ypresp_val *result,
183
 
                    struct svc_req *rqstp)
184
 
{
185
 
  int valid;
186
 
 
187
 
  if (debug_flag)
188
 
    {
189
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
190
 
 
191
 
      log_msg ("ypproc_match(): [From: %s:%d]",
192
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
193
 
 
194
 
      log_msg ("\t\tdomainname = \"%s\"", argp->domain);
195
 
      log_msg ("\t\tmapname = \"%s\"", argp->map);
196
 
      log_msg ("\t\tkeydat = \"%.*s\"", (int) argp->key.keydat_len,
197
 
               argp->key.keydat_val);
198
 
    }
199
 
 
200
 
  memset (result, 0, sizeof (ypresp_val));
201
 
 
202
 
  valid = is_valid (rqstp, argp->map, argp->domain);
203
 
  if (valid < 1)
204
 
    {
205
 
      switch (valid)
206
 
        {
207
 
        case -1:
208
 
          if (debug_flag)
209
 
            log_msg ("\t-> Ignored (not a valid source host)");
210
 
          result->stat = YP_NOMAP;
211
 
          break;
212
 
        case -2:
213
 
          if (debug_flag)
214
 
            log_msg ("\t-> Ignored (not a valid map name)");
215
 
          result->stat = YP_BADARGS;
216
 
          break;
217
 
        case -3:
218
 
          if (debug_flag)
219
 
            log_msg ("\t-> Ignored (not a valid domain)");
220
 
          result->stat = YP_NODOM;
221
 
          break;
222
 
        case 0:
223
 
          if (debug_flag)
224
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
225
 
          result->stat = YP_NOMAP;
226
 
          break;
227
 
        }
228
 
      return TRUE;
229
 
    }
230
 
 
231
 
  if (argp->key.keydat_len == 0 || argp->key.keydat_val[0] == '\0')
232
 
    result->stat = YP_BADARGS;
233
 
  else
234
 
    {
235
 
      datum rdat, qdat;
236
 
 
237
 
      DB_FILE dbp = ypdb_open (argp->domain, argp->map);
238
 
      if (dbp == NULL)
239
 
        result->stat = YP_NOMAP;
240
 
      else
241
 
        {
242
 
          qdat.dsize = argp->key.keydat_len;
243
 
          qdat.dptr = argp->key.keydat_val;
244
 
 
245
 
          rdat = ypdb_fetch (dbp, qdat);
246
 
          mangle(&rdat, valid);
247
 
 
248
 
          if (rdat.dptr != NULL)
249
 
            {
250
 
              result->stat = YP_TRUE;
251
 
              result->val.valdat_len = rdat.dsize;
252
 
              result->val.valdat_val = rdat.dptr;
253
 
            }
254
 
          else
255
 
            result->stat = YP_NOKEY;
256
 
 
257
 
          ypdb_close (dbp);
258
 
        }
259
 
    }
260
 
 
261
 
  if (debug_flag)
262
 
    {
263
 
      if (result->stat == YP_TRUE)
264
 
        log_msg ("\t-> Value = \"%.*s\"",
265
 
                 (int) result->val.valdat_len, result->val.valdat_val);
266
 
      else
267
 
        log_msg ("\t-> Error #%d", result->stat);
268
 
    }
269
 
 
270
 
  return TRUE;
271
 
}
272
 
 
273
 
 
274
 
bool_t
275
 
ypproc_first_2_svc (ypreq_nokey *argp, ypresp_key_val *result,
276
 
                    struct svc_req *rqstp)
277
 
{
278
 
  DB_FILE dbp;
279
 
  int valid;
280
 
 
281
 
  if (debug_flag)
282
 
    {
283
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
284
 
      log_msg ("ypproc_first(): [From: %s:%d]",
285
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
286
 
 
287
 
      log_msg ("\tdomainname = \"%s\"", argp->domain);
288
 
      log_msg ("\tmapname = \"%s\"", argp->map);
289
 
    }
290
 
 
291
 
  memset (result, 0, sizeof (ypresp_key_val));
292
 
 
293
 
  valid = is_valid (rqstp, argp->map, argp->domain);
294
 
  if (valid < 1)
295
 
    {
296
 
      switch (valid)
297
 
        {
298
 
        case -1:
299
 
          if (debug_flag)
300
 
            log_msg ("\t-> Ignored (not a valid source host)");
301
 
          result->stat = YP_NOMAP;
302
 
          break;
303
 
        case -2:
304
 
          if (debug_flag)
305
 
            log_msg ("\t-> Ignored (not a valid map name)");
306
 
          result->stat = YP_BADARGS;
307
 
          break;
308
 
        case -3:
309
 
          if (debug_flag)
310
 
            log_msg ("\t-> Ignored (not a valid domain)");
311
 
          result->stat = YP_NODOM;
312
 
          break;
313
 
        case 0:
314
 
          if (debug_flag)
315
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
316
 
          result->stat = YP_NOMAP;
317
 
          break;
318
 
        }
319
 
      return TRUE;
320
 
    }
321
 
 
322
 
 
323
 
  dbp = ypdb_open (argp->domain, argp->map);
324
 
  if (dbp == NULL)
325
 
    result->stat = YP_NOMAP;
326
 
  else
327
 
    {
328
 
      datum dkey = ypdb_firstkey (dbp);
329
 
 
330
 
      while (dkey.dptr != NULL && dkey.dptr[0] == 'Y' &&
331
 
             dkey.dptr[1] == 'P' && dkey.dptr[2] == '_')
332
 
        {
333
 
#if defined(HAVE_NDBM)
334
 
          /* This is much more faster then ypdb_nextkey, but
335
 
             it is terrible to port to other databases */
336
 
          dkey = dbm_nextkey (dbp);
337
 
#else
338
 
          datum tkey = dkey;
339
 
          dkey = ypdb_nextkey (dbp, tkey);
340
 
          ypdb_free (tkey.dptr);
341
 
#endif
342
 
        }
343
 
 
344
 
      if (dkey.dptr != NULL)
345
 
        {
346
 
          datum dval = ypdb_fetch (dbp, dkey);
347
 
          mangle(&dval, valid);
348
 
          result->stat = YP_TRUE;
349
 
 
350
 
          result->key.keydat_len = dkey.dsize;
351
 
          result->key.keydat_val = dkey.dptr;
352
 
 
353
 
          result->val.valdat_len = dval.dsize;
354
 
          result->val.valdat_val = dval.dptr;
355
 
        }
356
 
      else
357
 
        result->stat = YP_NOKEY;
358
 
      ypdb_close (dbp);
359
 
    }
360
 
 
361
 
  if (debug_flag)
362
 
    {
363
 
      if (result->stat == YP_TRUE)
364
 
        log_msg ("\t-> Key = \"%.*s\", Value = \"%.*s\"",
365
 
                 (int) result->key.keydat_len, result->key.keydat_val,
366
 
                 (int) result->val.valdat_len, result->val.valdat_val);
367
 
      else if (result->stat == YP_NOMORE)
368
 
        log_msg ("\t-> No more entry's");
369
 
      else
370
 
        log_msg ("\t-> Error #%d", result->stat);
371
 
    }
372
 
  return TRUE;
373
 
}
374
 
 
375
 
 
376
 
bool_t
377
 
ypproc_next_2_svc (ypreq_key *argp, ypresp_key_val *result,
378
 
                   struct svc_req *rqstp)
379
 
{
380
 
  DB_FILE dbp;
381
 
  int valid;
382
 
 
383
 
  if (debug_flag)
384
 
    {
385
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
386
 
 
387
 
      log_msg ("ypproc_next(): [From: %s:%d]",
388
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
389
 
 
390
 
      log_msg ("\tdomainname = \"%s\"", argp->domain);
391
 
      log_msg ("\tmapname = \"%s\"", argp->map);
392
 
      log_msg ("\tkeydat = \"%.*s\"",
393
 
              (int) argp->key.keydat_len,
394
 
              argp->key.keydat_val);
395
 
    }
396
 
 
397
 
  memset (result, 0, sizeof (ypresp_key_val));
398
 
 
399
 
  valid = is_valid (rqstp, argp->map, argp->domain);
400
 
  if (valid < 1)
401
 
    {
402
 
      switch (valid)
403
 
        {
404
 
        case -1:
405
 
          if (debug_flag)
406
 
            log_msg ("\t-> Ignored (not a valid source host)");
407
 
          result->stat = YP_NOMAP;
408
 
          break;
409
 
        case -2:
410
 
          if (debug_flag)
411
 
            log_msg ("\t-> Ignored (not a valid map name)");
412
 
          result->stat = YP_BADARGS;
413
 
          break;
414
 
        case -3:
415
 
          if (debug_flag)
416
 
            log_msg ("\t-> Ignored (not a valid domain)");
417
 
          result->stat = YP_NODOM;
418
 
          break;
419
 
        case 0:
420
 
          if (debug_flag)
421
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
422
 
          result->stat = YP_NOMAP;
423
 
          break;
424
 
        }
425
 
      return TRUE;
426
 
    }
427
 
 
428
 
  dbp = ypdb_open (argp->domain, argp->map);
429
 
  if (dbp == NULL)
430
 
    result->stat = YP_NOMAP;
431
 
  else
432
 
    {
433
 
      datum oldkey, dkey;
434
 
 
435
 
      oldkey.dsize = argp->key.keydat_len;
436
 
      oldkey.dptr = strndup (argp->key.keydat_val, oldkey.dsize);
437
 
 
438
 
      dkey = ypdb_nextkey (dbp, oldkey);
439
 
      while (dkey.dptr != NULL && dkey.dptr[0] == 'Y' &&
440
 
             dkey.dptr[1] == 'P' && dkey.dptr[2] == '_')
441
 
        {
442
 
          free (oldkey.dptr);
443
 
          oldkey.dsize = dkey.dsize;
444
 
          oldkey.dptr = strndup (dkey.dptr, dkey.dsize);
445
 
          ypdb_free (dkey.dptr);
446
 
          dkey = ypdb_nextkey (dbp, oldkey);
447
 
        }
448
 
 
449
 
      free (oldkey.dptr);
450
 
 
451
 
      if (dkey.dptr == NULL)
452
 
        result->stat = YP_NOMORE;
453
 
      else
454
 
        {
455
 
          datum dval = ypdb_fetch (dbp, dkey);
456
 
          mangle(&dval, valid);
457
 
 
458
 
          result->stat = YP_TRUE;
459
 
          result->key.keydat_len = dkey.dsize;
460
 
          result->key.keydat_val = dkey.dptr;
461
 
 
462
 
          result->val.valdat_len = dval.dsize;
463
 
          result->val.valdat_val = dval.dptr;
464
 
        }
465
 
      ypdb_close (dbp);
466
 
    }
467
 
 
468
 
  if (debug_flag)
469
 
    {
470
 
      if (result->stat == YP_TRUE)
471
 
        log_msg ("\t-> Key = \"%.*s\", Value = \"%.*s\"",
472
 
                 (int) result->key.keydat_len, result->key.keydat_val,
473
 
                 (int) result->val.valdat_len, result->val.valdat_val);
474
 
      else if (result->stat == YP_NOMORE)
475
 
        log_msg ("\t-> No more entry's");
476
 
      else
477
 
        log_msg ("\t-> Error #%d", result->stat);
478
 
    }
479
 
 
480
 
  return TRUE;
481
 
}
482
 
 
483
 
bool_t
484
 
ypproc_xfr_2_svc (ypreq_xfr *argp, ypresp_xfr *result,
485
 
                  struct svc_req *rqstp)
486
 
{
487
 
  DB_FILE dbp;
488
 
  const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
489
 
  int valid;
490
 
 
491
 
  if (debug_flag)
492
 
    {
493
 
      log_msg ("ypproc_xfr_2_svc(): [From: %s:%d]\n\tmap_parms:",
494
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
495
 
 
496
 
      log_msg ("\t\tdomain   = \"%s\"", argp->map_parms.domain);
497
 
      log_msg ("\t\tmap      = \"%s\"", argp->map_parms.map);
498
 
      log_msg ("\t\tordernum = %u", argp->map_parms.ordernum);
499
 
      log_msg ("\t\tpeer     = \"%s\"", argp->map_parms.peer);
500
 
      log_msg ("\t\ttransid  = %u", argp->transid);
501
 
      log_msg ("\t\tprog     = %u", argp->prog);
502
 
      log_msg ("\t\tport     = %u", argp->port);
503
 
    }
504
 
 
505
 
  memset (result, 0, sizeof (ypresp_xfr));
506
 
  result->transid = argp->transid;
507
 
 
508
 
  valid = is_valid (rqstp, argp->map_parms.map, argp->map_parms.domain);
509
 
  if (valid < 1)
510
 
    {
511
 
      switch (valid)
512
 
        {
513
 
        case 0:
514
 
          if (debug_flag)
515
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
516
 
          else
517
 
            log_msg ("refuse to transfer map from %s",
518
 
                     inet_ntoa (rqhost->sin_addr));
519
 
          result->xfrstat = YPXFR_REFUSED;
520
 
          break;
521
 
        case -1:
522
 
          if (debug_flag)
523
 
            log_msg ("\t-> Ignored (not a valid source host)");
524
 
          else
525
 
            log_msg ("refuse to transfer map from %s",
526
 
                     inet_ntoa (rqhost->sin_addr));
527
 
          result->xfrstat = YPXFR_REFUSED;
528
 
          break;
529
 
        case -2:
530
 
          if (debug_flag)
531
 
            log_msg ("\t-> Ignored (map contains \"/\"!)");
532
 
          else
533
 
            log_msg ("refuse to transfer map from %s, no valid mapname",
534
 
                     inet_ntoa (rqhost->sin_addr));
535
 
          result->xfrstat = YPXFR_REFUSED;
536
 
          break;
537
 
        case -3:
538
 
          if (debug_flag)
539
 
            log_msg ("\t-> Ignored (not a valid domain)");
540
 
          else
541
 
            log_msg ("refuse to transfer map from %s, no valid domain",
542
 
                     inet_ntoa (rqhost->sin_addr));
543
 
          result->xfrstat = YPXFR_NODOM;
544
 
          break;
545
 
        }
546
 
      return TRUE;
547
 
    }
548
 
 
549
 
  if (xfr_check_port)
550
 
    {
551
 
      if(ntohs(rqhost->sin_port) >= IPPORT_RESERVED)
552
 
        {
553
 
          if (debug_flag)
554
 
            log_msg ("\t-> Ignored (no reserved port!)");
555
 
          else
556
 
            log_msg ("refuse to transfer %s from %s, no valid port",
557
 
                     argp->map_parms.map, inet_ntoa (rqhost->sin_addr));
558
 
 
559
 
          result->xfrstat = YPXFR_REFUSED;
560
 
          return TRUE;
561
 
        }
562
 
    }
563
 
 
564
 
  /* If we have the map, check, if the master name is the same as in
565
 
     the ypreq_xfr struct. If we doesn't have the map, refuse. */
566
 
  dbp = ypdb_open(argp->map_parms.domain, argp->map_parms.map);
567
 
  if (dbp != NULL)
568
 
    {
569
 
      datum key;
570
 
 
571
 
      key.dsize = sizeof ("YP_MASTER_NAME") - 1;
572
 
      key.dptr = "YP_MASTER_NAME";
573
 
 
574
 
      if(ypdb_exists (dbp, key))
575
 
        {
576
 
          datum val = ypdb_fetch (dbp, key);
577
 
          mangle(&val, valid);
578
 
 
579
 
          if ((size_t)val.dsize != strlen (argp->map_parms.peer) ||
580
 
              strncmp (val.dptr, argp->map_parms.peer, val.dsize) != 0)
581
 
            {
582
 
              char *buf = alloca (val.dsize + 1);
583
 
 
584
 
              strncpy (buf, val.dptr, val.dsize);
585
 
              buf[val.dsize] = '\0';
586
 
 
587
 
              if (debug_flag)
588
 
                log_msg ("\t->Ignored (%s is not the master, master is %s)",
589
 
                         argp->map_parms.peer, buf);
590
 
              else
591
 
                log_msg ("refuse to transfer %s from %s, master is %s)",
592
 
                         argp->map_parms.map, inet_ntoa (rqhost->sin_addr),
593
 
                         buf);
594
 
 
595
 
              ypdb_close (dbp);
596
 
              result->xfrstat = YPXFR_NODOM;
597
 
              return TRUE;
598
 
            }
599
 
        }
600
 
      else
601
 
        {
602
 
          /* If we do not have a YP_MASTER_NAME key, we don't have a
603
 
             master/slave NIS system */
604
 
          if (debug_flag)
605
 
            log_msg ("\t->Ignored (no YP_MASTER_NAME key in local map)");
606
 
 
607
 
          ypdb_close (dbp);
608
 
          result->xfrstat = YPXFR_REFUSED;
609
 
          return TRUE;
610
 
        }
611
 
      ypdb_close (dbp);
612
 
    }
613
 
  else if (trusted_master != NULL)
614
 
    {
615
 
      /* We have a new map. We only allow new maps from a NIS master
616
 
         we trust (which means, the admin told us this master is ok. */
617
 
      if (strcasecmp (trusted_master, argp->map_parms.peer) != 0)
618
 
        {
619
 
          if (debug_flag)
620
 
            log_msg ("\t->Ignored (%s is not a trusted master!)",
621
 
                     argp->map_parms.peer);
622
 
          else
623
 
            log_msg ("refuse to transfer %s from %s, no trusted master",
624
 
                     argp->map_parms.map, inet_ntoa (rqhost->sin_addr));
625
 
 
626
 
          ypdb_close (dbp);
627
 
          result->xfrstat = YPXFR_NODOM;
628
 
          return TRUE;
629
 
        }
630
 
    }
631
 
  /* If you wish to allow the transfer of new maps, change the next
632
 
     #if 1 statement to #if 0 */
633
 
#if 1
634
 
  else
635
 
    {
636
 
      /* We doesn't have the map, refuse the transfer */
637
 
      if (debug_flag)
638
 
        log_msg ("\t->Ignored (I don't have this map)");
639
 
      else
640
 
        log_msg ("refuse to transfer %s from %s, map doesn't exist",
641
 
                 argp->map_parms.map, inet_ntoa (rqhost->sin_addr));
642
 
 
643
 
      result->xfrstat = YPXFR_REFUSED;
644
 
      return TRUE;
645
 
    }
646
 
#endif
647
 
 
648
 
  switch (fork ())
649
 
    {
650
 
    case 0:
651
 
      {
652
 
        char *ypxfr_command = alloca (sizeof (YPBINDIR) + 8);
653
 
        char g[30], t[30], p[30];
654
 
        int i;
655
 
 
656
 
        umask (0);
657
 
        i = open ("/dev/null", O_RDWR);
658
 
        dup (i);
659
 
        dup (i);
660
 
 
661
 
        sprintf (ypxfr_command, "%s/ypxfr", YPBINDIR);
662
 
        snprintf (t, sizeof (t), "%u", argp->transid);
663
 
        snprintf (g, sizeof (g), "%u", argp->prog);
664
 
        snprintf (p, sizeof (p), "%u", argp->port);
665
 
        if (debug_flag)
666
 
          execl (ypxfr_command, "ypxfr", "--debug", "-d",
667
 
                 argp->map_parms.domain, "-h", argp->map_parms.peer,
668
 
                 "-C", t, g,
669
 
                 inet_ntoa (rqhost->sin_addr), p, argp->map_parms.map, NULL);
670
 
        else
671
 
          execl (ypxfr_command, "ypxfr", "-d", argp->map_parms.domain, "-h",
672
 
                 argp->map_parms.peer, "-C", t, g,
673
 
                 inet_ntoa (rqhost->sin_addr), p, argp->map_parms.map, NULL);
674
 
 
675
 
        log_msg ("ypxfr execl(): %s", strerror (errno));
676
 
        exit (0);
677
 
      }
678
 
    case -1:
679
 
      log_msg ("Cannot fork: %s", strerror (errno));
680
 
      result->xfrstat = YPXFR_XFRERR;
681
 
      break;
682
 
   default:
683
 
      result->xfrstat = YPXFR_SUCC;
684
 
      break;
685
 
    }
686
 
 
687
 
  return TRUE;
688
 
}
689
 
 
690
 
bool_t ypproc_clear_2_svc (void *argp UNUSED, void *result UNUSED,
691
 
                           struct svc_req *rqstp)
692
 
{
693
 
  if (debug_flag)
694
 
    {
695
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
696
 
      log_msg ("ypproc_clear_2_svc() [From: %s:%d]",
697
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
698
 
    }
699
 
 
700
 
  if (is_valid (rqstp, NULL, NULL) < 1)
701
 
    {
702
 
      if (debug_flag)
703
 
        log_msg ("\t-> Ignored (not a valid source host)");
704
 
    }
705
 
  else
706
 
    ypdb_close_all ();
707
 
 
708
 
  return TRUE;
709
 
}
710
 
 
711
 
/* We need the struct for giving ypall_encode the DB_FILE handle */
712
 
typedef struct ypall_data {
713
 
  DB_FILE dbm;
714
 
  datum dkey;
715
 
  datum dval;
716
 
  int vcode;
717
 
} *ypall_data_t;
718
 
 
719
 
static int
720
 
ypall_close (void *data)
721
 
{
722
 
  if (data == NULL)
723
 
    {
724
 
      log_msg ("ypall_close() called with NULL pointer.");
725
 
      return 0;
726
 
    }
727
 
 
728
 
  ypdb_close (((ypall_data_t) data)->dbm);
729
 
  if (((ypall_data_t) data)->dkey.dptr)
730
 
    ypdb_free (((ypall_data_t) data)->dkey.dptr);
731
 
  if (((ypall_data_t) data)->dval.dptr)
732
 
    ypdb_free (((ypall_data_t) data)->dval.dptr);
733
 
  free (data);
734
 
  return 0;
735
 
}
736
 
 
737
 
static int
738
 
ypall_encode (ypresp_key_val *val, void *data)
739
 
{
740
 
  datum oldkey;
741
 
 
742
 
  oldkey.dsize = val->key.keydat_len;
743
 
  oldkey.dptr = strndup (val->key.keydat_val, oldkey.dsize);
744
 
  ypdb_free (((ypall_data_t) data)->dkey.dptr);
745
 
  ((ypall_data_t) data)->dkey.dptr = NULL;
746
 
  ypdb_free (((ypall_data_t) data)->dval.dptr);
747
 
  ((ypall_data_t) data)->dval.dptr = NULL;
748
 
 
749
 
  ((ypall_data_t) data)->dkey = ypdb_nextkey (((ypall_data_t) data)->dbm,
750
 
                                              oldkey);
751
 
 
752
 
  while (((ypall_data_t) data)->dkey.dptr != NULL &&
753
 
         ((ypall_data_t) data)->dkey.dptr[0] == 'Y' &&
754
 
         ((ypall_data_t) data)->dkey.dptr[1] == 'P' &&
755
 
         ((ypall_data_t) data)->dkey.dptr[2] == '_')
756
 
    {
757
 
      free (oldkey.dptr);
758
 
      oldkey.dsize = ((ypall_data_t) data)->dkey.dsize;
759
 
      oldkey.dptr = strndup (((ypall_data_t) data)->dkey.dptr,
760
 
                             ((ypall_data_t) data)->dkey.dsize);
761
 
      ypdb_free (((ypall_data_t) data)->dkey.dptr);
762
 
      ((ypall_data_t) data)->dkey.dptr = NULL;
763
 
 
764
 
      ((ypall_data_t) data)->dkey = ypdb_nextkey (((ypall_data_t) data)->dbm,
765
 
                                                  oldkey);
766
 
    }
767
 
 
768
 
  free (oldkey.dptr);
769
 
 
770
 
  if (((ypall_data_t) data)->dkey.dptr == NULL)
771
 
    val->stat = YP_NOMORE;
772
 
  else
773
 
    {
774
 
      ((ypall_data_t) data)->dval =
775
 
        ypdb_fetch (((ypall_data_t) data)->dbm, ((ypall_data_t) data)->dkey);
776
 
      mangle(&(((ypall_data_t) data)->dval), ((ypall_data_t) data)->vcode);
777
 
 
778
 
      val->stat = YP_TRUE;
779
 
 
780
 
      val->key.keydat_val = ((ypall_data_t) data)->dkey.dptr;
781
 
      val->key.keydat_len = ((ypall_data_t) data)->dkey.dsize;
782
 
 
783
 
      val->val.valdat_val = ((ypall_data_t) data)->dval.dptr;
784
 
      val->val.valdat_len = ((ypall_data_t) data)->dval.dsize;
785
 
    }
786
 
  return val->stat;
787
 
}
788
 
 
789
 
extern xdr_ypall_cb_t xdr_ypall_cb;
790
 
 
791
 
bool_t
792
 
ypproc_all_2_svc (ypreq_nokey *argp, ypresp_all *result, struct svc_req *rqstp)
793
 
{
794
 
  ypall_data_t data;
795
 
  int valid;
796
 
 
797
 
  if (debug_flag)
798
 
    {
799
 
      const struct sockaddr_in *rqhost;
800
 
 
801
 
      rqhost = svc_getcaller (rqstp->rq_xprt);
802
 
      log_msg ("ypproc_all_2_svc(): [From: %s:%d]",
803
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
804
 
 
805
 
      log_msg ("\t\tdomain = \"%s\"", argp->domain);
806
 
      log_msg ("\t\tmap = \"%s\"", argp->map);
807
 
    }
808
 
 
809
 
  memset (result, 0, sizeof (ypresp_all));
810
 
  xdr_ypall_cb.u.encode = NULL;
811
 
  xdr_ypall_cb.u.close = NULL;
812
 
  xdr_ypall_cb.data = NULL;
813
 
 
814
 
  /* Set this to TRUE so that the client will be forced to read
815
 
     at least one record from us. This could be the error code.  */
816
 
  result->more = TRUE;
817
 
 
818
 
  valid = is_valid (rqstp, argp->map, argp->domain);
819
 
  if (valid < 1)
820
 
    {
821
 
      switch (valid)
822
 
        {
823
 
        case 0:
824
 
          if (debug_flag)
825
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
826
 
          result->ypresp_all_u.val.stat = YP_NOMAP;
827
 
          break;
828
 
        case -1:
829
 
          if (debug_flag)
830
 
            log_msg ("\t-> Ignored (not a valid source host)");
831
 
          result->ypresp_all_u.val.stat = YP_NOMAP;
832
 
          break;
833
 
        case -2:
834
 
          if (debug_flag)
835
 
            log_msg ("\t-> Ignored (not a valid map name)");
836
 
          result->ypresp_all_u.val.stat = YP_BADARGS;
837
 
          break;
838
 
        case -3:
839
 
          if (debug_flag)
840
 
            log_msg ("\t-> Ignored (not a valid domain)");
841
 
          result->ypresp_all_u.val.stat = YP_NODOM;
842
 
        }
843
 
      return TRUE;
844
 
    }
845
 
 
846
 
  switch (fork ())
847
 
    {
848
 
    case 0: /* child */
849
 
#ifdef DEBUG
850
 
      log_msg ("ypserv has forked for ypproc_all(): pid=%i", getpid ());
851
 
#endif
852
 
      break;
853
 
    case -1:  /* parent, error */
854
 
      log_msg ("WARNING(ypproc_all_2_svc): cannot fork: %s",
855
 
               strerror (errno));
856
 
      result->ypresp_all_u.val.stat = YP_YPERR;
857
 
      return TRUE;
858
 
    default: /* parent, default */
859
 
      return FALSE;
860
 
      break;
861
 
    }
862
 
 
863
 
  /* We are now in the child part. Don't let the child ypserv share
864
 
     DB handles with the parent process.  */
865
 
  ypdb_close_all();
866
 
 
867
 
  if ((data = calloc (1, sizeof (struct ypall_data))) == NULL)
868
 
    {
869
 
      log_msg ("ERROR: could not allocate enough memory! [%s|%d]",
870
 
               __FILE__, __LINE__);
871
 
      result->ypresp_all_u.val.stat = YP_YPERR;
872
 
      goto out;
873
 
    }
874
 
 
875
 
  data->dbm = ypdb_open (argp->domain, argp->map);
876
 
 
877
 
  if (data->dbm == NULL)
878
 
    result->ypresp_all_u.val.stat = YP_NOMAP;
879
 
  else
880
 
    {
881
 
      data->dkey = ypdb_firstkey (data->dbm);
882
 
 
883
 
      while (data->dkey.dptr != NULL && data->dkey.dptr[0] == 'Y'
884
 
             && data->dkey.dptr[1] == 'P' && data->dkey.dptr[2] == '_')
885
 
        {
886
 
          datum tkey = data->dkey;
887
 
          data->dkey = ypdb_nextkey (data->dbm, tkey);
888
 
          ypdb_free (tkey.dptr);
889
 
        }
890
 
 
891
 
      if (data->dkey.dptr != NULL)
892
 
        {
893
 
          data->dval = ypdb_fetch (data->dbm, data->dkey);
894
 
          mangle(&(data->dval), valid);
895
 
 
896
 
          result->ypresp_all_u.val.stat = YP_TRUE;
897
 
 
898
 
          result->ypresp_all_u.val.key.keydat_len = data->dkey.dsize;
899
 
          result->ypresp_all_u.val.key.keydat_val = data->dkey.dptr;
900
 
 
901
 
          result->ypresp_all_u.val.val.valdat_len = data->dval.dsize;
902
 
          result->ypresp_all_u.val.val.valdat_val = data->dval.dptr;
903
 
 
904
 
          data->vcode = valid;
905
 
 
906
 
          xdr_ypall_cb.u.encode = ypall_encode;
907
 
          xdr_ypall_cb.u.close = ypall_close;
908
 
          xdr_ypall_cb.data = (void *) data;
909
 
 
910
 
          if (debug_flag)
911
 
            log_msg ("\t -> First value returned.");
912
 
 
913
 
          if (result->ypresp_all_u.val.stat == YP_TRUE)
914
 
            goto out; /* We return to commit the data.
915
 
                         This also means, we don't give
916
 
                         data free here */
917
 
        }
918
 
      else
919
 
        result->ypresp_all_u.val.stat = YP_NOMORE;
920
 
 
921
 
      ypdb_close (data->dbm);
922
 
    }
923
 
 
924
 
  free (data);
925
 
 
926
 
  if (debug_flag)
927
 
    log_msg ("\t -> Exit from ypproc_all without sending data.");
928
 
 
929
 
 out:
930
 
  if (!svc_sendreply (rqstp->rq_xprt, (xdrproc_t) xdr_ypresp_all,
931
 
                      (caddr_t) result))
932
 
    svcerr_systemerr (rqstp->rq_xprt);
933
 
  /* Note: no need to free args; we're exiting.  */
934
 
  _exit(0);
935
 
}
936
 
 
937
 
bool_t
938
 
ypproc_master_2_svc (ypreq_nokey *argp, ypresp_master *result,
939
 
                     struct svc_req *rqstp)
940
 
{
941
 
  DB_FILE dbp;
942
 
  int valid;
943
 
 
944
 
  if (debug_flag)
945
 
    {
946
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
947
 
      log_msg ("ypproc_master_2_svc(): [From: %s:%d]",
948
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
949
 
 
950
 
      log_msg ("\t\tdomain = \"%s\"", argp->domain);
951
 
      log_msg ("\t\tmap = \"%s\"", argp->map);
952
 
    }
953
 
 
954
 
  memset (result, 0, sizeof (ypresp_master));
955
 
 
956
 
  valid = is_valid (rqstp, argp->map, argp->domain);
957
 
  if (valid < 1)
958
 
    {
959
 
      switch (valid)
960
 
        {
961
 
        case -1:
962
 
          if (debug_flag)
963
 
            log_msg ("\t-> Ignored (not a valid source host)");
964
 
          result->stat = YP_NOMAP;
965
 
          break;
966
 
        case -2:
967
 
          if (debug_flag)
968
 
            log_msg ("\t-> Ignored (not a valid map name)");
969
 
          result->stat = YP_BADARGS;
970
 
          break;
971
 
        case -3:
972
 
          if (debug_flag)
973
 
            log_msg ("\t-> Ignored (not a domain)");
974
 
          result->stat = YP_NODOM;
975
 
          break;
976
 
        case 0:
977
 
          if (debug_flag)
978
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
979
 
          result->stat = YP_NOMAP;
980
 
          break;
981
 
        }
982
 
      result->peer = strdup ("");
983
 
      return TRUE;
984
 
    }
985
 
 
986
 
  dbp = ypdb_open (argp->domain, argp->map);
987
 
  if (dbp == NULL)
988
 
    result->stat = YP_NOMAP;
989
 
  else
990
 
    {
991
 
      datum key, val;
992
 
 
993
 
      key.dsize = sizeof ("YP_MASTER_NAME") - 1;
994
 
      key.dptr = "YP_MASTER_NAME";
995
 
 
996
 
      val = ypdb_fetch (dbp, key);
997
 
      mangle(&val, valid);
998
 
 
999
 
      if (val.dptr == NULL)
1000
 
        {
1001
 
          /* No YP_MASTER_NAME record in map? There is someting wrong */
1002
 
          result->stat = YP_BADDB;
1003
 
        }
1004
 
      else
1005
 
        {
1006
 
          int i;
1007
 
          char *hostbuf = alloca (val.dsize + 1);
1008
 
 
1009
 
          /* put the eof string mark at the end of the string */
1010
 
          for (i = 0; i < val.dsize; ++i)
1011
 
            hostbuf[i] = val.dptr[i];
1012
 
          hostbuf[val.dsize] = '\0';
1013
 
          ypdb_free (val.dptr);
1014
 
 
1015
 
          if ((result->peer = strdup (hostbuf)) == NULL)
1016
 
            result->stat = YP_YPERR;
1017
 
          else
1018
 
            result->stat = YP_TRUE;
1019
 
        }
1020
 
 
1021
 
      ypdb_close (dbp);
1022
 
    }
1023
 
 
1024
 
  if (result->peer == NULL)
1025
 
    result->peer = strdup ("");
1026
 
 
1027
 
  if (debug_flag)
1028
 
    log_msg ("\t-> Peer = \"%s\"", result->peer);
1029
 
 
1030
 
  return TRUE;
1031
 
}
1032
 
 
1033
 
 
1034
 
/* Get the DateTimeModified value for a certain map database */
1035
 
static inline unsigned long
1036
 
get_dtm (const char *domain, const char *map)
1037
 
{
1038
 
  struct stat sbuf;
1039
 
  char *buf = alloca (strlen (domain) + strlen (map) + 3);
1040
 
  char *cp;
1041
 
 
1042
 
  cp = stpcpy (buf, domain);
1043
 
  *cp++ = '/';
1044
 
  strcpy (cp, map);
1045
 
 
1046
 
  if (stat (buf, &sbuf) < 0)
1047
 
    return time (NULL); /* We set it to the current time. */
1048
 
  else
1049
 
    return (unsigned long) sbuf.st_mtime;
1050
 
}
1051
 
 
1052
 
bool_t
1053
 
ypproc_order_2_svc (ypreq_nokey *argp, ypresp_order *result,
1054
 
                    struct svc_req *rqstp)
1055
 
{
1056
 
  DB_FILE dbp;
1057
 
  int valid;
1058
 
 
1059
 
  if (debug_flag)
1060
 
    {
1061
 
      const struct sockaddr_in *rqhost;
1062
 
 
1063
 
      rqhost = svc_getcaller (rqstp->rq_xprt);
1064
 
 
1065
 
      log_msg ("ypproc_order_2_svc(): [From: %s:%d]",
1066
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
1067
 
 
1068
 
      log_msg ("\t\tdomain = \"%s\"", argp->domain);
1069
 
      log_msg ("\t\tmap = \"%s\"", argp->map);
1070
 
    }
1071
 
 
1072
 
  memset (result, 0, sizeof (ypresp_order));
1073
 
 
1074
 
  valid = is_valid (rqstp, argp->map, argp->domain);
1075
 
  if (valid < 1)
1076
 
    {
1077
 
      switch (valid)
1078
 
        {
1079
 
        case -1:
1080
 
          if (debug_flag)
1081
 
            log_msg ("\t-> Ignored (not a valid source host)");
1082
 
          result->stat = YP_NOMAP;
1083
 
          break;
1084
 
        case -2:
1085
 
          if (debug_flag)
1086
 
            log_msg ("\t-> Ignored (not a valid map name)");
1087
 
          result->stat = YP_BADARGS;
1088
 
          break;
1089
 
        case -3:
1090
 
          if (debug_flag)
1091
 
            log_msg ("\t-> Ignored (not a valid domain)");
1092
 
          result->stat = YP_NODOM;
1093
 
          break;
1094
 
        case 0:
1095
 
          if (debug_flag)
1096
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
1097
 
          result->stat = YP_NOMAP;
1098
 
          break;
1099
 
        }
1100
 
      return TRUE;
1101
 
    }
1102
 
 
1103
 
  dbp = ypdb_open (argp->domain, argp->map);
1104
 
 
1105
 
  if (dbp == NULL)
1106
 
    result->stat = YP_NOMAP;
1107
 
  else
1108
 
    {
1109
 
      datum key, val;
1110
 
 
1111
 
      key.dsize = sizeof ("YP_LAST_MODIFIED") - 1;
1112
 
      key.dptr = "YP_LAST_MODIFIED";
1113
 
 
1114
 
      val = ypdb_fetch (dbp, key);
1115
 
      mangle(&val, valid);
1116
 
 
1117
 
      if (val.dptr == NULL)
1118
 
        {
1119
 
          /* No YP_LAST_MODIFIED record in map? Use DTM timestamp.. */
1120
 
          result->ordernum = get_dtm (argp->domain, argp->map);
1121
 
        }
1122
 
      else
1123
 
        {
1124
 
          char *buf = alloca (val.dsize + 1);
1125
 
 
1126
 
          memcpy (buf, val.dptr, val.dsize);
1127
 
          buf[val.dsize] = '\0';
1128
 
          result->ordernum = atoi (buf);
1129
 
          ypdb_free (val.dptr);
1130
 
        }
1131
 
 
1132
 
      result->stat = YP_TRUE;
1133
 
      ypdb_close (dbp);
1134
 
    }
1135
 
 
1136
 
  if (debug_flag)
1137
 
    log_msg ("-> Order # %u", result->ordernum);
1138
 
 
1139
 
  return TRUE;
1140
 
}
1141
 
 
1142
 
 
1143
 
static int
1144
 
add_maplist (ypmaplist **mlhp, char *map)
1145
 
{
1146
 
  ypmaplist *mlp;
1147
 
#if defined(HAVE_NDBM)
1148
 
#if defined(sun) || defined(__sun__)
1149
 
  int len = strlen (map);
1150
 
 
1151
 
  /* We have all maps twice: with .dir and with .pag. Ignore .pag */
1152
 
  if (len > 3 && map[len - 4] == '.' && map[len - 3] == 'p' &&
1153
 
      map[len - 2] == 'a' && map[len - 1] == 'g')
1154
 
    return 0;
1155
 
 
1156
 
  if (len > 3 && map[len - 4] == '.' && map[len - 3] == 'd' &&
1157
 
      map[len - 2] == 'i' && map[len - 1] == 'r')
1158
 
    map[len - 4] = '\0';
1159
 
#else
1160
 
  int len = strlen (map);
1161
 
 
1162
 
  if (len > 2 && map[len - 3] == '.' && map[len - 2] == 'd' &&
1163
 
      map[len - 1] == 'b')
1164
 
    map[len - 3] = '\0';
1165
 
#endif
1166
 
#endif
1167
 
 
1168
 
  if ((mlp = malloc (sizeof (*mlp))) == NULL)
1169
 
    return -1;
1170
 
 
1171
 
  if ((mlp->map = strdup (map)) == NULL)
1172
 
    {
1173
 
      free (mlp);
1174
 
      return -1;
1175
 
    }
1176
 
 
1177
 
  mlp->next = *mlhp;
1178
 
  *mlhp = mlp;
1179
 
 
1180
 
  return 0;
1181
 
}
1182
 
 
1183
 
bool_t
1184
 
ypproc_maplist_2_svc (domainname *argp, ypresp_maplist *result,
1185
 
                      struct svc_req *rqstp)
1186
 
{
1187
 
  DIR *dp;
1188
 
  int valid;
1189
 
 
1190
 
  if (debug_flag)
1191
 
    {
1192
 
      const struct sockaddr_in *rqhost = svc_getcaller (rqstp->rq_xprt);
1193
 
 
1194
 
      log_msg ("ypproc_maplist_2_svc(): [From: %s:%d]",
1195
 
               inet_ntoa (rqhost->sin_addr), ntohs (rqhost->sin_port));
1196
 
 
1197
 
      log_msg ("\t\tdomain = \"%s\"", *argp);
1198
 
    }
1199
 
 
1200
 
  memset (result, 0, sizeof (ypresp_maplist));
1201
 
 
1202
 
  valid = is_valid (rqstp, NULL, *argp);
1203
 
  if (valid < 1)
1204
 
    {
1205
 
      switch (valid)
1206
 
        {
1207
 
        case 0:
1208
 
          if (debug_flag)
1209
 
            log_msg ("\t-> Ignored (forbidden by securenets)");
1210
 
          result->stat = YP_NOMAP;
1211
 
          break;
1212
 
        case -1:
1213
 
          if (debug_flag)
1214
 
            log_msg ("\t-> Ignored (not a valid source host)");
1215
 
          result->stat = YP_NOMAP;
1216
 
          break;
1217
 
        case -2: /* should never happen */
1218
 
        case -3:
1219
 
          if (debug_flag)
1220
 
            log_msg ("\t-> Ignored (not a valid domain)");
1221
 
          result->stat = YP_NODOM;
1222
 
          break;
1223
 
        }
1224
 
      return TRUE;
1225
 
    }
1226
 
 
1227
 
  /* open domain directory */
1228
 
  dp = opendir (*argp);
1229
 
  if (dp == NULL)
1230
 
    {
1231
 
      if (debug_flag)
1232
 
        log_msg ("opendir: %s", strerror (errno));
1233
 
 
1234
 
      result->stat = YP_BADDB;
1235
 
    }
1236
 
  else
1237
 
    {
1238
 
      struct dirent *dep;
1239
 
 
1240
 
      while ((dep = readdir (dp)) != NULL)
1241
 
        {
1242
 
          /* ignore files starting with . */
1243
 
          if (dep->d_name[0] == '.')
1244
 
            continue;
1245
 
          if (add_maplist (&result->maps, dep->d_name) < 0)
1246
 
            {
1247
 
              result->stat = YP_YPERR;
1248
 
              break;
1249
 
            }
1250
 
        }
1251
 
      closedir (dp);
1252
 
      result->stat = YP_TRUE;
1253
 
    }
1254
 
 
1255
 
  if (debug_flag)
1256
 
    {
1257
 
      if (result->stat == YP_TRUE)
1258
 
        {
1259
 
          ypmaplist *p;
1260
 
 
1261
 
          p = result->maps;
1262
 
          log_msg ("-> ");
1263
 
          while (p)
1264
 
            {
1265
 
              if (p->next)
1266
 
                log_msg ("   %s,", p->map);
1267
 
              else
1268
 
                log_msg ("   %s", p->map);
1269
 
              p = p->next;
1270
 
            }
1271
 
        }
1272
 
      else
1273
 
        log_msg ("\t-> Error #%d", result->stat);
1274
 
    }
1275
 
 
1276
 
  return TRUE;
1277
 
}
1278
 
 
1279
 
int
1280
 
ypprog_2_freeresult (SVCXPRT *transp UNUSED,
1281
 
                     xdrproc_t xdr_result, caddr_t result)
1282
 
{
1283
 
  xdr_free (xdr_result, result);
1284
 
 
1285
 
  return 1;
1286
 
}