← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ypserv-2.18/makedbm/makedbm.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.18/makedbm/makedbm.c
 
1
/* Copyright (c) 1996,1997, 1998, 1999, 2000, 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
#define _GNU_SOURCE
 
19
 
 
20
#if defined(HAVE_CONFIG_H)
 
21
#include "config.h"
 
22
#endif
 
23
 
 
24
#ifdef HAVE_ALLOCA_H
 
25
#include <alloca.h>
 
26
#endif /* HAVE_ALLOCA_H */
 
27
#include <stdio.h>
 
28
#include <stdlib.h>
 
29
#include <string.h>
 
30
#include <unistd.h>
 
31
#ifdef HAVE_GETOPT_H
 
32
#include <getopt.h>
 
33
#endif /* HAVE_GETOPT_H */
 
34
#include <fcntl.h>
 
35
#include <ctype.h>
 
36
#include <netdb.h>
 
37
#include <rpc/rpc.h>
 
38
 
 
39
#include "yp.h"
 
40
#include "compat.h"
 
41
 
 
42
#if defined (__NetBSD__) || (defined(__GLIBC__) && (__GLIBC__ == 2 && __GLIBC_MINOR__ == 0))
 
43
/* <rpc/rpc.h> is missing the prototype */
 
44
int callrpc (char *host, u_long prognum, u_long versnum, u_long procnum,
 
45
             xdrproc_t inproc, char *in, xdrproc_t outproc, char *out);
 
46
#endif
 
47
#include <sys/param.h>
 
48
#include <sys/time.h>
 
49
 
 
50
#if defined(HAVE_LIBGDBM)
 
51
 
 
52
#include <gdbm.h>
 
53
 
 
54
#define ypdb_store gdbm_store
 
55
#define YPDB_REPLACE GDBM_REPLACE
 
56
#define ypdb_close gdbm_close
 
57
static GDBM_FILE dbm;
 
58
 
 
59
#elif defined (HAVE_NDBM)
 
60
 
 
61
#include <ndbm.h>
 
62
 
 
63
#define ypdb_store dbm_store
 
64
#define YPDB_REPLACE DBM_REPLACE
 
65
#define ypdb_close dbm_close
 
66
static DBM *dbm;
 
67
 
 
68
#else
 
69
 
 
70
#error "No database found or selected!"
 
71
 
 
72
#endif
 
73
 
 
74
static int lower = 0;
 
75
 
 
76
static inline void
 
77
write_data (datum key, datum data)
 
78
{
 
79
  if (ypdb_store (dbm, key, data, YPDB_REPLACE) != 0)
 
80
    {
 
81
      perror ("makedbm: dbm_store");
 
82
      ypdb_close (dbm);
 
83
      exit (1);
 
84
    }
 
85
}
 
86
 
 
87
#ifdef HAVE_NDBM
 
88
static char *
 
89
strapp (const char *str1, const char *str2)
 
90
{
 
91
  char *buffer = alloca(strlen (str1) + strlen (str2) + 1);
 
92
 
 
93
  strcpy (buffer, str1);
 
94
  strcat (buffer, str2);
 
95
 
 
96
  return strdup (buffer);
 
97
}
 
98
#endif
 
99
 
 
100
static void
 
101
create_file (char *fileName, char *dbmName, char *masterName,
 
102
             char *domainName, char *inputName,
 
103
             char *outputName, int aliases, int shortlines,
 
104
             int b_flag, int s_flag, int remove_comments,
 
105
             int check_limit)
 
