home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #31 / NN_1992_31.iso / spool / de / comp / sources / os9 / 3 < prev    next >
Encoding:
Internet Message Format  |  1992-12-23  |  45.4 KB
  1. Xref: sparky de.comp.sources.os9:3 comp.os.os9:1545
  2. Path: sparky!uunet!cs.utexas.edu!sun-barr!news2me.EBay.Sun.COM!seven-up.East.Sun.COM!sungy!stasys!stasys!not-for-mail
  3. From: frank.kaefer@stasys.sta.sub.org (Frank Kaefer)
  4. Newsgroups: de.comp.sources.os9,comp.os.os9
  5. Subject: MNews Prerelease Part07/09
  6. Message-ID: <1hafdmINNpth@stasys.sta.sub.org>
  7. Date: 23 Dec 92 19:41:42 GMT
  8. Sender: news@stasys.sta.sub.org
  9. Followup-To: de.comp.sources.d
  10. Organization: Stasys News Server, Starnberg, Germany
  11. Lines: 1962
  12. Approved: frank.kaefer@stasys.sta.sub.org (Frank Kaefer)
  13. NNTP-Posting-Host: stasys.sta.sub.org
  14.  
  15. Submitted-by: Ulrich Dessauer <ud@Nightmare.ddt.sub.org>
  16. Archive-name: mnews/part07
  17.  
  18. : ----- Cut here ----- Cut here ----- Cut here ----- Cut here -----
  19. : Use  sh filename  to extract shell archive
  20. : This shell archive contains following files:
  21. :     'MAN/News_in.prf                               666 bytes'
  22. :     'MAN/News_out.prf                              448 bytes'
  23. :     'MAN/Rnews.prf                                 680 bytes'
  24. :     'MAN/Sbatch.prf                               2299 bytes'
  25. :     'MAN/Sys.prf                                  3156 bytes'
  26. :     'MISC/Makefile                                 912 bytes'
  27. :     'MISC/decode.c                                3366 bytes'
  28. :     'MISC/delold.c                                2730 bytes'
  29. :     'MISC/encode.c                                3063 bytes'
  30. :     'MISC/news_in.c                               1585 bytes'
  31. :     'MISC/news_out.c                              3113 bytes'
  32. :     'MISC/nstat.c                                 9149 bytes'
  33. :     'MISC/rot13.c                                 1040 bytes'
  34. :     'MISC/unmap.c                                 2012 bytes'
  35. :     'RNEWS/Makefile                                453 bytes'
  36. :     'RNEWS/compr.c                                4277 bytes'
  37. : 
  38. if test -f 'MAN/News_in.prf' ; then
  39.   echo 'File MAN/News_in.prf already exists, overwriting it'
  40.   del 'MAN/News_in.prf'
  41. fi
  42. echo Extracting \"'MAN/News_in.prf'\"
  43. sed "s/^X//" >'MAN/News_in.prf' <<'__END__OF__THIS__FILE__'
  44. X.THS News_in 8L News
  45. X.SH NAME
  46. X$N - gateways incoming mails to news.
  47. X.SH SYNOPSIS
  48. X$N [-f=<sender>] <newsgroup>
  49. X.SH DESCRIPTION
  50. XIn combination with
  51. X.B News_out
  52. X$N can be used to forward news as mails and to allow answering to an
  53. Xarticle via mail. For this you need a flexible mail transport agent,
  54. Xe.g. sendmail or MMail. The
  55. X.B <sender>
  56. Xis optional and currently not used.
  57. X.B <newsgroup>
  58. Xmust be a valid newsgroup either with dots or with hyphens. Valid
  59. Xnewsgroups are then (e.g.) comp-lang-c or rec.games.frp. The hyphen
  60. Xsolution is used to avoid a miss-parsing the dots as domains.
  61. X.SH CAVEATS
  62. XThis is only a very primitiv solution and may cause several problems.
  63. X
  64. __END__OF__THIS__FILE__
  65. if test -f 'MAN/News_out.prf' ; then
  66.   echo 'File MAN/News_out.prf already exists, overwriting it'
  67.   del 'MAN/News_out.prf'
  68. fi
  69. echo Extracting \"'MAN/News_out.prf'\"
  70. sed "s/^X//" >'MAN/News_out.prf' <<'__END__OF__THIS__FILE__'
  71. X.THS News_out 8L News
  72. X.SH NAME
  73. X$N - gateways incoming news to mail.
  74. X.SH SYNOPSIS
  75. X$N <receiver>
  76. X.SH DESCRIPTION
  77. XIn combination with
  78. X.B News_in
  79. X$N can be used to forward news as mails and to allow answering to an
  80. Xarticle via mail. $N tries to set the
  81. X.B Reply-To:
  82. Xline to a valid name (<group>\@newsgroup.<local-domain>) to allow a
  83. Xsimple answer posting by the user.
  84. X.SH CAVEATS
  85. XThis is only a very primitiv solution and may cause several problems.
  86. X
  87. __END__OF__THIS__FILE__
  88. if test -f 'MAN/Rnews.prf' ; then
  89.   echo 'File MAN/Rnews.prf already exists, overwriting it'
  90.   del 'MAN/Rnews.prf'
  91. fi
  92. echo Extracting \"'MAN/Rnews.prf'\"
  93. sed "s/^X//" >'MAN/Rnews.prf' <<'__END__OF__THIS__FILE__'
  94. X.THS Rnews 8L News
  95. X.SH NAME
  96. XRnews - Receive batched Articles from remote System
  97. X.SH SYNOPSIS
  98. Xrnews [-d=<dbglvl>] [<file>]
  99. X.SH DESCRIPTION
  100. X.ti +3
  101. XRnews is called by a remote system to unpack the received news article
  102. Xand feed them to Inews.  If Inews failed for any reasons, rnews will
  103. Xstore this article in
  104. X.B /h0/SPOOL/RNEWS
  105. X(or whereever set using Sysinfo).
  106. X.SH FILES
  107. X.O /h0/SPOOL/RNEWS
  108. XStore failed article there.
  109. X.NO /h0/SPOOL/UUCP/.LOG/rnews.log
  110. XThe logfile, will only be written if existing.
  111. X.EO
  112. X.SH SYSINFO
  113. X.O RNEWS.DIR,s=/h0/SPOOL/RNEWS
  114. XSets the directory where failed article should be placed
  115. X.EO
  116. X.SH SEE ALSO
  117. X Inews - in this distribution
  118. X Sbatch - in this distribution
  119. __END__OF__THIS__FILE__
  120. if test -f 'MAN/Sbatch.prf' ; then
  121.   echo 'File MAN/Sbatch.prf already exists, overwriting it'
  122.   del 'MAN/Sbatch.prf'
  123. fi
  124. echo Extracting \"'MAN/Sbatch.prf'\"
  125. sed "s/^X//" >'MAN/Sbatch.prf' <<'__END__OF__THIS__FILE__'
  126. X.THS Sbatch 8L News
  127. X.SH NAME
  128. XSbatch - Collect and batch News article for remote system
  129. X.SH SYNOPSIS
  130. X.raw
  131. Xsbatch [-c|-c7|-cf|-cf7|-b|-s] [-B=<size>] [-t]
  132. X       [-G=<grade>] [-f=<size>] [-C=<cmd>] [-n=<system>]
  133. X       <system>
  134. X.noraw
  135. X.SH DESCRIPTION
  136. X.ti +3
  137. XSbatch collects all article which should be send to a remote system.
  138. XOn default all articles are batched into one file until the size limit
  139. Xis reached. With
  140. X.O -c
  141. Xyou can compress the news to get a better throughput.
  142. X.NO -cf
  143. Xforces `freeze' to be used instead of compresss.
  144. X.NO -c7
  145. Xwill encode them after compression to transmit them over lines which
  146. Xonly supports 7 Bit.
  147. X.NO -cf7
  148. Xwill be used for 7 Bit channels with `freeze' to compress data.
  149. X.NO -s
  150. Xall articles are spooled as single files.
  151. X.NO -f=<size>
  152. Xgives the limit of a file in kBytes. the default is 50 kByte. 
  153. X.NO -B=<bitcount>
  154. XTo compress with another bitvalue than 16 (the default, use the option
  155. Xto set the bitvalue to 12 to 16. 
  156. X.NO -G=<grade>
  157. XIf your delivering program accepts a grade character in the command
  158. Xstring then you can change this here. 
  159. X.NO -C=<cmd>
  160. Xthe delivery command can be changed with this to a complete new value. 
  161. XThe command may contain two different sequences for inserting the grade
  162. Xcharacter and the system name.  These are
  163. X.bold
  164. X\%S
  165. Xfor the system and
  166. X.bold
  167. X\%G
  168. Xfor the grading.
  169. X.NO -t
  170. Xthis is for use with eight bit characters. If your neighbor host doesn't
  171. Xsupport these characters then they are translated back to pure seven bit
  172. XASCII. Currently only the german umlaute for ISO8859/1 are supported.
  173. X.NO -n=<system>
  174. XIf the name in the command to forward news differs from the filename the
  175. Xbatchfile is stored then this is used as the filename of the batched
  176. Xarticles.
  177. X.EO
  178. X.SH CAVEATS
  179. XThe files are stored in temporary on /dd. If this too small things may
  180. Xfail.
  181. X.SH BUGS
  182. XMay be a lot, none known.
  183. X.SH FILES
  184. X.O /h0/SPOOL/BATCH
  185. XThe articles are stored herein, for each system one file with the
  186. Xfilename of the system. The format is an optional flagfield seperated
  187. Xfrom the main filename by a bar
  188. X.RB (` | ').
  189. XCurrently there are the two flags
  190. X.RB ` N '
  191. Xand
  192. X.RB ` C '
  193. Xfor non-convert and convert from 8 bit (if these optiones are proper
  194. Xinserted the `-t' option is obsolete.)
  195. X.EO
  196. X.SH SEE ALSO
  197. X Inews - in this distribution
  198. X Rnews - in this distribution
  199. __END__OF__THIS__FILE__
  200. if test -f 'MAN/Sys.prf' ; then
  201.   echo 'File MAN/Sys.prf already exists, overwriting it'
  202.   del 'MAN/Sys.prf'
  203. fi
  204. echo Extracting \"'MAN/Sys.prf'\"
  205. sed "s/^X//" >'MAN/Sys.prf' <<'__END__OF__THIS__FILE__'
  206. X.THS Sys 5L News
  207. X.SH NAME
  208. XSys - this file describes the mechanism to forward received articles to
  209. Xother sites or to programs.
  210. X.SH DESCRIPTION
  211. X.ti +3
  212. XThis files specifies the newsgroups and distributions to be forwarded to
  213. Xanother site or to be pipe'd to a program. So you are able to limit the
  214. Xamount of articles to be forwarded by area (distribution) or/and the
  215. Xtopics (newsgroups).
  216. X.SH FORMAT
  217. XThe format of the file is
  218. X.ce
  219. X<system>{> <flags>}:<newsgroups>:<dists>{:<program>}
  220. Xwhere
  221. X.B <system>
  222. Xis in general the system to forward the news (or an ID for programs).
  223. XYou can append a list of other systemnames (seperated by a slash
  224. X.B /
  225. Xform the main system), which are seperated by commas to stop forwarding
  226. Xarticles which had already passed these systems. The
  227. X.B <flags>
  228. Xare a list of flags which are inserted before the filename in the
  229. Xbatchfile. These flags are interpreted by sbatch only. The
  230. X.B <newsgroups>
  231. Xis a list of newsgroups which are in regular expression format (using
  232. XHenry Spencer's regular expression library), seperated by spaces.
  233. XInternal the expression will be enclosed with
  234. X.B ^
  235. Xand
  236. X.bold
  237. X\$
  238. Xto allow only exact matches.
  239. X.B <dists>
  240. Xare the distributions which aren't regular expressions, but they may
  241. Xcontain the meta characters
  242. X.B ?
  243. Xand
  244. X.B *
  245. Xto match one (?) or zero or more (*) characters. The <newsgroups> and
  246. X<dists> field allow a not operation by prefixing an expression with an
  247. X.B !
  248. Xso you can select specific items not to be forwarded. If an article
  249. Xshould be forwarded the filename is written in a file in
  250. X.B /h0/SPOOL/BATCH
  251. Xwith the filename equal to <system> (if possible). This file is used by
  252. X.B sbatch
  253. Xto send the articles themselves.
  254. X.PP
  255. XThe
  256. X.B <program>
  257. Xis optional but if it is given the filename of the article isn't written
  258. Xto the file mentioned above but the article itself is pipe'd to this
  259. Xprogram (so the program must read the article from stdin).
  260. X.PP
  261. XIf the first character of <program> is a plus sign then the rest will be
  262. Xused as a full path to a directory where to store the articles with
  263. Xincreasing numbers. If the first character is a minus sign then the rest
  264. Xis a full path to a directory which is used instead of the batch
  265. Xdirectory (/h0/SPOOL/BATCH).
  266. X.PP
  267. XEach line in this file may be continued in the next line if the last
  268. Xcharacter in the prvious line had been a backslash.
  269. X.PP
  270. XIf a line starts with a colon
  271. X.RB ( : )
  272. Xthen the rest of the line is taken as a filename of a file to be
  273. Xincluded.  With this features it is possible to create one file for each
  274. Xsystem which can be changed from remote via mail.  For this purpose the
  275. Xprogram
  276. X.B remsys
  277. Xcan be found in this distribution.
  278. X.SH EXAMPLES
  279. X.raw 4
  280. Xmyfeed:!local.* to\\.myfeed !to\\..* .*:!local *
  281. Xsubfeed:(sub|muc)\\..*:sub muc world
  282. Xsave:.*source.*:*:save_it
  283. X.noraw
  284. X.B myfeed
  285. Xwill get everything expect these newsgroups which are prefixed by
  286. X.B local
  287. Xor have distribution
  288. X.B local
  289. Xor have the prefix
  290. X.B to.
  291. Xand not followed by myfeed.
  292. X.B subfeed
  293. Xwill only receive groups of a local are (Newsgroups prefixed by muc. or
  294. Xsub. and distribution muc sub and world). The entry
  295. X.B save
  296. Xwill store (assuming a proper program) all articles in source groups.
  297. __END__OF__THIS__FILE__
  298. if test -f 'MISC/Makefile' ; then
  299.   echo 'File MISC/Makefile already exists, overwriting it'
  300.   del 'MISC/Makefile'
  301. fi
  302. echo Extracting \"'MISC/Makefile'\"
  303. sed "s/^X//" >'MISC/Makefile' <<'__END__OF__THIS__FILE__'
  304. X# $Id: Makefile_v 1.1.1.1 90/09/08 16:08:49 ud Exp $
  305. X# $Log:    Makefile_v $
  306. X# Revision 1.1.1.1  90/09/08  16:08:49  ud
  307. X# Insert entry for delold
  308. X# 
  309. X# Revision 1.1  90/08/31  15:28:34  cv
  310. X# Initial revision
  311. X# 
  312. X#
  313. XCC=    cc
  314. XG=    -g
  315. XCFLAGS=    -qt=/dd/TMP $G -v=.. -v=../8BIT
  316. XLIBS=    -l=/dd/LIB/os9lib.l
  317. XLFLAGS=    -q $(LIBS) $G
  318. XODIR=    /h0/ETC/CMDS
  319. X
  320. Xencode:    encode.r
  321. X
  322. Xdecode:    decode.r
  323. X
  324. Xdelold:    delold.r
  325. X    $(CC) $(LFLAGS) delold.r -f=$(ODIR)/$@ -m=50
  326. X    fixmod -uo2.39 $(ODIR)/$@
  327. X
  328. Xunmap:    unmap.r
  329. X    $(CC) $(LFLAGS) unmap.r -f=$(ODIR)/$@
  330. X    fixmod -uo90.91 $(ODIR)/unmap
  331. X
  332. Xnews_in:    news_in.r
  333. X    $(CC) $(LFLAGS) news_in.r -f=$(ODIR)/$@
  334. X    fixmod -uo2.39 $(ODIR)/$@
  335. X
  336. Xnews_out:    news_out.r
  337. X    $(CC) $(LFLAGS) news_out.r -f=$(ODIR)/$@ -l=/dd/LIB/8bit.l
  338. X    fixmod -uo2.39 $(ODIR)/$@
  339. X
  340. Xrot13:    rot13.r
  341. X    $(CC) $(LFLAGS) rot13.r -f=$(ODIR)/$@ -l=/dd/LIB/8bit.l
  342. X
  343. Xnstat:    nstat.r
  344. X    $(CC) $(LFLAGS) nstat.r -f=$(ODIR)/$@ -l=/dd/LIB/8bit.l
  345. X    fixmod -uo2.39 $(ODIR)/$@
  346. __END__OF__THIS__FILE__
  347. if test -f 'MISC/decode.c' ; then
  348.   echo 'File MISC/decode.c already exists, overwriting it'
  349.   del 'MISC/decode.c'
  350. fi
  351. echo Extracting \"'MISC/decode.c'\"
  352. sed "s/^X//" >'MISC/decode.c' <<'__END__OF__THIS__FILE__'
  353. X#include <stdio.h>
  354. X
  355. X#ifdef SCCSID
  356. Xstatic char    *SccsId = "@(#)decode.c    1.3    5/15/85";
  357. X#endif /* SCCSID */
  358. X
  359. X/*
  360. X * This program is the inverse of encode
  361. X *
  362. X * It collects runs of 12 characters, combines pairs of those
  363. X * to form 6 13 bit numbers, extracts the top bit of each of
  364. X * those to make a 13th 6 bit character, and splits each of
  365. X * the remaining 6 12 bit numbers to form 12 6 bit ones.
  366. X *
  367. X * The strings of 6 bit numbers are collected into groups of
  368. X * 4 and converted into 3 8 bit characters.
  369. X *
  370. X * Now all that would be trivial, if we didn't need to worry
  371. X * about ending all this correctly.  About 1/2 of the following
  372. X * program wouldn't be here if the ending didn't matter....
  373. X */
  374. X
  375. X/*
  376. X * the following pair of characters can never occur as a pair
  377. X * in legal input (since (90 * 91 + 90) > 2^13) - they are
  378. X * noticed at the beginning of a 12 char block, and serve to
  379. X * indicate that this block is the terminator.  The character
  380. X * immediately following is the (expanded) terminator length.
  381. X */
  382. X#define    ENDMARK1    ((90*91 + 90) / 91)
  383. X#define    ENDMARK2    ((90*91 + 90) % 91)
  384. X
  385. Xmain()
  386. X{
  387. X    register c;
  388. X    register char *p;
  389. X    register i;
  390. X    register first = 1;
  391. X    register cnt = 0;
  392. X    int errcnt = 0;
  393. X    char b12[12];
  394. X    char c12[12];
  395. X
  396. X    p = b12;
  397. X    i = 12;
  398. X
  399. X    while ((c = getchar()) != EOF) {
  400. X        if (c < ' ' || c >= (' ' + 91)) {
  401. X            if (errcnt++ == 0)
  402. X                fprintf(stderr, "decode: Bad data\n");
  403. X            continue;
  404. X        }
  405. X        if (i == 10 && p[-1] == ENDMARK1 && p[-2] == ENDMARK2) {
  406. X            cnt = c - ' ';
  407. X            i = 12;
  408. X            p -= 2;
  409. X            continue;
  410. X        }
  411. X        *p++ = c - ' ';
  412. X        if (--i == 0) {
  413. X            if (p == &b12[12]) {
  414. X                if (!first)
  415. X                    pack12(c12, 12, 0);
  416. X                else
  417. X                    first = 0;
  418. X                p = c12;
  419. X            } else {
  420. X                pack12(b12, 12, 0);
  421. X                p = b12;
  422. X            }
  423. X            i = 12;
  424. X        }
  425. X    }
  426. X
  427. X    if (p >= &b12[0] && p < &b12[12]) {
  428. X        if (!first)
  429. X            pack12(c12, 12, i == 12 ? cnt : 0);
  430. X    } else
  431. X        pack12(b12, 12, i == 12 ? cnt : 0);
  432. X
  433. X    if (i != 12) {
  434. X        if (p >= &b12[0] && p < &b12[12])
  435. X            pack12(b12, 12-i, cnt);
  436. X        else
  437. X            pack12(c12, 12-i, cnt);
  438. X    }
  439. X
  440. X    exit(0);
  441. X}
  442. X
  443. Xstatic char b4[4];
  444. Xstatic int cnt = 0;
  445. X
  446. Xpack12(p, n, last)
  447. X    register char *p;
  448. X    register n;
  449. X    int last;
  450. X{
  451. X    register i;
  452. X    register char *q;
  453. X    char b13[13];
  454. X
  455. X    {
  456. X        register c;
  457. X        register c13;
  458. X
  459. X        q = b13;
  460. X        c13 = 0;
  461. X
  462. X        for (i = 0; i < n; i += 2) {
  463. X            c = *p++ * 91;
  464. X            c += *p++;
  465. X            c13 <<= 1;
  466. X            if (c & (1 << 12))
  467. X                c13 |= 1;
  468. X            *q++ = (c >> 6) & 0x3f;
  469. X            *q++ = c & 0x3f;
  470. X        }
  471. X        *q++ = c13;
  472. X        if (last)
  473. X            q = &b13[last];
  474. X    }
  475. X
  476. X    p = b13;
  477. X    n = q - p;
  478. X    i = cnt;
  479. X    q = &b4[cnt];
  480. X
  481. X    while (--n > 0) {
  482. X        *q++ = *p++;
  483. X        if (++i == 4) {
  484. X            char b3[3];
  485. X            register char *b = b4;
  486. X
  487. X            /* inline expansion of pack6bit, to save calls ... */
  488. X
  489. X            q = b3;
  490. X            *q++ = (b[0] << 2) | ((b[1] >> 4) & 0x3);
  491. X            *q++ = (b[1] << 4) | ((b[2] >> 2) & 0xf);
  492. X            *q = (b[2] << 6) | (b[3] & 0x3f);
  493. X
  494. X            q = b3;
  495. X            while (--i > 0)
  496. X                putchar(*q++);
  497. X
  498. X            q = b4;
  499. X        }
  500. X    }
  501. X
  502. X    *q++ = *p++;    /* the last octet */
  503. X    ++i;
  504. X
  505. X    if (last || i == 4) {
  506. X        pack6bit(b4, i, last);
  507. X        i = 0;
  508. X    }
  509. X
  510. X    cnt = i;
  511. X}
  512. X
  513. Xpack6bit(p, n, last)
  514. X    register char *p;
  515. X    register int n;
  516. X    int last;
  517. X{
  518. X    register char *q;
  519. X    register i = 3;
  520. X    char b3[3];
  521. X
  522. X    if (last) {
  523. X        i = p[n-1];
  524. X        if (i >= 3) {
  525. X            fprintf(stderr, "Badly encoded file\n");
  526. X            i = 3;        /* do the best we can */
  527. X        }
  528. X    }
  529. X
  530. X    q = b3;
  531. X    *q++ = (p[0] << 2) | ((p[1] >> 4) & 0x3);
  532. X    *q++ = (p[1] << 4) | ((p[2] >> 2) & 0xf);
  533. X    *q = (p[2] << 6) | (p[3] & 0x3f);
  534. X
  535. X    q = b3;
  536. X
  537. X    while (--i >= 0)
  538. X        putchar(*q++);
  539. X}
  540. X
  541. __END__OF__THIS__FILE__
  542. if test -f 'MISC/delold.c' ; then
  543.   echo 'File MISC/delold.c already exists, overwriting it'
  544.   del 'MISC/delold.c'
  545. fi
  546. echo Extracting \"'MISC/delold.c'\"
  547. sed "s/^X//" >'MISC/delold.c' <<'__END__OF__THIS__FILE__'
  548. X/*
  549. X * $Log:    delold.c_v $
  550. X * Revision 1.1  90/09/08  15:52:24  cv
  551. X * Initial revision
  552. X * 
  553. X */
  554. X# ifndef    LINT
  555. Xstatic char rcsid[] = "$Id: delold.c_v 1.1 90/09/08 15:52:24 cv Exp $";
  556. Xstatic char copyright[] = "Copyright (C) 1989, 1990 by Ulrich Dessauer, Germering, Germany.\n";
  557. X# endif        LINT
  558. X# include    <stdio.h>
  559. X# include    <ctype.h>
  560. X# include    <time.h>
  561. X# include    <types.h>
  562. X# include    <stat.h>
  563. X# include    <dir.h>
  564. X# include    "news.h"
  565. X
  566. Xextern char    *malloc ();
  567. Xextern int    errno;
  568. X
  569. Xtypedef struct _dirlist {
  570. X    char    fn[33];
  571. X    int    isdir;
  572. X    struct _dirlist    *next;
  573. X} dirlist;
  574. X
  575. Xtime_t    secs;
  576. Xtime_t    tim;
  577. Xint    count;
  578. Xchar    fpath[1024];
  579. X
  580. Xvoid
  581. Xdo_scan (path)
  582. Xchar *path;
  583. X{
  584. X    DIR        *dp;
  585. X    struct direct    *ent;
  586. X    dirlist        *head, *cur, *tmp;
  587. X    register char    *p;
  588. X    char        *sav;
  589. X    struct stat    st;
  590. X
  591. X    if (path)
  592. X        if (chdir (path) < 0) {
  593. X            fprintf (stderr, "Can't chdir to %s (errno %d).\n", path, errno);
  594. X            return;
  595. X        }
  596. X    head = NULL;
  597. X    cur = NULL;
  598. X    if (!(dp = opendir ("."))) {
  599. X        fprintf (stderr, "Can't open '%s' (errno %d), skip over.\n", path ? path : "[root]", errno);
  600. X        if (path)
  601. X            chdir ("..");
  602. X        return;
  603. X    }
  604. X    if (path) {
  605. X        p = fpath;
  606. X        while (*p)
  607. X            ++p;
  608. X        sav = p;
  609. X        *p++ = '/';
  610. X        strcpy (p, path);
  611. X        printf ("Now in %s\n", fpath);
  612. X    }
  613. X    while (ent = readdir (dp)) {
  614. X        if (ent->d_name[0] == '.')
  615. X            continue;
  616. X        p = ent->d_name;
  617. X        while (*p)
  618. X            if (!isdigit (*p))
  619. X                break;
  620. X            else
  621. X                ++p;
  622. X        if (!(tmp = (dirlist *) malloc (sizeof (dirlist)))) {
  623. X            fprintf (stderr, "PANIC: Out of memory! (errno %d)\n", errno);
  624. X            closedir (dp);
  625. X            exit (1);
  626. X        }
  627. X        strcpy (tmp->fn, ent->d_name);
  628. X        tmp->isdir = (*p != '\0');
  629. X        tmp->next = NULL;
  630. X        if (!head)
  631. X            head = tmp;
  632. X        else
  633. X            cur->next = tmp;
  634. X        cur = tmp;
  635. X    }
  636. X    closedir (dp);
  637. X    cur = head;
  638. X    while (cur) {
  639. X        if (cur->isdir)
  640. X            do_scan (cur->fn);
  641. X        else if (stat (cur->fn, &st) == -1)
  642. X            fprintf (stderr, "Can't stat %s (errno %d).\n", cur->fn, errno);
  643. X        else if (st.st_mtime + secs < tim)
  644. X            if (unlink (cur->fn) < 0)
  645. X                fprintf (stderr, "Can't unlink %s (errno %d).\n", cur->fn, errno);
  646. X            else
  647. X                ++count;
  648. X        tmp = cur;
  649. X        cur = cur->next;
  650. X        free ((char *) tmp);
  651. X    }
  652. X    if (path) {
  653. X        *sav = '\0';
  654. X        chdir ("..");
  655. X    }
  656. X}
  657. X
  658. Xint
  659. Xmain (argc, argv)
  660. Xint argc;
  661. Xchar *argv[];
  662. X{
  663. X    char    buf[256];
  664. X    int    days;
  665. X
  666. X    setuid (getmuid ());
  667. X    if ((argc != 2) || (!isdigit (argv[1][0])))
  668. X        exit (_errmsg (1, "Usage: %s <days>\n", argv[0]));
  669. X    if ((days = atoi (argv[1])) < 1)
  670. X        exit (_errmsg (1, "<days> must be greater than zero.\n"));
  671. X    secs = (time_t) (days * 24 * 60 * 60);
  672. X    time (&tim);
  673. X    if (!info_str (NEWSDIR, buf, sizeof (buf)))
  674. X        strcpy (buf, DEF_NEWSDIR);
  675. X    if (chdir (buf) < 0)
  676. X        exit (_errmsg (1, "Can't chdir() to %s, errno %d.\n", buf, errno));
  677. X    strcpy (fpath, ".");
  678. X    count = 0;
  679. X    do_scan (NULL);
  680. X    printf ("%d old articles deleted.\n", count);
  681. X}
  682. __END__OF__THIS__FILE__
  683. if test -f 'MISC/encode.c' ; then
  684.   echo 'File MISC/encode.c already exists, overwriting it'
  685.   del 'MISC/encode.c'
  686. fi
  687. echo Extracting \"'MISC/encode.c'\"
  688. sed "s/^X//" >'MISC/encode.c' <<'__END__OF__THIS__FILE__'
  689. X#include <stdio.h>
  690. X
  691. X#ifdef SCCSID
  692. Xstatic char    *SccsId = "@(#)encode.c    1.3    5/15/85";
  693. X#endif /* SCCSID */
  694. X
  695. X/*
  696. X * Produce a 7 bit printable encoding of stdin on stdout.
  697. X *
  698. X * Encoding uses acsii chars from ' ' .. 'z'
  699. X * (040 .. 0172) (0x20 - 0x7a) inclusive
  700. X *
  701. X * Method is to expand 3 chars -> 4 6 bit ones.
  702. X * Then collect 13 6 bit chars, and spread the 13th over
  703. X * the preceding 12, so that each of the 12 chars is now
  704. X * 6.5 bits.  These 2 6.5 bit chars are a little hard
  705. X * to represent on most common machines (one of these days
  706. X * sane hosts will have 1/2 bits just for this program)
  707. X * so we take a pair of them, and represent that in 13 bits.
  708. X * 13 bits (max value 8191) can be represented as
  709. X *    A * 91 + B
  710. X * where A < 91, B < 91  (91^2 == 8281, so it fits!)
  711. X *
  712. X * Each of A and B is encoded as a character by adding 32
  713. X * to make it printable (ie: 0x20).
  714. X *
  715. X * The termination conditions are foul beyond belief.  Don't
  716. X * monkey with them!
  717. X *
  718. X * If you think its a fluke that 040 .. 0171 just happen to
  719. X * be the chars that Piet Beertema's uucp 'f' protocol transmits
  720. X * as single bytes, you're insane.  0172 chars are produced
  721. X * with lower frequency than any other (given random data)
  722. X * so the doubling that occurs with that we will just suffer.
  723. X * (A newer 'f' proto, sometime, will probably not use 0172)
  724. X */
  725. X
  726. X/*
  727. X * the following pair of characters cannot legally occur
  728. X * in normal output (since 90*91 + 90 == 8280, which > 2^13)
  729. X * so we use them to indicate that the data that follows is the
  730. X * terminator.  The character immediately following this
  731. X * pair is the length of the (expanded) terminator (which
  732. X * otherwise might be indeterminable)
  733. X */
  734. X#define    ENDMARK1    ((90*91 + 90) / 91 + ' ')
  735. X#define    ENDMARK2    ((90*91 + 90) % 91 + ' ')
  736. X
  737. Xmain()
  738. X{
  739. X    register char *p;
  740. X    register char *e;
  741. X    register c;
  742. X    char b3[3];
  743. X
  744. X    p = b3;
  745. X    e = b3 + 3;
  746. X    while ((c = getchar()) != EOF) {
  747. X        *p++ = c;
  748. X        if (p == e) {
  749. X            encode(b3, 3);
  750. X            p = b3;
  751. X        }
  752. X    }
  753. X    encode(b3, p - b3);
  754. X    flushout();
  755. X    exit(0);
  756. X}
  757. X
  758. Xstatic char b13[13];
  759. Xstatic int cnt = 0;
  760. X
  761. Xencode(c, n)
  762. X    register char *c;
  763. X    int n;
  764. X{
  765. X    register char *p;
  766. X    register i = cnt;
  767. X    register j;
  768. X    char b4[4];
  769. X
  770. X    p = b4;
  771. X
  772. X    p[0] = (c[0] >> 2) & 0x3f;
  773. X    p[1] = ((c[0] & 0x3) << 4) | ((c[1] >> 4) & 0xf);
  774. X    p[2] = ((c[1] & 0xF) << 2) | ((c[2] >> 6) & 0x3);
  775. X    if (n == 3)
  776. X        p[3] = c[2] & 0x3f;
  777. X    else
  778. X        p[3] = n;
  779. X
  780. X    c = &b13[i];
  781. X    for (j = 4; --j >= 0; i++) {
  782. X        if (i == 13) {
  783. X            dumpcode(b13, 13);
  784. X            c = b13;
  785. X            i = 0;
  786. X        }
  787. X        *c++ = *p++;
  788. X    }
  789. X    cnt = i;
  790. X}
  791. X
  792. Xflushout()
  793. X{
  794. X    putchar(ENDMARK1);
  795. X    putchar(ENDMARK2);
  796. X    putchar(cnt + ' ');
  797. X    dumpcode(b13, cnt);
  798. X}
  799. X
  800. Xdumpcode(p, n)
  801. X    register char *p;
  802. X    register int n;
  803. X{
  804. X    register last;
  805. X    register c;
  806. X
  807. X    if (n == 13)
  808. X        n--, last = p[12];
  809. X    else if (n & 1)
  810. X        last = (1 << (6-1));
  811. X    else
  812. X        last = 0;
  813. X
  814. X    for ( ; n > 0; n -= 2) {
  815. X        c = *p++ << 6;
  816. X        c |= *p++;
  817. X        if (last & (1 << (6-1)))
  818. X            c |= (1 << 12);
  819. X        last <<= 1;
  820. X
  821. X        /*
  822. X         * note: 91^2 > 2^13, 90^2 < 2^13, (91 + ' ') is printable
  823. X         */
  824. X
  825. X        /* oh for a compiler that would only do one division... */
  826. X        putchar((c / 91) + ' ');
  827. X        putchar((c % 91) + ' ');
  828. X    }
  829. X}
  830. X
  831. __END__OF__THIS__FILE__
  832. if test -f 'MISC/news_in.c' ; then
  833.   echo 'File MISC/news_in.c already exists, overwriting it'
  834.   del 'MISC/news_in.c'
  835. fi
  836. echo Extracting \"'MISC/news_in.c'\"
  837. sed "s/^X//" >'MISC/news_in.c' <<'__END__OF__THIS__FILE__'
  838. X# include    <stdio.h>
  839. X
  840. Xextern char    *index ();
  841. Xextern char    *strdup ();
  842. Xextern FILE    *xpopen ();
  843. X
  844. Xvoid
  845. Xusage ()
  846. X{
  847. X    fprintf (stderr, "Usage: news_in [-f=<sender>] <newsgroup>\n");
  848. X}
  849. X
  850. Xint
  851. Xmain (ac, av)
  852. Xint ac;
  853. Xchar *av[];
  854. X{
  855. X    char    *from;
  856. X    char    *group;
  857. X    int    t;
  858. X    char    *ptr;
  859. X    FILE    *pp;
  860. X    char    buf[260];
  861. X    int    n;
  862. X    int    err;
  863. X    int    pend;
  864. X
  865. X    setuid (getmuid ());
  866. X    from = NULL;
  867. X    group = NULL;
  868. X    for (t = 1; t < ac; ++t)
  869. X        if (av[t][0] == '-') {
  870. X            ptr = av[t] + 1;
  871. X            while (*ptr) {
  872. X                switch (*ptr) {
  873. X                    case 'f':
  874. X                        ptr += *(ptr + 1) == '=' ? 2 : 1;
  875. X                        from = ptr;
  876. X                        while (*ptr)
  877. X                            ++ptr;
  878. X                        break;
  879. X                    case '?':
  880. X                        usage ();
  881. X                        exit (1);
  882. X                    default:
  883. X                        break;
  884. X                }
  885. X                if (*ptr)
  886. X                    ++ptr;
  887. X            }
  888. X        } else if (!group)
  889. X            group = strdup (av[t]);
  890. X    if (!group)
  891. X        exit (1);
  892. X    ptr = group;
  893. X    while (ptr)
  894. X        if (ptr = index (ptr, '-'))
  895. X            *ptr++ = '.';
  896. X    if (!_strccmp (group, "postmaster"))
  897. X        pp = xpopen ("mail -s=News_In Postmaster", "w");
  898. X    else
  899. X        pp = xpopen ("inews -h", "w");
  900. X    if (!pp)
  901. X        exit (1);
  902. X    err = 0;
  903. X    pend = 0;
  904. X    while ((n = readln (0, buf, 256)) > 0)
  905. X        if (!group) {
  906. X            if (fwrite (buf, sizeof (char), n, pp) != n) {
  907. X                ++err;
  908. X                break;
  909. X            }
  910. X        } else {
  911. X            if ((buf[n - 1] != '\n') || pend) {
  912. X                pend = (!pend);
  913. X                if (fwrite (buf, sizeof (char), n, pp) != n) {
  914. X                    ++err;
  915. X                    break;
  916. X                }
  917. X                continue;
  918. X            } else if (n == 1) {
  919. X                fprintf (pp, "Newsgroups: %s\n\n", group);
  920. X                free (group);
  921. X                group = NULL;
  922. X            } else if (fwrite (buf, sizeof (char), n, pp) != n) {
  923. X                ++err;
  924. X                break;
  925. X            }
  926. X        }
  927. X    free (buf);
  928. X    if (pclose (pp))
  929. X        ++err;
  930. X    exit (err ? 1 : 0);
  931. X}
  932. __END__OF__THIS__FILE__
  933. if test -f 'MISC/news_out.c' ; then
  934.   echo 'File MISC/news_out.c already exists, overwriting it'
  935.   del 'MISC/news_out.c'
  936. fi
  937. echo Extracting \"'MISC/news_out.c'\"
  938. sed "s/^X//" >'MISC/news_out.c' <<'__END__OF__THIS__FILE__'
  939. X# include    <stdio.h>
  940. X# include    <c8type.h>
  941. X
  942. Xextern char    *cuserid ();
  943. Xextern char    *getenv ();
  944. Xextern char    *index ();
  945. Xextern char    *malloc ();
  946. Xextern char    *strdup ();
  947. Xextern char    *strredup ();
  948. Xextern FILE    *xpopen ();
  949. X
  950. Xstruct {
  951. X    char    *pat;
  952. X    int    len;
  953. X} todel[] = {
  954. X    "path:",    5,
  955. X    "message-id:",    11,
  956. X    "reply-to:",    9,
  957. X    "sender:",    7,
  958. X    NULL,        0
  959. X};
  960. X
  961. Xchar *
  962. Xgetng (og, s)
  963. Xchar *og;
  964. Xregister char *s;
  965. X{
  966. X    char    *sav;
  967. X
  968. X    if (s = index (s, ':')) {
  969. X        ++s;
  970. X        while (is8space (*s))
  971. X            ++s;
  972. X        sav = s;
  973. X        while (*s && (*s != ',') && (!is8space (*s)))
  974. X            ++s;
  975. X        *s = '\0';
  976. X        og = strredup (og, sav);
  977. X        s = og;
  978. X        while (s = index (s, '.'))
  979. X            *s++ = '-';
  980. X    }
  981. X    return (og);
  982. X}
  983. X        
  984. Xint
  985. Xmain (ac, av)
  986. Xint ac;
  987. Xchar *av[];
  988. X{
  989. X    FILE        *pp;
  990. X    FILE        *fp;
  991. X    char        fn[128];
  992. X    char        *cmd;
  993. X    int        t;
  994. X    int        siz;
  995. X    int        n;
  996. X    int        inhead;
  997. X    int        mode;
  998. X    char        *ng;
  999. X    char        *path;
  1000. X    char        fhost[128];
  1001. X    char        sender[160];
  1002. X    register char    *sptr;
  1003. X    register char    *ptr;
  1004. X
  1005. X    setuid (getmuid ());
  1006. X    if (ac < 2)
  1007. X        exit (0);
  1008. X    if (!(sptr = cuserid ()))
  1009. X        if (!(sptr = getenv ("USER")))
  1010. X            if (!(sptr = getenv ("LOGNAME")))
  1011. X                sptr = "Postmaster";
  1012. X    strcpy (sender, sptr);
  1013. X    sptr = sender;
  1014. X    while (*sptr)
  1015. X        ++sptr;
  1016. X    *sptr++ = '@';
  1017. X    if (gethostname (sptr, 64))
  1018. X        while (*sptr)
  1019. X            ++sptr;
  1020. X    strcpy (fhost, "newsgroup");
  1021. X    ptr = fhost;
  1022. X    while (*ptr)
  1023. X        ++ptr;
  1024. X    if (info_str ("hostdomain", ptr + 1, 96)) {
  1025. X        *ptr = '.';
  1026. X        strcpy (sptr, ptr);
  1027. X    } else
  1028. X        *sptr = '\0';
  1029. X    siz = 0;
  1030. X    for (t = 1; t < ac; ++t)
  1031. X        siz += strlen (av[t]) + 4;
  1032. X    siz += 64;
  1033. X    if (!(cmd = malloc (siz < 260 ? 260 : siz)))
  1034. X        exit (0);
  1035. X    strcpy (cmd, "rmail");
  1036. X    for (t = 1; t < ac; ++t) {
  1037. X        strcat (cmd, " '");
  1038. X        strcat (cmd, av[t]);
  1039. X        strcat (cmd, "'");
  1040. X    }
  1041. X    strcpy (fn, "/dd/TMP/newsoutXXXXXX");
  1042. X    mktemp (fn);
  1043. X    if (!(fp = fopen (fn, "w+")))
  1044. X        exit (0);
  1045. X    if (pp = xpopen (cmd, "w")) {
  1046. X        ng = NULL;
  1047. X        path = NULL;
  1048. X        inhead = 1;
  1049. X        mode = 0;
  1050. X        while ((n = readln (0, cmd, 256)) > 0) {
  1051. X            cmd[n] = '\0';
  1052. X            if (inhead)
  1053. X                for (t = 0; todel[t].pat; ++t)
  1054. X                    if (!_strnccmp (cmd, todel[t].pat, todel[t].len))
  1055. X                        break;
  1056. X            if ((!inhead) || (!todel[t].pat))
  1057. X                if (fputs (cmd, fp) == -1)
  1058. X                    break;
  1059. X            if (inhead)
  1060. X                if (n == 1)
  1061. X                    inhead = 0;
  1062. X                else {
  1063. X                    if ((mode < 1) && (!_strnccmp (cmd, "Newsgroups:", 11))) {
  1064. X                        ng = getng (ng, cmd);
  1065. X                        mode = 1;
  1066. X                    } else if ((mode < 2) && (!_strnccmp (cmd, "Followup-To:", 12))) {
  1067. X                        ng = getng (ng, cmd);
  1068. X                        mode = 2;
  1069. X                    } else if ((!path) && (!_strnccmp (cmd, "Path:", 5)))
  1070. X                        path = strdup (cmd + 5);
  1071. X                }
  1072. X        }
  1073. X        inhead = ng ? 1 : 0;
  1074. X        if (path) {
  1075. X            if (ptr = index (path, '\n'))
  1076. X                *ptr = '\0';
  1077. X            ptr = path;
  1078. X            while (is8space (*ptr))
  1079. X                ++ptr;
  1080. X            while (*ptr)
  1081. X                if (is8alnum (*ptr) || index (".-+", *ptr))
  1082. X                    ++ptr;
  1083. X                else
  1084. X                    *ptr++ = '!';
  1085. X            ptr = path;
  1086. X            while (is8space (*ptr))
  1087. X                ++ptr;
  1088. X            fprintf (pp, "From %s\n", ptr);
  1089. X        }
  1090. X        fseek (fp, 0, 0);
  1091. X        while (fgets (cmd, 256, fp)) {
  1092. X            if (inhead)
  1093. X                if (!strcmp (cmd, "\n")) {
  1094. X                    fprintf (pp, "Sender: %s\n", sender);
  1095. X                    fprintf (pp, "Reply-To: %s@%s\n", ng, fhost);
  1096. X                    inhead = 0;
  1097. X                }
  1098. X            if (fputs (cmd, pp) == -1)
  1099. X                break;
  1100. X        }
  1101. X        fclose (fp);
  1102. X        unlink (fn);
  1103. X        pclose (pp);
  1104. X    }
  1105. X}
  1106. X    
  1107. __END__OF__THIS__FILE__
  1108. if test -f 'MISC/nstat.c' ; then
  1109.   echo 'File MISC/nstat.c already exists, overwriting it'
  1110.   del 'MISC/nstat.c'
  1111. fi
  1112. echo Extracting \"'MISC/nstat.c'\"
  1113. sed "s/^X//" >'MISC/nstat.c' <<'__END__OF__THIS__FILE__'
  1114. X# include    <stdio.h>
  1115. X# include    <c8type.h>
  1116. X# include    <modes.h>
  1117. X# include    <time.h>
  1118. X# include    <types.h>
  1119. X# include    <stat.h>
  1120. X
  1121. X# define    GROUP        "Newsgroups: "
  1122. X# define    FROM        "From: "
  1123. X
  1124. Xextern char    *index ();
  1125. Xextern char    *malloc ();
  1126. Xextern char    *strdup ();
  1127. X
  1128. Xtypedef enum {
  1129. X    False = 0,
  1130. X    True
  1131. X}    Bool;
  1132. X
  1133. Xstatic char    *help[] = {
  1134. X    "Syntax: nstat [<opts>] [<filename>] [<opts>]\n",
  1135. X    "Function: generates a statistic file or evaluates it\n",
  1136. X    "Options:\n",
  1137. X    "      -e        evaluate the statfile\n",
  1138. X    "      -p=<str>  prefix of every groupname\n",
  1139. X    "      -o=<file> the output file for the evaluation (def. stdout).\n",
  1140. X    "      -d        delete statfile after evaluation\n",
  1141. X    "      -h        create header to pipe directly to inews -h\n",
  1142. X    "      -t=<file> use <file> as timestamp since last report\n",
  1143. X    NULL
  1144. X};
  1145. X
  1146. Xstatic void
  1147. Xusage ()
  1148. X{
  1149. X    register int    t;
  1150. X
  1151. X    for (t = 0; help[t]; ++t)
  1152. X        fputs (help[t], stderr);
  1153. X}
  1154. X
  1155. Xstatic void
  1156. Xcollect (fd, file)
  1157. Xregister int fd;
  1158. Xchar *file;
  1159. X{
  1160. X    register char    *ptr;
  1161. X    char        *group;
  1162. X    char        *system;
  1163. X    register int    size;
  1164. X    register char    *buf;
  1165. X    register Bool    inhead;
  1166. X    register int    n;
  1167. X    char        *tmp;
  1168. X
  1169. X    if (! (buf = malloc (520)))
  1170. X        return;
  1171. X    group = NULL;
  1172. X    system = NULL;
  1173. X    size = 0;
  1174. X    inhead = True;
  1175. X    while ((n = readln (fd, buf, 512)) > 0) {
  1176. X        size += n;
  1177. X        if (inhead == True)
  1178. X            if (n == 1)
  1179. X                inhead = False;
  1180. X            else {
  1181. X                buf[n - 1] = '\0';
  1182. X                if ((! group) && (! _strnccmp (buf, GROUP, sizeof (GROUP) - 1))) {
  1183. X                    ptr = buf + sizeof (GROUP) - 1;
  1184. X                    while (is8space (*ptr))
  1185. X                        ++ptr;
  1186. X                    group = strdup (ptr);
  1187. X                } else if ((! system) && (! _strnccmp (buf, FROM, sizeof (FROM) - 1))) {
  1188. X                    ptr = buf + sizeof (FROM) - 1;
  1189. X                    while (is8space (*ptr))
  1190. X                        ++ptr;
  1191. X                    if (tmp = index (ptr, '@')) {
  1192. X                        ++tmp;
  1193. X                        for (ptr = tmp; *ptr && (! is8space (*ptr)) && (! index ("()>", *ptr)); ++ptr)
  1194. X                            ;
  1195. X                        *ptr = '\0';
  1196. X                        system = strdup (tmp);
  1197. X                    }
  1198. X                }
  1199. X            }
  1200. X    }
  1201. X    close (fd);
  1202. X    if (! (group && system))
  1203. X        return;
  1204. X    sprintf (buf, "%s %d %s\n", group, size, system);
  1205. X    n = strlen (buf);
  1206. X    if ((fd = open (file, S_IWRITE)) == -1)
  1207. X        fd = create (file, S_IWRITE, 03);
  1208. X    else
  1209. X        lseek (fd, 0, 2);
  1210. X    if (fd != -1) {
  1211. X        write (fd, buf, n);
  1212. X        close (fd);
  1213. X    }
  1214. X}
  1215. X
  1216. Xtypedef struct _list {
  1217. X    char    *name;        /* Group/System name            */
  1218. X    int    count;        /* # of articles            */
  1219. X    int    cper;        /* % * 100 (e.g. 100 = 1% 10000 = 100%)    */
  1220. X    int    size;        /* size of all articles            */
  1221. X    int    sper;        /* as cper                */
  1222. X    int    average;    /* avergae size of article        */
  1223. X    int    xpost;        /* number of crosspostings        */
  1224. X    struct _list
  1225. X        *next;
  1226. X}    list;
  1227. X
  1228. Xstatic int
  1229. Xadd_list (root, name, size, xpost)
  1230. Xlist **root;
  1231. Xchar *name;
  1232. Xint size;
  1233. Xint xpost;
  1234. X{
  1235. X    register list    *run, *tmp;
  1236. X
  1237. X    for (run = *root; run; run = run -> next)
  1238. X        if (! _strccmp (run -> name, name))
  1239. X            break;
  1240. X    if (run) {
  1241. X        run -> count++;
  1242. X        run -> size += size;
  1243. X        if (xpost > 1)
  1244. X            run -> xpost++;
  1245. X    } else if ((! (tmp = (list *) malloc (sizeof (list)))) || (! (tmp -> name = strdup (name)))) {
  1246. X        fprintf (stderr, "Can't alloc for new list entry.\n");
  1247. X        return (-1);
  1248. X    } else {
  1249. X        tmp -> count = 1;
  1250. X        tmp -> size = size;
  1251. X        tmp -> next = *root;
  1252. X        tmp -> xpost = (xpost > 1) ? 1 : 0;
  1253. X        *root = tmp;
  1254. X    }
  1255. X    return (0);
  1256. X}
  1257. X
  1258. Xstatic void
  1259. Xaver_list (tmp)
  1260. Xregister list *tmp;
  1261. X{
  1262. X    register int    ccount, csize;
  1263. X    register list    *start;
  1264. X
  1265. X    ccount = 0;
  1266. X    csize = 0;
  1267. X    start = tmp;
  1268. X    while (tmp) {
  1269. X        tmp -> average = tmp -> size / tmp -> count;
  1270. X        csize += tmp -> size;
  1271. X        ccount += tmp -> count;
  1272. X        tmp = tmp -> next;
  1273. X    }
  1274. X    for (tmp = start; tmp; tmp = tmp -> next) {
  1275. X        tmp -> cper = (tmp -> count * 10000) / ccount;
  1276. X        tmp -> sper = (tmp -> size * 10000) / csize;
  1277. X    }
  1278. X}
  1279. X
  1280. Xstatic void
  1281. Xsort_list (root, tosize)
  1282. Xlist **root;
  1283. Xregister Bool tosize;
  1284. X{
  1285. X    register list    *r, *p, *c, *t;
  1286. X
  1287. X    r = *root;
  1288. X    p = NULL;
  1289. X    c = r;
  1290. X    while (c -> next)
  1291. X        if (tosize ? (c -> next -> size > c -> size) : (c -> next -> count > c -> count)) {
  1292. X            if (p) {
  1293. X                p -> next = c -> next;
  1294. X                c -> next = c -> next -> next;
  1295. X                p -> next -> next = c;
  1296. X                c = p;
  1297. X                if (c == r)
  1298. X                    p = NULL;
  1299. X                else
  1300. X                    for (p = r; p -> next != c; p = p -> next)
  1301. X                        if (! p -> next) {
  1302. X                            fprintf (stderr, "*** Error in sorting! ***\n");
  1303. X                            break;
  1304. X                        }
  1305. X            } else {
  1306. X                c = c -> next;
  1307. X                r -> next = c -> next;
  1308. X                c -> next = r;
  1309. X                r = c;
  1310. X            }
  1311. X        } else {
  1312. X            p = c;
  1313. X            c = c -> next;
  1314. X        }
  1315. X    *root = r;
  1316. X}
  1317. X
  1318. Xstatic void
  1319. Xdump_list (fp, header, first, tmp)
  1320. Xregister FILE *fp;
  1321. Xchar *header, *first;
  1322. Xregister list *tmp;
  1323. X{
  1324. X    fprintf (fp, "\n%s:\n", header);
  1325. X    fprintf (fp, "%-25.25s  %7.7s (xx.xx%%)  %7.7s (xx.xx%%)  %7.7s  %7.7s\n",
  1326. X        first, "Size", "Count", "Siz/Cont", "X-post");
  1327. X    for (; tmp; tmp = tmp -> next)
  1328. X        fprintf (fp, "%-25.25s  %7d (%2d.%02d%%)  %7d (%2d.%02d%%)  %7d  %7d\n",
  1329. X            tmp -> name, tmp -> size,
  1330. X            tmp -> sper / 100, tmp -> sper % 100,
  1331. X            tmp -> count,
  1332. X            tmp -> cper / 100, tmp -> cper % 100,
  1333. X            tmp -> average, tmp -> xpost);
  1334. X}
  1335. X
  1336. Xstatic void
  1337. Xevaluate (ifile, ofile, prefix, delete, news_header, timestamp)
  1338. Xchar *ifile, *ofile;
  1339. XBool delete;
  1340. Xchar *prefix;
  1341. XBool news_header;
  1342. Xchar *timestamp;
  1343. X{
  1344. X    FILE        *fp;
  1345. X    list        *groot;
  1346. X    list        *sroot;
  1347. X    list        *tmp;
  1348. X    char        *rifile;
  1349. X    register char    *buf;
  1350. X    register int    n;
  1351. X    int        fd;
  1352. X    char        *siz, *sys;
  1353. X    char        *xpost;
  1354. X    char        *ptr, *gp;
  1355. X    int        size;
  1356. X    int        len;
  1357. X    int        tmpfd;
  1358. X    time_t        tim;
  1359. X    struct tm    *tt;
  1360. X    struct tm    ts;
  1361. X    struct stat    st;
  1362. X
  1363. X    if (! (buf = malloc (520))) {
  1364. X        fprintf (stderr, "Can't alloc for input buffer.\n");
  1365. X        return;
  1366. X    }
  1367. X    if (delete) {
  1368. X        if (! (rifile = malloc (strlen (ifile) + 40))) {
  1369. X            fprintf (stderr, "Can't alloc for temp. filename.\n");
  1370. X            return;
  1371. X        }
  1372. X        strcpy (rifile, ifile);
  1373. X        strcat (rifile, "XXXXXX");
  1374. X        mktemp (rifile);
  1375. X        if (rename (ifile, rifile)) {
  1376. X            fprintf (stderr, "Can't rename %s to %s, aborted.\n", ifile, rifile);
  1377. X            return;
  1378. X        }
  1379. X    } else
  1380. X        rifile = NULL;
  1381. X    groot = NULL;
  1382. X    sroot = NULL;
  1383. X    if ((fd = open (rifile ? rifile : ifile, S_IREAD)) == -1) {
  1384. X        fprintf (stderr, "Can't open %s, aborted.\n", rifile ? rifile : ifile);
  1385. X        return;
  1386. X    }
  1387. X    len = (prefix && *prefix) ? strlen (prefix) : 0;
  1388. X    while ((n = readln (fd, buf, 512)) > 0) {
  1389. X        buf[n - 1] = '\0';
  1390. X        if (! (siz = index (buf, ' ')))
  1391. X            continue;
  1392. X        *siz++ = '\0';
  1393. X        if (! (sys = index (siz, ' ')))
  1394. X            continue;
  1395. X        *sys++ = '\0';
  1396. X        size = atoi (siz);
  1397. X        n = 1;
  1398. X        xpost = buf;
  1399. X        gp = NULL;
  1400. X        do {
  1401. X            if (ptr = index (xpost, ',')) {
  1402. X                *ptr++ = '\0';
  1403. X                ++n;
  1404. X            }
  1405. X            if ((! gp) && ((! len) || (! _strnccmp (xpost, prefix, len))))
  1406. X                gp = xpost;
  1407. X            xpost = ptr;
  1408. X        } while (xpost);
  1409. X        if (! gp)
  1410. X            continue;
  1411. X        if ((add_list (& groot, gp, size, n) < 0) || (add_list (& sroot, sys, size, n) < 0))
  1412. X            return;
  1413. X    }
  1414. X    close (fd);
  1415. X    if (ofile) {
  1416. X        if (! (fp = fopen (ofile, "w"))) {
  1417. X            fprintf (stderr, "Can't open %s for writing.\n", ofile);
  1418. X            return;
  1419. X        }
  1420. X    } else
  1421. X        fp = stdout;
  1422. X    if (news_header) {
  1423. X        time (& tim);
  1424. X        tt = localtime (& tim);
  1425. X        fprintf (fp, "Subject: Newsstatistic (%02d/%02d/%02d)\n\n",
  1426. X            tt -> tm_year % 100, tt -> tm_mon + 1, tt -> tm_mday);
  1427. X    }
  1428. X    if (timestamp) {
  1429. X        if (stat (timestamp, & st) == -1)
  1430. X            fprintf (fp, "\nFirst evaluation\n");
  1431. X        else if (tt = localtime (& st.st_mtime)) {
  1432. X            ts = *tt;
  1433. X            time (& tim);
  1434. X            tt = localtime (& tim);
  1435. X            fprintf (fp, "Last evaluation: %02d/%02d/%02d\n",
  1436. X                ts.tm_year % 100, ts.tm_mon + 1, ts.tm_mday);
  1437. X            tim -= st.st_mtime;
  1438. X            tim = tim / (24 * 60 * 60);
  1439. X            fprintf (fp, "Data collected for %d day%s.\n",
  1440. X                tim, tim != 1 ? "s" : "");
  1441. X        }
  1442. X        if ((tmpfd = creat (timestamp, S_IWRITE)) != -1)
  1443. X            close (tmpfd);
  1444. X    }
  1445. X    aver_list (groot);
  1446. X    aver_list (sroot);
  1447. X    sort_list (& groot, True);
  1448. X    dump_list (fp, "Group statistic (sorted by size)", "Groupname", groot);
  1449. X    sort_list (& groot, False);
  1450. X    dump_list (fp, "Group statistic (sorted by # of Articles)", "Groupname", groot);
  1451. X    sort_list (& sroot, True);
  1452. X    dump_list (fp, "System statistic (sorted by size)", "Systemname", sroot);
  1453. X    sort_list (& sroot, False);
  1454. X    dump_list (fp, "System statistic (sorted by # of Articles)", "Systemname", sroot);
  1455. X    if (ofile)
  1456. X        fclose (fp);
  1457. X    if (delete)
  1458. X        unlink (rifile);
  1459. X}
  1460. X
  1461. Xint
  1462. Xmain (argc, argv)
  1463. Xint argc;
  1464. Xchar *argv[];
  1465. X{
  1466. X    register int    t;
  1467. X    register char    *ptr;
  1468. X    char        *file;
  1469. X    char        *ofile;
  1470. X    char        *prefix;
  1471. X    char        *timestamp;
  1472. X    Bool        eval;
  1473. X    Bool        delete;
  1474. X    Bool        news_header;
  1475. X
  1476. X    file = "NewsStat";
  1477. X    ofile = NULL;
  1478. X    prefix = NULL;
  1479. X    timestamp = NULL;
  1480. X    eval = False;
  1481. X    delete = False;
  1482. X    news_header = False;
  1483. X    for (t = 1; t < argc; ++t)
  1484. X        if (argv[t][0] == '-') {
  1485. X            ptr = argv[t] + 1;
  1486. X            while (*ptr) {
  1487. X                switch (*ptr) {
  1488. X                    case 'p':
  1489. X                        ptr += *(ptr + 1) == '=' ? 2 : 1;
  1490. X                        prefix = ptr;
  1491. X                        while (*ptr)
  1492. X                            ++ptr;
  1493. X                        break;
  1494. X                    case 'o':
  1495. X                        ptr += *(ptr + 1) == '=' ? 2 : 1;
  1496. X                        ofile = ptr;
  1497. X                        while (*ptr)
  1498. X                            ++ptr;
  1499. X                        break;
  1500. X                    case 't':
  1501. X                        ptr += *(ptr + 1) == '=' ? 2 : 1;
  1502. X                        timestamp = ptr;
  1503. X                        while (*ptr)
  1504. X                            ++ptr;
  1505. X                        break;
  1506. X                    case 'e':
  1507. X                        eval = True;
  1508. X                        break;
  1509. X                    case 'd':
  1510. X                        delete = True;
  1511. X                        break;
  1512. X                    case 'h':
  1513. X                        news_header = True;
  1514. X                        break;
  1515. X                    case '?':
  1516. X                    default:
  1517. X                        usage ();
  1518. X                        exit (*ptr == '?' ? 0 :
  1519. X                            _errmsg (1, "Unknown option '%c'.\n", *ptr));
  1520. X                }
  1521. X                if (*ptr)
  1522. X                    ++ptr;
  1523. X            }
  1524. X        } else
  1525. X            file = argv[t];
  1526. X    setuid (getmuid ());
  1527. X    if (eval == False)
  1528. X        collect (0, file);
  1529. X    else
  1530. X        evaluate (file, ofile, prefix, delete, news_header, timestamp);
  1531. X}
  1532. __END__OF__THIS__FILE__
  1533. if test -f 'MISC/rot13.c' ; then
  1534.   echo 'File MISC/rot13.c already exists, overwriting it'
  1535.   del 'MISC/rot13.c'
  1536. fi
  1537. echo Extracting \"'MISC/rot13.c'\"
  1538. sed "s/^X//" >'MISC/rot13.c' <<'__END__OF__THIS__FILE__'
  1539. X# include    <modes.h>
  1540. X# include    <c8type.h>
  1541. X
  1542. Xextern char    *malloc ();
  1543. X
  1544. Xchar8        table[256];
  1545. X
  1546. Xvoid
  1547. Xrot (fdi, fdo)
  1548. Xint fdi, fdo;
  1549. X{
  1550. X    static char8    *store = (char *) 0;
  1551. X    register char8    *ptr;
  1552. X    register int    n, t;
  1553. X
  1554. X    if (! store)
  1555. X        if (! (store = (char8 *) malloc (4096 + 4)))
  1556. X            return;
  1557. X    while ((n = read (fdi, store, 4096)) > 0) {
  1558. X        t = n;
  1559. X        ptr = store;
  1560. X        while (t-- > 0) {
  1561. X            *ptr = table[*ptr];
  1562. X            ++ptr;
  1563. X        }
  1564. X        if (fdo != -1) {
  1565. X            if (write (fdo, store, n) != n)
  1566. X                break;
  1567. X        } else {
  1568. X            if (lseek (fdi, -n, 1) == -1)
  1569. X                break;
  1570. X            if (write (fdi, store, n) != n)
  1571. X                break;
  1572. X        }
  1573. X    }
  1574. X}
  1575. X            
  1576. Xint
  1577. Xmain (argc, argv)
  1578. Xint argc;
  1579. Xchar *argv[];
  1580. X{
  1581. X    register int    t;
  1582. X
  1583. X    for (t = 0; t < 256; ++t)
  1584. X        if ((t >= 'a' && t <= 'm') || (t >= 'A' && t <= 'M'))
  1585. X            table[t] = t + 13;
  1586. X        else if ((t >= 'n' && t <= 'z') || (t >= 'N' && t <= 'Z'))
  1587. X            table[t] = t - 13;
  1588. X        else
  1589. X            table[t] = t;
  1590. X    if (argc == 1)
  1591. X        rot (0, 1);
  1592. X    else
  1593. X        for (t = 1; t < argc; ++t) {
  1594. X            int    fd = open (argv[t], S_IREAD | S_IWRITE);
  1595. X
  1596. X            if (fd != -1) {
  1597. X                rot (fd, -1);
  1598. X                close (fd);
  1599. X            }
  1600. X        }
  1601. X}
  1602. X            
  1603. __END__OF__THIS__FILE__
  1604. if test -f 'MISC/unmap.c' ; then
  1605.   echo 'File MISC/unmap.c already exists, overwriting it'
  1606.   del 'MISC/unmap.c'
  1607. fi
  1608. echo Extracting \"'MISC/unmap.c'\"
  1609. sed "s/^X//" >'MISC/unmap.c' <<'__END__OF__THIS__FILE__'
  1610. X/*
  1611. X * $Log:    unmap.c_v $
  1612. X * Revision 1.1  90/08/31  15:28:37  cv
  1613. X * Initial revision
  1614. X * 
  1615. X */
  1616. X# ifndef    LINT
  1617. Xstatic char rcsid[] = "$Id: unmap.c_v 1.1 90/08/31 15:28:37 cv Exp $";
  1618. Xstatic char copyright[] = "Copyright (C) 1989, 1990 by Ulrich Dessauer, Germering, Germany.\n";
  1619. X# endif        LINT
  1620. X# include    <ctype.h>
  1621. X# include    <modes.h>
  1622. X
  1623. Xextern char    *strdup ();
  1624. X
  1625. Xchar *
  1626. Xskip (s)
  1627. Xregister char *s;
  1628. X{
  1629. X    while (*s && (!isspace (*s)))
  1630. X        ++s;
  1631. X    if (*s)
  1632. X        *s++ = '\0';
  1633. X    while (isspace (*s))
  1634. X        ++s;
  1635. X    return (s);
  1636. X}
  1637. X
  1638. Xchar *
  1639. Xstrip (s)
  1640. Xregister char *s;
  1641. X{
  1642. X    register char    *p;
  1643. X    register char    c;
  1644. X
  1645. X    if ((*s == '\'') || (*s == '"')) {
  1646. X        c = *s++;
  1647. X        p = s;
  1648. X        while (*p && (*p != c))
  1649. X            ++p;
  1650. X        *p = '\0';
  1651. X    }
  1652. X    return (s);
  1653. X}
  1654. X
  1655. Xint
  1656. Xmain (argc, argv)
  1657. Xint argc;
  1658. Xchar *argv[];
  1659. X{
  1660. X    char        buffer[256];
  1661. X    int        n;
  1662. X    int        fd;
  1663. X    char        *eof;
  1664. X    char        *fn;
  1665. X    int        len;
  1666. X    register char    *ptr, *sav;
  1667. X
  1668. X    setuid (getmuid ());
  1669. X    eof = 0;
  1670. X    fn = 0;
  1671. X    fd = -1;
  1672. X    if ((argc != 1) && (argc != 2))
  1673. X        exit (_errmsg (1, "Usage: %s [<directory>].\n", argv[0]));
  1674. X    if (argc == 2)
  1675. X        if (chdir (argv[1]) < 0)
  1676. X            exit (_errmsg (1, "Can't chdir() to %s.\n", argv[1]));
  1677. X    while ((n = readln (0, buffer, 256)) > 0) {
  1678. X        buffer[n - 1] = '\0';
  1679. X        if (!_strnccmp (buffer, "cat ", 4)) {
  1680. X            sav = skip (buffer);
  1681. X            do {
  1682. X                ptr = skip (sav);
  1683. X                if ((!strcmp (sav, "<<")) && (!eof)) {
  1684. X                    sav = ptr;
  1685. X                    ptr = skip (sav);
  1686. X                    sav = strip (sav);
  1687. X                    eof = strdup (sav);
  1688. X                } else if ((!strcmp (sav, ">")) && (!fn)) {
  1689. X                    sav = ptr;
  1690. X                    ptr = skip (sav);
  1691. X                    sav = strip (sav);
  1692. X                    fn = strdup (sav);
  1693. X                }
  1694. X                sav = ptr;
  1695. X            } while (*sav);
  1696. X            if (eof && fn)
  1697. X                break;
  1698. X        }
  1699. X    }
  1700. X    if ((n > 0) && eof && fn) {
  1701. X        if ((fd = creat (fn, S_IWRITE)) != -1) {
  1702. X            chmod (fn, 013);
  1703. X            len = strlen (eof);
  1704. X            while ((n = readln (0, buffer, 256)) > 0) {
  1705. X                buffer[n - 1] = '\0';
  1706. X                if (n >= len && (!strcmp (eof, buffer)))
  1707. X                    break;
  1708. X                else {
  1709. X                    write (fd, buffer, n - 1);
  1710. X                    write (fd, "\n", 1);
  1711. X                }
  1712. X            }
  1713. X            close (fd);
  1714. X        }
  1715. X    }
  1716. X    if (n > 0)
  1717. X        while (readln (0, buffer, 256) > 0)
  1718. X            ;
  1719. X    close (0);
  1720. X}
  1721. __END__OF__THIS__FILE__
  1722. if test -f 'RNEWS/Makefile' ; then
  1723.   echo 'File RNEWS/Makefile already exists, overwriting it'
  1724.   del 'RNEWS/Makefile'
  1725. fi
  1726. echo Extracting \"'RNEWS/Makefile'\"
  1727. sed "s/^X//" >'RNEWS/Makefile' <<'__END__OF__THIS__FILE__'
  1728. X# $Id: Makefile_v 1.1 90/08/31 15:37:55 ud Exp $
  1729. X# $Log:    Makefile_v $
  1730. X# Revision 1.1  90/08/31  15:37:55  ud
  1731. X# Initial revision
  1732. X# 
  1733. X#
  1734. XCC=    cc
  1735. XG=    -g
  1736. XCFLAGS=    -qt=/dd/TMP $G -v=..
  1737. XLIBS=    -l=/dd/LIB/os9lib.l
  1738. XLFLAGS=    -qm=4 $(LIBS) $G
  1739. XODIR=    /h0/ETC/CMDS
  1740. X
  1741. XRNEWSC=    rnews.c send.c compr.c compr7.c logit.c mail.c
  1742. XRNEWSR=    rnews.r send.r compr.r compr7.r logit.r mail.r
  1743. X
  1744. X$(ODIR)/rnews:    $(RNEWSR)
  1745. X    $(CC) $(LFLAGS) $(RNEWSR) -f=$(ODIR)/rnews
  1746. X
  1747. Xtags:    $(RNEWSC)
  1748. X    ctags $?
  1749. __END__OF__THIS__FILE__
  1750. if test -f 'RNEWS/compr.c' ; then
  1751.   echo 'File RNEWS/compr.c already exists, overwriting it'
  1752.   del 'RNEWS/compr.c'
  1753. fi
  1754. echo Extracting \"'RNEWS/compr.c'\"
  1755. sed "s/^X//" >'RNEWS/compr.c' <<'__END__OF__THIS__FILE__'
  1756. X/*
  1757. X * $Log:    compr.c_v $
  1758. X * Revision 1.1  90/08/31  15:37:57  ud
  1759. X * Initial revision
  1760. X * 
  1761. X */
  1762. X# ifndef    LINT
  1763. Xstatic char rcsid[] = "$Id: compr.c_v 1.1 90/08/31 15:37:57 ud Exp $";
  1764. X# endif        LINT
  1765. X# include <stdio.h>
  1766. X# include <modes.h>
  1767. X# include <ctype.h>
  1768. X# include "rnews.h"
  1769. X
  1770. Xextern void    logit ();
  1771. Xextern void    start_rnews ();
  1772. Xextern long    lseek ();
  1773. Xextern char    *findmod ();
  1774. Xextern char    *index ();
  1775. Xextern char    *mktemp ();
  1776. Xextern char    *strcpy ();
  1777. X
  1778. Xextern int    errno;
  1779. X
  1780. Xvoid
  1781. Xdo_exec (cmd,w,r)
  1782. Xchar *cmd;
  1783. Xint w,r;
  1784. X{
  1785. X    extern int    os9forkc ();
  1786. X    extern char    **environ;
  1787. X    int        o0, o1;
  1788. X    char        **arg;
  1789. X    int        t, status, pid;
  1790. X    
  1791. X    o0 = dup (0);
  1792. X    o1 = dup (1);
  1793. X    (void) close (0);
  1794. X    (void) dup (w);
  1795. X    (void) close (1);
  1796. X    (void) dup (r);
  1797. X    t = 0;
  1798. X    if (getargs (cmd, &arg) > 0) {
  1799. X        logit (4,"Fork: '%s'\n",arg[0]);
  1800. X        if ((pid = os9exec (os9forkc,findmod (arg[0],arg[0]),arg,environ,0,0,3)) < 0) {
  1801. X            logit (2,"ERROR: Can't fork '%s'\n", arg[0]);
  1802. X            error |= FATAL;
  1803. X            return;
  1804. X        } else
  1805. X            while (((t = wait (&status)) != pid) && (t != -1))
  1806. X                ;
  1807. X        logit (status ? 2 : 3,"'%s' returns %d\n",arg[0],status);
  1808. X    } else {
  1809. X        error |= FATAL;
  1810. X        logit (2, "ERROR: Can't alloc memory for getargs\n");
  1811. X    }
  1812. X    (void) close (0);
  1813. X    (void) dup (o0);
  1814. X    (void) close (o0);
  1815. X    (void) close (1);
  1816. X    (void) dup (o1);
  1817. X    (void) close (o1);
  1818. X    if (status)
  1819. X        error |= FATAL;
  1820. X}
  1821. X
  1822. Xvoid    
  1823. Xcompr (fd,scratch,cmd)
  1824. Xint fd;
  1825. Xint scratch;
  1826. Xchar *cmd;
  1827. X{
  1828. X    char        tmp[40 + sizeof (TEMPDIR)];
  1829. X    char        *buf;
  1830. X    register char    *x;
  1831. X    register int    n;
  1832. X    unsigned int    siz, temp;
  1833. X    int        o;
  1834. X    
  1835. X    (void) sprintf (tmp,"%s/compr.XXXXXX", TEMPDIR);
  1836. X    (void) mktemp (tmp);
  1837. X    _unlink (tmp);
  1838. X    siz = 20000;
  1839. X    while ((siz != 0) && ((buf = malloc (siz + 5)) == (char *) NULL))
  1840. X        siz -= 1000;
  1841. X    if (!siz) {
  1842. X        logit (2,"ERROR: Can't alloc memory\n");
  1843. X        error |= SIMPLE;
  1844. X        return;
  1845. X    }
  1846. X    if ((o = create (tmp,S_IREAD | S_IWRITE,03, 0)) < 0) {
  1847. X        logit (2,"ERROR: Can't create tmpfile '%s'\n",tmp);
  1848. X        error |= SIMPLE;
  1849. X        free (buf);
  1850. X        return;
  1851. X    }
  1852. X    errno = 0;
  1853. X    while ((n = read (fd,buf,siz)) > 0) {
  1854. X        logit (6,"Read %d bytes\n",n);
  1855. X        x = buf;
  1856. X        temp = (unsigned int) n;
  1857. X        while (n-- > 0) {
  1858. X            if (*x && (index ("\l\r",*x) != (char *) NULL))
  1859. X                *x = *x == '\l' ? '\r' : '\l';
  1860. X            ++x;
  1861. X        }
  1862. X        n = write (o,buf,temp);
  1863. X        logit (6,"Wrote %d bytes\n",n);
  1864. X        if (n < 0) {
  1865. X            logit (2,"ERROR: Can't write tmpfile '%s'\n", tmp);
  1866. X            close (o);
  1867. X            _unlink (tmp);
  1868. X            error |= SIMPLE;
  1869. X            free (buf);
  1870. X            return;
  1871. X        }
  1872. X    }
  1873. X    (void) lseek (o,0,0);
  1874. X    o = uncompress_it (o,tmp,cmd);
  1875. X    if (error) {
  1876. X        if (o != -1)
  1877. X            (void) close (o);
  1878. X        _unlink (tmp);
  1879. X        free (buf);
  1880. X        return;
  1881. X    } else {
  1882. X        close (o);
  1883. X        if ((o = open (tmp, S_IREAD)) < 0) {
  1884. X            _unlink (tmp);
  1885. X            free (buf);
  1886. X            error |= SIMPLE;
  1887. X            return;
  1888. X        }
  1889. X    }
  1890. X    start_rnews (o,scratch);
  1891. X    (void) close (o);
  1892. X    _unlink (tmp);
  1893. X    free (buf);
  1894. X}
  1895. X
  1896. Xint
  1897. Xuncompress_it (o,ofile,cmd)
  1898. Xint o;
  1899. Xchar *ofile;
  1900. Xchar *cmd;
  1901. X{
  1902. X    char        tmp[40 + sizeof (TEMPDIR)];
  1903. X    char        *ucpr;
  1904. X    char        *buf;
  1905. X    unsigned int    siz, temp;
  1906. X    register int    n;
  1907. X    register char    *x;
  1908. X    int        w;
  1909. X    
  1910. X    (void) sprintf (tmp, "%s/uncpr.XXXXXX", TEMPDIR);
  1911. X    (void) mktemp (tmp);
  1912. X    _unlink (tmp);
  1913. X    if (((ucpr = malloc ((unsigned int) (strlen (cmd) + 2))) == (char *) NULL) || ((w = create (tmp,S_IREAD | S_IWRITE,03, 0)) < 0)) {
  1914. X        error |= FATAL;
  1915. X        return (-1);
  1916. X    } else
  1917. X        (void) strcpy (ucpr,cmd);
  1918. X    do_exec (ucpr,o,w);
  1919. X    (void) close (o);
  1920. X    (void) unlink (ofile);
  1921. X    if (error) {
  1922. X        (void) close (w);
  1923. X        _unlink (tmp);
  1924. X        free (ucpr);
  1925. X        return (-1);
  1926. X    }
  1927. X    if ((o = create (ofile,S_IREAD | S_IWRITE,03)) < 0) {
  1928. X        logit (2,"ERROR: Can't create tmpfile '%s'\n",ofile);
  1929. X        (void) close (w);
  1930. X        _unlink (tmp);
  1931. X        free (ucpr);
  1932. X        error |= FATAL;
  1933. X        return (-1);
  1934. X    }
  1935. X    (void) lseek (w,0,0);
  1936. X    siz = 20000;
  1937. X    while (siz && ((buf = malloc (siz + 5)) == (char *) NULL))
  1938. X        siz -= 1000;
  1939. X    if (!siz) {
  1940. X        (void) close (w);
  1941. X        _unlink (tmp);
  1942. X        error |= FATAL;
  1943. X        free (ucpr);
  1944. X        return (o);
  1945. X    }
  1946. X    while ((n = read (w,buf,siz)) > 0) {
  1947. X        logit (6,"Read %d bytes\n",n);
  1948. X        temp = (unsigned int) n;
  1949. X        x = buf;
  1950. X        while (n-- > 0) {
  1951. X            if (*x && (index ("\l\r",*x) != (char *) NULL))
  1952. X                *x = *x == '\l' ? '\r' : '\l';
  1953. X            ++x;
  1954. X        }            
  1955. X        n = write (o,buf,temp);
  1956. X        logit (6,"Wrote %d bytes\n",n);
  1957. X        if (n < 0) {
  1958. X            logit (2,"ERROR: Can't write data to '%s'\n",ofile);
  1959. X            close (o);
  1960. X            o = -1;
  1961. X            error |= FATAL;
  1962. X            break;
  1963. X        }
  1964. X    }
  1965. X    (void) close (w);
  1966. X    free (buf);
  1967. X    free (ucpr);
  1968. X    _unlink (tmp);
  1969. X    return (o);
  1970. X}
  1971. __END__OF__THIS__FILE__
  1972. exit 0
  1973. : end of shell archive
  1974.  
  1975. -- 
  1976. Frank Kaefer # fkk@stasys.sta.sub.org # Starnberg, Germany
  1977.