home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume17 / rkive / part02 < prev    next >
Internet Message Format  |  1991-02-24  |  56KB
  1. From: kent@sparky.imd.sterling.com (Kent Landfield)
  2. Newsgroups: comp.sources.misc
  3. Subject: v17i018:  rkive - Usenet sources archiver, Part02/06
  4. Message-ID: <1991Feb24.222503.26973@sparky.IMD.Sterling.COM>
  5. Date: 24 Feb 91 22:25:03 GMT
  6. Approved: kent@sparky.imd.sterling.com
  7. X-Checksum-Snefru: a0653cc2 6de1eff1 27e20a7f e94b5b43
  8.  
  9. Submitted-by: Kent Landfield <kent@sparky.imd.sterling.com>
  10. Posting-number: Volume 17, Issue 18
  11. Archive-name: rkive/part02
  12.  
  13. #! /bin/sh
  14. # This is a shell archive.  Remove anything before this line, then feed it
  15. # into a shell via "sh file" or similar.  To overwrite existing files,
  16. # type "sh file -c".
  17. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  18. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  19. # If this archive is complete, you will see the following message at the end:
  20. #        "End of archive 2 (of 6)."
  21. # Contents:  rkive/rkive.c rkive/setup.c
  22. # Wrapped by kent@sparky on Sun Feb 24 16:11:22 1991
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. if test -f 'rkive/rkive.c' -a "${1}" != "-c" ; then 
  25.   echo shar: Will not clobber existing file \"'rkive/rkive.c'\"
  26. else
  27. echo shar: Extracting \"'rkive/rkive.c'\" \(27854 characters\)
  28. sed "s/^X//" >'rkive/rkive.c' <<'END_OF_FILE'
  29. X/*
  30. X**  Subsystem:   USENET Sources Archiver             
  31. X**  File Name:   rkive.c               
  32. X**                                                        
  33. X**  usage: rkive [-?dgstuvV] [-f config_file] [-n newsgroup] 
  34. X**                           [-B batchfile] [-S newsgroup]
  35. X**
  36. X**
  37. X** This software is Copyright (c) 1989, 1990, 1991 by Kent Landfield.
  38. X**
  39. X** Permission is hereby granted to copy, distribute or otherwise 
  40. X** use any part of this package as long as you do not try to make 
  41. X** money from it or pretend that you wrote it.  This copyright 
  42. X** notice must be maintained in any copy made.
  43. X**
  44. X** Use of this software constitutes acceptance for use in an AS IS 
  45. X** condition. There are NO warranties with regard to this software.  
  46. X** In no event shall the author be liable for any damages whatsoever 
  47. X** arising out of or in connection with the use or performance of this 
  48. X** software.  Any use of this software is at the user's own risk.
  49. X**
  50. X**  If you make modifications to this software that you feel 
  51. X**  increases it usefulness for the rest of the community, please 
  52. X**  email the changes, enhancements, bug fixes as well as any and 
  53. X**  all ideas to me. This software is going to be maintained and 
  54. X**  enhanced as deemed necessary by the community.
  55. X**
  56. X**              Kent Landfield
  57. X**              uunet!sparky!kent
  58. X**        kent@sparky.imd.sterling.com
  59. X*/
  60. X
  61. X#include <sys/types.h>
  62. X#include <sys/stat.h>
  63. X#include <stdio.h>
  64. X#include "article.h"
  65. X#include "cfg.h"
  66. X
  67. X#ifdef NNTP
  68. Xchar sccsid[] = "@(#)rkive.c    2.2 2/23/91 - NNTP Version";
  69. X#else
  70. Xchar sccsid[] = "@(#)rkive.c    2.2 2/23/91";
  71. X#endif /*!NNTP*/
  72. X
  73. X/* 
  74. X** This is necessary since the builtin makedir call uses
  75. X** mknod which is a superuser only call for directories.
  76. X*/
  77. X#if (!HAVE_MKDIR && !USE_SYSMKDIR)
  78. X#define ROOT_ONLY
  79. X#endif
  80. X
  81. X/* 
  82. X** The following define is use for compilation
  83. X** so that format_output can use the extended
  84. X** fomating characters that are not available
  85. X** in article.
  86. X*/
  87. X#define RKIVE
  88. X
  89. Xchar tmp_mailfile[] = "/tmp/rkive.mail";
  90. Xchar global_mailfile[] = "/tmp/gbl.mail";
  91. X
  92. Xchar *batch_file = NULL;
  93. Xchar article_name[MAXNAMLEN];
  94. X
  95. Xint retrieve = FROM_DISK;      /* default archiving is done from local disk */
  96. Xint overwrite;
  97. Xint status_only;
  98. X
  99. Xstruct stat sbuf;
  100. X
  101. XFILE *inputfp;
  102. X
  103. Xint needs_to_be_archived();
  104. Xchar *save_article();
  105. Xchar *compress_file();
  106. Xchar *do_compress();
  107. Xchar *basename();
  108. Xchar *suffix();
  109. Xchar *format_output();
  110. Xvoid archive();
  111. Xvoid build_index();
  112. Xvoid display_group_info();
  113. Xvoid logit();
  114. Xvoid log_activities();
  115. Xvoid mail_file();
  116. Xvoid notify_users();
  117. Xvoid record_problem();
  118. Xvoid set_ownership();
  119. X
  120. Xint fclose();
  121. Xint stat();
  122. Xint strcmp();
  123. Xint strlen();
  124. Xint system();
  125. Xint unlink();
  126. Xchar *strcpy();
  127. Xchar *strcat();
  128. Xchar *strchr();
  129. XFILE *efopen();
  130. Xvoid exit();
  131. X
  132. Xextern int yydebug;
  133. Xextern char inputstring[];
  134. Xextern parser_return_value;
  135. X
  136. Xextern int debug;
  137. Xextern int verbose;
  138. Xextern int test;
  139. Xextern int inum;
  140. Xextern int problem_article;
  141. Xextern char *nntp_server;
  142. X
  143. Xvoid usage()
  144. X{
  145. X    (void)fprintf(stderr,"usage: %s [-?dgstuvV] [-f config_file]\n", progname);
  146. X    (void)fprintf(stderr,"          [-n newsgroup] [-B batchfile] [-S newsgroup]\n");
  147. X    (void)fprintf(stderr,"options:\n");
  148. X    (void)fprintf(stderr,"  -?   Display this message.\n");
  149. X    (void)fprintf(stderr,"  -d   Debug, assumes verbose flag as well.\n");
  150. X    (void)fprintf(stderr,"  -g   Fill in default values with group display.\n"); 
  151. X    (void)fprintf(stderr,"       Only effective with verbose mode flag.\n");
  152. X    (void)fprintf(stderr,"  -s   Display status of article archiving.\n");
  153. X    (void)fprintf(stderr,"  -t   Test mode, display what would be done but do no archiving.\n");
  154. X    (void)fprintf(stderr,"  -u   Unconditionally overwrite dupliclate articles.\n");
  155. X    (void)fprintf(stderr,"  -v   Verbose archiving information printed.\n");
  156. X    (void)fprintf(stderr,"  -V   Display %s software version information.\n",
  157. X                  progname);
  158. X    (void)fprintf(stderr,"  -f config_file\n");
  159. X    (void)fprintf(stderr,"       Specify alternate configuration file to be used.\n");
  160. X    (void)fprintf(stderr,"  -n newsgroup\n");
  161. X    (void)fprintf(stderr,"       Specify newsgroup to archive or display status for.\n");
  162. X    (void)fprintf(stderr,"  -B batchfile\n");
  163. X    (void)fprintf(stderr,"       Read names of articles to archive from batchfile.\n");
  164. X    (void)fprintf(stderr,"       Note: Use of the -B option requires a newsgroup\n");
  165. X    (void)fprintf(stderr,"             be specified using the -n option.\n");
  166. X    (void)fprintf(stderr,"  -S newsgroup\n");
  167. X    (void)fprintf(stderr,"       Take the name of articles to archive from stdin.\n");
  168. X}
  169. X
  170. Xint main(argc, argv)
  171. Xint argc;
  172. Xchar **argv;
  173. X{
  174. X   int getopt();
  175. X   void version();
  176. X   void setup_defaults();
  177. X   void init_article();
  178. X
  179. X   int c;
  180. X   extern char *optarg;
  181. X   extern int opterr;
  182. X   char *nwsg = NULL;
  183. X
  184. X   yydebug = FALSE;
  185. X
  186. X   opterr = 0;
  187. X   progname = argv[0];
  188. X   inputfp = stdin;
  189. X   logfp = stdout;
  190. X   errfp = stderr;
  191. X
  192. X   status_only = debug = verbose = 0;
  193. X   test = overwrite = fill_in_defaults = 0;
  194. X
  195. X   /*
  196. X   ** Setup the default config file to be used
  197. X   ** unless the user specifies otherwise.
  198. X   */
  199. X   config_file = LOCATION;
  200. X
  201. X   if (argc > 1) {
  202. X      while ((c = getopt(argc, argv, "?dgstuvVn:f:B:S:y")) != EOF) {
  203. X         switch (c) {
  204. X             case 'B':   /* take filenames from batch file  */
  205. X                 retrieve = FROM_BATCHFILE;
  206. X                 batch_file = optarg;
  207. X                 break;
  208. X             case 'd':   /* for extremely verbose output    */
  209. X                 debug++;
  210. X                 verbose++;
  211. X                 break;
  212. X             case 'f':   /* alternate configuration file    */
  213. X                 config_file = optarg;  
  214. X                 break;  
  215. X             case 'g':   /* display defaults filled in      */
  216. X                 fill_in_defaults++;
  217. X                 break;
  218. X             case 'n':   /* specify an individual newsgroup */
  219. X                 nwsg = optarg;
  220. X                 break;
  221. X             case 's':   /* display article archive status  */
  222. X                 status_only++;
  223. X                 break;
  224. X             case 'S':   /* single article archiving        */
  225. X                 retrieve = FROM_NAME;
  226. X                 nwsg = optarg;
  227. X                 break;
  228. X             case 't':   /* test mode, show but do nothing  */
  229. X                 test++;
  230. X                 verbose++;
  231. X                 break;
  232. X             case 'u':   /* overwrite existing duplicates   */
  233. X                 overwrite++;
  234. X                 break;
  235. X             case 'v':   /* display expanded output         */
  236. X                 verbose++;
  237. X                 break;
  238. X             case 'V':   /* display software version only   */
  239. X                 version();
  240. X                 break;
  241. X             case 'y':   /* turn on yydebug facilities      */
  242. X                 yydebug++;
  243. X                 break;
  244. X             case '?':   /* display usage information       */
  245. X             default:    /* display usage, invalid option   */
  246. X                 usage();
  247. X                 return(1);
  248. X         }
  249. X      }
  250. X   }
  251. X
  252. X   /*
  253. X   ** If the user has specified that input is be filenames
  254. X   ** retrieved from a batch file, the user must specify a
  255. X   ** a newsgroup in addition to the batch filename.
  256. X   */
  257. X   if (retrieve == FROM_BATCHFILE) {
  258. X       if (nwsg == NULL) {
  259. X           (void) fprintf(errfp,
  260. X                  "%s: Must specify a newsgroup when using batchfile mode\n",
  261. X                  progname);
  262. X           (void) fprintf(errfp,"Sample command line...\n");
  263. X           (void) fprintf(errfp,"\t%s -B %s -n newsgroup-here\n",
  264. X                  progname, batch_file);
  265. X           return(1);
  266. X       }
  267. X   }
  268. X
  269. X   setup_defaults();
  270. X
  271. X   init_article();
  272. X
  273. X   for (c = 0; c <= num; c++)  {
  274. X       newsgrp = &group[c];
  275. X       /*
  276. X       ** Was a newsgroup specified on the command line ?
  277. X       */
  278. X       if (nwsg != NULL) {
  279. X          if (strcmp(nwsg, newsgrp->ng_name) != 0)
  280. X              continue;
  281. X       }
  282. X       archive();
  283. X   }
  284. X
  285. X   if (!status_only) {
  286. X       /*
  287. X       ** Mail notification of the archived members to the 
  288. X       ** list of users specified in the configuration file
  289. X       ** and remove the file containing the archived info.
  290. X       */
  291. X       mail_file(mail, global_mailfile, "Rkive results");
  292. X       (void) unlink(global_mailfile);
  293. X   }
  294. X   return(0);
  295. X}
  296. X
  297. Xvoid archive()
  298. X{
  299. X    char *get_archived_rec();
  300. X    int retrieve_article();
  301. X    void get_header();
  302. X
  303. X    int cct;
  304. X    int first;
  305. X    int val;
  306. X    char *rp, *rec;
  307. X    char *new_member;
  308. X    char *archived_file;
  309. X    
  310. X#ifdef ROOT_ONLY
  311. X    /*
  312. X    ** check to assure that the user is root if 
  313. X    ** actual archiving is to take place. This is necessary
  314. X    ** if there is no mkdir system call.
  315. X    */
  316. X
  317. X    if (!status_only && (getuid() != 0)) {
  318. X        (void) fprintf(errfp, "%s: Sorry, Must be root to rkive.\n",
  319. X                        progname);
  320. X        exit(1);
  321. X    }
  322. X#endif /* ROOT_ONLY */
  323. X
  324. X    inum = 0;  /* initialize chronological issue counter */
  325. X
  326. X    /* Remove any existing temporary mail file */
  327. X
  328. X    (void) unlink(tmp_mailfile);
  329. X    cct = 0;  /* counter for newsgroup message in global mail */
  330. X
  331. X    /*
  332. X    ** Assure that there something specified in the 
  333. X    ** archive location variable...
  334. X    */
  335. X    if (!*newsgrp->location) {
  336. X        (void) fprintf(errfp, "SKIPPING %s: No archive location specified..\n",
  337. X                        newsgrp->ng_name);
  338. X        return;
  339. X    }
  340. X
  341. X    /*
  342. X    ** print out the appropriate 
  343. X    ** header for the newsgroup.
  344. X    ** If the user wishes to see the newsgroup info as well as all the
  345. X    ** information about a file archived, the user must specify 
  346. X    ** rkive -svv to see it all... 
  347. X    */
  348. X
  349. X    if (debug || (verbose == 2 && status_only)) {
  350. X        (void) fprintf(logfp,"\n\n");
  351. X        display_group_info(newsgrp);
  352. X        (void) fprintf(logfp,"\n");
  353. X    }
  354. X    else if (status_only || verbose == 2)
  355. X        (void) fprintf(logfp, "%s\n",newsgrp->ng_name);
  356. X
  357. X    /*
  358. X    ** Create a path to the .archived file for the newsgroup's archive.
  359. X    ** This file is used to determine if an article has already been
  360. X    ** archived.  If the user did not specify one ...
  361. X    */
  362. X    if (!*newsgrp->arc_done)
  363. X       (void) sprintf(newsgrp->arc_done,"%s/.archived",newsgrp->location);
  364. X
  365. X    /*
  366. X    ** Create a path to the .patchlog file for the newsgroup's archive.
  367. X    ** This file is used to record patches to posted software so that
  368. X    ** it can easily be determined what the full set of software is.
  369. X    */
  370. X    if (!*newsgrp->patchlog)
  371. X       (void) sprintf(newsgrp->patchlog,"%s/.patchlog",newsgrp->location);
  372. X
  373. X    /*
  374. X    ** first indicates that archiving has just begun for this group
  375. X    ** so that any necessary setup can be done in retrieve_article().
  376. X    */
  377. X
  378. X    first = 1;
  379. X
  380. X#ifdef NNTP
  381. X    /* 
  382. X    ** Determine if the newsgroup being archived is to be accessed via
  383. X    ** nntp or via local disk access.
  384. X    */
  385. X    if (*newsgrp->nntp) {
  386. X        nntp_server = newsgrp->nntp;
  387. X        retrieve = FROM_NNTP;
  388. X    }
  389. X    else if (*nntp) {
  390. X        nntp_server = nntp;
  391. X        retrieve = FROM_NNTP;
  392. X    }
  393. X#endif /*NNTP*/
  394. X
  395. X    while ((val = retrieve_article(article_name,first)) != DONE) {
  396. X        first = 0;
  397. X        if (val == ERROR_ENCOUNTERED)
  398. X            return;
  399. X        else if (val != RETRIEVED) {
  400. X           /* 
  401. X           ** Invalid return value encountered, we're in truble now..
  402. X           */
  403. X           (void) fprintf(errfp,"Invalid return from retrieve_article..?? Skipping %s\n",
  404. X                          newsgrp->ng_path);
  405. X           return;
  406. X       }
  407. X
  408. X       /*
  409. X       ** Read the news article file to extract the
  410. X       ** header information and fill appropriate
  411. X       ** data structures.
  412. X       */
  413. X       get_header(article_name);
  414. X
  415. X       /* 
  416. X       ** If the user has specified that a quick status 
  417. X       ** listing should be produced then hop to it....
  418. X       */
  419. X
  420. X       if (status_only) {
  421. X            if ((rec = get_archived_rec(header.ident)) == NULL) {
  422. X                /*
  423. X                ** Assure that the article that we are going
  424. X                ** to give status on is one that would be archived
  425. X                ** if archiving was occuring. (e.g. does it match 
  426. X                ** the user supplied criteria for archiving...)
  427. X                */
  428. X                if (*newsgrp->match) {
  429. X                     parser_return_value = 0;
  430. X                     (void) strcpy(inputstring, newsgrp->match);
  431. X                     if (yyparse()) 
  432. X                         (void) fprintf(logfp, "Parse failed and returned %d\n",
  433. X                                                parser_return_value);
  434. X                     else {
  435. X                         /* Did match string produce true as result? */
  436. X
  437. X                        if (debug)
  438. X                            (void) fprintf(logfp, "Parser returned %d\n",
  439. X                                                   parser_return_value);
  440. X                    }
  441. X                    if (!parser_return_value) {
  442. X#ifdef NNTP
  443. X                        /*
  444. X                        ** Since they only want status, remove the 
  445. X                        ** nntp transfer tmpfile if newsgroup is
  446. X                        ** being archived via nntp.
  447. X                        */
  448. X                        if (retrieve == FROM_NNTP)
  449. X                            (void) unlink(article_name);
  450. X#endif /*NNTP*/
  451. X                        continue;
  452. X                    }
  453. X               }
  454. X#ifdef NNTP
  455. X               if (retrieve == FROM_NNTP)
  456. X                  (void) fprintf(logfp,
  457. X                                 "\t[%s] Awaiting Archiving\n",header.ident);
  458. X               else
  459. X                  (void) fprintf(logfp,
  460. X                                 "\t[%s] Awaiting Archiving\n",article_name);
  461. X#else /*!NNTP*/
  462. X               (void) fprintf(logfp,"\t[%s] Awaiting Archiving\n",article_name);
  463. X#endif /*NNTP*/
  464. X            }
  465. X            else if (verbose) {
  466. X                if ((rp = strchr(rec,' ')) == NULL) {
  467. X#ifdef NNTP
  468. X                   if (retrieve == FROM_NNTP)
  469. X                      (void) fprintf(logfp,"\t[%s] Archived\n",header.ident);
  470. X                   else
  471. X                      (void) fprintf(logfp,"\t[%s] Archived\n",article_name);
  472. X#else /*!NNTP*/
  473. X                   (void) fprintf(logfp,"\t[%s] Archived\n",article_name);
  474. X#endif /*NNTP*/
  475. X                }
  476. X                else {
  477. X                    rp++;
  478. X                    *(rp-1) = '\0';
  479. X                    (void) fprintf(logfp,"\t%s Archived as %s\n",rec,rp);
  480. X                }
  481. X            }
  482. X#ifdef NNTP
  483. X            /*
  484. X            ** Since they only want status, remove the 
  485. X            ** nntp transfer tmpfile if newsgroup is
  486. X            ** being archived via nntp.
  487. X            */
  488. X            if (retrieve == FROM_NNTP)
  489. X                (void) unlink(article_name);
  490. X#endif /*NNTP*/
  491. X            continue;
  492. X       }  /* End of status only... */
  493. X
  494. X       /* 
  495. X       **
  496. X       ** We have located a file that may need to be archived. 
  497. X       ** First read the header information from the found file.
  498. X       ** Next, determine if the file needs to be archived by
  499. X       ** doing a linear search of of the contents of the .archived file
  500. X       ** comparing the message-id of the new article with the message-ids
  501. X       ** recorded in the .archived file. If the new message-id is not
  502. X       ** specified in the .archived file, it has not been archived
  503. X       ** before and we can proceed with the archiving.
  504. X       ** Can we say slow... maybe dbm in the future ???
  505. X       */
  506. X
  507. X       if (!needs_to_be_archived(header.ident)) {
  508. X#ifdef NNTP
  509. X           /*
  510. X           ** Remove the nntp transfer tmpfile if the
  511. X           ** newsgroup is being archived via nntp.
  512. X           */
  513. X           if (retrieve == FROM_NNTP)
  514. X               (void) unlink(article_name);
  515. X#endif /*NNTP*/
  516. X           continue;
  517. X       }
  518. X          
  519. X       if (*newsgrp->match) {
  520. X           (void) strcpy(inputstring, newsgrp->match);
  521. X
  522. X           if (yyparse()) {
  523. X               (void) fprintf(logfp, "Parse failed and returned %d\n",
  524. X                                      parser_return_value);
  525. X#ifdef NNTP
  526. X               /*
  527. X               ** Remove the nntp transfer tmpfile if the
  528. X               ** newsgroup is being archived via nntp.
  529. X               */
  530. X               if (retrieve == FROM_NNTP)
  531. X                   (void) unlink(article_name);
  532. X#endif /*NNTP*/
  533. X               continue;
  534. X           }
  535. X
  536. X           /* Did match string produce true as result? */
  537. X
  538. X           if (debug)
  539. X               (void) fprintf(logfp, "Parser returned %d\n", parser_return_value);
  540. X
  541. X           if (!parser_return_value) {
  542. X#ifdef NNTP
  543. X               /*
  544. X               ** Remove the nntp transfer tmpfile if the
  545. X               ** newsgroup is being archived via nntp.
  546. X               */
  547. X               if (retrieve == FROM_NNTP)
  548. X                   (void) unlink(article_name);
  549. X#endif /*NNTP*/
  550. X               continue;
  551. X           }
  552. X       }
  553. X
  554. X       /*
  555. X       ** Archiving from here on out.
  556. X       */
  557. X 
  558. X       if ((new_member = save_article(article_name,newsgrp)) != NULL) {
  559. X           /*
  560. X           ** To not do any compression of setting of ownership
  561. X           ** for newsgroup articles that are archived by an
  562. X           ** external application.
  563. X           */
  564. X           if (newsgrp->type != EXTERNAL_COMMAND) {
  565. X               archived_file = compress_file(new_member,newsgrp);
  566. X               set_ownership(archived_file,new_member,newsgrp);
  567. X           }
  568. X           else
  569. X               archived_file = new_member;
  570. X           
  571. X           /*
  572. X           ** If a problem has been encountered,
  573. X           ** the function do_problem handles
  574. X           ** the logging, and notifying.
  575. X           */
  576. X
  577. X           if (!problem_article) {
  578. X               log_activities(archived_file,newsgrp);
  579. X               build_index(new_member,newsgrp);
  580. X               notify_users(archived_file,newsgrp,cct++);
  581. X           }
  582. X       }
  583. X       else {
  584. X           if (newsgrp->type != ONLY_ARCHIVE_NAME) {
  585. X               (void) fprintf(logfp,"Unable to archive %s/%s!!!\n",
  586. X                          newsgrp->ng_path, article_name);
  587. X           }
  588. X       }
  589. X#ifdef NNTP
  590. X       /*
  591. X       ** Remove the nntp transfer tmpfile if the
  592. X       ** newsgroup is being archived via nntp.
  593. X       */
  594. X       if (retrieve == FROM_NNTP)
  595. X           (void) unlink(article_name);
  596. X#endif /*NNTP*/
  597. X    }
  598. X
  599. X    if (!status_only) {
  600. X        /* Mail notification of the archived members to the   */
  601. X        /* list of users specified in the configuration file  */
  602. X        /* and remove the file containing the archived info.  */
  603. X
  604. X        mail_file(newsgrp->mail_list, tmp_mailfile, newsgrp->ng_name);
  605. X        (void) unlink(tmp_mailfile);
  606. X    }
  607. X    return;
  608. X}
  609. X
  610. X/* 
  611. X** Notify Users of Archiving.
  612. X**      If users have been specified to be informed, check to see
  613. X**      if they have requested a specific logging format. If so
  614. X**      use the specified format to notify the user. If not, use
  615. X**      "file archived at path" message.
  616. X*/
  617. Xvoid notify_users(filename,ng,num_msgs)
  618. Xchar *filename;
  619. Xstruct group_archive *ng;
  620. Xint num_msgs;
  621. X{
  622. X    /*
  623. X    ** Are there users specified in the 
  624. X    ** newsgroup section ? 
  625. X    */
  626. X    if ( *(ng->mail_list) ) {
  627. X        if ( *(ng->logformat) )
  628. X           logit(tmp_mailfile, ng->logformat, filename);
  629. X        else
  630. X           logit(tmp_mailfile, DEFAULT_LOG_FORMAT, filename);
  631. X    }
  632. X
  633. X    /* 
  634. X    ** Are there users specified in the 
  635. X    ** global section ? 
  636. X    */
  637. X    if ( *mail ) {
  638. X        if (num_msgs == 0) /* print the newsgroup name out */
  639. X            logit(global_mailfile, "\n\t\t:%G:\n",filename);
  640. X        if (*log_format)
  641. X            logit(global_mailfile, log_format,filename);
  642. X        else 
  643. X            logit(global_mailfile, DEFAULT_LOG_FORMAT, filename);
  644. X    }
  645. X}
  646. X
  647. X/*
  648. X** Log_activities
  649. X**
  650. X** There are two possible logfiles that need to be written. 
  651. X** The group specific logfile (ng->logfile) and the global 
  652. X** log. If it has been configured to use a specific format
  653. X** for the logging, do so. Else, just record the fact the
  654. X** file was sucessfully archived and the date.          
  655. X*/
  656. Xvoid log_activities(filename,ng)
  657. Xchar *filename;
  658. Xstruct group_archive *ng;
  659. X{
  660. X   long clock;
  661. X   long time();
  662. X   char *ctime();
  663. X   
  664. X   char logbuf[BUFSIZ];
  665. X   char dms_date[30];
  666. X   
  667. X   if ( !*(ng->logformat) || !*log_format) {
  668. X       clock = time((long *)0);
  669. X       (void) strcpy(dms_date, ctime(&clock));
  670. X       *(dms_date+(strlen(dms_date)-1)) = '\0';
  671. X       (void) sprintf(logbuf,"%s archived %s",filename, dms_date);
  672. X   }
  673. X
  674. X   if ( *(ng->logformat) )
  675. X       logit(ng->logfile, ng->logformat, filename);
  676. X   else
  677. X       logit(ng->logfile, logbuf, filename);
  678. X
  679. X   if ( *log_format )
  680. X       logit(log, log_format, filename);
  681. X   else
  682. X       logit(log, logbuf, filename);
  683. X}
  684. X
  685. X/*
  686. X** logit
  687. X**
  688. X** This function is used to append a logfile record 
  689. X** if there is a logfile name specified.
  690. X**
  691. X*/
  692. X
  693. Xvoid logit(filename, format_of_log, arch_file)
  694. Xchar *filename;
  695. Xchar *format_of_log;
  696. Xchar *arch_file;
  697. X{
  698. X    FILE *fp, *fopen();
  699. X    char *qp;
  700. X
  701. X    if (!test) {
  702. X        if ( *(filename) ) {   /* Is a logfile specified ? */
  703. X            if ((fp = fopen(filename,"a")) != NULL) {
  704. X                qp = format_output(format_of_log, arch_file, ARCHIVE);
  705. X                (void) fprintf(fp,"%s\n",qp);
  706. X                (void) fclose(fp);
  707. X            }
  708. X        }
  709. X    }
  710. X}    
  711. X
  712. X/*
  713. X** Set_ownership
  714. X**
  715. X**      This functions is responsible for setting the owner, group
  716. X**      and modes of a file just put into the archive. Two file names
  717. X**      are passed to this function. "filename" contains the compression
  718. X**      suffix if the file is to be compressed. "flname" is the name of
  719. X**      the file without the compression suffix. If the ownership or
  720. X**      modes can not be set on the target "filename", this function
  721. X**      then tries to set the original file, "flname". In this manner,
  722. X**      the file permissions get set even if the compression routine fails.
  723. X*/     
  724. X
  725. Xvoid set_ownership(filename,flname,ng)
  726. Xchar *filename;             /* filename with compression suffix    */ 
  727. Xchar *flname;               /* filename without compression suffix */
  728. Xstruct group_archive *ng;
  729. X{
  730. X    int chmod();
  731. X    int chown();
  732. X
  733. X    if (verbose)    /* Print out the actions about to be preformed */
  734. X        (void) fprintf(logfp,"chmod\t<%o> <%s>\n", ng->modes, filename);
  735. X
  736. X    if (!test) {    /* change the file modes to the specified modes */
  737. X        if (chmod(filename,ng->modes) != 0) {
  738. X            /* Assume the compress failed and try the original... */
  739. X            if (chmod(flname,ng->modes) != 0) 
  740. X                record_problem("Can't change modes of %O", filename, ng);
  741. X        }
  742. X    }
  743. X
  744. X    if (verbose) {  /* Print out the actions about to be preformed */
  745. X        (void) fprintf(logfp,"chown\t<%d> <%s>\n", ng->owner, filename);
  746. X        (void) fprintf(logfp,"chgrp\t<%d> <%s>\n", ng->group, filename);
  747. X    }
  748. X
  749. X    if (!test) {    /* chown the owner/group to the desired values */
  750. X        if (chown(filename, ng->owner, ng->group) != 0) {
  751. X            /* Assume the compress failed and try the original... */
  752. X            if (chown(flname, ng->owner, ng->group) != 0) { 
  753. X                /*
  754. X                ** Are we on a system that has a braindamaged chown 
  755. X                ** and does not let a general user give files away ?
  756. X                ** Assume so.  Quota be gone!!
  757. X                */
  758. X                if (getuid() == 0)
  759. X                    record_problem("Can't change ownership of %O",filename,ng);
  760. X            }
  761. X        }
  762. X    }
  763. X}
  764. X
  765. Xvoid mail_file(user_list, file_to_mail, nwsgrp)
  766. Xchar *user_list;
  767. Xchar *file_to_mail;
  768. Xchar *nwsgrp;
  769. X{
  770. X    char  *list, *name;
  771. X    char  cmdstr[80];
  772. X
  773. X    /* Is there a list of users to mail to ? */
  774. X    if ( !*user_list || (strlen(user_list) == 0))
  775. X        return;
  776. X
  777. X    /* Was there a notification file created ? */
  778. X    if (stat(file_to_mail, &sbuf) != 0) 
  779. X        return;
  780. X
  781. X    name = user_list;
  782. X    do {
  783. X       if ((list = strchr(name,',')) != NULL) {
  784. X            list++;
  785. X            *(list-1) = '\0';
  786. X        }
  787. X
  788. X#ifdef SUBJECT_LINE
  789. X        (void) sprintf(cmdstr, "%s -s '%s' %s < %s", 
  790. X                   MAIL, nwsgrp, name, file_to_mail);
  791. X#else
  792. X        (void) sprintf(cmdstr, "%s %s < %s", MAIL, name, file_to_mail);
  793. X#endif
  794. X        if (verbose)
  795. X            (void) fprintf(logfp,"Mailing %s to %s\n",
  796. X                           nwsgrp, name);
  797. X        if (!test) 
  798. X            (void) system(cmdstr);
  799. X
  800. X        name = list;
  801. X
  802. X    } while (name != NULL);
  803. X    return;
  804. X}
  805. X
  806. Xvoid build_index(filename,ng)
  807. Xchar *filename;
  808. Xstruct group_archive *ng;
  809. X{
  810. X    if (*(ng->index)) {        /* Is there a newsgroup index file ?  */
  811. X        if (*(ng->indformat))  /* Yes, Is there a index file format? */
  812. X            logit(ng->index, ng->indformat, filename);
  813. X        else if (*index_format)    /* No, is there a global format ? */
  814. X            logit(ng->index, index_format, filename);
  815. X        else                   /* No, use the default index format   */
  816. X            logit(ng->index, DEFAULT_INDEX_FORMAT, filename);
  817. X    }
  818. X
  819. X    if (*mindex) {            /* Is there a global index file ?       */
  820. X        if (*index_format)   /* Yes, Is there a global file format ? */
  821. X            logit(mindex, index_format, filename);
  822. X        else                 /* No, so use the default index format  */
  823. X            logit(ng->index, DEFAULT_INDEX_FORMAT , filename);
  824. X    }
  825. X}
  826. X
  827. X
  828. Xchar *compress_file(filename,ng)
  829. Xchar *filename;
  830. Xstruct group_archive *ng;
  831. X{
  832. X    static char compressed[MAXNAMLEN];
  833. X
  834. X    (void) strcpy(compressed, filename);  /* store the filename */
  835. X
  836. X    /* Check to see if a group specific compress was specified.      */
  837. X    /* If so, then execute the command with the filename passed in.  */
  838. X    /* Else check to see if a global compress was specified. If so,  */
  839. X    /* then execute the command with the filename passed in.         */
  840. X    /* If both are NULL, no compression is done.                     */
  841. X
  842. X    if (*(ng->compress) || (*compress)) { 
  843. X        if (*(ng->compress)) 
  844. X            (void) strcat(compressed, do_compress(ng->compress, filename));
  845. X        else if (*compress) 
  846. X            (void) strcat(compressed, do_compress(compress, filename));
  847. X
  848. X        /* Check to see if the compression worked. If not, return the */
  849. X        /* original file name passed to this function. The check is   */
  850. X        /* done by assuring the compressed file exists. If not then   */
  851. X        /* it is assumed that it failed.                              */
  852. X
  853. X        if (stat(compressed, &sbuf) == -1) 
  854. X            (void) strcpy(compressed, filename);   /* restore filename */
  855. X    }
  856. X    return(compressed);
  857. X}
  858. X
  859. Xchar *do_compress(packit,filename)
  860. Xchar *packit;
  861. Xchar *filename;
  862. X{
  863. X    char *comp_cmd;
  864. X    char *kp;
  865. X    char cmd[BUFSIZ];
  866. X
  867. X    (void) sprintf(cmd,"%s %s", packit, filename);
  868. X
  869. X    /* 
  870. X    ** get the basename of the command to use.
  871. X    */
  872. X    comp_cmd = basename(packit);
  873. X
  874. X    if (verbose)
  875. X       (void) fprintf(logfp,"%s %s\n", comp_cmd, filename);
  876. X
  877. X    if (!test) 
  878. X       (void) system(cmd);
  879. X
  880. X    /* 
  881. X    ** Need to remove any compression command 
  882. X    ** options if they exist. (compress -f)
  883. X    */
  884. X
  885. X    (void) sprintf(cmd,"%s", comp_cmd);
  886. X
  887. X    if ((kp = strchr(cmd,' ')) != NULL) {
  888. X         *kp = '\0';
  889. X    }
  890. X    return(suffix(cmd));
  891. X}
  892. X
  893. X
  894. X/*
  895. X** Record_problem()
  896. X**    This function is used to log problems encountered
  897. X**    to the designated parties.
  898. X*/
  899. X
  900. Xvoid record_problem(msg_fmt,filename,ng)
  901. Xchar *msg_fmt;
  902. Xchar *filename;
  903. Xstruct group_archive *ng;
  904. X{
  905. X    /* 
  906. X    ** This function is used in the event that a problem
  907. X    ** has occurred during archiving. It mails a message
  908. X    ** to the newsgroup speecified list and it mails a 
  909. X    ** message to the globally specified users.
  910. X    ** 
  911. X    ** It then logs the fact into both the newsgroup 
  912. X    ** and the global logfiles if they have been specified.
  913. X    */
  914. X
  915. X    if ( *(ng->mail_list) ) 
  916. X        logit(tmp_mailfile, msg_fmt, filename);
  917. X    
  918. X    if ( *mail ) 
  919. X        logit(global_mailfile, msg_fmt,filename);
  920. X    
  921. X    logit(ng->logfile, msg_fmt, filename);
  922. X    logit(log, msg_fmt, filename);
  923. X}
  924. END_OF_FILE
  925. if test 27854 -ne `wc -c <'rkive/rkive.c'`; then
  926.     echo shar: \"'rkive/rkive.c'\" unpacked with wrong size!
  927. fi
  928. # end of 'rkive/rkive.c'
  929. fi
  930. if test -f 'rkive/setup.c' -a "${1}" != "-c" ; then 
  931.   echo shar: Will not clobber existing file \"'rkive/setup.c'\"
  932. else
  933. echo shar: Extracting \"'rkive/setup.c'\" \(23815 characters\)
  934. sed "s/^X//" >'rkive/setup.c' <<'END_OF_FILE'
  935. X/*
  936. X** This software is Copyright (c) 1989, 1990, 1991 by Kent Landfield.
  937. X**
  938. X** Permission is hereby granted to copy, distribute or otherwise 
  939. X** use any part of this package as long as you do not try to make 
  940. X** money from it or pretend that you wrote it.  This copyright 
  941. X** notice must be maintained in any copy made.
  942. X**
  943. X*/
  944. X
  945. X#if !defined(lint) && !defined(SABER)
  946. Xstatic char SID[] = "@(#)setup.c    2.2 2/23/91";
  947. X#endif
  948. X
  949. X#include <sys/types.h>
  950. X#include <sys/stat.h>
  951. X#include <stdio.h>
  952. X#include <ctype.h>
  953. X#include <pwd.h>
  954. X#include <grp.h>
  955. X#include "cfg.h"
  956. X
  957. X#define GAG(b) ((void) fprintf(errfp,"%s invalid variable, ignoring.\n",b))
  958. X
  959. Xchar spooldir[MAXNAMLEN]     = { SPOOLDIR };
  960. Xchar problems_dir[MAXNAMLEN] = { PROBLEMS_DIR };
  961. X
  962. Xint default_owner = OWNER;
  963. Xint default_group = GROUP;
  964. Xint default_modes = MODES;
  965. Xint default_type = CHRONOLOGICAL;
  966. Xint default_patch_type = HISTORICAL;
  967. X
  968. Xchar default_match[MAXMATCHLEN];
  969. X
  970. X/*
  971. X** compress -
  972. X** Used to  determine whether or not articles should be compressed 
  973. X** to save space. The command to execute is stored in compress.
  974. X*/
  975. Xchar compress[MAXNAMLEN] = { '\0' };
  976. X
  977. X/*
  978. X** arch_command -
  979. X** Used to determine whether or not articles should be piped
  980. X** to an external command for the actual archiving.
  981. X*/
  982. Xchar arch_command[MAXNAMLEN] = { '\0' };
  983. X
  984. X/*
  985. X** mail -
  986. X** If specified, all actions logged are mailed to the list of users 
  987. X** specified.  The user names are a comma seperated list. 
  988. X*/
  989. Xchar mail[MAXNAMLEN] = { '\0' };
  990. X
  991. X/*
  992. X** checkhash -
  993. X** If specified, command to feed article to for transit damage.
  994. X*/
  995. Xchar checkhash[MAXNAMLEN] = { '\0' };
  996. X
  997. X#ifdef NNTP
  998. X/*
  999. X** nntp -
  1000. X** If specified, nntp contains the system name of the nntp server.
  1001. X*/
  1002. Xchar nntp[MAXNAMLEN] = { '\0' };
  1003. X#endif /*NNTP*/
  1004. X
  1005. X/*
  1006. X** log -
  1007. X** The location of the master log in which all actions are logged. 
  1008. X** If not specified, all logged events are printed on stdout.
  1009. X*/
  1010. Xchar log[MAXNAMLEN] = { '\0' };
  1011. X
  1012. X/*
  1013. X** log_format -
  1014. X** The format of each individual log file record. The format is
  1015. X** then filled with information contained in the headers.
  1016. X*/
  1017. Xchar log_format[BUFSIZ] = { '\0' };
  1018. X
  1019. X/*
  1020. X** mindex -
  1021. X** The location of the master index.
  1022. X*/
  1023. Xchar mindex[MAXNAMLEN] = { '\0' };
  1024. X
  1025. X/*
  1026. X** index_format -
  1027. X** The format of each individual master index record. The format 
  1028. X** is then filled with information contained in the headers.
  1029. X*/
  1030. Xchar index_format[BUFSIZ] = { '\0' };
  1031. X
  1032. Xchar *config_file;
  1033. XFILE *config;
  1034. X
  1035. Xstruct stat stbuf;
  1036. Xstruct passwd *pwent;
  1037. X
  1038. Xint get_group();
  1039. Xint get_owner();
  1040. Xint correct_modes();
  1041. Xint get_patch_type();
  1042. Xint get_archive_type();
  1043. Xint fclose();
  1044. Xint sscanf();
  1045. Xint stat();
  1046. Xint strlen();
  1047. Xint strcmp();
  1048. Xint strncmp();
  1049. Xchar *strstrip();
  1050. Xchar *strchr();
  1051. Xchar *strcpy();
  1052. Xvoid error();
  1053. Xvoid get_spooldir();
  1054. Xvoid get_archive_basedir();
  1055. Xstruct passwd *getpwnam();
  1056. X
  1057. Xstruct restricted_dirs {
  1058. X    char   *dirstr;            /* path of restricted directory */
  1059. X};
  1060. X
  1061. Xstatic struct restricted_dirs base_dirs[] = {
  1062. X{  "/"               },
  1063. X{  "/bin"            },
  1064. X{  "/dev"            },
  1065. X{  "/dev/dsk"        },
  1066. X{  "/dev/rdsk"       },
  1067. X{  "/etc"            },
  1068. X{  "/lib"            },
  1069. X{  "/stand"          },
  1070. X{  "/sbin"           },
  1071. X{  "/sys"            },
  1072. X{  "/usr/5bin"       },
  1073. X{  "/usr/5include"   },
  1074. X{  "/usr/5lib"       },
  1075. X{  "/usr/adm"        },
  1076. X{  "/usr/adm"        },
  1077. X{  "/usr/boot"       },
  1078. X{  "/usr/diag"       },
  1079. X{  "/usr/etc"        },
  1080. X{  "/usr/include"    },
  1081. X{  "/usr/kvm"        },
  1082. X{  "/usr/spool/uucp" },
  1083. X{  "/usr/man"        },
  1084. X{  "/usr/sccs"       },
  1085. X{  "/usr/sys"        },
  1086. X{  "/usr/ucb"        },
  1087. X{  "/usr/ucbinclude" },
  1088. X{  "/usr/ucblib"     },
  1089. X{  "/usr/xpg2bin"    },
  1090. X{  "/usr/xpg2include" },
  1091. X{  "/usr/xpg2lib"    },
  1092. X{  NULL              },
  1093. X};
  1094. X
  1095. Xint config_line_count = 0;
  1096. X
  1097. X/*
  1098. X**  Reads lines from file, catting lines 
  1099. X**  ending with a backslash together. 
  1100. X*/
  1101. X
  1102. Xchar *long_fgets(buffer, size, fp)
  1103. Xchar *buffer;
  1104. Xint size;
  1105. XFILE *fp;
  1106. X{
  1107. X    static char buf[BUFSIZ];
  1108. X    extern char *strcat();
  1109. X    register char *p;
  1110. X
  1111. X    *buffer = 0;
  1112. X
  1113. X    for (;;) {
  1114. X        if (fgets(buf, BUFSIZ, fp) == NULL) {
  1115. X            if (*buffer) {
  1116. X                if ((p = strchr(buf, '\n')) != NULL) 
  1117. X                    *p = 0;
  1118. X                return buffer;
  1119. X            }
  1120. X            else
  1121. X                return NULL;
  1122. X        }
  1123. X
  1124. X        if ((p = strchr(buf, '\n')) != NULL)
  1125. X            *p = 0;
  1126. X
  1127. X        if (*buf) {
  1128. X            if (*(buf + strlen(buf) - 1) != '\\') {
  1129. X                /* 
  1130. X                ** If line would be too long,
  1131. X                ** print warning and return empty 
  1132. X                */
  1133. X                if (strlen(buffer) + strlen(buf) >= size) {
  1134. X                   (void) fprintf(errfp,"Config %d: Input line overflow, %d max\n",
  1135. X                             config_line_count, size);
  1136. X                    *buffer = 0;
  1137. X                    return buffer;
  1138. X                }
  1139. X                (void) strcat(buffer, buf);
  1140. X                return buffer;
  1141. X            }
  1142. X            else {
  1143. X                *(buf + strlen(buf) - 1) = 0; /* Remove backslash */
  1144. X
  1145. X                /* 
  1146. X                ** If too long, print warning, read 
  1147. X                ** all continuation lines and ignore 
  1148. X                ** them, return empty line 
  1149. X                */
  1150. X
  1151. X                if (strlen(buffer) + strlen(buf) >= size) {
  1152. X                    (void) fprintf(errfp,"Config %d: Input line overflow, %d max\n",
  1153. X                           config_line_count, size);
  1154. X                    while (*(buf + strlen(buf) - 1) == '\\' && fgets(buf, BUFSIZ, fp))
  1155. X                          ;
  1156. X                    *buffer = 0;
  1157. X                    return buffer;
  1158. X                }
  1159. X
  1160. X                /* Add new line and read next one */
  1161. X
  1162. X                (void) strcat(buffer, buf);
  1163. X             }
  1164. X         }
  1165. X         else
  1166. X             return buffer;
  1167. X
  1168. X       } /* End for(ever) */
  1169. X}
  1170. X
  1171. X
  1172. Xvoid setup_defaults()
  1173. X{
  1174. X    char *sp;
  1175. X    char *buf;
  1176. X    char buffer[BUFSIZ];
  1177. X    char mode_str[128];
  1178. X
  1179. X    char *sav_format();
  1180. X    char *get_cmd();
  1181. X    char *get_users();
  1182. X#ifdef NNTP
  1183. X    char *getnntp();
  1184. X#endif /*NNTP*/
  1185. X    FILE *efopen();
  1186. X
  1187. X    config = efopen(config_file,"r");
  1188. X
  1189. X    num = -1; /* initialize group structure index */
  1190. X    
  1191. X    while (long_fgets(buffer, sizeof buffer, config) != NULL) {
  1192. X        config_line_count++;
  1193. X        /* ignore comments and blank lines */
  1194. X        if (*buffer == '#' || !*buffer) 
  1195. X            continue;
  1196. X
  1197. X        buf = buffer;
  1198. X
  1199. X        /* strip leading spaces and tabs */
  1200. X    while(*buf == ' ' || *buf == '\t')
  1201. X             ++buf;
  1202. X
  1203. X        /* if embedded comments, truncate at the comment */
  1204. X        if ((sp = strchr(buf,'#')) != NULL)
  1205. X             *sp = '\0';
  1206. X    
  1207. X        /* check to see if newsgroup entry */
  1208. X
  1209. X        if (*buf == '$' && *(buf+1) == '$') {
  1210. X            if (++num >= NUM_NEWSGROUPS)
  1211. X               error("Maximum number of newsgroups exceeded!!\n", 
  1212. X                    "Please increase the NUM_NEWSGROUPS define...");
  1213. X
  1214. X            sp = buf+2;
  1215. X            while (*sp && !isspace(*sp))
  1216. X        ++sp;
  1217. X            *sp = '\0';
  1218. X
  1219. X            group[num].owner     = default_owner;
  1220. X            group[num].group     = default_group;
  1221. X            group[num].modes     = default_modes;
  1222. X            group[num].type      = default_type;
  1223. X            group[num].patch_type = default_patch_type;
  1224. X            (void) strcpy (group[num].ng_name, strstrip(buf+2));
  1225. X            group[num].location[0]  = '\0';
  1226. X            group[num].mail_list[0] = '\0';
  1227. X            group[num].arc_done[0]  = '\0';
  1228. X            group[num].logfile[0]   = '\0';
  1229. X            group[num].index[0]     = '\0';
  1230. X            group[num].patchlog[0]  = '\0';
  1231. X            group[num].logformat[0] = '\0';
  1232. X            group[num].indformat[0] = '\0';
  1233. X            group[num].compress[0]  = '\0';
  1234. X            group[num].checkhash[0]  = '\0';
  1235. X            group[num].match[0]     = '\0';
  1236. X            group[num].arch_command[0] = '\0';
  1237. X
  1238. X#ifdef NNTP
  1239. X            group[num].nntp[0]  = '\0';
  1240. X#endif /*NNTP*/
  1241. X        }
  1242. X
  1243. X        else if ((sp = strchr(buf,'=')) != NULL) {
  1244. X            sp++;
  1245. X                    /* Global assignment */
  1246. X            while (*sp == ' ' || *sp == '\t')
  1247. X                sp++;
  1248. X
  1249. X            if (!*sp)        /* is something still there ? */
  1250. X        continue;
  1251. X
  1252. X            switch(*buf) {
  1253. X               case 'A': if (strncmp(buf, "ARCHIVE_CMD", 11) == 0)
  1254. X                            (void) strcpy(arch_command, get_cmd(sp));
  1255. X                         else
  1256. X                            GAG(buf);
  1257. X                         break;
  1258. X               case 'C': if (strncmp(buf, "COMPRESS", 8) == 0)
  1259. X                            (void) strcpy(compress, get_cmd(sp));
  1260. X                         else if (strncmp(buf, "CHECKHASH", 9) == 0)
  1261. X                            (void) strcpy(checkhash, get_cmd(sp));
  1262. X                         else
  1263. X                            GAG(buf);
  1264. X                         break;
  1265. X               case 'G': if (strncmp(buf,"GROUP",5) == 0)
  1266. X                             default_group = get_group(sp);
  1267. X                         else
  1268. X                            GAG(buf);
  1269. X                         break;
  1270. X               case 'I': if (strncmp(buf, "INDEX_FORMAT", 12) == 0)
  1271. X                            (void) strcpy(index_format, sav_format(sp));
  1272. X                         else if (strncmp(buf, "INDEX", 3) == 0)
  1273. X                            (void) strcpy(mindex, strstrip(sp));
  1274. X                         else
  1275. X                            GAG(buf);
  1276. X                         break;
  1277. X               case 'L': if (strncmp(buf, "LOG_FORMAT", 10) == 0)
  1278. X                            (void) strcpy(log_format, sav_format(sp));
  1279. X                         else if (strncmp(buf, "LOG", 3) == 0)
  1280. X                            (void) strcpy(log, strstrip(sp));
  1281. X                         else
  1282. X                            GAG(buf);
  1283. X                         break;
  1284. X               case 'M': if (strncmp(buf, "MAIL",4) == 0) 
  1285. X                             (void) strcpy(mail,get_users(sp));
  1286. X                         else if (strncmp(buf, "MODE",4) == 0) 
  1287. X                             default_modes = correct_modes(sp, mode_str);
  1288. X                         else if (strncmp(buf, "MATCH", 5) == 0)
  1289. X                             (void) strcpy(default_match, sp);
  1290. X                         else
  1291. X                             GAG(buf);
  1292. X                         break;
  1293. X#ifdef NNTP
  1294. X               case 'N': if (strncmp(buf, "NNTP",4) == 0) 
  1295. X                             (void) strcpy(nntp, getnntp(sp));
  1296. X                         else 
  1297. X                             GAG(buf);
  1298. X                         break;
  1299. X#endif /*NNTP*/
  1300. X               case 'O': if (strncmp(buf,"OWNER",5) == 0)
  1301. X                             default_owner = get_owner(sp);
  1302. X                         else 
  1303. X                             GAG(buf);
  1304. X                         break;
  1305. X               case 'P': if (strncmp(buf, "PROBLEMS", 8) == 0)
  1306. X                           (void) strcpy(problems_dir, strstrip(sp));
  1307. X                         else if (strncmp(buf,"PATCHES",7) == 0)
  1308. X                           default_patch_type = get_patch_type("Global",sp);
  1309. X                         else 
  1310. X                             GAG(buf);
  1311. X                         break;
  1312. X               case 'S': if (strncmp(buf,"SPOOLDIR",8) == 0)
  1313. X                             get_spooldir(sp);
  1314. X                         else 
  1315. X                             GAG(buf);
  1316. X                         break;
  1317. X               case 'T': if (strncmp(buf,"TYPE",4) == 0)
  1318. X                             default_type = get_archive_type("Global", sp);
  1319. X                         else 
  1320. X                             GAG(buf);
  1321. X                         break;
  1322. X               default : (void) fprintf(errfp,
  1323. X                                  "%s invalid global assignment, ignoring.\n",
  1324. X                                  buf);
  1325. X            }
  1326. X        }
  1327. X        else if ((sp = strchr(buf,':')) != NULL) {
  1328. X            sp++;
  1329. X                /* group variable assignment */
  1330. X            while (*sp == ' ' || *sp == '\t')
  1331. X                sp++;
  1332. X
  1333. X            if (!*sp)        /* is something still there ? */
  1334. X        continue;
  1335. X
  1336. X            switch(*buf) {
  1337. X               case 'A': if (strncmp(buf, "ARCHIVE_CMD", 11) == 0)
  1338. X                            (void)strcpy(group[num].arch_command,get_cmd(sp));
  1339. X                         else if (strncmp(buf, "ARCHIVED_LOG", 11) == 0) 
  1340. X                            (void) sprintf(group[num].arc_done, strstrip(sp));
  1341. X                         else
  1342. X                            GAG(buf);
  1343. X                         break;
  1344. X               case 'B': if (strncmp(buf, "BASEDIR",7) == 0) 
  1345. X                            get_archive_basedir(sp);
  1346. X                         break;
  1347. X               case 'C': if (strncmp(buf, "COMPRESS", 8) == 0)
  1348. X                            (void) strcpy(group[num].compress,get_cmd(sp));
  1349. X                         else if (strncmp(buf, "CHECKHASH", 9) == 0)
  1350. X                            (void) strcpy(group[num].checkhash,get_cmd(sp));
  1351. X                         else
  1352. X                            GAG(buf);
  1353. X                         break;
  1354. X               case 'G': if (strncmp(buf,"GROUP",5) == 0)
  1355. X                             group[num].group = get_group(sp);
  1356. X                         else
  1357. X                            GAG(buf);
  1358. X                         break;
  1359. X               case 'I': if (strncmp(buf, "INDEX_FORMAT", 12) == 0)
  1360. X                            (void) strcpy(group[num].indformat,sav_format(sp));
  1361. X                         else if (strncmp(buf, "INDEX", 3) == 0)
  1362. X                             (void) strcpy(group[num].index, strstrip(sp));
  1363. X                         else
  1364. X                             GAG(buf);
  1365. X                         break;
  1366. X               case 'L': if (strncmp(buf, "LOG_FORMAT", 10) == 0)
  1367. X                            (void) strcpy(group[num].logformat, sav_format(sp));
  1368. X                         else if (strncmp(buf, "LOG", 3) == 0)
  1369. X                            (void) strcpy(group[num].logfile, strstrip(sp));
  1370. X                         else
  1371. X                            GAG(buf);
  1372. X                         break;
  1373. X               case 'M': if (strncmp(buf, "MAIL",4) == 0)
  1374. X                            (void) strcpy(group[num].mail_list, get_users(sp));
  1375. X                         else if (strncmp(buf, "MODE",4) == 0) 
  1376. X                             group[num].modes = correct_modes(sp, mode_str);
  1377. X                         else if (strncmp(buf, "MATCH", 5) == 0)
  1378. X                             /* Copy as it is! */
  1379. X                             (void) strcpy(group[num].match, sp);
  1380. X                         else 
  1381. X                             GAG(buf);
  1382. X                         break;
  1383. X#ifdef NNTP
  1384. X               case 'N': if (strncmp(buf, "NNTP",4) == 0) 
  1385. X                             (void) strcpy(group[num].nntp, getnntp(sp));
  1386. X                         else 
  1387. X                             GAG(buf);
  1388. X                         break;
  1389. X#endif /*NNTP*/
  1390. X               case 'O': if (strncmp(buf,"OWNER",5) == 0)
  1391. X                             group[num].owner = get_owner(sp);
  1392. X                         else 
  1393. X                             GAG(buf);
  1394. X                         break;
  1395. X               case 'P': if (strncmp(buf,"PATCHLOG",8) == 0)
  1396. X                             (void) sprintf(group[num].patchlog, strstrip(sp));
  1397. X                         else if (strncmp(buf,"PATCHES",7) == 0)
  1398. X                             group[num].patch_type = get_patch_type(group[num].ng_name,sp);
  1399. X                         else 
  1400. X                             GAG(buf);
  1401. X                         break;
  1402. X               case 'T': if (strncmp(buf,"TYPE",4) == 0)
  1403. X                             group[num].type = get_archive_type(group[num].ng_name,sp);
  1404. X                         else 
  1405. X                             GAG(buf);
  1406. X                         break;
  1407. X               default : (void) fprintf(errfp,
  1408. X                                  "%s invalid group assignment, ignoring.\n",
  1409. X                                  buf);
  1410. X            }
  1411. X        }
  1412. X        else /* no idea what it is */
  1413. X            error("unknown line type", buf);
  1414. X    }
  1415. X    (void) fclose(config);
  1416. X    config_line_count = 0;
  1417. X}
  1418. X
  1419. Xvoid error(msg1,msg2)
  1420. X   char *msg1;
  1421. X   char *msg2;
  1422. X{
  1423. X   if (config_line_count)
  1424. X      (void) fprintf(errfp,"%s: config line %d: %s %s\n",
  1425. X                   progname, config_line_count, msg1, msg2);
  1426. X   else
  1427. X      (void) fprintf(errfp,"%s: %s %s\n",progname,msg1, msg2);
  1428. X
  1429. X    exit(1);
  1430. X/*NOTREACHED*/
  1431. X}
  1432. X
  1433. X/*
  1434. X** valid_base_directory
  1435. X**
  1436. X** Assure the directory specified in the configuration file 
  1437. X** as the base directory for a newsgroup archive is not found 
  1438. X** in the table of restricted base directories. 
  1439. X**
  1440. X** This kind of checking is almost insulting to me as an 
  1441. X** administrator but, enough people asked me to put it in 
  1442. X** so "this duds for you"..
  1443. X*/
  1444. X
  1445. Xint valid_base_directory(argstr)
  1446. X    char *argstr;
  1447. X {
  1448. X    register char *rp;
  1449. X    register char *dp;
  1450. X    char wpath[MAXNAMLEN];
  1451. X    char lastchar;
  1452. X    struct restricted_dirs *pt;
  1453. X
  1454. X    /* 
  1455. X    ** First check to see if the base directory is any
  1456. X    ** character other than a slash. We need to assure
  1457. X    ** that "../../../etc" or ./etc is not allowed.  We
  1458. X    ** need a valid absolute path with which to do relative
  1459. X    ** path addressing. (Have I confused myself yet ?)
  1460. X    */
  1461. X
  1462. X    if (*argstr != '/') 
  1463. X            return(FALSE);
  1464. X
  1465. X    /* 
  1466. X    ** Strip the string of duplicate '/'s.
  1467. X    ** Also check to assure that the path specified
  1468. X    ** does not contain the '..' sequence.
  1469. X    */
  1470. X
  1471. X    dp = argstr;
  1472. X    rp = wpath;
  1473. X    lastchar = ' ';
  1474. X
  1475. X    while (*dp) {
  1476. X       if (*dp != '/' || lastchar != '/') {
  1477. X           lastchar = *dp;
  1478. X           *rp++ = *dp;
  1479. X       }
  1480. X       if (*dp == '.' && lastchar == '.') {
  1481. X           if ((*(dp+1) == '/') || (*(dp+1) == '\0'))
  1482. X               return(FALSE);
  1483. X       }
  1484. X       ++dp;
  1485. X    }
  1486. X    *rp = '\0';
  1487. X
  1488. X    /* 
  1489. X    ** strip the string of trailing '/'s so
  1490. X    ** I can use the simple checking below.
  1491. X    */
  1492. X
  1493. X    dp = wpath+(strlen(wpath)-1);
  1494. X    while(*dp == '/' && dp > wpath)
  1495. X        *dp = '\0';
  1496. X
  1497. X    /* 
  1498. X    ** check if they match 
  1499. X    */
  1500. X
  1501. X    pt = &base_dirs[0];
  1502. X    while ((pt->dirstr) != NULL) {
  1503. X
  1504. X        if (strcmp(wpath, pt->dirstr) == 0) 
  1505. X            return(FALSE);
  1506. X
  1507. X        pt++;
  1508. X    }
  1509. X    return(TRUE);
  1510. X}
  1511. X
  1512. Xvoid get_archive_basedir(s)
  1513. Xchar *s;
  1514. X{
  1515. X    (void) strcpy(group[num].location, strstrip(s));
  1516. X
  1517. X    if (!valid_base_directory(group[num].location))
  1518. X        error(group[num].ng_name," - Invalid archive base directory!");
  1519. X}
  1520. X
  1521. Xint correct_modes(s,mode_string)
  1522. Xchar *s;
  1523. Xchar *mode_string;
  1524. X{
  1525. X    register int c;
  1526. X    register int i;
  1527. X
  1528. X    i = 0;
  1529. X    (void) sscanf(s, "%s", mode_string);
  1530. X    while ((c = *mode_string++) >= '0' && c <= '7')
  1531. X        i = (i << 3) + (c - '0');
  1532. X    mode_string--;
  1533. X    return(i);
  1534. X}
  1535. X
  1536. X
  1537. Xchar *get_cmd(cmd)
  1538. Xchar *cmd;
  1539. X{
  1540. X    static char *rp;
  1541. X    char *kp;
  1542. X
  1543. X    rp = strstrip(cmd);
  1544. X
  1545. X    /*
  1546. X    ** Here an external command needs to be verified.
  1547. X    ** To do so, the options must be removed. I am being
  1548. X    ** real lazy here but what the hey..
  1549. X    ** If a space is found after the cmdline is striped
  1550. X    ** put a null there and then replace it with a 
  1551. X    ** space after the check... 
  1552. X    */
  1553. X   
  1554. X    if ((kp = strchr(rp,' ')) != NULL)
  1555. X        *kp = '\0';
  1556. X    else if ((kp = strchr(rp,'\t')) != NULL)
  1557. X        *kp = '\0';
  1558. X
  1559. X    /* need to assure the user has specified */
  1560. X    /* a valid executable path.              */
  1561. X
  1562. X    if (stat(rp, &stbuf) != 0) 
  1563. X        error("Can't find specified command -", rp);
  1564. X
  1565. X    if (kp != NULL)  /* replace the space.. */
  1566. X        *kp = ' ';
  1567. X
  1568. X    return(rp);
  1569. X}
  1570. X
  1571. X#ifdef NNTP
  1572. Xchar *getnntp(loc)
  1573. Xchar *loc;
  1574. X{
  1575. X    static char *rp;
  1576. X
  1577. X    rp = strstrip(loc);
  1578. X     
  1579. X    /*
  1580. X    ** check to assure that the user does not wish to negate 
  1581. X    ** a global declaration for the nntp server.
  1582. X    */
  1583. X
  1584. X    if ((strncmp(rp,"LOCAL",5) == 0) || (strncmp(rp, "local",5) == 0))
  1585. X        return("");
  1586. X
  1587. X    return(rp);
  1588. X}
  1589. X#endif /*NNTP*/
  1590. X        
  1591. X
  1592. X
  1593. Xint get_group(valstr)
  1594. Xchar *valstr;
  1595. X{
  1596. X    char *wp;
  1597. X    struct group *grent;
  1598. X    struct group *getgrnam();
  1599. X    
  1600. X    /* group specified by names but */
  1601. X    /* needs to be numbers          */
  1602. X
  1603. X    wp = strstrip(valstr);
  1604. X
  1605. X    if ((grent = getgrnam(wp)) == NULL)
  1606. X         error("Invalid system group:",wp);
  1607. X    return(grent->gr_gid);
  1608. X}
  1609. X
  1610. X
  1611. Xint get_owner(valstr)
  1612. Xchar *valstr;
  1613. X{
  1614. X    char *wp;
  1615. X
  1616. X    /* owner specified by names but */
  1617. X    /* needs to be numbers          */
  1618. X
  1619. X    wp = strstrip(valstr);
  1620. X
  1621. X    if ((pwent = getpwnam(wp)) == NULL)
  1622. X         error("Invalid user:",wp);
  1623. X    return(pwent->pw_uid);
  1624. X}
  1625. X
  1626. Xint get_archive_type(ngname, s)
  1627. Xchar *ngname;
  1628. Xchar *s;
  1629. X{
  1630. X    int return_type = default_type;
  1631. X
  1632. X    if (strcmp(s, "Archive-Name") == 0) 
  1633. X        return_type = ARCHIVE_NAME;
  1634. X    else if (strcmp(s, "Volume-Issue") == 0) 
  1635. X        return_type = VOLUME_ISSUE;
  1636. X    else if (strcmp(s, "Chronological") == 0) 
  1637. X        return_type = CHRONOLOGICAL;
  1638. X    else if (strcmp(s, "Article-Number") == 0) 
  1639. X        return_type = ARTICLE_NUMBER;
  1640. X    else if (strcmp(s, "Comp-Archives") == 0) 
  1641. X        return_type = COMP_ARCHIVES;
  1642. X    else if (strcmp(s, "External-Command") == 0) 
  1643. X        return_type = EXTERNAL_COMMAND;
  1644. X    else if (strcmp(s, "Only-Archive-Name") == 0) 
  1645. X        return_type = ONLY_ARCHIVE_NAME;
  1646. X    else {
  1647. X        (void) fprintf(errfp,"%s: %s: %s %s\n", progname,
  1648. X                   ngname, "Invalid Archive Type:", s);
  1649. X        (void) fprintf(errfp,"\tTYPE Must be %s, %s, %s, %s, %s, %s or %s\n",
  1650. X                   "Archive-Name",  "Volume-Issue", "Comp-Archives",
  1651. X                   "External-Command", "Only-Archive-Name", 
  1652. X                   "Chronological", "Article-Number");
  1653. X        exit(1);
  1654. X    }
  1655. X    return(return_type);
  1656. X}
  1657. X
  1658. Xvoid get_spooldir(s)
  1659. Xchar *s;
  1660. X{
  1661. X    static char *rp;
  1662. X
  1663. X    rp = strstrip(s);
  1664. X
  1665. X    /* need to assure the user has specified */
  1666. X    /* a valid directory path for the base   */
  1667. X    /* directory for the news subsystem..    */
  1668. X    
  1669. X    if (stat(rp, &stbuf) != 0) 
  1670. X        error("Can't find SPOOLDIR -", rp);
  1671. X    
  1672. X    (void) strcpy(spooldir, rp);
  1673. X}
  1674. X
  1675. Xchar *get_users(s)
  1676. Xchar *s;
  1677. X{
  1678. X    char *strcat();
  1679. X
  1680. X    static char users[512];
  1681. X    char tmp_users[512];
  1682. X    char *list, *name;
  1683. X    char *cp, *dp;
  1684. X    register int i;
  1685. X
  1686. X    /* prepare the string for saving by stripping any spaces */
  1687. X
  1688. X    for (i = 0; i < sizeof users; i++)
  1689. X       users[i] = '\0';
  1690. X
  1691. X    cp = s;
  1692. X    dp = users;
  1693. X    while (*cp) {
  1694. X          if (*cp != ' ' && *cp != '\t')
  1695. X              *dp++ = *cp;
  1696. X          ++cp;
  1697. X    }
  1698. X      
  1699. X    /* Need to check the specified user list */
  1700. X    /* to assure that all users are valid.   */
  1701. X
  1702. X    (void) strcpy(tmp_users, users);
  1703. X    *users = '\0';
  1704. X
  1705. X    name = tmp_users;
  1706. X
  1707. X    while (name != NULL) {
  1708. X        /* is there additional users specified ? */
  1709. X    if ((list = strchr(name,',')) != NULL) {
  1710. X             list++;
  1711. X             *(list-1) = '\0';
  1712. X        }
  1713. X
  1714. X#ifdef CHECK_LOGNAME 
  1715. X        /* check if user is found in passwd file */
  1716. X        if ((pwent = getpwnam(name)) == NULL) 
  1717. X            error("Invalid user:",name);
  1718. X#endif /* CHECK_LOGNAME */
  1719. X
  1720. X        if (*users != '\0') {
  1721. X            (void) strcat(users, ",");
  1722. X            (void) strcat(users, name);
  1723. X        }
  1724. X        else 
  1725. X            (void) strcpy(users, name);
  1726. X        name = list;
  1727. X    }
  1728. X    return(users);
  1729. X}
  1730. X
  1731. X/*
  1732. X** get a specified format from the buffer
  1733. X**    Must allow for spaces and tabs so they
  1734. X**      need to be passed intact in the format.
  1735. X*/
  1736. Xchar *sav_format(s)
  1737. X    char *s;
  1738. X{
  1739. X    static char *cp;
  1740. X    char *dp;
  1741. X    
  1742. X    if ((cp = strchr(s,'"')) != NULL && 
  1743. X        (dp = strchr(++cp,'"')) != NULL) {
  1744. X        *dp = '\0';
  1745. X    }
  1746. X    else
  1747. X        cp = NULL;
  1748. X    return(cp);
  1749. X}
  1750. X
  1751. Xint get_patch_type(ngname,s)
  1752. Xchar *ngname;
  1753. Xchar *s;
  1754. X{
  1755. X    int return_type = default_type;
  1756. X
  1757. X    if (strcmp(s, "Package") == 0) 
  1758. X        return_type = PACKAGE;
  1759. X    else if (strcmp(s, "Historical") == 0) 
  1760. X        return_type = HISTORICAL;
  1761. X    else {
  1762. X        (void) fprintf(errfp,"%s: %s: %s %s\n", progname,
  1763. X                   ngname, "Invalid Patches Type:", s);
  1764. X        (void) fprintf(errfp,"\tPATCHES Must be %s, or %s\n",
  1765. X                   "Historical", "Package");
  1766. X        exit(1);
  1767. X    }
  1768. X    return(return_type);
  1769. X}
  1770. END_OF_FILE
  1771. if test 23815 -ne `wc -c <'rkive/setup.c'`; then
  1772.     echo shar: \"'rkive/setup.c'\" unpacked with wrong size!
  1773. fi
  1774. # end of 'rkive/setup.c'
  1775. fi
  1776. echo shar: End of archive 2 \(of 6\).
  1777. cp /dev/null ark2isdone
  1778. MISSING=""
  1779. for I in 1 2 3 4 5 6 ; do
  1780.     if test ! -f ark${I}isdone ; then
  1781.     MISSING="${MISSING} ${I}"
  1782.     fi
  1783. done
  1784. if test "${MISSING}" = "" ; then
  1785.     echo You have unpacked all 6 archives.
  1786.     rm -f ark[1-9]isdone
  1787. else
  1788.     echo You still need to unpack the following archives:
  1789.     echo "        " ${MISSING}
  1790. fi
  1791. ##  End of shell archive.
  1792. exit 0
  1793. exit 0 # Just in case...
  1794. -- 
  1795. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1796. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1797. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1798. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1799.