106
{
 
107
  datum kdat, vdat;
 
108
  char *key = NULL;
 
109
  size_t keylen = 0;
 
110
  char *filename = NULL;
 
111
  FILE *input;
 
112
  char orderNum[12];
 
113
  struct timeval tv;
 
114
  struct timezone tz;
 
115
 
 
116
  input = strcmp (fileName, "-") ? fopen (fileName, "r") : stdin;
 
117
  if (input == NULL)
 
118
    {
 
119
      fprintf (stderr, "makedbm: Cannot open %s\n", fileName);
 
120
      exit (1);
 
121
    }
 
122
 
 
123
  filename = calloc (1, strlen (dbmName) + 3);
 
124
  sprintf (filename, "%s~", dbmName);
 
125
#if defined(HAVE_LIBGDBM)
 
126
  dbm = gdbm_open (filename, 0, GDBM_NEWDB | GDBM_FAST, 0600, NULL);
 
127
#elif defined(HAVE_NDBM)
 
128
  dbm = dbm_open (filename, O_CREAT | O_RDWR, 0600);
 
129
#endif
 
130
  if (dbm == NULL)
 
131
    {
 
132
      fprintf (stderr, "makedbm: Cannot open %s\n", filename);
 
133
      exit (1);
 
134
    }
 
135
 
 
136
  if (masterName && *masterName)
 
137
    {
 
138
      kdat.dptr = "YP_MASTER_NAME";
 
139
      kdat.dsize = strlen (kdat.dptr);
 
140
      vdat.dptr = masterName;
 
141
      vdat.dsize = strlen (vdat.dptr);
 
142
      write_data (kdat, vdat);
 
143
    }
 
144
 
 
145
  if (domainName && *domainName)
 
146
    {
 
147
      kdat.dptr = "YP_DOMAIN_NAME";
 
148
      kdat.dsize = strlen (kdat.dptr);
 
149
      vdat.dptr = domainName;
 
150
      vdat.dsize = strlen (vdat.dptr);
 
151
      write_data (kdat, vdat);
 
152
    }
 
153
 
 
154
  if (inputName && *inputName)
 
155
    {
 
156
      kdat.dptr = "YP_INPUT_NAME";
 
157
      kdat.dsize = strlen (kdat.dptr);
 
158
      vdat.dptr = inputName;
 
159
      vdat.dsize = strlen (vdat.dptr);
 
160
      write_data (kdat, vdat);
 
161
    }
 
162
 
 
163
  if (outputName && *outputName)
 
164
    {
 
165
      kdat.dptr = "YP_OUTPUT_NAME";
 
166
      kdat.dsize = strlen (kdat.dptr);
 
167
      vdat.dptr = outputName;
 
168
      vdat.dsize = strlen (vdat.dptr);
 
169
      write_data (kdat, vdat);
 
170
    }
 
171
 
 
172
  if (b_flag)
 
173
    {
 
174
      kdat.dptr = "YP_INTERDOMAIN";
 
175
      kdat.dsize = strlen (kdat.dptr);
 
176
      vdat.dptr = "";
 
177
      vdat.dsize = strlen (vdat.dptr);
 
178
      write_data (kdat, vdat);
 
179
    }
 
180
 
 
181
  if (s_flag)
 
182
    {
 
183
      kdat.dptr = "YP_SECURE";
 
184
      kdat.dsize = strlen (kdat.dptr);
 
185
      vdat.dptr = "";
 
186
      vdat.dsize = strlen (vdat.dptr);
 
187
      write_data (kdat, vdat);
 
188
    }
 
189
 
 
190
  if (aliases)
 
191
    {
 
192
      kdat.dptr = "@";
 
193
      kdat.dsize = strlen (kdat.dptr);
 
194
      vdat.dptr = "@";
 
195
      vdat.dsize = strlen (vdat.dptr);
 
196
      write_data (kdat, vdat);
 
197
    }
 
198
 
 
199
  gettimeofday (&tv, &tz);
 
200
  sprintf (orderNum, "%ld", (long) tv.tv_sec);
 
201
  kdat.dptr = "YP_LAST_MODIFIED";
 
202
  kdat.dsize = strlen (kdat.dptr);
 
203
  vdat.dptr = orderNum;
 
204
  vdat.dsize = strlen (vdat.dptr);
 
205
  write_data (kdat, vdat);
 
206
 
 
207
  while (!feof (input))
 
208
    {
 
209
      char *cptr;
 
210
 
 
211
#ifdef HAVE_GETLINE
 
212
      ssize_t n = getline (&key, &keylen, input);
 
213
#elif HAVE_GETDELIM
 
214
      ssize_t n = getdelim (&key, &keylen, '\n', input);
 
215
#else
 
216
      ssize_t n;
 
217
 
 
218
      if (key == NULL)
 
219
        {
 
220
          keylen = 8096;
 
221
          key = malloc (keylen);
 
222
        }
 
223
      key[0] = '\0';
 
224
      fgets (key, keylen - 1, input);
 
225
      if (key != NULL)
 
226
        n = strlen (key);
 
227
      else
 
228
        n = 0;
 
229
#endif
 
230
      if (n < 1)
 
231
        break;
 
232
      if (key[n - 1] == '\n' || key[n - 1] == '\r')
 
233
        key[n - 1] = '\0';
 
234
      if (n > 1 && (key[n - 2] == '\n' || key[n - 2] == '\r'))
 
235
        key[n - 2] = '\0';
 
236
 
 
237
      if (remove_comments)
 
238
        if ((cptr = strchr (key, '#')) != NULL)
 
239
          {
 
240
            *cptr = '\0';
 
241
            --cptr;
 
242
            while (*cptr == ' ' || *cptr == '\t')
 
243
              {
 
244
                *cptr = '\0';
 
245
                --cptr;
 
246
              }
 
247
          }
 
248
 
 
249
      if (strlen (key) == 0)
 
250
        continue;
 
251
 
 
252
      if (aliases)
 
253
        {
 
254
          int len;
 
255
 
 
256
          len = strlen (key);
 
257
          while (key[len - 1] == ' ' || key[len - 1] == '\t')
 
258
            {
 
259
              key[len - 1] = '\0';
 
260
              --len;
 
261
            }
 
262
 
 
263
          while (key[len - 1] == ',')
 
264
            {
 
265
              char *nkey = NULL;
 
266
              size_t nkeylen = 0;
 
267
#ifdef HAVE_GETLINE
 
268
              getline (&nkey, &nkeylen, input);
 
269
#elif HAVE_GETDELIM
 
270
              getdelim (&nkey, &nkeylen, '\n', input);
 
271
#else
 
272
              nkeylen = 8096;
 
273
              nkey = malloc (nkeylen);
 
274
              nkey[0] = '\0';
 
275
              fgets (nkey, nkeylen - 1, input);
 
276
#endif
 
277
 
 
278
              cptr = nkey;
 
279
              while ((*cptr == ' ') || (*cptr == '\t'))
 
280
                ++cptr;
 
281
              if (strlen (key) + strlen (cptr) < keylen)
 
282
                strcat (key, cptr);
 
283
              else
 
284
                {
 
285
                  keylen += nkeylen;
 
286
                  key = realloc (key, keylen);
 
287
                  if (key == NULL)
 
288
                    abort ();
 
289
                  strcat (key, cptr);
 
290
                }
 
291
 
 
292
              free (nkey);
 
293
 
 
294
              if ((cptr = strchr (key, '\n')) != NULL)
 
295
                *cptr = '\0';
 
296
              len = strlen (key);
 
297
              while (key[len - 1] == ' ' || key[len - 1] == '\t')
 
298
                {
 
299
                  key[len - 1] = '\0';
 
300
                  len--;
 
301
                }
 
302
            }
 
303
          if ((cptr = strchr (key, ':')) != NULL)
 
304
            *cptr = ' ';
 
305
        }
 
306
      else
 
307
        while (key[strlen (key) - 1] == '\\')
 
308
          {
 
309
            char *nkey;
 
310
            size_t nkeylen = 0;
 
311
#ifdef HAVE_GETLINE
 
312
            ssize_t n = getline (&nkey, &nkeylen, input);
 
313
#elif HAVE_GETDELIM
 
314
            ssize_t n = getdelim (&nkey, &nkeylen, '\n', input);
 
315
#else
 
316
            ssize_t n;
 
317
 
 
318
            nkeylen = 8096;
 
319
            nkey = malloc (nkeylen);
 
320
            nkey[0] = '\0';
 
321
            fgets (nkey, nkeylen - 1, input);
 
322
            if (nkey != NULL)
 
323
              n = strlen (nkey);
 
324
            else
 
325
              n = 0;
 
326
#endif
 
327
            if (n < 1)
 
328
              break;
 
329
            if (nkey[n - 1] == '\n' || nkey[n - 1] == '\r')
 
330
              nkey[n - 1] = '\0';
 
331
            if (n > 1 && (nkey[n - 2] == '\n' || nkey[n - 2] == '\r'))
 
332
              nkey[n - 2] = '\0';
 
333
 
 
334
            key[strlen (key) - 1] = '\0';
 
335
 
 
336
            if (shortlines)
 
337
              {
 
338
                int len;
 
339
 
 
340
                len = strlen (key);
 
341
                key[len - 1] = '\0';
 
342
                len--;
 
343
                if ((key[len - 1] != ' ') && (key[len - 1] != '\t'))
 
344
                  strcat (key, " ");
 
345
                cptr = nkey;
 
346
                while ((*cptr == ' ') || (*cptr == '\t'))
 
347
                  ++cptr;
 
348
                if (len + 1 + strlen (cptr) < keylen)
 
349
                  strcat (key, cptr);
 
350
                else
 
351
                  {
 
352
                    keylen += nkeylen;
 
353
                    key = realloc (key, keylen);
 
354
                    if (key == NULL)
 
355
                      abort ();
 
356
                    strcat (key, nkey);
 
357
                  }
 
358
              }
 
359
            else
 
360
              {
 
361
                keylen += nkeylen;
 
362
                key = realloc (key, keylen);
 
363
                if (key == NULL)
 
364
                  abort ();
 
365
                strcat (key, nkey);
 
366
              }
 
367
            free (nkey);
 
368
 
 
369
            if ((cptr = strchr (key, '\n')) != NULL)
 
370
              *cptr = '\0';
 
371
          }
 
372
 
 
373
      cptr = key;
 
374
 
 
375
      /* Hack for spaces in passwd, group and hosts keys. If we
 
376
         find a <TAB> in the string, Makefile generates it to
 
377
         seperate the key. This should be the standard, but is not
 
378
         done for all maps (like bootparamd).  */
 
379
      if (strchr (cptr, '\t') == NULL)
 
380
        {
 
381
          while (*cptr && *cptr != '\t' && *cptr != ' ')
 
382
            ++cptr;
 
383
        }
 
384
      else
 
385
        {
 
386
          while (*cptr && *cptr != '\t')
 
387
            ++cptr;
 
388
          /* But a key should not end with a space.  */
 
389
          while (cptr[-1] == ' ')
 
390
            --cptr;
 
391
        }
 
392
 
 
393
      *cptr++ = '\0';
 
394
 
 
395
      while (*cptr == '\t' || *cptr == ' ')
 
396
        ++cptr;
 
397
 
 
398
      if (strlen (key) == 0)
 
399
        {
 
400
          if (strlen (cptr) != 0)
 
401
            fprintf (stderr,
 
402
                     "makedbm: warning: malformed input data (ignored)\n");
 
403
        }
 
404
      else
 
405
        {
 
406
          int i;
 
407
 
 
408
          if (check_limit && strlen (key) > YPMAXRECORD)
 
409
            {
 
410
              fprintf (stderr, "makedbm: warning: key too long: %s\n", key);
 
411
              continue;
 
412
            }
 
413
          kdat.dsize = strlen (key);
 
414
          kdat.dptr = key;
 
415
 
 
416
          if (check_limit && strlen (cptr) > YPMAXRECORD)
 
417
            {
 
418
              fprintf (stderr, "makedbm: warning: data too long: %s\n", cptr);
 
419
              continue;
 
420
            }
 
421
          vdat.dsize = strlen (cptr);
 
422
          vdat.dptr = cptr;
 
423
 
 
424
          if (lower)
 
425
            for (i = 0; i < kdat.dsize; i++)
 
426
              kdat.dptr[i] = tolower (kdat.dptr[i]);
 
427
 
 
428
          write_data (kdat, vdat);
 
429
        }
 
430
    }
 
431
 
 
432
  ypdb_close (dbm);
 
433
#if defined(HAVE_NDBM)
 
434
#if defined(__GLIBC__) && __GLIBC__ >= 2
 
435
  {
 
436
    char *dbm_db = strapp (dbmName, ".db");
 
437
    char *filedb = strapp (filename, ".db");
 
438
 
 
439
    unlink (dbm_db);
 
440
    rename (filedb, dbm_db);
 
441
  }
 
442
#else
 
443
  {
 
444
    char *dbm_pag = strapp (dbmName, ".pag");
 
445
    char *dbm_dir = strapp (dbmName, ".dir");
 
446
    char *filepag = strapp (filename, ".pag");
 
447
    char *filedir = strapp (filename, ".dir");
 
448
 
 
449
    unlink (dbm_pag);
 
450
    unlink (dbm_dir);
 
451
    rename (filepag, dbm_pag);
 
452
    rename (filedir, dbm_dir);
 
453
  }
 
454
#endif
 
455
#else
 
456
  unlink (dbmName);
 
457
  rename (filename, dbmName);
 
458
#endif
 
459
  free (filename);
 
460
}
 
