home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / auucp+-1.02 / fuucp_plus_src.lzh / unsharmap / unsharmap.Z / unsharmap
Encoding:
Text File  |  1990-11-21  |  42.4 KB  |  1,536 lines
  1. Article 1644 of sub.config:
  2. Path: xenon!nadia!doitcr!tmpmbx!mcshh!artcom0!pf
  3. From: pf@artcom0.artcom.north.de (Peter Funk)
  4. Newsgroups: sub.config,dnet.and.sub.general
  5. Subject: REPOST: unpack-map Paket
  6. Summary: unsharmap -- Dank makefile auf Xenix kinderleicht zu installieren
  7. Keywords: Mail-Maps, Automatik, Aktualisierung
  8. Message-ID: <2062@artcom0.artcom.north.de>
  9. Date: 1 Jun 90 00:31:19 GMT
  10. Followup-To: poster
  11. Distribution: sub,dnet
  12. Organization: ArtCom GmbH, Atelier f. Computergrafik, Bremen(FRG)
  13. Lines: 1519
  14. Flames-To: poster
  15.  
  16. Da ich auf meine Ankuendigung kein Gemeckere und nur Zustimmung gehoert
  17. habe, hier der REPOST des 'unsharmap'-Paketes.  Die Installation ist
  18. zumindest unter SCO Xenix 386 kinderleicht.  Wer schon 'nn6.4' laufen
  19. hat, braucht jetzt nur ':unshar' einzutippen und dann in dem 
  20. betreffenden Directory 'make' aufzurufen.
  21.  
  22. Okay, hier isses ...
  23.  
  24. #    Dies ist ein UNIX-Shell Archiv.
  25. #    Loesche alles ueber und einschliesslich der Schnittzeile.
  26. #    Dann lasse den Rest der Datei durch sh laufen.
  27. #----schnitt-----schnippel-----fetz-----reiz-----schnitz----
  28. : /bin/sh
  29. # shar:    UNIX-Shell Archivier-Programm
  30. #    Bei Ausfuehrung dieses Textes durch /bin/sh enstehen die Dateien :
  31. #    README
  32. #    map.daily
  33. #    mkpaths
  34. #    Makefile
  35. #    unsharmap.c
  36. #    install
  37. #    avoid-unido
  38. #    getmap
  39. #    patch.README
  40. # Dieses Archiv wurde erzeugt : Fri Jun  1 02:28:27 1990
  41. echo shar: Extraktion von README
  42. sed 's/^Z //' << \----SHAR-EOF---- > README
  43. Z #  Title    : README - unpack-map
  44. Z #  Version      :       Sat, 26-May-90 / 12:55 / (pf@artcom0)
  45. Z 
  46. Z Das Paket 'unpack-map' dient zum automatischen Aktualisieren der
  47. Z EMail-Routing Database (/usr/lib/uucp/paths) anhand der regelmaessigen
  48. Z Postings in 'sub.config.maps'.
  49. Z 
  50. Z Ich habe dieses Unsharmap-Paket hier an meine speziellen
  51. Z SCO-Xenix 386 Beduerfnisse und meine Directory-Struktur 
  52. Z angepasst und zwecks leichterer Installation um ein paar
  53. Z Shell-Skripte und ein Makefile erweitert.  Das in der
  54. Z Original-Version mitgelieferte Skript 'getmap' wird
  55. Z hier nicht mehr benoetigt, ist aber aus Gruenden
  56. Z der Vollstaendigkeit dabei belassen.  Wer es so wie
  57. Z ich nicht braucht, kann es einfach loeschen. 
  58. Z 
  59. Z Die Installation ist sehr einfach, wenn man sowieso schon 'smail2.5',
  60. Z 'pathalias' und 'news' laufen hat. :
  61. Z 
  62. Z     make
  63. Z     make install 
  64. Z     make clobber
  65. Z 
  66. Z Danach kann man dieses Directory wieder einpacken und irgendwo
  67. Z verstauen.  Will man die eintrudelden Maps kontrollieren,
  68. Z kann man dies tun, da sie im Verzeichnis /usr/lib/uucp/maps/work
  69. Z stehen bleiben.  Erst durch 'map.daily' werden sie an Ort und
  70. Z Stelle 'gemoved' und dann eine neue 'paths'-Datei generiert.
  71. Z Vertraut man der Moderation von 'sub.config.maps', kann man
  72. Z einfach wie ich das 'map.daily' in die 'root'-crontab eintragen.
  73. Z 
  74. Z Wer trotzdem auf Nummer sicher gehen will, kann sich ein Directory
  75. Z /usr/lib/uucp/oldmaps einrichten, in dem man eine gewisse Anzahl
  76. Z von Sicherheitskopien alter (vorhergehender) Maps aufbewahren kann.
  77. Z Details dazu sind in 'map.daily' dokumentiert.
  78. Z 
  79. Z Einige Geschmackssachen (oder Portabilitaetsprobleme) :
  80. Z -------------------------------------------------------
  81. Z Ein Veraendern des Paketes auf eine andere Directory-Struktur
  82. Z (bei mir stehen die benutzten Maps alle in /usr/lib/uucp/maps und
  83. Z das Executable in /usr/local/bin) sollte Dank der SHELL-Variablen
  84. Z mit maessigem Editier-Aufwand moeglich sein. 
  85. Z 
  86. Z Veraendert werden muessten dazu die Dateien :
  87. Z     install
  88. Z     map.daily
  89. Z     mkpaths
  90. Z 
  91. Z Wenn man 'C'-News hat, wird das 'sys'-File vielleicht sonstwo liegen.
  92. Z Dann muss man dies natuerlich auch in 'install' abaendern.
  93. Z --
  94. Z Peter Funk  / ArtCom GmbH, Schwachhauser Heerstr. 78, D-2800 Bremen 1
  95. Z Work at home/ Oldenburger Str.86, D-2875 Ganderkesee 1 /+49 4222 6018 (8am-6pm)
  96. Z pf@artcom0.artcom.north.de
  97. ----SHAR-EOF----
  98. if test 2252 -ne "`wc -c README`"
  99. then
  100. echo shar: Uebertragungsfehler in README '(Soll-Laenge = 2252 Zeichen)'
  101. fi
  102. echo shar: Extraktion von map.daily
  103. sed 's/^Z //' << \----SHAR-EOF---- > map.daily
  104. Z :
  105. Z # ------------------------------------------------------------------
  106. Z #  Title    : map.daily -- automatically install new maps
  107. Z #  Usage    : map.daily [ -v ] [ -V ]
  108. Z #  Options    :     -v : Verbose mode, show up "no op" invocation
  109. Z #            -V : Very Verbose Mode
  110. Z #  Version      :       Sat, 26-May-90 / 11:45 / (root@artcom0)
  111. Z #  Remarks    : You may create a directory /usr/lib/uucp/oldmaps
  112. Z #              with some numerical named subdirectories. e.g.
  113. Z #          /usr/lib/uucp/oldmaps/0
  114. Z #              /usr/lib/uucp/oldmaps/1 ...
  115. Z #          Older maps will be preserved there. 
  116. Z #              These directories should be owned by 'news' and
  117. Z #          should also have write-Permissions, if You don't
  118. Z #          want to run this script here under 'root' !
  119. Z #          If you don't trust new maps, You may also choose
  120. Z #          the '-V' option, and You will get a diff mail,
  121. Z #          whenever there are new maps arrived !
  122. Z # ------------------------------------------------------------------
  123. Z if [ "$1" = "-v" ]
  124. Z then VERBOSE=TRUE
  125. Z      shift
  126. Z else VERBOSE=
  127. Z fi
  128. Z if [ "$1" = "-V" ]
  129. Z then VERBOSE=Talkative
  130. Z      shift
  131. Z fi
  132. Z MAPDIR=/usr/lib/uucp/maps
  133. Z OLDMAPS=/usr/lib/uucp/oldmaps
  134. Z cd $MAPDIR/work
  135. Z # --- Do the installation
  136. Z NEWMAPS=
  137. Z for i in * ; do
  138. Z     if [ "$i" = "*" ]
  139. Z     then if [ "$VERBOSE" ]
  140. Z      then echo "No new maps arrived !"  
  141. Z      fi 
  142. Z      exit 0
  143. Z     fi
  144. Z     # -- preserve old maps 
  145. Z     for olddirnum in 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 ; do
  146. Z     OLDMAPDIR=$OLDMAPS/$olddirnum
  147. Z     if [ -d $OLDMAPDIR ]
  148. Z     then if [ $olddirnum -gt 0 ]
  149. Z          then prevdirnum=`expr $olddirnum - 1`
  150. Z           PREVDIR=$OLDMAPS/$prevdirnum
  151. Z          else PREVDIR=$MAPDIR
  152. Z          fi
  153. Z          if [ -f $PREVDIR/$i ]
  154. Z          then mv $PREVDIR/$i $OLDMAPDIR/$i
  155. Z          fi
  156. Z     fi
  157. Z     done
  158. Z     mv $i $MAPDIR
  159. Z     NEWMAPS="$NEWMAPS $i"
  160. Z done
  161. Z # -- mail significant map changes as diff to the postmaster :
  162. Z if [ "$VERBOSE" = "Talkative" ] && [ -d $OLDMAPS/0 ]
  163. Z then if [ -x /usr/local/bin/gdiff ]
  164. Z      then /usr/local/bin/gdiff -r -c $OLDMAPS/0 $MAPDIR
  165. Z      else cd $MAPDIR
  166. Z       for i in $NEWMAPS ; do
  167. Z           if [ -r $OLDMAPS/0/$i ]
  168. Z           then echo "--- $i Differences: ---"
  169. Z            diff $OLDMAPS/0/$i $i
  170. Z           else echo "--- $i is a new map file ! ---"
  171. Z           fi
  172. Z       done
  173. Z      fi | mail -s "Map Changes" postmaster
  174. Z fi
  175. Z # -- regenerate the paths database :
  176. Z cd $MAPDIR
  177. Z ./mkpaths
  178. ----SHAR-EOF----
  179. if test 2232 -ne "`wc -c map.daily`"
  180. then
  181. echo shar: Uebertragungsfehler in map.daily '(Soll-Laenge = 2232 Zeichen)'
  182. fi
  183. echo shar: Extraktion von mkpaths
  184. sed 's/^Z //' << \----SHAR-EOF---- > mkpaths
  185. Z : use /bin/sh
  186. Z # ------------------------------------------------------------------------------
  187. Z #  Title    : mkpaths -- Create a new paths data base from diverse map files
  188. Z #  Version      :       Sat, 26-May-90 / 11:29 / (pf@artcom0)
  189. Z #  Portability  : Bourne Shell SCO Xenix 2.3
  190. Z #  Usage    : mkpaths [ "test" [ <rechnername> ] ]
  191. Z #    Durch den Aufruf 'mkpaths test kiste' kann man sich die von 'kiste'
  192. Z #    aus generierten Pfade im Pager anschauen.  Das ist manchmal ganz 
  193. Z #    praktisch.
  194. Z # ------------------------------------------------------------------------------
  195. Z PATH="$PATH:/usr/local/bin"
  196. Z MAPDIR=/usr/lib/uucp/maps
  197. Z PATHS=/usr/lib/uucp/paths
  198. Z if [ -x /usr/local/bin/less ]
  199. Z then PAGER="/usr/local/bin/less -e"
  200. Z else PAGER=more
  201. Z fi
  202. Z # --- Es gibt die Konvention, das alle Pathalias Eingabe-Dateien mit 
  203. Z #     'd.' oder 'u.' beginnen. 
  204. Z #     Die Map-Dateien des 'Sub-Netzes' heissen 'u.sub.*'. 
  205. Z #     Lokale Map-Daten sollte man in 'u.local' halten.
  206. Z MAPS="u.* d.*"
  207. Z # --- Wenn kein Rechnername angegeben ist, dann benutze das 'uuname'-Kommando
  208. Z #     (Wie geht das auf NICHT-Xenix Systemen ?)
  209. Z if [ "$2" ]
  210. Z then HOST=$2
  211. Z else HOST=`uuname -l`
  212. Z fi
  213. Z # ---
  214. Z cd $MAPDIR
  215. Z echo ".UUCP    %s" > paths
  216. Z pathalias -l $HOST $MAPS | /bin/sort >> paths
  217. Z if [ "$1" != "test" ]
  218. Z then # -- The following 'cat' will preserve permissions and links to the
  219. Z      #    system path data base, which would have been lost, if we had used
  220. Z      #    a simple 'mv paths $PATHS' ...
  221. Z      cat paths > $PATHS
  222. Z      rm -f paths
  223. Z      # -- The following is just for safety (If 'paths' did not exist before !) :
  224. Z      chown mail $PATHS ; chgrp news $PATHS ; chmod 664 $PATHS 
  225. Z else # -- Don't install 'paths', just view it :
  226. Z      chmod +r paths
  227. Z      $PAGER paths
  228. Z      # You may consider to remove the paths file afterwards :
  229. Z      # rm -f paths 
  230. Z      mv paths /tmp/paths.$HOST
  231. Z      exit 0
  232. Z fi
  233. ----SHAR-EOF----
  234. if test 1826 -ne "`wc -c mkpaths`"
  235. then
  236. echo shar: Uebertragungsfehler in mkpaths '(Soll-Laenge = 1826 Zeichen)'
  237. fi
  238. echo shar: Extraktion von Makefile
  239. sed 's/^Z //' << \----SHAR-EOF---- > Makefile
  240. Z # Makefile for unsharmap under SCO XENIX 386
  241. Z #
  242. Z #  Version      :       Wed, 16-May-90 / 19:11 / (pf@artcom0)
  243. Z #    Documented for net distribution.
  244. Z 
  245. Z # Things to do:
  246. Z #    make            make executables
  247. Z #    make all         "       "
  248. Z #    make install        perform XENIX installation
  249. Z #    make clean        cleanup this directory
  250. Z #    make clobber        clean ...and remove executables from this dir
  251. Z #     make shar        create a file 'unpack-map.sha'
  252. Z 
  253. Z SHELL=        /bin/sh
  254. Z CFLAGS    =    -O
  255. Z 
  256. Z OBJECTS =    unsharmap.o
  257. Z 
  258. Z all:        unsharmap
  259. Z 
  260. Z unsharmap:    $(OBJECTS)
  261. Z         cc $(CFLAGS) $(OBJECTS) -o unsharmap
  262. Z 
  263. Z $(OBJECTS):
  264. Z         cc $(CFLAGS) -c $<
  265. Z 
  266. Z clean:
  267. Z         rm -f *.o *.ln a.out core
  268. Z 
  269. Z clobber:    clean
  270. Z         rm -f unsharmap 
  271. Z 
  272. Z install:    all 
  273. Z         ./install
  274. Z 
  275. Z shar:        
  276. Z         shar -cgvp'Z ' README map.daily mkpaths Makefile \
  277. Z                 unsharmap.c install avoid-unido \
  278. Z                 getmap patch.README > unpack-map.sha
  279. ----SHAR-EOF----
  280. if test 801 -ne "`wc -c Makefile`"
  281. then
  282. echo shar: Uebertragungsfehler in Makefile '(Soll-Laenge = 801 Zeichen)'
  283. fi
  284. echo shar: Extraktion von unsharmap.c
  285. sed 's/^Z //' << \----SHAR-EOF---- > unsharmap.c
  286. Z /* @(#)unsharmap.c    1.6 2/5/89 14:14:01 */
  287. Z /*
  288. Z  *    Copyright (C) 1988 Ronald S. Karr and Landon Curt Noll
  289. Z  * 
  290. Z  * See the file COPYING, distributed with smail, for restriction
  291. Z  * and warranty information.
  292. Z  */
  293. Z 
  294. Z /*
  295. Z  * unsharmap - unshar a USENET comp.news.maps article
  296. Z  *
  297. Z  * usage:  unsharmap [-d dir] < filelist > log
  298. Z  *
  299. Z  *       -d dir    - cd to 'dir' before unsharing
  300. Z  *       -n newsgroups - colon separated list of allowed newsgroups
  301. Z  *       -p        - use stdin (for piped input from 'sys')
  302. Z  *
  303. Z  * where "filelist" contains a list of files that are in the format below.
  304. Z  *
  305. Z  * The USENET map project distributes files in the following format:
  306. Z  *
  307. Z  * The header, which starts at the firts line and continues up until
  308. Z  * there is a blank line as the follow lins it:
  309. Z  *
  310. Z  *    Newsgroups: comp.mail.maps
  311. Z  *    Subject: UUCP ...
  312. Z  *    Message-ID: ...
  313. Z  *    Date: ...
  314. Z  *    Approved: ...
  315. Z  *
  316. Z  * These lines are not the complete list, nor do they show up in that order.
  317. Z  * After the header is a blank line.  Next comes the shar file preamble
  318. Z  * which consists of a bunch of lines that begin with a :, followed
  319. Z  * by the 2 lines:
  320. Z  *
  321. Z  *    echo shar: extracting THE-FILE-NAME
  322. Z  *    cat << 'SHAR_EOF' > THE-FILE-NAME
  323. Z  *
  324. Z  * what follows is the map data intended to override THE-FILE-NAME in the
  325. Z  * UNSHAR_MAP_DIR directory.  The final 3 lines:
  326. Z  *
  327. Z  *    SHAR_EOF
  328. Z  *    :   End of shell archive
  329. Z  *    exit 0
  330. Z  *
  331. Z  * terminate the shar file, and are not considered a part of the map data.
  332. Z  *
  333. Z  * For each shar file processed, the following information is written
  334. Z  * to stdout:
  335. Z  *
  336. Z  *    filename read
  337. Z  *    filename written
  338. Z  *    subject line
  339. Z  *    message-ID
  340. Z  *    date
  341. Z  *    approved info
  342. Z  *    any error message
  343. Z  *
  344. Z  * All error message lines begin with 'error:'.
  345. Z  *
  346. Z  * exits by 0 if there was no errors, non-0 otherwise.
  347. Z  */
  348. Z  
  349. Z #include <stdio.h>
  350. Z 
  351. Z #define HEADER_OK 1            /* the article header is correct */
  352. Z #define HEADER_ERROR 2            /* bad header, skip and log */
  353. Z #define HEADER_SKIP 3            /* not a map shar, ignore file */
  354. Z 
  355. Z char *program;                /* our name */
  356. Z char err[BUFSIZ+1];            /* error and log message */
  357. Z char buf[BUFSIZ+1];            /* input buffer */
  358. Z char mapname[BUFSIZ+1];            /* name of the output map file */
  359. Z int lineno = 0;                /* current line number */
  360. Z char *newsgroups = "comp.mail.maps";    /* : list of allowed newsgroups */
  361. Z 
  362. Z char *get_date();            /* system dependent date string */
  363. Z void log();                /* write to log and error log */
  364. Z int check_header();            /* check the article header */
  365. Z void skip_article();            /* skip a bad article */
  366. Z void ignore_article();            /* ignore the non-map article */
  367. Z char *check_preamble();            /* check shar preamble, get map name */
  368. Z int write_map();            /* write a map file */
  369. Z char *check_newline();            /* check to be sure we read a '\n' */
  370. Z 
  371. Z char *xmalloc();            /* for string.c and strcolon()*/
  372. Z char *xrealloc();            /* for string.c and strcolon() */
  373. Z 
  374. Z extern char *strcolon();        /* grap strcolon() from src/string.c */
  375. Z 
  376. Z main( argc, argv )
  377. Z     int argc;                /* arg count */
  378. Z     char *argv[];            /* args */
  379. Z {
  380. Z     char filename[BUFSIZ+1];        /* name of the input article */
  381. Z     char *p;                /* pointer */
  382. Z     int c;                /* the option flag */
  383. Z     int header;                /* HEADER_OK,ERROR,SKIP */
  384. Z     int errors=0;            /* number of problems found */
  385. Z     int stdinfile;            /* get just one file from std input */
  386. Z     FILE *article;            /* input article stream */
  387. Z     extern char *optarg;        /* the option argument */
  388. Z     extern int optind;            /* operand index */
  389. Z 
  390. Z     /*
  391. Z      * parse args
  392. Z      */
  393. Z     program = argv[0];
  394. Z     while ((c = getopt(argc, argv, "pd:n:")) != EOF) {
  395. Z     switch(c) {
  396. Z     case 'p':
  397. Z         stdinfile = 1;
  398. Z         break;
  399. Z     case 'd':            /* directory to cd to */
  400. Z         if (chdir(optarg) < 0) {
  401. Z         sprintf(err, "error: can not cd to %s\n", optarg);
  402. Z         log(err);
  403. Z         sprintf(err, "exiting: status: 5 -  %s", get_date());
  404. Z         log(err);
  405. Z         exit(5);
  406. Z         }
  407. Z         break;
  408. Z     case 'n':
  409. Z         newsgroups = optarg;
  410. Z         break;
  411. Z 
  412. Z     case '?':
  413. Z         sprintf(err,
  414. Z             "error: usage: %s [-d dir] < filelist > log 2> error\n",
  415. Z             program);
  416. Z         log(err);
  417. Z         sprintf(err, "exiting: status: 1 -  %s", get_date());
  418. Z         log(err);
  419. Z         exit(1);
  420. Z         break;
  421. Z     }
  422. Z     }
  423. Z     if (optind != argc) {
  424. Z     sprintf(err, "error: usage: %s [-d dir] < filelist > log 2> error\n",
  425. Z         program);
  426. Z     log(err);
  427. Z     sprintf(err, "exiting: status: 1 -  %s", get_date());
  428. Z     log(err);
  429. Z     exit(1);
  430. Z     }
  431. Z     
  432. Z 
  433. Z     /*
  434. Z      * process all file names on input
  435. Z      */
  436. Z     sprintf(err, "starting: %s", get_date());
  437. Z     log(err);
  438. Z     while (stdinfile || fgets(filename, BUFSIZ, stdin) != NULL) {
  439. Z     
  440. Z       if(!stdinfile){
  441. Z     /*
  442. Z      * open the map file
  443. Z      */
  444. Z     lineno = 0;            /* clear the line count */
  445. Z     if ((p = check_newline(filename)) == NULL) {
  446. Z         sprintf(err, "error: filename longer than %d chars\n",
  447. Z             program, BUFSIZ-2);
  448. Z         log(err);
  449. Z         sprintf(err, "exiting: status: 2 -  %s", get_date());
  450. Z         log(err);
  451. Z         exit(2);
  452. Z     }
  453. Z     *p = '\0';    /* remove the newline from the filename */
  454. Z     if ((article = fopen(filename, "r")) == NULL) {
  455. Z         sprintf(err, "error: can not open: %s\n", filename);
  456. Z         log(err);
  457. Z         ++errors;
  458. Z         continue;
  459. Z     }
  460. Z     sprintf(err, "filename: %s\n", filename);
  461. Z     log(err);
  462. Z       } else {
  463. Z     strcpy(filename,"stdin");
  464. Z     article = stdin;
  465. Z       }
  466. Z     /*
  467. Z      * verify the article header
  468. Z      *
  469. Z      * close file if error or skip
  470. Z      */
  471. Z     switch (header = check_header(article)) {
  472. Z     case HEADER_OK:            /* we have a good header */
  473. Z         break;
  474. Z     case HEADER_ERROR:        /* the article is bad, skip & log */
  475. Z         skip_article(article, filename);
  476. Z         ++errors;
  477. Z         break;
  478. Z     case HEADER_SKIP:        /* not a map article, ignore it */
  479. Z         ignore_article(article, filename);
  480. Z         break;
  481. Z     default:            /* how did we get here? */
  482. Z         sprintf(err, "error: check_header returned %d, why?\n", header);
  483. Z         log(err);
  484. Z         sprintf(err, "exiting: status: 3 -  %s", get_date());
  485. Z         log(err);
  486. Z         exit(3);
  487. Z     }
  488. Z     if (header != HEADER_OK) {
  489. Z         continue;            /* try another file */
  490. Z     }
  491. Z 
  492. Z     /*
  493. Z      * check the shar preamble, get the shar file name
  494. Z      */
  495. Z     if (check_preamble(article) == NULL) {
  496. Z         skip_article(article, filename);
  497. Z         ++errors;
  498. Z         continue;
  499. Z     }
  500. Z 
  501. Z     if(stdinfile) strcpy(filename,mapname);
  502. Z     /*
  503. Z      * write the map, verify final lines
  504. Z      */
  505. Z     if (write_map(article) != 0) {
  506. Z         skip_article(article, filename);
  507. Z         ++errors;
  508. Z         continue;
  509. Z     }
  510. Z 
  511. Z     /*
  512. Z      * all done with this article
  513. Z      */
  514. Z     fclose(article);
  515. Z     fflush(stdout);
  516. Z     if(stdinfile)break;
  517. Z     }
  518. Z 
  519. Z     /*
  520. Z      * note if everything went ok
  521. Z      */
  522. Z     sprintf(err, "exiting: status: %d -  %s", (errors>0) ? 4 : 0, get_date());
  523. Z     log(err);
  524. Z     exit( (errors>0) ? 4 : 0 );
  525. Z }
  526. Z 
  527. Z 
  528. Z /*
  529. Z  * get_date - get the date followed by newline in the standard way
  530. Z  *
  531. Z  * returns the date in ctime(3) format
  532. Z  */
  533. Z char *
  534. Z get_date()
  535. Z {
  536. Z     extern long time();
  537. Z     long clock = time((long *)0);   /* seconds since 1-jan-1970 0:00:00 GMT */
  538. Z     char *ctime();            /* convert clock into string */
  539. Z 
  540. Z     return(ctime(&clock));
  541. Z }
  542. Z 
  543. Z 
  544. Z /*
  545. Z  * log - write a message to the log
  546. Z  */
  547. Z void
  548. Z log( msg )
  549. Z     char *msg;                /* the message to write */
  550. Z {
  551. Z     /* write to the log */
  552. Z     fputs(msg, stdout);
  553. Z }
  554. Z 
  555. Z 
  556. Z /*
  557. Z  * check_header - check the article header
  558. Z  *
  559. Z  * This routine verifies that a article header has the following lines:
  560. Z  *
  561. Z  *    Newsgroups: comp.mail.maps
  562. Z  *    Subject: UUCP ...
  563. Z  *    Message-ID: ...
  564. Z  *    Date: ...
  565. Z  *    Approved: ...
  566. Z  *
  567. Z  * The text of all but the Newsgroups lines are logged.  If the Newsgroups
  568. Z  * line is bad, that too is logged.  The header ends before a blank line.
  569. Z  * The final blank line is read and discarded.
  570. Z  *
  571. Z  * returns HEADER_OK is all 5 header lines were read and were valid,
  572. Z  *         HEADER_ERROR is the header was bad and needs to be skipped & logged,
  573. Z  *       HEADER_SKIP if the file is not a UUCP shar file and should be skipped
  574. Z  */
  575. Z int
  576. Z check_header( article )
  577. Z     FILE *article;            /* the article stream */
  578. Z {
  579. Z     int saw_groups=0;            /* 1 ==> saw Newsgroups: */
  580. Z     int saw_subject=0;            /* 1 ==> saw Subject: */
  581. Z     int saw_message=0;            /* 1 ==> saw Message-ID: */
  582. Z     int saw_date=0;            /* 1 ==> saw Date: */
  583. Z     int saw_approved=0;            /* 1 ==> saw Approved: */
  584. Z     char *p;                /* temp */
  585. Z 
  586. Z     /*
  587. Z      * read the header
  588. Z      */
  589. Z     do {
  590. Z     /*
  591. Z      * read the line
  592. Z      */
  593. Z     clearerr(article);
  594. Z     if (fgets(buf, BUFSIZ, article) == NULL) {
  595. Z         if (ferror(article)) {
  596. Z         sprintf(buf, "error: bad header read after line %d\n", lineno);
  597. Z         log(err);
  598. Z         } else {
  599. Z         log("error: EOF while reading the header\n");
  600. Z         }
  601. Z         return(HEADER_ERROR);
  602. Z     }
  603. Z     ++lineno;            /* count this line */
  604. Z     if (! check_newline(buf)) {
  605. Z         sprintf(err, "error: line %d, header line too long\n", lineno);
  606. Z         log(err);
  607. Z         return(HEADER_ERROR);
  608. Z     }
  609. Z 
  610. Z     /*
  611. Z      * look for special types
  612. Z      */
  613. Z     switch (buf[0]) {
  614. Z     case 'n':
  615. Z     case 'N':            /* could be Newsgroups: */
  616. Z         if (strncmpic("Newsgroups: ", buf, 12) == 0) {
  617. Z         for (p = strcolon(newsgroups); p; p = strcolon((char *)NULL)) {
  618. Z             if (strncmpic(buf + 12, p, strlen(p)) == 0 &&
  619. Z             buf[12 + strlen(p)] == '\n')
  620. Z             {
  621. Z             break;
  622. Z             }
  623. Z         }
  624. Z         if (p != NULL) {
  625. Z             saw_groups = 1;
  626. Z         } else {
  627. Z             sprintf(err, "error: line %d, bad %s", lineno, buf);
  628. Z             log(err);
  629. Z             return(HEADER_ERROR);
  630. Z         }
  631. Z         }
  632. Z         break;
  633. Z     case 's':
  634. Z     case 'S':            /* Subject: buf */
  635. Z         if (strncmpic("Subject: ", buf, 9) == 0) {
  636. Z         if (strncmpic("Subject: UUCP ", buf, 14) == 0) {
  637. Z             saw_subject = 1;
  638. Z             log("    ");
  639. Z             log(buf);
  640. Z         } else {
  641. Z             log("    ");
  642. Z             log(err);
  643. Z             return(HEADER_SKIP); /* not a shar map file */
  644. Z         }
  645. Z         }
  646. Z         break;
  647. Z     case 'm':
  648. Z     case 'M':            /* Message-ID: buf */
  649. Z         if (strncmpic("Message-ID: ", buf, 12) == 0) {
  650. Z             saw_message = 1;
  651. Z             log("    ");
  652. Z             log(buf);
  653. Z         }
  654. Z         break;
  655. Z     case 'd':
  656. Z     case 'D':            /* Message-ID: buf */
  657. Z         if (strncmpic("Date: ", buf, 6) == 0) {
  658. Z         saw_date = 1;
  659. Z         log("    ");
  660. Z         log(buf);
  661. Z         }
  662. Z         break;
  663. Z     case 'a':
  664. Z     case 'A':            /* Message-ID: buf */
  665. Z         if (strncmpic("Approved: ", buf, 10) == 0) {
  666. Z         saw_approved = 1;
  667. Z         log("    ");
  668. Z         log(buf);
  669. Z         }
  670. Z         break;
  671. Z     }
  672. Z 
  673. Z     } while(strcmp("\n", buf) != 0);    /* while heading the header */
  674. Z 
  675. Z     /*
  676. Z      * report if er got everything
  677. Z      */
  678. Z     if (saw_groups == 0) {
  679. Z     log("error: no Newsgroups: line\n");
  680. Z     return(HEADER_ERROR);
  681. Z     }
  682. Z     if (saw_subject == 0) {
  683. Z     log("error: no Subject: line\n");
  684. Z     return(HEADER_ERROR);
  685. Z     }
  686. Z     if (saw_message == 0) {
  687. Z     log("error: no Message-ID: line\n");
  688. Z     return(HEADER_ERROR);
  689. Z     }
  690. Z     if (saw_date == 0) {
  691. Z     log("error: no Date: line\n");
  692. Z     return(HEADER_ERROR);
  693. Z     }
  694. Z     if (saw_approved == 0) {
  695. Z     log("error: no Approved: line\n");
  696. Z     return(HEADER_ERROR);
  697. Z     }
  698. Z     return(HEADER_OK);            /* passed all the tests */
  699. Z }
  700. Z 
  701. Z /*
  702. Z  * skip_article - skip article, log and close it
  703. Z  */
  704. Z void
  705. Z skip_article( article, filename )
  706. Z     FILE *article;            /* the article stream */
  707. Z     char *filename;            /* the filename we are skipping */
  708. Z {
  709. Z     /*
  710. Z      * log that we are skipping the remainder of the article
  711. Z      */
  712. Z     sprintf(err, "    skipping: %s after reading line %d\n", filename, lineno);
  713. Z     log(err);
  714. Z 
  715. Z     /*
  716. Z      * close the stream
  717. Z      */
  718. Z     fclose(article);
  719. Z 
  720. Z     /*
  721. Z      * report the close
  722. Z      */
  723. Z     sprintf(err, "finished: %s\n", filename);
  724. Z     log(err);
  725. Z     return;
  726. Z }
  727. Z 
  728. Z 
  729. Z /*
  730. Z  * ingore_article - ignore an article, close and report it
  731. Z  */
  732. Z void
  733. Z ignore_article( article, filename )
  734. Z     FILE *article;            /* the article stream */
  735. Z     char *filename;            /* the filename we are skipping */
  736. Z {
  737. Z     /*
  738. Z      * log that we are ignoring the remainder of the article
  739. Z      */
  740. Z     sprintf(err, "    ignore non map file: %s after reading line %d\n",
  741. Z         filename, lineno);
  742. Z     log(err);
  743. Z 
  744. Z     /*
  745. Z      * close the stream
  746. Z      */
  747. Z     fclose(article);
  748. Z 
  749. Z     /*
  750. Z      * report the close
  751. Z      */
  752. Z     sprintf(err, "finished: %s\n", filename);
  753. Z     log(err);
  754. Z     return;
  755. Z }
  756. Z 
  757. Z 
  758. Z /*
  759. Z  * check_preamble - check for a valid shar preamble
  760. Z  *
  761. Z  * The shar preamble consists of a bunch of lines that begin with :,
  762. Z  * followed by the 2 lines:
  763. Z  *
  764. Z  *    echo shar: extracting THE-FILE-NAME
  765. Z  *    cat << 'SHAR_EOF' > THE-FILE-NAME
  766. Z  *
  767. Z  * Any other line is printed to both logs as an error.  The "THE-FILE-NAME"
  768. Z  * string is returned if a valid preamble is found, NULL otherwise.
  769. Z  */
  770. Z char *
  771. Z check_preamble( article )
  772. Z     FILE *article;            /* the article stream */
  773. Z {
  774. Z     char *p;                /* pointer */
  775. Z     char *q;                /* pointer, NULL byte of mapname */
  776. Z     int bad_echo=0;            /* 1 ==> a bad echo was found */
  777. Z 
  778. Z     /*
  779. Z      * read the preamble
  780. Z      */
  781. Z     mapname[0] = '\0';    /* no mapname yet */
  782. Z     while (1) {
  783. Z     /*
  784. Z      * read the line
  785. Z      */
  786. Z     clearerr(article);
  787. Z     if (fgets(buf, BUFSIZ, article) == NULL) {
  788. Z         if (ferror(article)) {
  789. Z         sprintf(err, "error: bad preamble read after line %d\n",
  790. Z             lineno);
  791. Z         log(err);
  792. Z         } else {
  793. Z         log("error: EOF while reading the preamble\n");
  794. Z         }
  795. Z         return(NULL);
  796. Z     }
  797. Z     ++lineno;            /* count line */
  798. Z     if (! check_newline(buf)) {
  799. Z         sprintf(err, "error: line %d, preamble line too long\n", lineno);
  800. Z         log(err);
  801. Z         return(NULL);
  802. Z     }
  803. Z 
  804. Z     /*
  805. Z      * skip the : lines
  806. Z      */
  807. Z     if (buf[0] == ':') {
  808. Z         continue;
  809. Z     }
  810. Z 
  811. Z     /*
  812. Z      * look for the echo line
  813. Z      */
  814. Z     if (strncmp("echo shar: extracting ", buf, 22) == 0) {
  815. Z         /* grab the mapname */
  816. Z         for (p=buf+22, q=mapname, bad_echo=0; *p; ++p) {
  817. Z         /* be sure it is well formed */
  818. Z         switch (*p) {
  819. Z         case ' ':
  820. Z         case '\t':
  821. Z             bad_echo = 1;    /* unlikely char in a filename */
  822. Z             *q++ = *p;
  823. Z             break;
  824. Z         case '\n':        /* should be the end */
  825. Z             if (*(p+1) != '\0') {
  826. Z             bad_echo = 1;    /* why is '\n' not the end */
  827. Z             }
  828. Z             break;        /* don't copy the newline */
  829. Z         case '\\':        /* avoid \ and / in filenames */
  830. Z         case '/':
  831. Z             bad_echo = 1;
  832. Z             *q++ = *p;
  833. Z             break;
  834. Z         default:
  835. Z             *q++ = *p;
  836. Z             break;
  837. Z         }
  838. Z         }
  839. Z         *q = '\0';            /* NULL terminate filename */
  840. Z 
  841. Z         /* verify mapname */
  842. Z         if (bad_echo == 1) {
  843. Z         sprintf(err, "error: line %d, bad echo mapname: %s\n",
  844. Z             lineno, mapname);
  845. Z         log(err);
  846. Z         return(NULL);        /* bad preamble */
  847. Z         }
  848. Z 
  849. Z     /*
  850. Z      * watch for the cat line
  851. Z      */
  852. Z     } else if (strncmp("cat << 'SHAR_EOF' > ", buf, 20) == 0) {
  853. Z 
  854. Z         /*
  855. Z          * compare cat filename against echo filename
  856. Z          */
  857. Z         if (mapname[0] == '\0') {
  858. Z         sprintf(err, "error: line %d, cat with no preceding echo: %s",
  859. Z             lineno, buf);
  860. Z         log(err);
  861. Z         return(NULL);        /* bad preamble */
  862. Z         } else if (strncmp(buf+20, mapname, q-mapname) != 0) {
  863. Z         sprintf(err,
  864. Z             "error: line %d, echo mapname: %s != cat mapname: %s",
  865. Z             lineno, mapname, buf+20);
  866. Z         log(err);
  867. Z         return(NULL);        /* bad preamble */
  868. Z         } else {
  869. Z         return(mapname);    /* found end of preamble */
  870. Z         }
  871. Z         
  872. Z     /*
  873. Z      * watch for unkown lines
  874. Z      */
  875. Z     } else {
  876. Z         sprintf(err, "error: line %d, unknown preamble: %s", lineno, buf);
  877. Z         log(err);
  878. Z         return(NULL);
  879. Z     }
  880. Z     }
  881. Z     /* NOT REACHED */
  882. Z }
  883. Z 
  884. Z 
  885. Z /*
  886. Z  * write_map - write a map file
  887. Z  *
  888. Z  * Given an verified article header and shar preamble, copy the contents
  889. Z  * of the shar HERE_IS document up until the ending shar lines:
  890. Z  *
  891. Z  *    SHAR_EOF
  892. Z  *    :   End of shell archive
  893. Z  *    exit 0
  894. Z  *
  895. Z  * A previous call to check_preamble placed the name of the mapfile in
  896. Z  * the mapname array.
  897. Z  *
  898. Z  * returns 1 if all was ok, 0 otherwise.
  899. Z  */
  900. Z int
  901. Z write_map( article )
  902. Z     FILE *article;            /* the article stream */
  903. Z {
  904. Z     int fd;                /* map file descriptor */
  905. Z     FILE *map;                /* the map file stream */
  906. Z 
  907. Z     /*
  908. Z      * open and truncate the map file
  909. Z      */
  910. Z     fd = creat(mapname, 0644);
  911. Z     if (fd < 0) {
  912. Z     sprintf(err, "error: unable to creat/truncate %s\n", mapname);
  913. Z     log(err);
  914. Z     return(1);
  915. Z     }
  916. Z     map = fdopen(fd, "w");
  917. Z     sprintf(err, "extracting: %s\n", mapname);
  918. Z     log(err);
  919. Z 
  920. Z     /*
  921. Z      * copy article shar data to the map file
  922. Z      */
  923. Z     while (1) {
  924. Z     /*
  925. Z      * read the line
  926. Z      */
  927. Z     clearerr(article);
  928. Z     if (fgets(buf, BUFSIZ, article) == NULL) {
  929. Z         if (ferror(article)) {
  930. Z         sprintf(err, "error: bad map data read after line %d\n",
  931. Z             lineno);
  932. Z         log(err);
  933. Z         } else {
  934. Z         log("error: EOF while reading the map data\n");
  935. Z         }
  936. Z         return(1);
  937. Z     }
  938. Z     ++lineno;
  939. Z     if (! check_newline(buf)) {
  940. Z         sprintf(err, "error: line %d, map data line too long\n", lineno);
  941. Z         log(err);
  942. Z         return(1);
  943. Z     }
  944. Z 
  945. Z     /*
  946. Z      * watch for the end of the shar
  947. Z      */
  948. Z     if (strcmp("SHAR_EOF\n", buf) == 0) {
  949. Z         /* end of the shar file */
  950. Z         if (fclose(map) == EOF) {
  951. Z         log("error: bad fclose\n");
  952. Z         return(1);
  953. Z         }
  954. Z         mapname[0] = '\0';
  955. Z         break;            /* look for final two lines */
  956. Z     }
  957. Z 
  958. Z     /*
  959. Z      * write the line
  960. Z      */
  961. Z     if (fputs(buf, map) == EOF) {
  962. Z         log("error: bad write\n");
  963. Z         return(1);
  964. Z     }
  965. Z     }
  966. Z 
  967. Z     /*
  968. Z      * verify the : line after the end of the map
  969. Z      */
  970. Z     clearerr(article);
  971. Z     if (fgets(buf, BUFSIZ, article) == NULL) {
  972. Z     if (ferror(article)) {
  973. Z         sprintf(err, "error: bad ending : read after line %d\n",
  974. Z             lineno);
  975. Z         log(err);
  976. Z     } else {
  977. Z         log("error: EOF while reading the ending : line\n");
  978. Z     }
  979. Z     return(1);
  980. Z     }
  981. Z     ++lineno;
  982. Z     if (! check_newline(buf)) {
  983. Z     sprintf(err, "error: line %d, ending : line too long\n", lineno);
  984. Z     log(err);
  985. Z     return(1);
  986. Z     }
  987. Z     if (buf[0] != ':') {
  988. Z     sprintf(err, "error: line %d, not an ending : line: %s", lineno, buf);
  989. Z     log(err);
  990. Z     return(1);
  991. Z     }
  992. Z 
  993. Z     /*
  994. Z      * verify the exit 0
  995. Z      */
  996. Z     clearerr(article);
  997. Z     if (fgets(buf, BUFSIZ, article) == NULL) {
  998. Z     if (ferror(article)) {
  999. Z         sprintf(err, "error: bad ending exit read after line %d\n",
  1000. Z             lineno);
  1001. Z         log(err);
  1002. Z     } else {
  1003. Z         log("error: EOF while reading the ending exit line\n");
  1004. Z     }
  1005. Z     return(1);
  1006. Z     }
  1007. Z     ++lineno;
  1008. Z     if (! check_newline(buf)) {
  1009. Z     sprintf(err, "error: line %d, ending exit line too long\n", lineno);
  1010. Z     log(err);
  1011. Z     return(1);
  1012. Z     }
  1013. Z     if (strcmp("exit 0\n", buf) != 0) {
  1014. Z     sprintf(err, "error: line %d, not an ending exit line: %s",
  1015. Z         lineno, buf);
  1016. Z     log(err);
  1017. Z     return(1);
  1018. Z     }
  1019. Z 
  1020. Z     /*
  1021. Z      * if we are here, all must be ok
  1022. Z      */
  1023. Z     return(0);
  1024. Z }
  1025. Z 
  1026. Z 
  1027. Z /*
  1028. Z  * check_newline - check to be sure that the string endds in a newline
  1029. Z  *
  1030. Z  * returns a pointer to the newline, or NULL if none found
  1031. Z  */
  1032. Z char *
  1033. Z check_newline( str )
  1034. Z     char *str;                /* check for newline in str */
  1035. Z {
  1036. Z     char *p;                /* pointer */
  1037. Z 
  1038. Z     /* guess the newline location */
  1039. Z     p = str + strlen(str);
  1040. Z     p -= ((p > str) ? 1 : 0);
  1041. Z 
  1042. Z     /* return result of guess */
  1043. Z     return( (*p == '\n') ? p : NULL );
  1044. Z }
  1045. Z 
  1046. Z char *
  1047. Z xmalloc(size)
  1048. Z     unsigned size;
  1049. Z {
  1050. Z     extern char *malloc();
  1051. Z     char *ret = malloc(size);
  1052. Z 
  1053. Z     if (ret == NULL) {
  1054. Z     sprintf(err, "error: out of memory in xmalloc\n");
  1055. Z     log(err);
  1056. Z     sprintf(err, "exiting: status: 1 -  %s", get_date());
  1057. Z     log(err);
  1058. Z     exit(1);
  1059. Z     }
  1060. Z 
  1061. Z     return ret;
  1062. Z }
  1063. Z 
  1064. Z char *
  1065. Z xrealloc(region, size)
  1066. Z     char *region;
  1067. Z     unsigned size;
  1068. Z {
  1069. Z     extern char *realloc();
  1070. Z     register char *ret = realloc(region, size);
  1071. Z 
  1072. Z     if (ret == NULL) {
  1073. Z     sprintf(err, "error: out of memory in xrealloc\n");
  1074. Z     log(err);
  1075. Z     sprintf(err, "exiting: status: 1 - %s", get_date());
  1076. Z     log(err);
  1077. Z     exit(1);
  1078. Z     }
  1079. Z 
  1080. Z     return ret;
  1081. Z }
  1082. Z 
  1083. Z 
  1084. Z /*
  1085. Z  * strcmpic - case independent strcmp function
  1086. Z  */
  1087. Z int
  1088. Z strncmpic(s1, s2, n)
  1089. Z     register char *s1, *s2;        /* strings to compare */
  1090. Z     int n;                /* compare up to this many chars */
  1091. Z {
  1092. Z     register int c1, c2;        /* temp */
  1093. Z     register int cnt = n;        /* count of chars so far compared */
  1094. Z 
  1095. Z     while (*s1 && *s2 && cnt > 0) {
  1096. Z     if ((c1 = tolower(*s1)) != (c2 = tolower(*s2))) {
  1097. Z         return c1-c2;
  1098. Z     }
  1099. Z     s1++;
  1100. Z     s2++;
  1101. Z     cnt--;                /* count this character */
  1102. Z     }
  1103. Z 
  1104. Z     /*
  1105. Z      * If we ran out of chars, then the string segments are equal, otherwise
  1106. Z      * one or both strings must have ended. In this case the subtraction
  1107. Z      * will show which one is shorter, if any.
  1108. Z      */
  1109. Z     return cnt ? (int)((*s1)-(*s2)) : 0;
  1110. Z }
  1111. Z 
  1112. Z /*
  1113. Z  * strcolon - step through string parts separated by colons
  1114. Z  *
  1115. Z  * when called with a string, return a copy of the first part of
  1116. Z  * the string up to, but excluding the first `:'.  When called with
  1117. Z  * NULL return a copy of the next part of the previously passed string,
  1118. Z  * with each part separated by a colon `:'.
  1119. Z  *
  1120. Z  * return NULL if no more parts are left.
  1121. Z  *
  1122. Z  * strcolon is typically used in a loop on ':' separated names such as:
  1123. Z  *
  1124. Z  *    for (p = strcolon(names); p; p = strcolon((char *)NULL)) {
  1125. Z  *        ... do something with the name p ...
  1126. Z  *    }
  1127. Z  *
  1128. Z  * the malloc region returned is reused, so if you wish to keep a string
  1129. Z  * around, you will need to copy it.
  1130. Z  */
  1131. Z char *
  1132. Z strcolon(s)
  1133. Z     register char *s;            /* string or NULL */
  1134. Z {
  1135. Z     static char *next = NULL;        /* pointer to next ':' */
  1136. Z     static char *region = NULL;        /* region used to store result */
  1137. Z     static int alloc = 0;        /* alloc size of region */
  1138. Z 
  1139. Z     if (!s) {
  1140. Z     s = next;
  1141. Z     if (s == NULL) {
  1142. Z         return NULL;
  1143. Z     }
  1144. Z     }
  1145. Z     next = strchr(s, ':');
  1146. Z     if (next) {
  1147. Z     register int len = next - s;
  1148. Z 
  1149. Z     if (len >= alloc) {
  1150. Z         if (region == NULL) {
  1151. Z         region = xmalloc(alloc = len + 1);
  1152. Z         } else {
  1153. Z         region = xrealloc(region, alloc = len + 1);
  1154. Z         }
  1155. Z     }
  1156. Z     (void) memcpy(region, s, next - s);
  1157. Z     region[next - s] = '\0';
  1158. Z     next++;
  1159. Z     return region;
  1160. Z     }
  1161. Z     return s;
  1162. Z }
  1163. ----SHAR-EOF----
  1164. if test 20620 -ne "`wc -c unsharmap.c`"
  1165. then
  1166. echo shar: Uebertragungsfehler in unsharmap.c '(Soll-Laenge = 20620 Zeichen)'
  1167. fi
  1168. echo shar: Extraktion von install
  1169. sed 's/^Z //' << \----SHAR-EOF---- > install
  1170. Z : use /bin/sh
  1171. Z # ---------------------------------------------------------------------
  1172. Z #  Title     : installation von 'unsharmap' (als root ausfuehren)
  1173. Z #  Version      :       Wed, 16-May-90 / 21:00 / (root@artcom0)
  1174. Z # ---------------------------------------------------------------------
  1175. Z if [ ! -r /usr/sysadm ]
  1176. Z then echo "Install must be done with 'root' priv !" ; exit 1
  1177. Z fi
  1178. Z MAPDIR=/usr/lib/uucp/maps
  1179. Z BINDIR=/usr/local/bin
  1180. Z if [ ! -d $BINDIR ]
  1181. Z then echo "Oh... ich finde '/usr/local/bin' viel uebersichtlicher.
  1182. Z egal... wenn's denn sein soll, nehmen wir halt '/usr/bin' : "
  1183. Z      BINDIR=/usr/bin
  1184. Z fi
  1185. Z NEWSDIR=/usr/local/lib/news
  1186. Z if [ ! -d $NEWSDIR ]
  1187. Z then echo "Oh... ich finde '/usr/local/lib/news' viel uebersichtlicher.
  1188. Z egal... wenn's denn sein soll, nehmen wir halt '/usr/lib/news' : "
  1189. Z      NEWSDIR=/usr/lib/news
  1190. Z fi
  1191. Z 
  1192. Z if [ ! -d $MAPDIR ]
  1193. Z then mkdir $MAPDIR
  1194. Z      chmod 755 $MAPDIR
  1195. Z      chgrp news $MAPDIR
  1196. Z fi
  1197. Z 
  1198. Z if [ ! -d $MAPDIR/work ]
  1199. Z then mkdir $MAPDIR/work
  1200. Z      chmod 775 $MAPDIR/work
  1201. Z      # Ganz Wichtig : Gruppen Schreibzugriff fuer News !
  1202. Z      chgrp news $MAPDIR/work
  1203. Z fi
  1204. Z 
  1205. Z cp unsharmap $BINDIR
  1206. Z chgrp news $BINDIR/unsharmap
  1207. Z chown mail $BINDIR/unsharmap
  1208. Z chmod 6755 $BINDIR/unsharmap
  1209. Z 
  1210. Z cp mkpaths map.daily $MAPDIR
  1211. Z cd $MAPDIR
  1212. Z chown mail mkpaths map.daily
  1213. Z chgrp news mkpaths map.daily
  1214. Z chmod 755  mkpaths map.daily
  1215. Z 
  1216. Z #
  1217. Z # Aufruf von 'unsharmap' ins News-Sysfile einfuegen :
  1218. Z # 
  1219. Z SYSFILE=$NEWSDIR/sys
  1220. Z if [ ! -w $SYSFILE ]
  1221. Z then echo "Oh. Kein News-Sysfile ? ($SYSFILE)" ; exit 1
  1222. Z fi
  1223. Z 
  1224. Z grep "^automapadm" $SYSFILE >/dev/null || echo \
  1225. Z "# Automatische Mail-Routing-Map-Administration :
  1226. Z automapadm:world,sub,!sub.all,sub.config.maps::$BINDIR/unsharmap -p \\
  1227. Z     -n sub.config.maps -d $MAPDIR/work | mail -s \"Auto map adm\" \\
  1228. Z     postmaster" >> $SYSFILE
  1229. Z 
  1230. Z echo "Installation in $MAPDIR fertig ... 
  1231. Z und nun \"$MAPDIR/map.daily\" taeglich via root-crontab 
  1232. Z ausfuehren lassen oder per Hand aufrufen, wenn neue Maps ankamen."
  1233. ----SHAR-EOF----
  1234. if test 1902 -ne "`wc -c install`"
  1235. then
  1236. echo shar: Uebertragungsfehler in install '(Soll-Laenge = 1902 Zeichen)'
  1237. fi
  1238. echo shar: Extraktion von avoid-unido
  1239. sed 's/^Z //' << \----SHAR-EOF---- > avoid-unido
  1240. Z : use /bin/sh
  1241. Z #
  1242. Z #  Title    : avoid-unido -- avoid routing over unido, whenever possible
  1243. Z #  Version      :       Sat, 26-May-90 / 12:38 / (root@artcom0)
  1244. Z #
  1245. Z for i in u.deu.* ; do
  1246. Z     if [ "$i" = "*" ]
  1247. Z     then exit 0
  1248. Z     fi
  1249. Z     mv $i tmp
  1250. Z     awk ' { gsub (/DAILY/, "DEAD"); 
  1251. Z         gsub (/HOURLY/, "DEAD");
  1252. Z         gsub (/LOCAL/, "DEAD");
  1253. Z         gsub (/ARPA/, "DEAD");
  1254. Z         print $0 } ' < tmp > $i
  1255. Z     rm tmp
  1256. Z done
  1257. ----SHAR-EOF----
  1258. if test 402 -ne "`wc -c avoid-unido`"
  1259. then
  1260. echo shar: Uebertragungsfehler in avoid-unido '(Soll-Laenge = 402 Zeichen)'
  1261. fi
  1262. echo shar: Extraktion von getmap
  1263. sed 's/^Z //' << \----SHAR-EOF---- > getmap
  1264. Z #! /bin/sh
  1265. Z # @(#)getmap.sh    1.15 2/5/89 14:13:35
  1266. Z #
  1267. Z #    Copyright (C) 1988 Ronald S. Karr and Landon Curt Noll
  1268. Z #
  1269. Z # See the file COPYING, distributed with smail, for restriction
  1270. Z # and warranty information.
  1271. Z 
  1272. Z # getmap - unshar usenet map articles into the UNSHAR_MAP_DIR directory
  1273. Z #
  1274. Z # usage: getmap [-m mapdir] [-w workdir] [-b batchfile] [-u username]
  1275. Z #
  1276. Z #     -m mapdir    - 'mapdir' is where maps are unpacked,
  1277. Z #              by default 'mapdir' is $UNSHAR_MAP_DIR
  1278. Z #     -w workdir    - where logs and default batch files are kept,
  1279. Z #              by default 'workdir' is 'mapdir'/work
  1280. Z #      -b batch    - 'batch' is a file of filenames to unshar,
  1281. Z #              '-' impiles read filenames from stdin,
  1282. Z #              by default 'batch' is 'workdir'/batch
  1283. Z #     -u username    - errors are Emailed to 'username' rather than
  1284. Z #              Posmaster, the username '-' imples that
  1285. Z #              the errors should be written to standard error
  1286. Z #     -n newsgroups    - allowed newsgroups for articles
  1287. Z #
  1288. Z # unsharmap errors will be emailed to the postmaster.
  1289. Z #
  1290. Z # default files:
  1291. Z #    $UNSHAR_MAP_DIR            - maps are unpacked here
  1292. Z #    $UNSHAR_MAP_DIR/work/getmap.log    - log of getmap activity and errors
  1293. Z #    $UNSHAR_MAP_DIR/work/getmap.err    - like getmap.log + skipped lines
  1294. Z #                      removed if no major unshar errors
  1295. Z #    $UNSHAR_MAP_DIR/work/batch        - default list of artciles to unshar
  1296. Z #    batch.work                - tmp copy of batch work, normally
  1297. Z #                      $UNSHAR_MAP_DIR/work/batch.work,
  1298. Z #                      ignored if "-w -"
  1299. Z 
  1300. Z # locations and constants
  1301. Z #
  1302. Z PATH="/usr/bin:/bin:/usr/local/bin"
  1303. Z UTIL_BIN="/usr/spool/maps/bin"
  1304. Z UNSHAR_MAP_DIR="/usr/spool/maps"
  1305. Z UNSHAR=$UTIL_BIN/unsharmap
  1306. Z 
  1307. Z # set defaults value for location that can change by option
  1308. Z #
  1309. Z MAPDIR=$UNSHAR_MAP_DIR
  1310. Z WORKDIR=$MAPDIR/work
  1311. Z BATCH=$WORKDIR/batch
  1312. Z USERNAME=postmaster
  1313. Z NEWSGROUPS=comp.mail.maps:sub.config.maps
  1314. Z 
  1315. Z # parse args
  1316. Z #
  1317. Z PROG=$0
  1318. Z USAGE="usage: $PROG [-m mapdir] [-w workdir] [-b batch] [-u username]"
  1319. Z set -- `getopt -n $PROG -q m:w:b:u:n: $*`
  1320. Z if [ $? != 0 ]; then
  1321. Z     echo $USAGE 1>&2
  1322. Z     exit 1
  1323. Z fi
  1324. Z for i in $*; do
  1325. Z     case $i in
  1326. Z     -m) MAPDIR=$2; shift 2;;
  1327. Z     -w) WORKDIR=$2; shift 2;;
  1328. Z     -b) BATCH=$2; shift 2;;
  1329. Z     -u) USERNAME=$2; shift 2;;
  1330. Z     -n) NEWSGROUPS=$2; shift 2;;
  1331. Z     --) shift; break;;
  1332. Z     esac
  1333. Z done
  1334. Z if [ "$#" -ne 0 ]; then
  1335. Z     echo $USAGE 1>&2
  1336. Z     exit 2
  1337. Z fi
  1338. Z if [ "$BATCH" = "-" ]; then    # catch stdin case
  1339. Z     BATCH=
  1340. Z fi
  1341. Z if [ "$USERNAME" = "-" ]; then    # catch the cat errors to stderr case
  1342. Z     REPORT="cat 1>&2"
  1343. Z else
  1344. Z     REPORT="/usr/local/lib/sendmail -i -t"
  1345. Z fi
  1346. Z 
  1347. Z # set locations now that we have the flags
  1348. Z #
  1349. Z LOG=$WORKDIR/getmap.log
  1350. Z ERROR_LOG=$WORKDIR/getmap.err
  1351. Z REBUILD=$WORKDIR/getmap.rebuild
  1352. Z 
  1353. Z # be sure the working file does not exist, unless we read from stdin
  1354. Z #
  1355. Z if [ ! -z "$BATCH" ]; then
  1356. Z     BATCH_TMP="$BATCH".work
  1357. Z     if [ -f "$BATCH_TMP" ]; then
  1358. Z         echo "$PROG: working batch file $BATCH_TMP exists" 1>&2
  1359. Z         echo "$PROG: remove $BATCH_TMP by hand if stale" 1>&2
  1360. Z         exit 3
  1361. Z     fi
  1362. Z fi
  1363. Z 
  1364. Z # setup log files
  1365. Z #
  1366. Z if [ ! -z "$BATCH" ]; then
  1367. Z     BATCH_MSG="$PROG: starting work on $BATCH at `date`"
  1368. Z else
  1369. Z     BATCH_MSG="$PROG: starting work on [stdin] at `date`"
  1370. Z fi
  1371. Z echo "$BATCH_MSG" > $ERROR_LOG
  1372. Z if [ "$?" -ne 0 ]; then
  1373. Z     echo "$PROG: can not clear $ERROR_LOG" 1>&2
  1374. Z     exit 4
  1375. Z fi
  1376. Z touch $LOG 2>/dev/null
  1377. Z if [ "$?" -ne 0 ]; then
  1378. Z     echo "$PROG: can not write to $LOG" 1>&2
  1379. Z     echo "$PROG: can not write to $LOG" >> $ERROR_LOG
  1380. Z     (if [ "$USERNAME" != "-" ]; then
  1381. Z     echo "To: $USERNAME"
  1382. Z     echo "Subject: getmap error"
  1383. Z     echo ""
  1384. Z     echo ""
  1385. Z      fi
  1386. Z      echo "getmap error log follows -----"
  1387. Z      cat $ERROR_LOG
  1388. Z      echo "end of getmap error log =====") | eval "$REPORT"
  1389. Z     exit 5
  1390. Z fi
  1391. Z 
  1392. Z 
  1393. Z # save the batch file, if not from stdin
  1394. Z #
  1395. Z if [ ! -z "$BATCH" ]; then
  1396. Z     # do nothing if no batch file or no work in the batch file
  1397. Z     if [ ! -f "$BATCH" -o ! -s "$BATCH" ]; then
  1398. Z     echo "$PROG: no work in $BATCH" >> $LOG
  1399. Z     rm -f $ERROR_LOG
  1400. Z         exit 0
  1401. Z     fi
  1402. Z     mv $BATCH $BATCH_TMP
  1403. Z     if [ "$?" -ne 0 ]; then
  1404. Z         echo "$PROG: could not move $BATCH to $BATCH_TMP" 1>&2
  1405. Z         echo "$PROG: could not move $BATCH to $BATCH_TMP" >> $ERROR_LOG
  1406. Z     (if [ "$USERNAME" != "-" ]; then
  1407. Z         echo "To: $USERNAME"
  1408. Z         echo "Subject: getmap error"
  1409. Z         echo ""
  1410. Z         echo ""
  1411. Z      fi
  1412. Z      echo "getmap error log follows -----"
  1413. Z      cat $ERROR_LOG
  1414. Z      echo "end of getmap error log =====") | eval "$REPORT"
  1415. Z     cat $ERROR_LOG >> $LOG
  1416. Z     exit 6
  1417. Z     fi
  1418. Z 
  1419. Z # if work from stdin, prep a file to be used to save a copy
  1420. Z #
  1421. Z else
  1422. Z     BATCH_TMP=$WORKDIR/getmap.in$$
  1423. Z     cat /dev/null > $BATCH_TMP
  1424. Z     if [ "$?" -ne 0 ]; then
  1425. Z         echo "$PROG: could not clear $BATCH_TMP to hold a copy of [stdin]" 1>&2
  1426. Z         echo "$PROG: could not clear $BATCH_TMP to hold a copy of [stdin]" >> $ERROR_LOG
  1427. Z     (if [ "$USERNAME" != "-" ]; then
  1428. Z         echo "To: $USERNAME"
  1429. Z         echo "Subject: getmap error"
  1430. Z         echo ""
  1431. Z         echo ""
  1432. Z      fi
  1433. Z      echo "getmap error log follows -----"
  1434. Z      cat $ERROR_LOG
  1435. Z      echo "end of getmap error log =====") | eval "$REPORT"
  1436. Z     cat $ERROR_LOG >> $LOG
  1437. Z     exit 7
  1438. Z     fi
  1439. Z fi
  1440. Z 
  1441. Z # process the map artcile files
  1442. Z #
  1443. Z if [ ! -z "$BATCH" ]; then
  1444. Z     $UNSHAR -d $MAPDIR -n $NEWSGROUPS < $BATCH_TMP >> $ERROR_LOG
  1445. Z     STATUS=$?
  1446. Z else
  1447. Z     tee -a $BATCH_TMP | $UNSHAR -d $MAPDIR >> $ERROR_LOG
  1448. Z     STATUS=$?
  1449. Z fi
  1450. Z 
  1451. Z # note if we unpacked anything
  1452. Z if [ -s "$BATCH_TMP" ]; then
  1453. Z     touch $REBUILD
  1454. Z fi
  1455. Z 
  1456. Z # log the activity
  1457. Z #
  1458. Z cat $ERROR_LOG >> $LOG
  1459. Z 
  1460. Z # post processing - look for errors to report
  1461. Z #
  1462. Z if [ "$STATUS" -ne 0 ]; then
  1463. Z     # form the mail message header
  1464. Z     (if [ "$USERNAME" != "-" ]; then
  1465. Z     echo "To: $USERNAME"
  1466. Z     echo "Subject: getmap error"
  1467. Z     echo ""
  1468. Z     echo ""
  1469. Z      fi
  1470. Z      echo "getmap error log follows -----"
  1471. Z      cat $ERROR_LOG
  1472. Z      echo "end of getmap error log ====="
  1473. Z      echo ""
  1474. Z      echo ""
  1475. Z      if [ ! -z "$BATCH" ]; then
  1476. Z          echo "$BATCH_TMP work queue follows -----"
  1477. Z          cat $BATCH_TMP
  1478. Z          echo "end of $BATCH_TMP work queue ====="
  1479. Z      else
  1480. Z          echo "[stdin] work queue follows -----"
  1481. Z      cat $BATCH_TMP
  1482. Z          echo "end of [stdin] work queue ====="
  1483. Z      fi) | eval "$REPORT"
  1484. Z else
  1485. Z     rm -f $ERROR_LOG    # no error, so remove the error log
  1486. Z fi
  1487. Z rm -f $BATCH_TMP
  1488. Z 
  1489. Z exit 0
  1490. ----SHAR-EOF----
  1491. if test 6008 -ne "`wc -c getmap`"
  1492. then
  1493. echo shar: Uebertragungsfehler in getmap '(Soll-Laenge = 6008 Zeichen)'
  1494. fi
  1495. echo shar: Extraktion von patch.README
  1496. sed 's/^Z //' << \----SHAR-EOF---- > patch.README
  1497. Z From: Matthias Urlichs <urlichs@smurf.sub.org>
  1498. Z Newsgroups: sub.os.unix
  1499. Z Subject: Re: Map-Unpacker
  1500. Z 
  1501. Z In sub.os.unix, Artikel <1672@chiuur.chi.sub.org>,
  1502. Z   schreibt maps@chi.sub.org (Christian Kaiser):
  1503. Z [ unsharmap deleted ]
  1504. Z 
  1505. Z Wer die Maps alternativ gleich aus sub.config.maps raussaugen will, kann
  1506. Z folgenden Patch applizieren:
  1507. Z 
  1508. Z In der /usr/lib/news/sys-Datei (oder wo auch immer -- bei mir heisst das Ding
  1509. Z momentan /usr/local/news/c/admin/sys ;-) ) steht dann noch ein
  1510. Z 
  1511. Z map:world,sub,!sub.all,sub.config.maps.ctl::/usr/local/mail/bin/unsharmap -p -n sub.config.maps -d /usr/local/mail/map
  1512. Z 
  1513. Z Sicherheitsfanatiker machen dann noch ein (bzw. drei :-)
  1514. Z chown mail unsharmap
  1515. Z chgrp news unsharmap
  1516. Z chmod 6750 unsharmap
  1517. Z Die Maps liegen dann gleich ausgepackt im richtigen Verzeichnis.
  1518. Z 
  1519. Z Ach ja, den Pathalias laesst man am besten zur selben Zeit laufen wie den
  1520. Z Expire, damit es keine Probleme mit halben Maps gibt...
  1521. Z 
  1522. Z -p heisst "Pipe". Ein "-" konnte ich nicht verwenden, weil einige
  1523. Z getopt-Implementationen das missverstehen.
  1524. ----SHAR-EOF----
  1525. if test 1011 -ne "`wc -c patch.README`"
  1526. then
  1527. echo shar: Uebertragungsfehler in patch.README '(Soll-Laenge = 1011 Zeichen)'
  1528. fi
  1529. #    Ende des Shell Archivs
  1530. exit 0
  1531.  
  1532. -->
  1533. Peter Funk \\ ArtCom GmbH, Schwachhauser Heerstr. 78, D-2800 Bremen 1
  1534. Work at home: Oldenburger Str.86, D-2875 Ganderkesee 1 /+49 4222 6018 (8am-6pm)
  1535.  
  1536.