home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #31 / NN_1992_31.iso / spool / de / comp / sources / os9 / 6 < prev    next >
Encoding:
Internet Message Format  |  1992-12-23  |  44.3 KB
  1. Xref: sparky de.comp.sources.os9:6 comp.os.os9:1548
  2. Path: sparky!uunet!zaphod.mps.ohio-state.edu!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 Part08/09
  6. Message-ID: <1hafdpINNptp@stasys.sta.sub.org>
  7. Date: 23 Dec 92 19:41:45 GMT
  8. Sender: news@stasys.sta.sub.org
  9. Followup-To: de.comp.sources.d
  10. Organization: Stasys News Server, Starnberg, Germany
  11. Lines: 1958
  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/part08
  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. :     'RNEWS/compr7.c                               3373 bytes'
  22. :     'RNEWS/conv.c                                 2289 bytes'
  23. :     'RNEWS/logit.c                                 940 bytes'
  24. :     'RNEWS/mail.c                                  779 bytes'
  25. :     'RNEWS/rnews.c                                5196 bytes'
  26. :     'RNEWS/rnews.h                                 624 bytes'
  27. :     'RNEWS/send.c                                 2835 bytes'
  28. :     'SBATCH/Makefile                               589 bytes'
  29. :     'SBATCH/batch.c                               2157 bytes'
  30. :     'SBATCH/com.c                                 2736 bytes'
  31. :     'SBATCH/com7.c                                1777 bytes'
  32. :     'SBATCH/conv.c                                3579 bytes'
  33. :     'SBATCH/exec.c                                 859 bytes'
  34. :     'SBATCH/file.c                                1820 bytes'
  35. :     'SBATCH/none.c                                1136 bytes'
  36. :     'SBATCH/sbatch.c                              7077 bytes'
  37. : 
  38. if test -f 'RNEWS/compr7.c' ; then
  39.   echo 'File RNEWS/compr7.c already exists, overwriting it'
  40.   del 'RNEWS/compr7.c'
  41. fi
  42. echo Extracting \"'RNEWS/compr7.c'\"
  43. sed "s/^X//" >'RNEWS/compr7.c' <<'__END__OF__THIS__FILE__'
  44. X/*
  45. X * $Log:    compr7.c_v $
  46. X * Revision 1.1  90/08/31  15:38:01  ud
  47. X * Initial revision
  48. X * 
  49. X */
  50. X# ifndef    LINT
  51. Xstatic char rcsid[] = "$Id: compr7.c_v 1.1 90/08/31 15:38:01 ud Exp $";
  52. X# endif        LINT
  53. X# include <stdio.h>
  54. X# include <ctype.h>
  55. X# include <modes.h>
  56. X# include "rnews.h"
  57. X
  58. Xextern void    free ();
  59. Xextern void    logit ();
  60. Xextern void    start_rnews ();
  61. Xextern long    lseek ();
  62. Xextern char    *findmod ();
  63. Xextern char    *index ();
  64. Xextern char    *mktemp ();
  65. Xextern char    *strcpy ();
  66. X
  67. Xint
  68. Xexec (cmd)
  69. Xchar *cmd;
  70. X{
  71. X    extern int os9forkc ();
  72. X    extern char **environ;
  73. X    char *newcmd;
  74. X    register char *x;
  75. X    char *arg[10];
  76. X    int t,pid;
  77. X    
  78. X    if ((newcmd = (char *) malloc ((unsigned int) (strlen (cmd) + 2))) == (char *) NULL)
  79. X        return (-1);
  80. X    t = 0;
  81. X    (void) strcpy (newcmd,cmd);
  82. X    x = newcmd;
  83. X    while (*x && (t < 9)) {
  84. X        arg[t++] = x;
  85. X        while (*x && (!isspace (*x)))
  86. X            ++x;
  87. X        if (*x) {
  88. X            *x++ = '\0';
  89. X            while (isspace (*x))
  90. X                ++x;
  91. X        }
  92. X    }
  93. X    arg[t] = NULL;
  94. X    logit (4,"Fork: '%s'\n",arg[0]);
  95. X    pid = os9exec (os9forkc,findmod (arg[0],arg[0]),arg,environ,0,0,3);
  96. X    logit ((pid < 0) ? 2 : 4,"pid of '%s' is %d\n",arg[0],pid);
  97. X    free (newcmd);
  98. X    return (pid);
  99. X}
  100. X
  101. Xvoid    
  102. Xcompr7 (fd,scratch,cmd)
  103. Xint fd;
  104. Xint scratch;
  105. Xchar *cmd;
  106. X{
  107. X    int        old0, old1;
  108. X    int        pid1, pid2;
  109. X    int        pip;
  110. X    int        o, t, status;
  111. X    char        tmp[40 + sizeof (TEMPDIR)];
  112. X    unsigned int    siz, temp;
  113. X    register char    *x;
  114. X    register int    n;
  115. X    char        *buf;
  116. X    
  117. X    if ((pip = create ("/pipe",S_IREAD | S_IWRITE,03, 0)) < 0) {
  118. X        error |= FATAL;
  119. X        return;
  120. X    }
  121. X    (void) sprintf (tmp, "%s/dec.XXXXXX", TEMPDIR);
  122. X    (void) mktemp (tmp);
  123. X    if ((o = create (tmp,S_IREAD | S_IWRITE,03, 0)) < 0) {
  124. X        logit (2,"ERROR:  Can't create tmpfile '%s'\n",tmp);
  125. X        (void) close (pip);
  126. X        error |= FATAL;
  127. X        return;
  128. X    }
  129. X    old0 = dup (0);
  130. X    old1 = dup (1);
  131. X    if (fd != 0) {
  132. X        (void) close (0);
  133. X        (void) dup (fd);
  134. X    }
  135. X    (void) close (1);
  136. X    (void) dup (pip);
  137. X    if ((pid1 = exec (decode)) < 0) {
  138. X        (void) close (1);
  139. X        (void) dup (old1);
  140. X        if (fd != 0) {
  141. X            (void) close (0);
  142. X            (void) dup (old0);
  143. X        }
  144. X        (void) close (pip);
  145. X        (void) close (o);
  146. X        _unlink (tmp);
  147. X        error |= FATAL;
  148. X        return;
  149. X    }
  150. X    (void) close (1);
  151. X    (void) close (0);
  152. X    if (fd != 0)
  153. X        (void) close (fd);
  154. X    else {
  155. X        (void) close (old0);
  156. X        old0 = -1;
  157. X    }
  158. X    (void) dup (pip);
  159. X    (void) close (pip);
  160. X    (void) dup (o);
  161. X    if ((pid2 = exec (cmd)) < 0) {
  162. X        (void) close (1);
  163. X        (void) dup (old1);
  164. X        (void) close (0);
  165. X        if (old0 != -1)
  166. X            (void) dup (old0);
  167. X        (void) close (o);
  168. X        _unlink (tmp);
  169. X        error |= FATAL;
  170. X        return;
  171. X    }
  172. X    (void) close (0);
  173. X    if (old0 != -1) {
  174. X        (void) dup (old0);
  175. X        (void) close (old0);
  176. X    }
  177. X    (void) close (1);
  178. X    (void) dup (old1);
  179. X    (void) close (old1);
  180. X    while (((t = wait (&status)) != -1) && ((pid1 != -1) || (pid2 != -1))) {
  181. X        logit (status ? 2 : 4,"%d returns %d\n",t,status);
  182. X        if (t == pid1) {
  183. X            if (status)
  184. X                error |= FATAL;
  185. X            pid1 = -1;
  186. X        }
  187. X        if (t == pid2) {
  188. X            if (status)
  189. X                error |= FATAL;
  190. X            pid2 = -1;
  191. X        }
  192. X    }
  193. X    (void) lseek (o,0,0);
  194. X    siz = 20000;
  195. X    while (siz && ((buf = (char *) malloc (siz + 5)) == (char *) NULL))
  196. X        siz -= 1000;
  197. X    if (!siz) {
  198. X        (void) close (o);
  199. X        _unlink (tmp);
  200. X        error |= FATAL;
  201. X        return;
  202. X    }
  203. X    while ((n = read (o,buf,siz)) > 0) {
  204. X        temp = n;
  205. X        (void) lseek (o,(long) 0-n,1);
  206. X        x = buf;
  207. X        while (n-- > 0) {
  208. X            if (*x && index ("\l\r",*x))
  209. X                *x = *x == '\l' ? '\r' : '\l';
  210. X            ++x;
  211. X        }
  212. X        (void) write (o,buf,temp);
  213. X    }
  214. X    (void) lseek (o,0,0);
  215. X    start_rnews (o,scratch);
  216. X    (void) close (o);
  217. X    free (buf);
  218. X    _unlink (tmp);
  219. X}
  220. __END__OF__THIS__FILE__
  221. if test -f 'RNEWS/conv.c' ; then
  222.   echo 'File RNEWS/conv.c already exists, overwriting it'
  223.   del 'RNEWS/conv.c'
  224. fi
  225. echo Extracting \"'RNEWS/conv.c'\"
  226. sed "s/^X//" >'RNEWS/conv.c' <<'__END__OF__THIS__FILE__'
  227. X/*
  228. X * $Log:    conv.c_v $
  229. X * Revision 1.1  90/08/31  15:38:06  ud
  230. X * Initial revision
  231. X * 
  232. X */
  233. X# ifndef    LINT
  234. Xstatic char rcsid[] = "$Id: conv.c_v 1.1 90/08/31 15:38:06 ud Exp $";
  235. X# endif        LINT
  236. X# include    <stdio.h>
  237. X# include    "rnews.h"
  238. X
  239. Xextern char    *malloc ();
  240. Xextern char    *strdup ();
  241. X
  242. Xtypedef struct _keymap {
  243. X    char        *seq;
  244. X    int        len;
  245. X    unsigned char    map;
  246. X    struct _keymap    *next;
  247. X} keymap;
  248. X
  249. Xstatic keymap    *kmap[256];
  250. X
  251. Xstatic int    isinit = FALSE;
  252. X
  253. Xstatic keymap kdefault[] = {
  254. X#ifdef    ISO
  255. X    "\\\"A",    3,    0xc4,        NULL,
  256. X    "\\\"O",    3,    0xd6,        NULL,
  257. X    "\\\"U",    3,    0xdc,        NULL,
  258. X    "\\\"a",    3,    0xe4,        NULL,
  259. X    "\\\"o",    3,    0xf6,        NULL,
  260. X    "\\\"u",    3,    0xfc,        NULL,
  261. X    "\\\"s",    3,    0xdf,        NULL,
  262. X
  263. X    "A\\\"",    3,    0xc4,        NULL,
  264. X    "O\\\"",    3,    0xd6,        NULL,
  265. X    "U\\\"",    3,    0xdc,        NULL,
  266. X    "a\\\"",    3,    0xe4,        NULL,
  267. X    "o\\\"",    3,    0xf6,        NULL,
  268. X    "u\\\"",    3,    0xfc,        NULL,
  269. X    "s\\\"",    3,    0xdf,        NULL,
  270. X#endif    ISO
  271. X#ifdef    CUMANA_ST
  272. X    "\\\"A",    3,    0x8e,        NULL,
  273. X    "\\\"O",    3,    0x99,        NULL,
  274. X    "\\\"U",    3,    0x9a,        NULL,
  275. X    "\\\"a",    3,    0x84,        NULL,
  276. X    "\\\"o",    3,    0x94,        NULL,
  277. X    "\\\"u",    3,    0x81,        NULL,
  278. X    "\\\"s",    3,    0xe1,        NULL,
  279. X
  280. X    "A\\\"",    3,    0x8e,        NULL,
  281. X    "O\\\"",    3,    0x99,        NULL,
  282. X    "U\\\"",    3,    0x9a,        NULL,
  283. X    "a\\\"",    3,    0x84,        NULL,
  284. X    "o\\\"",    3,    0x94,        NULL,
  285. X    "u\\\"",    3,    0x81,        NULL,
  286. X    "s\\\"",    3,    0xe1,        NULL,
  287. X#endif    CUMANA_ST
  288. X    NULL,        0,    0,        NULL
  289. X};
  290. X
  291. Xstatic void
  292. Xinit_conv ()
  293. X{
  294. X    register int    t;
  295. X    keymap        *tmp, *t2;
  296. X
  297. X    for (t = 0; t < 256; ++t)
  298. X        kmap[t] = NULL;
  299. X    for (t = 0; kdefault[t].seq; ++t)
  300. X        if (tmp = (keymap *) malloc (sizeof (keymap)))
  301. X            if (tmp->seq = strdup (kdefault[t].seq)) {
  302. X                tmp->len = kdefault[t].len;
  303. X                tmp->map = kdefault[t].map;
  304. X                tmp->next = 0;
  305. X                if (t2 = kmap[tmp->seq[0] & 0xff]) {
  306. X                    while (t2->next)
  307. X                        t2 = t2->next;
  308. X                    t2->next = tmp;
  309. X                } else
  310. X                    kmap[tmp->seq[0] & 0xff] = tmp;
  311. X            } else
  312. X                free ((char *) tmp);
  313. X    isinit = TRUE;
  314. X}
  315. X
  316. Xvoid
  317. Xconv_8bit (s, n, fp)
  318. Xregister char *s;
  319. Xregister int n;
  320. Xregister FILE *fp;
  321. X{
  322. X    unsigned char    c;
  323. X    register keymap    *tmp;
  324. X
  325. X    if (!isinit)
  326. X        init_conv ();
  327. X    while (n-- > 0)
  328. X        if (tmp = kmap[((unsigned char) *s) & 0xff]) {
  329. X            while (tmp)
  330. X                if ((n >= tmp->len) && (!strncmp (s, tmp->seq, tmp->len)))
  331. X                    break;
  332. X                else
  333. X                    tmp = tmp->next;
  334. X            if (tmp) {
  335. X                n -= tmp->len - 1;
  336. X                s += tmp->len;
  337. X                putc (tmp->map, fp);
  338. X            } else
  339. X                putc (*s++, fp);
  340. X        } else
  341. X            putc (*s++, fp);
  342. X}
  343. __END__OF__THIS__FILE__
  344. if test -f 'RNEWS/logit.c' ; then
  345.   echo 'File RNEWS/logit.c already exists, overwriting it'
  346.   del 'RNEWS/logit.c'
  347. fi
  348. echo Extracting \"'RNEWS/logit.c'\"
  349. sed "s/^X//" >'RNEWS/logit.c' <<'__END__OF__THIS__FILE__'
  350. X/*
  351. X * $Log:    logit.c_v $
  352. X * Revision 1.1  90/08/31  15:38:12  ud
  353. X * Initial revision
  354. X * 
  355. X */
  356. X# ifndef    LINT
  357. Xstatic char rcsid[] = "$Id: logit.c_v 1.1 90/08/31 15:38:12 ud Exp $";
  358. X# endif        LINT
  359. X# include <stdio.h>
  360. X# include <time.h>
  361. X# include "rnews.h"
  362. X
  363. Xextern time_t        time ();
  364. Xextern char        *asctime ();
  365. Xextern struct tm    *localtime ();
  366. X
  367. X /*VARARGS2*/
  368. Xvoid
  369. Xlogit (nr,a,b,c,d,e,f)
  370. Xint nr;
  371. Xchar *a,*b,*c,*d,*e,*f;
  372. X{
  373. X    static int    first = TRUE;
  374. X    time_t        t;
  375. X    struct tm    *tt;
  376. X    static char    tbuf[32];
  377. X
  378. X    if (first) {
  379. X        (void) time (&t);
  380. X        if (tt = localtime (& t))
  381. X            sprintf (tbuf, "%02d/%02d/%02d  %02d:%02d:%02d",
  382. X                tt -> tm_year, tt -> tm_mon + 1, tt -> tm_mday,
  383. X                tt -> tm_hour, tt -> tm_min, tt -> tm_sec);
  384. X        else
  385. X            tbuf[0] = '\0';
  386. X        (void) fprintf (stderr,"Start: %s", tbuf);
  387. X        first = FALSE;
  388. X    }
  389. X    (void) fprintf (stderr,a,b,c,d,e,f);
  390. X    if ((!lp) || (Debug < nr))
  391. X        return;
  392. X    (void) fprintf (lp,"%s: ", tbuf);
  393. X    (void) fprintf (lp,a,b,c,d,e,f);
  394. X}
  395. __END__OF__THIS__FILE__
  396. if test -f 'RNEWS/mail.c' ; then
  397.   echo 'File RNEWS/mail.c already exists, overwriting it'
  398.   del 'RNEWS/mail.c'
  399. fi
  400. echo Extracting \"'RNEWS/mail.c'\"
  401. sed "s/^X//" >'RNEWS/mail.c' <<'__END__OF__THIS__FILE__'
  402. X/*
  403. X * $Log:    mail.c_v $
  404. X * Revision 1.1  90/08/31  15:38:14  ud
  405. X * Initial revision
  406. X * 
  407. X */
  408. X# ifndef    LINT
  409. Xstatic char rcsid[] = "$Id: mail.c_v 1.1 90/08/31 15:38:14 ud Exp $";
  410. X# endif        LINT
  411. X# include    <stdio.h>
  412. X
  413. Xextern char    *cuserid ();
  414. Xextern FILE    *popen ();
  415. X
  416. Xvoid
  417. Xsend_mail (lost, articles)
  418. Xint lost;
  419. Xint articles;
  420. X{
  421. X    char    cmd[128];
  422. X    char    *name;
  423. X    FILE    *fp;
  424. X    
  425. X    if ((name = cuserid ()) == (char *) NULL)
  426. X        name = "postmaster";
  427. X    (void) sprintf (cmd, "%s %s", findmod ("/h0/ETC/CMDS/rmail", "rmail"), name);
  428. X    if ((fp = popen (cmd, "w")) == (FILE *) NULL) {
  429. X        logit (2, "ERROR: Can't fork rmail\n");
  430. X        return;
  431. X    }
  432. X    (void) fprintf (fp, "Subject: Failed articles\n\n");
  433. X    (void) fprintf (fp, "Spooled: %d\n", articles);
  434. X    (void) fprintf (fp, "Failed:  %d\n", lost);
  435. X    (void) pclose (fp);
  436. X}
  437. __END__OF__THIS__FILE__
  438. if test -f 'RNEWS/rnews.c' ; then
  439.   echo 'File RNEWS/rnews.c already exists, overwriting it'
  440.   del 'RNEWS/rnews.c'
  441. fi
  442. echo Extracting \"'RNEWS/rnews.c'\"
  443. sed "s/^X//" >'RNEWS/rnews.c' <<'__END__OF__THIS__FILE__'
  444. X/*
  445. X * $Log:    main.c_v $
  446. X * Revision 1.1  90/08/31  15:38:17  ud
  447. X * Initial revision
  448. X * 
  449. X */
  450. X# ifndef    LINT
  451. Xstatic char rcsid[] = "$Id: main.c_v 1.1 90/08/31 15:38:17 ud Exp $";
  452. Xstatic char copyright[] = "Copyright (C) 1989, 1990 by Ulrich Dessauer, Germering, Germany.\n";
  453. X# endif        LINT
  454. X# include <stdio.h>
  455. X# include <modes.h>
  456. X# define EXTERN
  457. X# include "rnews.h"
  458. X
  459. Xextern void     compr ();
  460. Xextern void    compr7 ();
  461. Xextern void    exit ();
  462. Xextern void    logit ();
  463. Xextern void    send_mail ();
  464. Xextern long    lseek ();
  465. Xextern char    *info_str ();
  466. Xextern char    *malloc ();
  467. Xextern char    *mktemp ();
  468. Xextern char    *strcpy ();
  469. Xextern FILE    *fopen ();
  470. X
  471. Xvoid        start_rnews ();
  472. X
  473. Xextern int    errno;
  474. X
  475. Xstatic int yet;
  476. X
  477. Xstatic char *help[] = {
  478. X    "Syntax: rnews [<opts>] [<file>] [<opts>]\n",
  479. X    "Function: reading standard input or file and parsing batched news\n",
  480. X    "Options:\n",
  481. X    "     -d<=>num      Debuglevel\n",
  482. X    NULL
  483. X};
  484. X
  485. Xvoid
  486. Xusage ()
  487. X{
  488. X    int t;
  489. X    
  490. X    for (t=0;help[t];++t)
  491. X        (void) fputs (help[t],stderr);
  492. X}
  493. X
  494. Xvoid
  495. Xparse_args (ac,av)
  496. Xint ac;
  497. Xchar *av[];
  498. X{
  499. X    int t;
  500. X    char *x;
  501. X    int i;
  502. X
  503. X    Debug = 0;
  504. X    i = -1;
  505. X    for (t=1;t<ac;++t)
  506. X        if (*av[t] == '-') {
  507. X            x = av[t] + 1;
  508. X            while (*x) {
  509. X                switch (*x) {
  510. X                    case 'd':
  511. X                        x += (*(x+1) == '=' ? 2 : 1);
  512. X                        Debug = atoi (x);
  513. X                        while (*x)
  514. X                            ++x;
  515. X                        break;
  516. X                    case '?':
  517. X                    default:
  518. X                        usage ();
  519. X                        exit (1);
  520. X                }
  521. X                if (*x)
  522. X                    ++x;
  523. X            }
  524. X        } else
  525. X            if (i == -1)
  526. X                if ((i = open (av[t],S_IREAD)) != -1) {
  527. X                    (void) close (0);
  528. X                    (void) dup (i);
  529. X                    (void) close (i);
  530. X                    i = 0;
  531. X                }
  532. X}
  533. X
  534. Xmain (argc,argv)
  535. Xint argc;
  536. Xchar *argv[];
  537. X{
  538. X    char    tmp[40 + sizeof (TEMPDIR)];
  539. X    char    s[512];
  540. X    int    i;
  541. X    
  542. X    parse_args (argc,argv);
  543. X    (void) sprintf (tmp, "%s/rn.XXXXXX", TEMPDIR);
  544. X    (void) mktemp (tmp);
  545. X    unlink (tmp);
  546. X    if ((i = create (tmp,S_IWRITE | S_IREAD,03, 0)) < 0)
  547. X        exit (_errmsg (1,"Can't create temp-file!\n"));
  548. X
  549. X    if ((info_str (INEWS,s,512) == (char *) NULL) || ((inews= (char *) malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  550. X        inews = INEWS;
  551. X    else
  552. X        (void) strcpy (inews, s);
  553. X    if ((info_str (UNCOMPRESS,s,512) == (char *) NULL) || ((uncompress = (char *) malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  554. X        uncompress = UNCOMPRESS;
  555. X    else
  556. X        (void) strcpy (uncompress,s);
  557. X    if ((info_str (MELT,s,512) == (char *) NULL) || ((melt = (char *) malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  558. X        melt = MELT;
  559. X    else
  560. X        (void) strcpy (melt,s);
  561. X    if ((info_str (DECODE,s,512) == (char *) NULL) || ((decode = (char *) malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  562. X        decode = DECODE;
  563. X    else
  564. X        (void) strcpy (decode,s);
  565. X
  566. X    if ((info_str (RNEWSLOG,s,512) == (char *) NULL) || ((lpfn = (char *) malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  567. X        lpfn = LPFN;
  568. X    else
  569. X        (void) strcpy (lpfn,s);
  570. X
  571. X    if ((info_str (RNEWS_SPOOL, s, 512) == (char *) NULL) || ((rnews_spool = malloc ((unsigned int) strlen (s) + 2)) == (char *) NULL))
  572. X        rnews_spool = RNEWS_SPOOLDIR;
  573. X    else
  574. X        (void) strcpy (rnews_spool, s);
  575. X
  576. X    if (access (lpfn,S_IWRITE) < 0)
  577. X        lp = NULL;
  578. X    else
  579. X        lp = fopen (lpfn,"a");
  580. X
  581. X    logit (0,"=== Started (Level %d) ===\n",Debug);
  582. X    error = 0;
  583. X    lost = 0;
  584. X    yet = 0;
  585. X    articles = 0;
  586. X    start_rnews (0,i);
  587. X    (void) close (i);
  588. X    _unlink (tmp);
  589. X    logit (0,"Exits with error %d (Received %d articles)\n",error, articles);
  590. X
  591. X    if (lp) {
  592. X        (void) fclose (lp);
  593. X        lp = NULL;
  594. X    }
  595. X    if (lost)
  596. X        send_mail (lost, articles);
  597. X    exit (error & FATAL ? error : 0);
  598. X}
  599. X
  600. Xvoid
  601. Xstart_rnews (fd,i)
  602. Xint fd;
  603. Xint i;
  604. X{
  605. X    char s[512], sav;
  606. X    int len,mode;
  607. X    int n;
  608. X
  609. X    len = -1;
  610. X    mode = NONE;
  611. X    while ((n = readln (fd,s,512)) > 0) {
  612. X        sav = s[n-1];
  613. X        s[n-1] = '\0';
  614. X        logit (6,"Start_rnews reads '%s'\n",s);
  615. X        if (*s == '#')
  616. X            if (!strncmp (s,BATCHHEAD,BATCHLEN)) {
  617. X                len = get_len (s);
  618. X                logit (1,"Receive batched, len = %d\n",len);
  619. X                mode = BATCH;
  620. X                break;
  621. X            } else if (!strncmp (s,COMHEAD,COMLEN)) {
  622. X                logit (1,"Receive batch/compr\n");
  623. X                mode = COM;
  624. X                break;
  625. X            } else if (!strncmp (s,COM7HEAD,COM7LEN)) {
  626. X                logit (1,"Receive batch/compr/encode\n");
  627. X                mode = COM7;
  628. X                break;
  629. X            } else if (!strncmp (s,FREHEAD,FRELEN)) {
  630. X                logit (1,"Receive batch/freeze\n");
  631. X                mode = FRE;
  632. X                break;
  633. X            } else if (!strncmp (s,FRE7HEAD,FRE7LEN)) {
  634. X                logit (1,"Receive batch/freeze/encode\n");
  635. X                mode = FRE7;
  636. X                break;
  637. X            } else {
  638. X                (void) writeln (i,s,(unsigned int) (n - 1));
  639. X                (void) writeln (i, &sav, 1);
  640. X            }
  641. X        else {
  642. X            (void) writeln (i,s,(unsigned int) (n - 1));
  643. X            (void) writeln (i, &sav, 1);
  644. X        }
  645. X    }
  646. X    if (yet & (1<<mode)) {
  647. X        logit (2,"ERROR: This batch already done\n");
  648. X        error |= SIMPLE;
  649. X        return;
  650. X    } else
  651. X        yet |= 1<<mode;
  652. X    switch (mode) {
  653. X        case NONE:
  654. X            (void) lseek (i,0,0);
  655. X            n = _gs_size (i);
  656. X            logit (3,"Send single File, size = %d\n",n);
  657. X            (void) send_to_inews (i,n);
  658. X            break;
  659. X        case BATCH:
  660. X            logit (3,"Send batch to inews\n");
  661. X            while ((len = send_to_inews (fd,len)) != -1)
  662. X                logit (3,"Sent, next len = %d\n",len);
  663. X            logit (3,"Finished sending batch to inews\n");
  664. X            break;
  665. X        case COM:
  666. X        case FRE:
  667. X            logit (3,"Send compress\n");
  668. X            compr (fd,i,mode == COM ? uncompress : melt);
  669. X            break;
  670. X        case COM7:
  671. X        case FRE7:
  672. X            logit (3,"Send compress/encode\n");
  673. X            compr7 (fd,i,mode == COM7 ? uncompress : melt);
  674. X            break;
  675. X    }
  676. X}
  677. __END__OF__THIS__FILE__
  678. if test -f 'RNEWS/rnews.h' ; then
  679.   echo 'File RNEWS/rnews.h already exists, overwriting it'
  680.   del 'RNEWS/rnews.h'
  681. fi
  682. echo Extracting \"'RNEWS/rnews.h'\"
  683. sed "s/^X//" >'RNEWS/rnews.h' <<'__END__OF__THIS__FILE__'
  684. X/*
  685. X * $Log:    rnews.h_v $
  686. X * Revision 1.1  90/08/31  15:38:22  ud
  687. X * Initial revision
  688. X * 
  689. X */
  690. X# include    "news.h"
  691. X
  692. X# define    RNEWSLOG    "rnews.logfile"
  693. X# define    LPFN        MNEWS_RNEWS_LOGFILE
  694. X
  695. X# define    RNEWS_SPOOL    "RNEWS.DIR"
  696. X# define    RNEWS_SPOOLDIR    MNEWS_RNEWS_SPOOLDIR
  697. X# define    RNEWS_SPOOLSEQ    ".seq"
  698. X
  699. X# ifndef    EXTERN
  700. X# define    EXTERN        extern
  701. X# endif        EXTERN
  702. X
  703. XEXTERN char    *inews;
  704. XEXTERN char    *uncompress;
  705. XEXTERN char    *melt;
  706. XEXTERN char    *decode;
  707. XEXTERN int    error;
  708. X
  709. XEXTERN FILE    *lp;
  710. XEXTERN char    *lpfn;
  711. XEXTERN char    *rnews_spool;
  712. XEXTERN int    Debug;
  713. XEXTERN int    articles;
  714. XEXTERN int    lost;
  715. X
  716. X# define    _unlink(s)    if (Debug < 3) (void) unlink(s)
  717. __END__OF__THIS__FILE__
  718. if test -f 'RNEWS/send.c' ; then
  719.   echo 'File RNEWS/send.c already exists, overwriting it'
  720.   del 'RNEWS/send.c'
  721. fi
  722. echo Extracting \"'RNEWS/send.c'\"
  723. sed "s/^X//" >'RNEWS/send.c' <<'__END__OF__THIS__FILE__'
  724. X/*
  725. X * $Log:    send.c_v $
  726. X * Revision 1.1  90/08/31  15:38:45  ud
  727. X * Initial revision
  728. X * 
  729. X */
  730. X# ifndef    LINT
  731. Xstatic char rcsid[] = "$Id: send.c_v 1.1 90/08/31 15:38:45 ud Exp $";
  732. X# endif        LINT
  733. X# include <stdio.h>
  734. X# include <ctype.h>
  735. X# include <modes.h>
  736. X# include "rnews.h"
  737. X
  738. Xextern void    logit ();
  739. Xextern char    *realloc ();
  740. Xextern FILE    *xpopen ();
  741. X
  742. Xvoid        save_it ();
  743. X
  744. Xint
  745. Xget_len (s)
  746. Xregister char *s;
  747. X{
  748. X    if (strlen (s) <= BATCHLEN)
  749. X        return (-1);
  750. X    s += BATCHLEN;
  751. X    while (*s && (!isdigit (*s)))
  752. X        ++s;
  753. X    if (!*s)
  754. X        return (-1);
  755. X    else
  756. X        return (atoi (s));
  757. X}
  758. X
  759. Xint
  760. Xsend_to_inews (fd,len)
  761. Xint fd,len;
  762. X{
  763. X    static char *buf = NULL;
  764. X    static int csiz = 0;
  765. X    char s[512];
  766. X    int n;
  767. X    int asone;
  768. X    FILE *fp;
  769. X    int nlen;
  770. X    
  771. X    if (!(fp = xpopen (inews,"w"))) {
  772. X        logit (1,"Can't execute '%s'\n", inews);
  773. X        error |= FATAL;
  774. X        return (FALSE);
  775. X    }
  776. X    asone = FALSE;
  777. X    if (len > csiz) {
  778. X        while (len > csiz)
  779. X            csiz += 2048;
  780. X        if (!(buf = (char *) realloc (buf,(unsigned int) (csiz + 5)))) {
  781. X            csiz = 0;
  782. X            while ((len > 0) && ((n = readln (fd,s,512)) > 0)) {
  783. X                s[n] = '\0';
  784. X                logit (6,"Send line '%s' to %s\n", s, inews);
  785. X                (void) fputs (s,fp);
  786. X                len -= n;
  787. X            }
  788. X            asone = FALSE;
  789. X        }
  790. X    }
  791. X    if (len <= csiz)
  792. X        if ((n = read (fd,buf,(unsigned int) len)) == len) {
  793. X            logit (4,"Send article with %d Bytes to %s\n", len, inews);
  794. X            (void) fwrite (buf,n,1,fp);
  795. X            asone = TRUE;
  796. X        } else
  797. X            logit (2,"ERROR: Can't send to %s (reached eof, errno = %d)\n", inews, errno);
  798. X    nlen = -1;
  799. X    while ((n = readln (fd,s,512)) > 0) {
  800. X        s[n] = '\0';
  801. X        if (!strncmp (s,BATCHHEAD,BATCHLEN)) {
  802. X            nlen = get_len (s);
  803. X            logit (3,"Got next batchentry, len = %d\n",nlen);
  804. X            break;
  805. X        } else
  806. X            logit (6,"Skiping junk '%s'\n",s);
  807. X    }
  808. X    n = pclose (fp);
  809. X    logit (n ? 2 : 3,"Pclose returns %d\n",n);
  810. X    if (n)
  811. X        if (asone) {
  812. X            save_it (buf, len);
  813. X            ++lost;
  814. X            error |= SIMPLE;
  815. X        } else
  816. X            error |= FATAL;
  817. X    ++articles;
  818. X    return (nlen);
  819. X}
  820. X
  821. Xvoid
  822. Xsave_it (buf, len)
  823. Xchar *buf;
  824. Xint len;
  825. X{
  826. X    char    seq[128];
  827. X    char    fn[128];
  828. X    int    fd;
  829. X    int    nr;
  830. X    int    t;
  831. X    
  832. X    (void) sprintf (seq, "%s/%s", rnews_spool, RNEWS_SPOOLSEQ);
  833. X    t = 20;
  834. X    do {
  835. X        if (access (seq, S_IREAD | S_IWRITE) < 0) {
  836. X            fd = create (seq, S_IWRITE | S_ISHARE, 03 | S_ISHARE);
  837. X            nr = 1;
  838. X        } else {
  839. X            fd = open (seq, S_IREAD | S_IWRITE | S_ISHARE);
  840. X            if (fd > 0) {
  841. X                (void) read (fd, &nr, 4);
  842. X                (void) lseek (fd, 0, 0L);
  843. X            }
  844. X        }
  845. X        if (fd < 0)
  846. X            sleep (1);
  847. X    } while ((fd < 0) && (t-- > 0));
  848. X    if (fd < 0) {
  849. X        logit (2, "Can't get spool-seq (errno = %d)\n", errno);
  850. X        error |= FATAL;
  851. X        return;
  852. X    }
  853. X    (void) sprintf (fn, "%s/%05d", rnews_spool, nr++);
  854. X    (void) write (fd, &nr, 4);
  855. X    (void) close (fd);
  856. X    while (access (fn, 0) == 0)
  857. X        (void) strcat (fn, "a");
  858. X    if ((fd = create (fn, S_IWRITE, 03)) < 0) {
  859. X        logit (2, "Can't create spoolfile '%s'\n", fn);
  860. X        error |= FATAL;
  861. X        return;
  862. X    }
  863. X    (void) write (fd, buf, (unsigned int) len);
  864. X    (void) close (fd);
  865. X}
  866. __END__OF__THIS__FILE__
  867. if test -f 'SBATCH/Makefile' ; then
  868.   echo 'File SBATCH/Makefile already exists, overwriting it'
  869.   del 'SBATCH/Makefile'
  870. fi
  871. echo Extracting \"'SBATCH/Makefile'\"
  872. sed "s/^X//" >'SBATCH/Makefile' <<'__END__OF__THIS__FILE__'
  873. X# $Id: Makefile_v 1.1 90/08/31 15:40:27 ud Exp $
  874. X# $Log:    Makefile_v $
  875. X# Revision 1.1  90/08/31  15:40:27  ud
  876. X# Initial revision
  877. X# 
  878. X#
  879. XCC=    cc
  880. XG=    -g
  881. XCFLAGS=    -qt=/dd/TMP $G -v=.. -v=../8BIT
  882. XLIBS=    -l=/dd/LIB/os9lib.l -l=/h3/LIB/8bit.l
  883. XLFLAGS=    -q $(LIBS) $G
  884. XODIR=    /h0/ETC/CMDS
  885. X
  886. XBATCHC=    sbatch.c batch.c none.c com.c com7.c file.c exec.c conv.c
  887. XBATCHR=    sbatch.r batch.r none.r com.r com7.r file.r exec.r conv.r
  888. X
  889. X$(ODIR)/sbatch:    $(BATCHR)
  890. X    $(CC) $(LFLAGS) $(BATCHR) -f=$(ODIR)/sbatch
  891. X    fixmod -uo2.39 -ua8002 $(ODIR)/sbatch
  892. X
  893. Xtags:    $(BATCHC)
  894. X    echo "Ctags:" $?
  895. X    ctags $?
  896. X
  897. Xsbatch.r:    sbatch.c sbatch.h
  898. __END__OF__THIS__FILE__
  899. if test -f 'SBATCH/batch.c' ; then
  900.   echo 'File SBATCH/batch.c already exists, overwriting it'
  901.   del 'SBATCH/batch.c'
  902. fi
  903. echo Extracting \"'SBATCH/batch.c'\"
  904. sed "s/^X//" >'SBATCH/batch.c' <<'__END__OF__THIS__FILE__'
  905. X/*
  906. X * $Log:    batch.c_v $
  907. X * Revision 1.1  90/08/31  15:40:10  ud
  908. X * Initial revision
  909. X * 
  910. X */
  911. X# ifndef    LINT
  912. Xstatic char rcsid[] = "$Id: batch.c_v 1.1 90/08/31 15:40:10 ud Exp $";
  913. X# endif        LINT
  914. X# include <stdio.h>
  915. X# include <modes.h>
  916. X# include <dir.h>
  917. X# include "sbatch.h"
  918. X
  919. Xextern void        closedir ();
  920. Xextern void        send_file ();
  921. Xextern void        free ();
  922. Xextern long        lseek ();
  923. Xextern char        *conv_8bit ();
  924. Xextern char        *malloc ();
  925. Xextern char        *mktemp ();
  926. Xextern char        *strcat ();
  927. Xextern char        *strcpy ();
  928. Xextern DIR        *opendir ();
  929. Xextern struct direct    *readdir ();
  930. X
  931. Xvoid
  932. Xsend_batch (fd, sys)
  933. Xint fd;
  934. Xchar *sys;
  935. X{
  936. X    char    tmp[40 + sizeof (TEMPDIR)];
  937. X    int    i;
  938. X
  939. X    (void) sprintf (tmp, "%s/s_bt.XXXXXX", TEMPDIR);
  940. X    (void) mktemp (tmp);
  941. X    while ((i = make_batch (fd, tmp)) != -1) {
  942. X        send_file (sys, i);
  943. X        (void) unlink (tmp);
  944. X    }
  945. X    if (!access (tmp,0))
  946. X        (void) unlink (tmp);
  947. X}
  948. X
  949. Xvoid
  950. X_copy (in,out)
  951. Xregister int in, out;
  952. X{
  953. X    static char    *_bufptr = NULL;
  954. X    static char    sbuf[130];
  955. X    static int    siz;
  956. X    register int    n;
  957. X    register char    *buf;
  958. X
  959. X    if (!_bufptr) {
  960. X        siz = 20000;
  961. X        while (siz && (!(_bufptr = malloc (siz + 16))))
  962. X            siz -= 1000;
  963. X        if (!siz) {
  964. X            siz = 128;
  965. X            _bufptr = sbuf;
  966. X        }
  967. X    }
  968. X    buf = _bufptr;
  969. X    while ((n = read (in,buf,siz)) > 0)
  970. X        (void) write (out,buf,(unsigned int) n);
  971. X}
  972. X
  973. Xint
  974. Xmake_batch (fd, tmp)
  975. Xint fd;
  976. Xchar *tmp;
  977. X{
  978. X    int    found;
  979. X    char    s[128];
  980. X    int    o,i,siz,fsiz;
  981. X    char    *fn;
  982. X    int    n;
  983. X
  984. X    if ((o = create (tmp,S_IWRITE | S_IREAD,03,0)) < 0) {
  985. X        (void) fprintf (stderr,"Can't create '%s' (errno = %d)\n",tmp,errno);
  986. X        error = TRUE;
  987. X        return (-1);
  988. X    }
  989. X    found = FALSE;
  990. X    fsiz = 0;
  991. X    while ((n = readln (fd, buffer, 500)) > 0) {
  992. X        buffer[n-1] = '\0';
  993. X        fprintf (stderr, "Spooling %s\n", buffer);
  994. X        if (!(fn = conv_8bit (buffer)))
  995. X            continue;
  996. X        if ((i = open (fn, S_IREAD)) < 0) {
  997. X            fprintf (stderr, "File %s doesn't exists?!?\n", fn);
  998. X            continue;
  999. X        }
  1000. X        siz = _gs_size (i);
  1001. X        (void) sprintf (s,"%s %d\n",BATCHHEAD,siz);
  1002. X        (void) write (o,s,(unsigned int) strlen (s));
  1003. X        _copy (i,o);
  1004. X        (void) close (i);
  1005. X        unlink (fn);
  1006. X        found = TRUE;
  1007. X        fsiz += siz;
  1008. X        if (fsiz > maxsiz)
  1009. X            break;
  1010. X    }
  1011. X    if (found) {
  1012. X        lseek (o, 0, 0);
  1013. X        return (o);
  1014. X    } else {
  1015. X        close (o);
  1016. X        return (-1);
  1017. X    }
  1018. X}
  1019. X
  1020. X
  1021. __END__OF__THIS__FILE__
  1022. if test -f 'SBATCH/com.c' ; then
  1023.   echo 'File SBATCH/com.c already exists, overwriting it'
  1024.   del 'SBATCH/com.c'
  1025. fi
  1026. echo Extracting \"'SBATCH/com.c'\"
  1027. sed "s/^X//" >'SBATCH/com.c' <<'__END__OF__THIS__FILE__'
  1028. X/*
  1029. X * $Log:    com.c_v $
  1030. X * Revision 1.1  90/08/31  15:40:13  ud
  1031. X * Initial revision
  1032. X * 
  1033. X */
  1034. X# ifndef    LINT
  1035. Xstatic char rcsid[] = "$Id: com.c_v 1.1 90/08/31 15:40:13 ud Exp $";
  1036. X# endif        LINT
  1037. X# include    <stdio.h>
  1038. X# include    <types.h>
  1039. X# include    <modes.h>
  1040. X# include    "sbatch.h"
  1041. X
  1042. Xextern void    free ();
  1043. Xextern void    send_file ();
  1044. Xextern long    lseek ();
  1045. Xextern char    *index ();
  1046. Xextern char    *malloc ();
  1047. Xextern char    *mktemp ();
  1048. Xextern char    *strcpy ();
  1049. X
  1050. Xvoid
  1051. Xlfcr (fd)
  1052. Xregister int fd;
  1053. X{
  1054. X    static char    *_bufptr = NULL;
  1055. X    static char    sbuf[130];
  1056. X    static u_int    siz;
  1057. X    register char    *buf;
  1058. X    register char    *x;
  1059. X    register u_int    temp;
  1060. X    register int    n;
  1061. X    
  1062. X    if (!_bufptr) {
  1063. X        siz = 20000;
  1064. X        while (siz && (!(_bufptr = malloc (siz + 5))))
  1065. X            siz -= 1000;
  1066. X        if (!siz) {
  1067. X            siz = 128;
  1068. X            _bufptr = sbuf;
  1069. X        }
  1070. X    }
  1071. X    buf = _bufptr;
  1072. X    while ((n = read (fd,buf,siz)) > 0) {
  1073. X        (void) lseek (fd,(long) -n,1);
  1074. X        temp = (u_int) n;
  1075. X        x = buf;
  1076. X        while (n-- > 0) {
  1077. X            if (*x && (index ("\l\r",*x) != (char *) NULL))
  1078. X                *x = *x == '\l' ? '\r' : '\l';
  1079. X            ++x;
  1080. X        }
  1081. X        (void) write (fd,buf,temp);
  1082. X    }
  1083. X}
  1084. X
  1085. Xvoid
  1086. Xsend_com (fd, sys, mode)
  1087. Xint fd;
  1088. Xchar *sys;
  1089. Xint mode;
  1090. X{
  1091. X    char    tmp[40 + sizeof (TEMPDIR)];
  1092. X    int    i;
  1093. X    
  1094. X    (void) sprintf (tmp, "%s/s_bt.XXXXXX", TEMPDIR);
  1095. X    (void) mktemp (tmp);
  1096. X    while ((i = make_batch (fd, tmp)) != -1) {
  1097. X        lfcr (i);
  1098. X        (void) lseek (i,0,0);
  1099. X        i = compress_it (i,tmp,mode == COM ? compress : freeze, TRUE);
  1100. X        if (i != -1)
  1101. X            send_file (sys,i);
  1102. X        (void) unlink (tmp);
  1103. X    }
  1104. X    if (!access (tmp,0))
  1105. X        (void) unlink (tmp);
  1106. X}
  1107. X
  1108. Xvoid
  1109. Xexec_cprs (cmd)
  1110. Xchar *cmd;
  1111. X{
  1112. X    int t,pid,status;
  1113. X    
  1114. X    pid = _exec (cmd);
  1115. X    if (pid < 0) {
  1116. X        (void) fprintf (stderr,"Can't fork '%s' (errno = %d)\n", cmd, errno);
  1117. X        error = TRUE;
  1118. X        return;
  1119. X    } else
  1120. X        while (((t = wait (&status)) != pid) && (t != -1))
  1121. X            ;
  1122. X    if (status) {
  1123. X        (void) fprintf (stderr,"'%s' returns %d (errno = %d)\n",cmd,status,errno);
  1124. X        error = TRUE;
  1125. X    }
  1126. X    return;
  1127. X}    
  1128. X
  1129. Xint
  1130. Xcompress_it (fd,sf,cmd,header)
  1131. Xint fd;
  1132. Xchar *sf;
  1133. Xchar *cmd;
  1134. Xint header;
  1135. X{
  1136. X    char    tmp[40 + sizeof (TEMPDIR)];
  1137. X    int    o0, o1;
  1138. X    int    o;
  1139. X    
  1140. X    fprintf (stderr, "Compress %d bytes\n", _gs_size (fd));
  1141. X    (void) sprintf (tmp, "%s/cpr.XXXXXX", TEMPDIR);
  1142. X    (void) mktemp (tmp);
  1143. X    if ((o = create (tmp,S_IREAD | S_IWRITE,03, 0)) < 0) {
  1144. X        (void) fprintf (stderr,"Can't create '%s' (errno = %d)\n",tmp,errno);
  1145. X        error = TRUE;
  1146. X        return (-1);
  1147. X    }
  1148. X    if (header) {
  1149. X        (void) write (o,COMHEAD,COMLEN);
  1150. X        (void) write (o,"\l",1);
  1151. X    }
  1152. X    o0 = dup (0);
  1153. X    o1 = dup (1);
  1154. X    (void) close (0);
  1155. X    (void) dup (fd);
  1156. X    (void) close (fd);
  1157. X    (void) close (1);
  1158. X    (void) dup (o);
  1159. X    exec_cprs (cmd);
  1160. X    (void) close (0);
  1161. X    (void) dup (o0);
  1162. X    (void) close (1);
  1163. X    (void) dup (o1);
  1164. X    (void) close (o0);
  1165. X    (void) close (o1);
  1166. X    (void) lseek (o,0,0);
  1167. X    lfcr (o);
  1168. X    (void) lseek (o,0,0);
  1169. X    (void) unlink (sf);
  1170. X    (void) strcpy (sf,tmp);
  1171. X    return (o);
  1172. X}
  1173. __END__OF__THIS__FILE__
  1174. if test -f 'SBATCH/com7.c' ; then
  1175.   echo 'File SBATCH/com7.c already exists, overwriting it'
  1176.   del 'SBATCH/com7.c'
  1177. fi
  1178. echo Extracting \"'SBATCH/com7.c'\"
  1179. sed "s/^X//" >'SBATCH/com7.c' <<'__END__OF__THIS__FILE__'
  1180. X/*
  1181. X * $Log:    com7.c_v $
  1182. X * Revision 1.1  90/08/31  15:40:17  ud
  1183. X * Initial revision
  1184. X * 
  1185. X */
  1186. X# ifndef    LINT
  1187. Xstatic char rcsid[] = "$Id: com7.c_v 1.1 90/08/31 15:40:17 ud Exp $";
  1188. X# endif        LINT
  1189. X# include    <stdio.h>
  1190. X# include    <modes.h>
  1191. X# include    "sbatch.h"
  1192. X
  1193. Xextern void    lfcr ();
  1194. Xextern void    send_file ();
  1195. Xextern long    lseek ();
  1196. Xextern char    *mktemp ();
  1197. Xextern char    *strcpy ();
  1198. X
  1199. Xvoid
  1200. Xsend_com7 (fd, sys, mode)
  1201. Xint fd;
  1202. Xchar *sys;
  1203. Xint mode;
  1204. X{
  1205. X    char    tmp[40 + sizeof (TEMPDIR)],
  1206. X        tmp2[40 + sizeof (TEMPDIR)];
  1207. X    int    i, status, t;
  1208. X    int    o, o0, o1;
  1209. X    int    pid;
  1210. X    
  1211. X    (void) sprintf (tmp, "%s/s_bt.XXXXXX", TEMPDIR);
  1212. X    (void) mktemp (tmp);
  1213. X    while ((i = make_batch (fd, tmp)) != -1) {
  1214. X        lfcr (i);
  1215. X        (void) lseek (i,0,0);
  1216. X        i = compress_it (i,tmp,mode == COM7 ? compress : freeze, FALSE);
  1217. X        (void) sprintf (tmp2, "%s/enc.XXXXXX", TEMPDIR);
  1218. X        (void) mktemp (tmp2);
  1219. X        if ((o = create (tmp2,S_IREAD | S_IWRITE,03, 0)) < 0) {
  1220. X            (void) fprintf (stderr,"Can't create tmp2 '%s' (errno = %d)\n",tmp2,errno);
  1221. X            (void) close (i);
  1222. X            (void) unlink (tmp);
  1223. X            error = TRUE;
  1224. X            return;
  1225. X        }
  1226. X        (void) write (o,COM7HEAD,COM7LEN);
  1227. X        (void) write (o,"\n",1);
  1228. X        o0 = dup (0);
  1229. X        (void) close (0);
  1230. X        (void) dup (i);
  1231. X        (void) close (i);
  1232. X        o1 = dup (1); 
  1233. X        (void) close (1);
  1234. X        (void) dup (o);
  1235. X        pid = _exec (encode);
  1236. X        (void) close (1); 
  1237. X        (void) dup (o1);
  1238. X        (void) close (0); 
  1239. X        (void) dup (o0);
  1240. X        if (pid < 0) {
  1241. X            (void) fprintf (stderr,"Can't fork '%s' (errno = %d)\n",encode,errno);
  1242. X            error = TRUE;
  1243. X        }
  1244. X        while (((t = wait (&status)) != pid) && (t != -1))
  1245. X            ;
  1246. X        if (status) {
  1247. X            (void) fprintf (stderr,"'%s' retuns %d (errno = %d)\n",encode,status,errno);
  1248. X            error = TRUE;
  1249. X        }
  1250. X        (void) unlink (tmp);
  1251. X        (void) lseek (o,0,0);
  1252. X        send_file (sys,o);
  1253. X        (void) unlink (tmp2);
  1254. X    }
  1255. X    if (!access (tmp,0))
  1256. X        (void) unlink (tmp);
  1257. X}
  1258. __END__OF__THIS__FILE__
  1259. if test -f 'SBATCH/conv.c' ; then
  1260.   echo 'File SBATCH/conv.c already exists, overwriting it'
  1261.   del 'SBATCH/conv.c'
  1262. fi
  1263. echo Extracting \"'SBATCH/conv.c'\"
  1264. sed "s/^X//" >'SBATCH/conv.c' <<'__END__OF__THIS__FILE__'
  1265. X/*
  1266. X * $Log:    conv.c_v $
  1267. X * Revision 1.1  90/08/31  15:41:09  ud
  1268. X * Initial revision
  1269. X * 
  1270. X */
  1271. X# ifndef    LINT
  1272. Xstatic char rcsid[] = "$Id: conv.c_v 1.1 90/08/31 15:41:09 ud Exp $";
  1273. X# endif        LINT
  1274. X# include    <stdio.h>
  1275. X# include    <c8type.h>
  1276. X# include    <types.h>
  1277. X# include    <modes.h>
  1278. X# include    "sbatch.h"
  1279. X
  1280. Xextern char    *strdup ();
  1281. X
  1282. Xstatic char    *ext_tab[256];
  1283. X
  1284. Xchar *
  1285. Xconv_8bit (ofn)
  1286. Xchar *ofn;
  1287. X{
  1288. X    static char    tmpfn[40 + sizeof (TEMPDIR)];
  1289. X    FILE        *ifp, *ofp;
  1290. X    int        fd;
  1291. X    int        siz;
  1292. X    char        buf[258];
  1293. X    int        rconv;
  1294. X    int        sizlimit;
  1295. X    register char    *text;
  1296. X    register int    n, t;
  1297. X    register char    *ptr;
  1298. X
  1299. X    sprintf (tmpfn, "%s/convXXXXXX", TEMPDIR);
  1300. X    mktemp (tmpfn);
  1301. X    rconv = convmode;
  1302. X    sizlimit = maxartsiz;
  1303. X    if (index (ofn, '|')) {
  1304. X        while (*ofn != '|')
  1305. X            switch (to8lower (*ofn++)) {
  1306. X                case 'n':
  1307. X                    rconv = FALSE;
  1308. X                    break;
  1309. X                case 'c':
  1310. X                    rconv = TRUE;
  1311. X                    break;
  1312. X                case 's':
  1313. X                    sizlimit = atoi (*ofn == '=' ? ofn + 1 : ofn) << 10;
  1314. X                    break;
  1315. X            }
  1316. X            while ((*ofn != '|') && (*ofn != ','))
  1317. X                ++ofn;
  1318. X        ++ofn;
  1319. X    }
  1320. X    if (! (ifp = fopen (ofn, "r"))) {
  1321. X        fprintf (stderr, "Can't open %s\n", ofn);
  1322. X        return (NULL);
  1323. X    }
  1324. X    if ((siz = _gs_size (fileno (ifp))) < 0)
  1325. X        siz = 4096;
  1326. X    if ((sizlimit != -1) && (siz > sizlimit)) {
  1327. X        fprintf (stderr, "File exceeds limit of %d kByte (article %s has %d kBytes)\n",
  1328. X            (sizlimit >> 10) + 1, ofn, (siz >> 10) + 1);
  1329. X        fclose (ifp);
  1330. X        return (NULL);
  1331. X    }
  1332. X    if ((fd = create (tmpfn, S_IWRITE | S_ISIZE, 03, siz)) != -1) {
  1333. X        if (! (ofp = fdopen (fd, "w")))
  1334. X            close (fd);
  1335. X    } else
  1336. X        ofp = NULL;
  1337. X    if (! ofp) {
  1338. X        fprintf (stderr, "Can't create tempfile %s\n", tmpfn);
  1339. X        fclose (ifp);
  1340. X        return (NULL);
  1341. X    }
  1342. X    while (fgets (buf, 256, ifp)) {
  1343. X        n = strlen (buf);
  1344. X        if (rconv) {
  1345. X            ptr = buf;
  1346. X            t = n;
  1347. X            while (t-- > 0)
  1348. X                if (!(text = ext_tab[((unsigned char) *ptr++)]))
  1349. X                    putc (*(ptr - 1), ofp);
  1350. X                else
  1351. X                    fputs (text, ofp);
  1352. X        } else
  1353. X            fputs (buf, ofp);
  1354. X    }
  1355. X    fclose (ifp);
  1356. X    fclose (ofp);
  1357. X    return (tmpfn);
  1358. X}
  1359. X
  1360. Xstatic char *
  1361. Xget_tab (s, c)
  1362. Xchar *s;
  1363. Xunsigned char *c;
  1364. X{
  1365. X    char    *ptr;
  1366. X
  1367. X    ptr = s;
  1368. X    while (*s && (!is8space (*s)))
  1369. X        ++s;
  1370. X    if (!*s)
  1371. X        return (NULL);
  1372. X    *s++ = '\0';
  1373. X    while (is8space (*s))
  1374. X        ++s;
  1375. X    if (*s == '\\')
  1376. X        ++s;
  1377. X    *c = 0;
  1378. X    switch (*ptr) {
  1379. X        case '#':
  1380. X            ++ptr;
  1381. X            /* Fall through ... */
  1382. X        case '1': case '2': case '3': case '4': case '5':
  1383. X        case '6': case '7': case '8': case '9':
  1384. X            while (*ptr && index ("0123456789", *ptr)) {
  1385. X                *c *= 10;
  1386. X                *c += *ptr++ - '0';
  1387. X            }
  1388. X            break;
  1389. X        case '0':
  1390. X            ++ptr;
  1391. X            if (*ptr != 'x') {
  1392. X                while (*ptr && index ("01234567", *ptr)) {
  1393. X                    *c *= 8;
  1394. X                    *c += *ptr++ - '0';
  1395. X                }
  1396. X                break;
  1397. X            }
  1398. X            /* Fall through ... */
  1399. X        case '$':
  1400. X            ++ptr;
  1401. X            while (*ptr && index ("01234567890abcdefABCDEF", *ptr)) {
  1402. X                *c *= 16;
  1403. X                *c += (((*ptr >= '0' && *ptr <= '9')) ? (*ptr - '0') :
  1404. X                      (((*ptr >= 'a' && *ptr <= 'f')) ? (*ptr - 'a' + 10) :
  1405. X                      (*ptr - 'A' + 10)));
  1406. X                ++ptr;
  1407. X            }
  1408. X            break;
  1409. X        case '\\':
  1410. X            ++ptr;
  1411. X            /* Fall through ... */
  1412. X        default:
  1413. X            *c = *ptr;
  1414. X            break;
  1415. X    }
  1416. X    return (s);
  1417. X}
  1418. X
  1419. Xvoid
  1420. Xsetup_8bit ()
  1421. X{
  1422. X    register int    t;
  1423. X    char        *buf;
  1424. X    int        fd, n;
  1425. X    char        *ptr;
  1426. X    unsigned char    c;
  1427. X
  1428. X    for (t = 0; t < 256; ++t)
  1429. X        ext_tab[t] = NULL;
  1430. X    if (!(buf = malloc (strlen (newslib) + 64)))
  1431. X        exit (_errmsg (1, "Can't alloc in setup_8bit for buffer.\n"));
  1432. X    sprintf (buf, "%s/%s", newslib, EXT_TAB);
  1433. X    if ((fd = open (buf, S_IREAD)) != -1) {
  1434. X        while ((n = readln (fd, buf, 64)) > 0) {
  1435. X            if ((n == 1) || (buf[0] == '#'))
  1436. X                continue;
  1437. X            buf[n - 1] = '\0';
  1438. X            if (ptr = get_tab (buf, &c))
  1439. X                if (!(ext_tab[c] = strdup (ptr)))
  1440. X                    exit (_errmsg (1, "Can't alloc for conv-table.\n"));
  1441. X        }
  1442. X        close (fd);
  1443. X    }
  1444. X    free (buf);
  1445. X}
  1446. __END__OF__THIS__FILE__
  1447. if test -f 'SBATCH/exec.c' ; then
  1448.   echo 'File SBATCH/exec.c already exists, overwriting it'
  1449.   del 'SBATCH/exec.c'
  1450. fi
  1451. echo Extracting \"'SBATCH/exec.c'\"
  1452. sed "s/^X//" >'SBATCH/exec.c' <<'__END__OF__THIS__FILE__'
  1453. X/*
  1454. X * $Log:    exec.c_v $
  1455. X * Revision 1.1  90/08/31  15:40:25  ud
  1456. X * Initial revision
  1457. X * 
  1458. X */
  1459. X# ifndef    LINT
  1460. Xstatic char rcsid[] = "$Id: exec.c_v 1.1 90/08/31 15:40:25 ud Exp $";
  1461. X# endif        LINT
  1462. X# include <stdio.h>
  1463. X# include "sbatch.h"
  1464. X
  1465. Xextern void    free ();
  1466. Xextern char    *malloc ();
  1467. Xextern char    *findmod ();
  1468. Xextern char    *strcpy ();
  1469. X
  1470. Xint
  1471. X_exec (lcmd)
  1472. Xchar *lcmd;
  1473. X{
  1474. X    char        **arg;
  1475. X    int        pid, t;
  1476. X    register char    *x;
  1477. X    char        *cmd;
  1478. X    
  1479. X    if ((cmd = malloc ((unsigned int) (strlen (lcmd) + 5))) == (char *) NULL) {
  1480. X        (void) fprintf (stderr,"Can't malloc (errno = %d)\n",errno);
  1481. X        error = TRUE;
  1482. X        return (-1);
  1483. X    }
  1484. X    (void) strcpy (cmd, lcmd);
  1485. X    if (getargs (cmd, &arg) <= 0) {
  1486. X        fprintf (stderr, "Can't split off %s\n", cmd);
  1487. X        error = TRUE;
  1488. X        return (-1);
  1489. X    }
  1490. X    pid = os9exec (os9forkc,findmod (arg[0], arg[0]),arg,environ,0,0,3);
  1491. X    free (cmd);
  1492. X    free ((char *) arg);
  1493. X    return (pid);
  1494. X}
  1495. __END__OF__THIS__FILE__
  1496. if test -f 'SBATCH/file.c' ; then
  1497.   echo 'File SBATCH/file.c already exists, overwriting it'
  1498.   del 'SBATCH/file.c'
  1499. fi
  1500. echo Extracting \"'SBATCH/file.c'\"
  1501. sed "s/^X//" >'SBATCH/file.c' <<'__END__OF__THIS__FILE__'
  1502. X/*
  1503. X * $Log:    file.c_v $
  1504. X * Revision 1.1  90/08/31  15:40:22  ud
  1505. X * Initial revision
  1506. X * 
  1507. X */
  1508. X# ifndef    LINT
  1509. Xstatic char rcsid[] = "$Id: file.c_v 1.1 90/08/31 15:40:22 ud Exp $";
  1510. X# endif        LINT
  1511. X# include <stdio.h>
  1512. X# include "sbatch.h"
  1513. X
  1514. Xextern void    free ();
  1515. Xextern char    *index ();
  1516. X
  1517. Xint
  1518. Xexec_xmit (sys)
  1519. Xchar *sys;
  1520. X{
  1521. X    char        *cmd;
  1522. X    int        pid;
  1523. X    register char    *p1, *p2, *p3;
  1524. X    int        siz;
  1525. X    int        t;
  1526. X
  1527. X    for (t = 0; t < 2; ++t) {
  1528. X        if (!t) {
  1529. X            siz = 0;
  1530. X            p1 = command;
  1531. X        } else {
  1532. X            if (!(cmd = malloc (siz + 32)))
  1533. X                return (-1);
  1534. X            p1 = command;
  1535. X            p2 = cmd;
  1536. X        }
  1537. X        while (*p1)
  1538. X            if (*p1 == '%') {
  1539. X                ++p1;
  1540. X                switch (*p1) {
  1541. X                    case 'G':
  1542. X                        if (!t)
  1543. X                            ++siz;
  1544. X                        else {
  1545. X                            if (grade)
  1546. X                                *p2++ = grade;
  1547. X                            else
  1548. X                                *p2++ = DEF_GRADE;
  1549. X                        }
  1550. X                        ++p1;
  1551. X                        break;
  1552. X                    case 'S':
  1553. X                        if (!t)
  1554. X                            siz += strlen (sys);
  1555. X                        else {
  1556. X                            p3 = sys;
  1557. X                            while (*p3)
  1558. X                                *p2++ = *p3++;
  1559. X                        }
  1560. X                        ++p1;
  1561. X                        break;
  1562. X                    default:
  1563. X                        if (!t)
  1564. X                            siz += 2;
  1565. X                        else {
  1566. X                            *p2++ = '%';
  1567. X                            *p2++ = *p1;
  1568. X                        }
  1569. X                        ++p1;
  1570. X                        break;
  1571. X                }
  1572. X            } else {
  1573. X                if (!t)
  1574. X                    ++siz, ++p1;
  1575. X                else
  1576. X                    *p2++ = *p1++;
  1577. X            }
  1578. X    }
  1579. X    *p2 = '\0';
  1580. X    pid = _exec (cmd);
  1581. X    free (cmd);
  1582. X    return (pid);
  1583. X}
  1584. X
  1585. Xvoid
  1586. Xsend_file (sys,fd)
  1587. Xchar *sys;
  1588. Xint fd;
  1589. X{
  1590. X    int old0;
  1591. X    int pid,status,ret;
  1592. X
  1593. X    fprintf (stderr, "Sending %d bytes\n", _gs_size (fd));
  1594. X    old0 = dup (0);
  1595. X    (void) close (0);
  1596. X    (void) dup (fd);
  1597. X    (void) close (fd);
  1598. X    pid = exec_xmit (sys);
  1599. X    if (pid < 0)
  1600. X        (void) fprintf (stderr,"Can't fork '%s' (errno = %d)\n",command,errno);
  1601. X    (void) close (0);
  1602. X    (void) dup (old0);
  1603. X    (void) close (old0);
  1604. X    if (pid < 0)
  1605. X        error = TRUE;
  1606. X    else
  1607. X        while (((ret = wait (&status)) != -1) && (ret != pid))
  1608. X            ;
  1609. X    if (status) {
  1610. X        (void) fprintf (stderr,"'%s' returns %d (errno = %d)\n",command,status,errno);
  1611. X        error = TRUE;
  1612. X    }
  1613. X}
  1614. __END__OF__THIS__FILE__
  1615. if test -f 'SBATCH/none.c' ; then
  1616.   echo 'File SBATCH/none.c already exists, overwriting it'
  1617.   del 'SBATCH/none.c'
  1618. fi
  1619. echo Extracting \"'SBATCH/none.c'\"
  1620. sed "s/^X//" >'SBATCH/none.c' <<'__END__OF__THIS__FILE__'
  1621. X/*
  1622. X * $Log:    none.c_v $
  1623. X * Revision 1.1  90/08/31  15:40:19  ud
  1624. X * Initial revision
  1625. X * 
  1626. X */
  1627. X# ifndef    LINT
  1628. Xstatic char rcsid[] = "$Id: none.c_v 1.1 90/08/31 15:40:19 ud Exp $";
  1629. X# endif        LINT
  1630. X# include <stdio.h>
  1631. X# include <modes.h>
  1632. X# include "sbatch.h"
  1633. X
  1634. Xextern void        free ();
  1635. Xextern char        *conv_8bit ();
  1636. Xextern char        *malloc ();
  1637. Xextern char        *strcat ();
  1638. Xextern char        *strcpy ();
  1639. X
  1640. Xint
  1641. Xsend_single (fd, sys)
  1642. Xint fd;
  1643. Xchar *sys;
  1644. X{
  1645. X    int    i,old0,t,status,pid;
  1646. X    int    n;
  1647. X    char    *fn;
  1648. X
  1649. X    while ((n = readln (fd, buffer, 500)) > 0) {
  1650. X        buffer[n-1] = '\0';
  1651. X        if (!(fn = conv_8bit (buffer)))
  1652. X            continue;
  1653. X        if ((i = open (fn,  S_IREAD)) < 0)
  1654. X            continue;
  1655. X        old0 = dup (0); 
  1656. X        (void) close (0);
  1657. X        (void) dup (i);
  1658. X        (void) close (i);
  1659. X        if ((pid = exec_xmit (sys)) < 0) {
  1660. X            (void) fprintf (stderr,"Can't fork '%s' (errno = %d)\n",command,errno);
  1661. X            error = TRUE;
  1662. X        } else {
  1663. X            while (((t = wait (&status)) != pid) && (t != -1))
  1664. X                ;
  1665. X            if (status) {
  1666. X                (void) fprintf (stderr,"'%s' returns %d (errno = %d)\n",command,status,errno);
  1667. X                error = TRUE;
  1668. X            }
  1669. X        }
  1670. X        (void) close (0);
  1671. X        (void) dup (old0);
  1672. X        (void) close (old0);
  1673. X        unlink (fn);
  1674. X    }
  1675. X    return (0);
  1676. X}
  1677. __END__OF__THIS__FILE__
  1678. if test -f 'SBATCH/sbatch.c' ; then
  1679.   echo 'File SBATCH/sbatch.c already exists, overwriting it'
  1680.   del 'SBATCH/sbatch.c'
  1681. fi
  1682. echo Extracting \"'SBATCH/sbatch.c'\"
  1683. sed "s/^X//" >'SBATCH/sbatch.c' <<'__END__OF__THIS__FILE__'
  1684. X/*
  1685. X * $Log:    sbatch.c_v $
  1686. X * Revision 1.1  90/08/31  15:40:05  ud
  1687. X * Initial revision
  1688. X * 
  1689. X */
  1690. X# ifndef    LINT
  1691. Xstatic char rcsid[] = "$Id: sbatch.c_v 1.1 90/08/31 15:40:05 ud Exp $";
  1692. Xstatic char copyright[] = "Copyright (C) 1989, 1990 by Ulrich Dessauer, Germering, Germany.\n";
  1693. X# endif        LINT
  1694. X# include <stdio.h>
  1695. X# include <c8type.h>
  1696. X# include <modes.h>
  1697. X# define EXTERN
  1698. X# include "sbatch.h"
  1699. X
  1700. Xextern char        *info_str ();
  1701. Xextern char        *malloc ();
  1702. Xextern char        *rindex ();
  1703. Xextern char        *strcpy ();
  1704. Xextern char        *strdup ();
  1705. X
  1706. Xvoid            get_info ();
  1707. X
  1708. Xchar *help[] = {
  1709. X    "Syntax: sbatch [<opts>] <system> [<opts>]\n",
  1710. X    "Function: sends spoolt newsarticle to <system>\n",
  1711. X    "Options:\n",
  1712. X    "     -c         Send articles compressed\n",
  1713. X    "     -c7        Send articles compressed and encoded\n",
  1714. X    "     -cf        Use freeze as the compression program\n",
  1715. X    "     -cf7       Like c7 but use freeze\n",
  1716. X    "     -B=<bits>  Number of bits for compress (12 - 16)\n",
  1717. X    "     -G=<grade> A grading character for the transport mechanism\n",
  1718. X    "     -b         Send articles batched (default)\n",
  1719. X    "     -s         Send articles as single files\n",
  1720. X    "     -C=<cmd>   command to be used when sending articles\n",
  1721. X    "     -f=<nr>    sets the maximum spoolfile size to <nr> kByte\n",
  1722. X    "     -a=<nr>    sets the maximum size of a single article to <nr> kByte\n",
  1723. X    "     -n=<sys>   if systemname for command differs from systemname in filename\n",
  1724. X    "     -t         transform 8 bit characters into equivalent 7 bit replacements\n",
  1725. X    NULL
  1726. X};
  1727. X
  1728. Xstatic void
  1729. Xusage ()
  1730. X{
  1731. X    int t;
  1732. X    
  1733. X    for (t=0;help[t];++t)
  1734. X        (void) fputs (help[t],stderr);
  1735. X}
  1736. X
  1737. Xstatic int
  1738. Xhand (sig)
  1739. Xint sig;
  1740. X{
  1741. X    ++error;
  1742. X}
  1743. X
  1744. Xint
  1745. Xmain (argc,argv)
  1746. Xint argc;
  1747. Xchar *argv[];
  1748. X{
  1749. X    register char    *ptr;
  1750. X    int        mode;
  1751. X    int        freeze_it;
  1752. X    char        *system;
  1753. X    char        *sysfn;
  1754. X    char        *x;
  1755. X    int        t, u, st;
  1756. X    char         *spfn;
  1757. X    int        fd;
  1758. X    char        batchtmp[40 + sizeof (BATCH_TMP)];
  1759. X
  1760. X    setuid (getmuid ());
  1761. X    system = NULL;
  1762. X    sysfn = NULL;
  1763. X    mode = BATCH;
  1764. X    command = NULL;
  1765. X    maxsiz = DEF_MAXSIZ;
  1766. X    maxartsiz = DEF_MAXARTSIZ;
  1767. X    bitsize = DEF_BITSIZE;
  1768. X    grade = DEF_GRADE;
  1769. X    convmode = FALSE;
  1770. X    error = FALSE;
  1771. X    intercept (hand);
  1772. X    for (t=1;t<argc;++t)
  1773. X        if (*argv[t] == '-') {
  1774. X            x = argv[t] + 1;
  1775. X            while (*x) {
  1776. X                switch (*x) {
  1777. X                    case 'b':
  1778. X                        ++x;
  1779. X                        mode = BATCH;
  1780. X                        break;
  1781. X                    case 'c':
  1782. X                        ++x;
  1783. X                        if (*x == 'f') {
  1784. X                            freeze_it = TRUE;
  1785. X                            ++x;
  1786. X                        } else
  1787. X                            freeze_it = FALSE;
  1788. X                        if (*x == '7') {
  1789. X                            mode = freeze_it ? FRE7 : COM7;
  1790. X                            ++x;
  1791. X                        } else
  1792. X                            mode = freeze_it ? FRE : COM;
  1793. X                        break;
  1794. X                    case 's':
  1795. X                        ++x;
  1796. X                        mode = NONE;
  1797. X                        break;
  1798. X                    case 'f':
  1799. X                        x += (*(x+1) == '=') ? 2 : 1;
  1800. X                        /* in kByte, so mult with  1024 */
  1801. X                        maxsiz = atoi (x) << 10;
  1802. X                        while (*x)
  1803. X                            ++x;
  1804. X                        break;
  1805. X                    case 'a':
  1806. X                        x += (*(x+1) == '=') ? 2 : 1;
  1807. X                        maxartsiz = atoi (x) << 10;
  1808. X                        while (*x)
  1809. X                            ++x;
  1810. X                        break;
  1811. X                    case 'B':
  1812. X                        x += (*(x+1) == '=') ? 2 : 1;
  1813. X                        u = atoi (x);
  1814. X                        if ((u >= 12) && (u <= 16))
  1815. X                            bitsize = u;
  1816. X                        while (*x)
  1817. X                            ++x;
  1818. X                        break;
  1819. X                    case 'G':
  1820. X                        x += (*(x+1) == '=') ? 2 : 1;
  1821. X                        grade = *x++;
  1822. X                        break;
  1823. X                    case 'C':
  1824. X                        x += (*(x+1) == '=') ? 2 : 1;
  1825. X                        command = x;
  1826. X                        while (*x)
  1827. X                            ++x;
  1828. X                        break;
  1829. X                    case 'n':
  1830. X                        x += (*(x+1) == '=') ? 2 : 1;
  1831. X                        sysfn = strdup (x);
  1832. X                        while (*x)
  1833. X                            ++x;
  1834. X                        break;
  1835. X                    case 't':
  1836. X                        ++x;
  1837. X                        convmode = TRUE;
  1838. X                        break;
  1839. X                    case '?':
  1840. X                    default:
  1841. X                        usage ();
  1842. X                        if (*x != '?')
  1843. X                            (void) fprintf (stderr,"Unknown Option '%c'\n",*x);
  1844. X                        exit (*x == '?');
  1845. X                        break;
  1846. X                }
  1847. X            }
  1848. X        } else
  1849. X            if (system)
  1850. X                exit (_errmsg (1,"Can't send to more than one system at a time\n"));
  1851. X            else
  1852. X                system = argv[t];
  1853. X    if (!system)
  1854. X        exit (_errmsg (1, "Missing system\n"));
  1855. X    get_info ();
  1856. X    setup_8bit ();
  1857. X    if (!command)
  1858. X        command = transport;
  1859. X    if (!sysfn)
  1860. X        if (!(sysfn = strdup (system)))
  1861. X            exit (_errmsg (1, "Can't alloc memory\n"));
  1862. X    ptr = sysfn;
  1863. X    while (*ptr)
  1864. X        if (is8ascii (*ptr) && is8alnum (*ptr))
  1865. X            ++ptr;
  1866. X        else
  1867. X            *ptr++ = '_';
  1868. X    if (!(spfn = malloc (strlen (batchdir) + 40)))
  1869. X        exit (_errmsg (1, "Can't alloc memory\n"));
  1870. X    sprintf (spfn, "%s/%s", batchdir, sysfn);
  1871. X    if (access (spfn, 0) < 0)
  1872. X        exit (_errmsg (0, "No aritcle spooled\n"));
  1873. X    if (chdir (newsdir) < 0)
  1874. X        exit (_errmsg (1, "Can't chdir to %s\n", newsdir));
  1875. X    sprintf (batchtmp, "%s.%d.%.24s", BATCH_TMP, getpid (), sysfn);
  1876. X    batchtmp[28] = '\0';
  1877. X# if    0
  1878. X    t = 20;
  1879. X    while (((st = info_lock (BATCHLOCK,-1)) < 0) && (t-- > 0))
  1880. X        (void) sleep (1);
  1881. X    if (st < 0)
  1882. X        exit (_errmsg (1,"Unable to lock '%s'\n", BATCHLOCK));
  1883. X# endif
  1884. X    error = rename (spfn, batchtmp);
  1885. X# if    0
  1886. X    info_unlock (BATCHLOCK);
  1887. X# endif
  1888. X    if (error)
  1889. X        exit (_errmsg (1, "Can't rename %s to %s\n", spfn, batchtmp));
  1890. X    fprintf (stderr, "Spooling news for %s\n", system);
  1891. X    sprintf (spfn, "%s/%s", batchdir, batchtmp);
  1892. X    if ((fd = open (spfn, S_IREAD)) < 0)
  1893. X        exit (_errmsg (1, "Can't open %s\n", spfn));
  1894. X    switch (mode) {
  1895. X        case NONE:
  1896. X            (void) send_single (fd, system);
  1897. X            break;
  1898. X        case BATCH:
  1899. X            send_batch (fd, system);
  1900. X            break;
  1901. X        case COM:
  1902. X        case FRE:
  1903. X            /* increase maxsiz by 80% */
  1904. X            maxsiz = (maxsiz * 180) / 100;
  1905. X            send_com (fd, system, mode);
  1906. X            break;
  1907. X        case COM7:
  1908. X        case FRE7:
  1909. X            /* increase maxsiz by 40% */
  1910. X            maxsiz = (maxsiz * 140) / 100;
  1911. X            send_com7 (fd, system, mode);
  1912. X            break;
  1913. X        default:
  1914. X            exit (_errmsg (1,"Unknown mode %d\n",mode));
  1915. X            break;
  1916. X    }
  1917. X    close (fd);
  1918. X    if (!error)
  1919. X        unlink (spfn);
  1920. X    else
  1921. X        rename (spfn, sysfn);
  1922. X    if (error)
  1923. X        (void) fprintf (stderr,"Error = %d\n",error);
  1924. X    exit (error);
  1925. X}
  1926. X
  1927. Xvoid
  1928. Xget_info ()
  1929. X{
  1930. X    char s[256];
  1931. X    
  1932. X    if ((info_str (COMPRESS,s,250) == (char *) NULL) || ((compress = malloc ((unsigned int) (strlen (s) + 10))) == (char *) NULL)) {
  1933. X        if (!(compress = malloc (sizeof (COMPRESS) + 10)))
  1934. X            exit (_errmsg (1, "Can't alloc memory.\n"));
  1935. X        strcpy (compress, COMPRESS);
  1936. X    } else
  1937. X        (void) strcpy (compress,s);
  1938. X    if (bitsize != DEF_BITSIZE) {
  1939. X        sprintf (s, "-b%d", bitsize);
  1940. X        strcat (compress, s);
  1941. X    }
  1942. X    if ((info_str (FREEZE,s,250) == (char *) NULL) || ((freeze = malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  1943. X        freeze = FREEZE;
  1944. X    else
  1945. X        (void) strcpy (freeze,s);
  1946. X    if ((info_str (ENCODE,s,250) == (char *) NULL) || ((encode = malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  1947. X        encode = ENCODE;
  1948. X    else
  1949. X        (void) strcpy (encode,s);
  1950. X    if ((info_str (TRANSPORT, s, 250) == (char *) NULL) || ((transport = malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  1951. X        transport = TRANSPORT_DFLT;
  1952. X    else
  1953. X        (void) strcpy (transport, s);
  1954. X    if ((info_str (BATCHDIR,s,250) == (char *) NULL) || ((batchdir = malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  1955. X        batchdir = DEF_BATCHDIR;
  1956. X    else
  1957. X        (void) strcpy (batchdir,s);
  1958. X    if ((info_str (NEWSDIR,s,250) == (char *) NULL) || ((newsdir = malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  1959. X        newsdir = DEF_NEWSDIR;
  1960. X    else
  1961. X        (void) strcpy (newsdir,s);
  1962. X    if ((info_str (LIBDIR,s,250) == (char *) NULL) || ((newslib = malloc ((unsigned int) (strlen (s) + 2))) == (char *) NULL))
  1963. X        newslib = DEF_LIBDIR;
  1964. X    else
  1965. X        (void) strcpy (newslib,s);
  1966. X}
  1967. __END__OF__THIS__FILE__
  1968. exit 0
  1969. : end of shell archive
  1970.  
  1971. -- 
  1972. Frank Kaefer # fkk@stasys.sta.sub.org # Starnberg, Germany
  1973.