461
 
 
462
static void
 
463
dump_file (char *dbmName)
 
464
{
 
465
  datum key, data;
 
466
#if defined(HAVE_LIBGDBM)
 
467
  dbm = gdbm_open (dbmName, 0, GDBM_READER, 0600, NULL);
 
468
#elif defined(HAVE_NDBM)
 
469
  dbm = dbm_open (dbmName, O_RDONLY, 0600);
 
470
#endif
 
471
  if (dbm == NULL)
 
472
    {
 
473
      fprintf (stderr, "makedbm: Cannot open %s\n", dbmName);
 
474
      exit (1);
 
475
    }
 
476
#if defined(HAVE_LIBGDBM)
 
477
  for (key = gdbm_firstkey (dbm); key.dptr; key = gdbm_nextkey (dbm, key))
 
478
    {
 
479
      data = gdbm_fetch (dbm, key);
 
480
      if (!data.dptr)
 
481
        {
 
482
          fprintf (stderr, "Error:\n");
 
483
          perror (dbmName);
 
484
          exit (1);
 
485
        }
 
486
      printf ("%.*s\t%.*s\n",
 
487
              key.dsize, key.dptr,
 
488
              data.dsize, data.dptr);
 
489
      free (data.dptr);
 
490
    }
 
491
#elif defined(HAVE_NDBM)
 
492
  key = dbm_firstkey (dbm);
 
493
  while (key.dptr)
 
494
    {
 
495
      data = dbm_fetch (dbm, key);
 
496
      if (!data.dptr)
 
497
        {
 
498
          fprintf (stderr, "Error:\n");
 
499
          perror (dbmName);
 
500
          exit (1);
 
501
        }
 
502
      printf ("%.*s\t%.*s\n",
 
503
              key.dsize, key.dptr,
 
504
              data.dsize, data.dptr);
 
505
      key = dbm_nextkey (dbm);
 
506
    }
 
507
#endif
 
508
  ypdb_close (dbm);
 
509
}
 
510
 
 
511
static void
 
512
send_clear (void)
 
513
{
 
514
  char in = 0;
 
515
  char *out = NULL;
 
516
  int stat;
 
517
  if ((stat = callrpc ("localhost", YPPROG, YPVERS, YPPROC_CLEAR,
 
518
                       (xdrproc_t) xdr_void, &in,
 
519
                       (xdrproc_t) xdr_void, out)) != RPC_SUCCESS)
 
520
    {
 
521
      fprintf (stderr, "failed to send 'clear' to local ypserv: %s",
 
522
               clnt_sperrno ((enum clnt_stat) stat));
 
523
    }
 
524
}
 
525
 
 
526
static void
 
527
Usage (int exit_code)
 
528
{
 
529
  fprintf (stderr, "usage: makedbm -u dbname\n");
 
530
  fprintf (stderr, "       makedbm [-a|-r] [-b] [-c] [-s] [-l] [-i YP_INPUT_NAME]\n");
 
531
  fprintf (stderr, "               [-o YP_OUTPUT_NAME] [-m YP_MASTER_NAME] inputfile dbname\n");
 
532
  fprintf (stderr, "       makedbm -c\n");
 
533
  fprintf (stderr, "       makedbm --version\n");
 
534
  exit (exit_code);
 
535
}
 
536
 
 
537
int
 
538
main (int argc, char *argv[])
 
539
{
 
540
  char *domainName = NULL;
 
541
  char *inputName = NULL;
 
542
  char *outputName = NULL;
 
543
  char masterName[MAXHOSTNAMELEN + 1] = "";
 
544
  int dump = 0;
 
545
  int aliases = 0;
 
546
  int shortline = 0;
 
547
  int clear = 0;
 
548
  int b_flag = 0;
 
549
  int s_flag = 0;
 
550
  int remove_comments = 0;
 
551
  int check_limit = 1;
 
552
 
 
553
  while (1)
 
554
    {
 
555
      int c;
 
556
      int option_index = 0;
 
557
      static struct option long_options[] =
 
558
      {
 
559
        {"version", no_argument, NULL, '\255'},
 
560
        {"dump", no_argument, NULL, 'u'},
 
561
        {"help", no_argument, NULL, 'h'},
 
562
        {"usage", no_argument, NULL, 'h'},
 
563
        {"secure", no_argument, NULL, 's'},
 
564
        {"aliases", no_argument, NULL, 'a'},
 
565
        {"send_clear", no_argument, NULL, 'c'},
 
566
        {"remove-spaces", no_argument, NULL, '\254'},
 
567
        {"remove-comments", no_argument, NULL, 'r'},
 
568
        {"no-limit-check", no_argument, NULL, '\253'},
 
569
        {NULL, 0, NULL, '\0'}
 
570
      };
 
571
 
 
572
      c = getopt_long (argc, argv, "abcd:hi:lm:o:rsu", long_options, &option_index);
 
573
      if (c == EOF)
 
574
        break;
 
575
      switch (c)
 
576
        {
 
577
        case 'a':
 
578
          aliases++;
 
579
          shortline++;
 
580
          break;
 
581
        case 'b':
 
582
          b_flag++;
 
583
          break;
 
584
        case 'c':
 
585
          clear++;
 
586
          break;
 
587
        case 'l':
 
588
          lower++;
 
589
          break;
 
590
        case 'u':
 
591
          dump++;
 
592
          break;
 
593
        case '\254':
 
594
          shortline++;
 
595
          break;
 
596
        case 'r':
 
597
          remove_comments++;
 
598
          break;
 
599
        case 's':
 
600
          s_flag++;
 
601
          break;
 
602
        case 'd':
 
603
          domainName = optarg;
 
604
          break;
 
605
        case 'i':
 
606
          inputName = optarg;
 
607
          break;
 
608
        case 'o':
 
609
          outputName = optarg;
 
610
          break;
 
611
        case 'm':
 
612
          if (strlen (optarg) <= MAXHOSTNAMELEN)
 
613
            strcpy (masterName, optarg);
 
614
          else
 
615
            fprintf (stderr, "hostname to long: %s\n", optarg);
 
616
          break;
 
617
        case '\253':
 
618
          check_limit = 0;
 
619
          break;
 
620
        case '\255':
 
621
          fprintf  (stdout, "makedbm (%s) %s", PACKAGE, VERSION);
 
622
          return 0;
 
623
        case 'h':
 
624
          Usage (0);
 
625
          break;
 
626
        case '?':
 
627
          Usage (1);
 
628
          break;
 
629
        }
 
630
    }
 
631
 
 
632
  argc -= optind;
 
633
  argv += optind;
 
634
 
 
635
  if (dump)
 
636
    {
 
637
      if (argc < 1)
 
638
        Usage (1);
 
639
      else
 
640
        dump_file (argv[0]);
 
641
    }
 
642
  else
 
643
    {
 
644
      if (clear && argc == 0)
 
645
        {
 
646
          send_clear ();
 
647
          return 0;
 
648
        }
 
649
 
 
650
      if (argc < 2)
 
651
        Usage (1);
 
652
      else
 
653
        {
 
654
          if (strlen (masterName) == 0)
 
655
            {
 
656
              if (gethostname (masterName, sizeof (masterName)) < 0)
 
657
                perror ("gethostname");
 
658
#if USE_FQDN
 
659
              else
 
660
                {
 
661
                  struct hostent *hp;
 
662
 
 
663
                  if (!(hp = gethostbyname (masterName)))
 
664
                    perror ("gethostbyname()");
 
665
                  else
 
666
                    {
 
667
                      strncpy (masterName, hp->h_name, MAXHOSTNAMELEN);
 
668
                      masterName[MAXHOSTNAMELEN] = '\0';
 
669
                    }
 
670
                }
 
671
#endif
 
672
            }
 
673
          create_file (argv[0], argv[1], masterName, domainName,
 
674
                       inputName, outputName, aliases, shortline,
 
675
                       b_flag, s_flag, remove_comments, check_limit);
 
676
 
 
677
          if (clear)
 
678
            send_clear ();
 
679
        }
 
680
    }
 
681
 
 
682
  return 0;
 
683
}