home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume28 / tin / part09 < prev    next >
Text File  |  1992-02-23  |  52KB  |  2,320 lines
  1. Newsgroups: comp.sources.misc
  2. From: iain%estevax.uucp@unido.Informatik.Uni-Dortmund.DE (Iain Lea)
  3. Subject:  v28i053:  tin - threaded full screen newsreader v1.1, Part09/11
  4. Message-ID: <1992Feb18.043906.13394@sparky.imd.sterling.com>
  5. X-Md4-Signature: 4412c003d8f1c31d4771ca237c327ac6
  6. Date: Tue, 18 Feb 1992 04:39:06 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: iain%estevax.uucp@unido.Informatik.Uni-Dortmund.DE (Iain Lea)
  10. Posting-number: Volume 28, Issue 53
  11. Archive-name: tin/part09
  12. Environment: BSD, SCO, ISC, SUNOS, SYSVR3, SYSVR4, ULTRIX, XENIX
  13. Supersedes: tin: Volume 23, Issue 15-23
  14.  
  15. #!/bin/sh
  16. # this is tin.shar.09 (part 9 of tin1.1)
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file save.c continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 9; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping save.c'
  34. else
  35. echo 'x - continuing file save.c'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'save.c' &&
  37. X     */
  38. X    if (path[0] == '=') {
  39. X        return TRUE;
  40. X    }
  41. X
  42. X    /*
  43. X     * if ~/file expand (ie. /usr/homedir/file)
  44. X     */
  45. X    switch (path[0]) {
  46. X        case '~':
  47. X            my_strncpy (buf, path+1, LEN);
  48. X            sprintf (path, "%s%s", homedir, buf);
  49. X            break;
  50. X        case '+':
  51. X            my_strncpy (buf, path+1, LEN);
  52. #ifdef USE_LONG_FILENAMES 
  53. X            strcpy (group, glob_group);
  54. #else
  55. X            my_strncpy (group, glob_group, 14);
  56. #endif
  57. X            /*
  58. X             *  convert 1st letter to uppercase
  59. X             */
  60. X            if (group[0] >= 'a' && group[0] <= 'z') {
  61. X                group[0] = group[0] - 32;
  62. X            }
  63. X            sprintf (path, "%s/%s/%s", savedir, group, buf);
  64. X            break;
  65. X        case '$':
  66. X            for (i = 0 ; isalnum (path[i+1]) ; i++) {
  67. X                buf[i] = path[i+1];
  68. X            }
  69. X            buf[i] = '\0';
  70. X            if (buf[0] == '\0' || (env = getenv (buf)) == NULL ||
  71. X                (len = strlen (env)) == 0) {
  72. X            }
  73. X            sprintf (buf, "%s%s%s", env, (path[i+1] != '/' &&
  74. X                    env[len-1] != '/') ? "/" : "", &path[i+1]);
  75. X            strcpy (path, buf);
  76. X            break;
  77. X        case '/':
  78. X            break;
  79. X        case '.':
  80. X            error_message ("Cannot create %s", buf);
  81. X            return FALSE;
  82. X            /* NOTREACHED */
  83. X        default:
  84. X            sprintf (buf, "%s/%s", savedir, path);
  85. X            my_strncpy (path, buf, LEN);
  86. X            break;
  87. X    }
  88. X
  89. X    /*
  90. X     *  create any directories, otherwise check
  91. X     *  errno and give appropiate error message
  92. X     */
  93. X    len = (int) strlen (path);
  94. X    
  95. X    for (i=0, j=0 ; i < len ; i++, j++) {
  96. X        buf[j] = path[i];
  97. X        if (i+1 < len && path[i+1] == '/') {
  98. X            buf[j+1] = '\0';
  99. X            if (stat (buf, &st) == -1) {
  100. X                if (mkdir (buf, 0755) == -1) {
  101. X                    error_message ("Cannot create %s", buf);
  102. X                    return FALSE;
  103. X                }
  104. X            }
  105. X        }
  106. X    }
  107. X    return FALSE;
  108. }
  109. X
  110. X
  111. int create_sub_dir (i)
  112. X    int i;
  113. {
  114. X    char dir[LEN];
  115. X    struct stat st;
  116. X
  117. X    if (! save[i].is_mailbox && save[i].archive) {
  118. X        sprintf (dir, "%s/%s", save[i].dir, save[i].archive);
  119. X        if (stat (dir, &st) == -1) {
  120. X            mkdir (dir, 0755);
  121. X            return TRUE;
  122. X        }
  123. X        if ((st.st_mode & S_IFMT) == S_IFDIR) {
  124. X            return TRUE;
  125. X        } else {
  126. X            return FALSE;
  127. X        }
  128. X    }
  129. X    return FALSE;
  130. }
  131. X
  132. /*
  133. X *  add files to be saved to save array
  134. X */
  135. X
  136. void add_to_save_list (index, article, is_mailbox, path)
  137. X    int index;
  138. X    struct article_t *article;
  139. X    int is_mailbox;
  140. X    char *path;
  141. {
  142. X    char dir[LEN];
  143. X    char file[LEN];
  144. X    int i;
  145. X    
  146. X    dir[0] = '\0';
  147. X    file[0] = '\0';
  148. X
  149. X    if (save_num == max_save-1) {
  150. X        expand_save ();
  151. X    }
  152. X
  153. X    save[save_num].index   = index;
  154. X    save[save_num].saved   = FALSE;
  155. X    save[save_num].is_mailbox = is_mailbox;
  156. X    save[save_num].dir     = (char *) 0;
  157. X    save[save_num].file    = (char *) 0;
  158. X    save[save_num].archive = (char *) 0;
  159. X    save[save_num].part    = (char *) 0;
  160. X    save[save_num].patch   = (char *) 0;
  161. X
  162. X    save[save_num].subject = str_dup (article->subject);
  163. X    if (article->archive) {
  164. X        save[save_num].archive = str_dup (article->archive);
  165. X    }
  166. X    if (article->part) {
  167. X        save[save_num].part = str_dup (article->part);
  168. X    }
  169. X    if (article->patch) {
  170. X        save[save_num].patch = str_dup (article->patch);
  171. X    }
  172. X
  173. X    if (is_mailbox) {
  174. X        if ((int) strlen (path) > 1) {
  175. X            if (path[0] == '=') {
  176. X                strcpy (file, path+1);
  177. X            } else {
  178. X                strcpy (file, path);
  179. X            }
  180. X        } else {
  181. X            strcpy (file, glob_group);
  182. X        }
  183. X        save[save_num].dir = str_dup (maildir);
  184. X        save[save_num].file = str_dup (file);
  185. X    } else {
  186. X        if (path[0]) {
  187. X            for (i=strlen (path) ; i ; i--) {
  188. X                if (path[i] == '/') {
  189. X                    strncpy (dir, path, i);
  190. X                    dir[i] = '\0';
  191. X                    strcpy (file, path+i+1);
  192. X                    break;
  193. X                }
  194. X            }
  195. X        }
  196. X        
  197. X        if (dir[0]) {
  198. X            save[save_num].dir = str_dup (dir);
  199. X        } else {
  200. X            save[save_num].dir = str_dup (savedir);
  201. X        }
  202. X
  203. X        if (file[0]) {
  204. X            save[save_num].file = str_dup (file);
  205. X        } else {
  206. X            if (path[0]) {
  207. X                save[save_num].file = str_dup (path);
  208. X            } else {
  209. X                save[save_num].file = str_dup (save[save_num].archive);
  210. X            }
  211. X        }
  212. X    }
  213. X    save_num++;
  214. }
  215. X
  216. /*
  217. X *  print save array of files to be saved
  218. X */
  219. X
  220. void sort_save_list ()
  221. {
  222. X    qsort ((char *) save, save_num, sizeof (struct save_t), save_comp);
  223. }
  224. X
  225. /*
  226. X *  string comparison routine for the qsort()
  227. X *  ie. qsort(array, 5, 32, save_comp);
  228. X */
  229. X
  230. int save_comp (p1, p2)
  231. X    char *p1;
  232. X    char *p2;
  233. {
  234. X    struct save_t *s1 = (struct save_t *)p1;
  235. X    struct save_t *s2 = (struct save_t *)p2;
  236. X
  237. X    /* s1->subject less than s2->subject */
  238. X    if (strcmp (s1->subject, s2->subject) < 0) {
  239. X        return -1;
  240. X    }
  241. X    /* s1->subject greater than s2->subject */
  242. X    if (strcmp (s1->subject, s2->subject) > 0) {
  243. X        return 1;
  244. X    }
  245. X    return 0;
  246. }
  247. X
  248. X
  249. char *save_filename (i)
  250. X    int i;
  251. {
  252. X    char *filename;
  253. X
  254. X    filename = (char *) my_malloc (LEN);
  255. X
  256. X    if (save[i].is_mailbox) {
  257. X        sprintf (filename, "%s/%s", save[i].dir, save[i].file);
  258. X        return (filename);
  259. X    }
  260. X    
  261. X    if (! save_separate || ! save_archive_name || (! save[i].part && ! save[i].patch)) {
  262. X        if (! save_separate || save_num == 1) {
  263. X            sprintf (filename, "%s/%s", save[i].dir, save[i].file);
  264. X        } else {
  265. X            sprintf (filename, "%s/%s.%02d", save[i].dir, save[i].file, i+1);
  266. X        }
  267. X    } else {
  268. X        if (save[i].part) {
  269. X            if (create_sub_dir (i)) {
  270. X                sprintf (filename, "%s/%s/%s.%s%s", save[i].dir, save[i].archive, save[i].archive, LONG_PATH_PART, save[i].part);
  271. X            } else {
  272. X                sprintf (filename, "%s/%s.%s%s", save[i].dir, save[i].archive, LONG_PATH_PART, save[i].part);
  273. X            }
  274. X        } else {
  275. X            if (save[i].patch) {
  276. X                if (create_sub_dir (i)) {
  277. X                    sprintf (filename, "%s/%s/%s.%s%s", save[i].dir, save[i].archive, save[i].archive, LONG_PATH_PATCH, save[i].patch);
  278. X                } else {
  279. X                    sprintf (filename, "%s/%s.%s%s", save[i].dir, save[i].archive, LONG_PATH_PATCH, save[i].patch);
  280. X                }
  281. X            } else {
  282. X                  sprintf (filename, "%s/%s", save[i].dir, save[i].file);
  283. X            }
  284. X        }
  285. X    }
  286. X
  287. X    return (filename);
  288. }
  289. X
  290. X
  291. char *get_first_savefile ()
  292. {
  293. X    char *file;
  294. X    int i;
  295. X
  296. X    for (i=0 ; i < save_num ; i++) {
  297. X        if (save[i].saved) {
  298. X            file = (char *) my_malloc (LEN);
  299. X            if (save[i].is_mailbox) {
  300. X                sprintf (file, "%s/%s", save[i].dir, save[i].file);
  301. X                return (file);
  302. X            } else {
  303. X                if (save[i].archive && save_archive_name) {
  304. X                    if (save[i].part) {
  305. X                        if (create_subdir) {
  306. X                            sprintf (file, "%s/%s.%s%s", save[i].archive, save[i].archive, LONG_PATH_PART, save[i].part);
  307. X                        } else {
  308. X                            sprintf (file, "%s.%s%s", save[i].archive, LONG_PATH_PART, save[i].part);
  309. X                        }
  310. X                    } else {
  311. X                        if (create_subdir) {
  312. X                            sprintf (file, "%s/%s.%s%s", save[i].archive, save[i].archive, LONG_PATH_PATCH, save[i].patch);
  313. X                        } else {
  314. X                            sprintf (file, "%s.%s%s", save[i].archive, LONG_PATH_PATCH, save[i].patch);
  315. X                        }
  316. X                    }
  317. X                } else {
  318. X                    if (! save_separate || save_num == 1) {
  319. X                        sprintf (file, "%s", save[i].file);
  320. X                    } else {
  321. X                        sprintf (file, "%s.%02d", save[i].file, i+1);
  322. X                    }
  323. X                }
  324. X                return (file);
  325. X            }
  326. X        }
  327. X    }
  328. X    return ((char *) 0);
  329. }
  330. X
  331. X
  332. char *get_last_savefile ()
  333. {
  334. X    char *file;
  335. X    int i;
  336. X    
  337. X    for (i=save_num-1 ; i >= 0 ; i--) {
  338. X        if (save[i].saved) {
  339. X            file = (char *) my_malloc (LEN);
  340. X            if (save[i].is_mailbox) {
  341. X                sprintf (file, "%s/%s", save[i].dir, save[i].file);
  342. X                return (file);
  343. X            } else {
  344. X                if (save[i].archive && save_archive_name) {
  345. X                    if (save[i].part) {
  346. X                        if (create_subdir) {
  347. X                            sprintf (file, "%s/%s.%s%s", save[i].archive, save[i].archive, LONG_PATH_PART, save[i].part);
  348. X                        } else {
  349. X                            sprintf (file, "%s.%s%s", save[i].archive, LONG_PATH_PART, save[i].part);
  350. X                        }
  351. X                    } else {
  352. X                        if (create_subdir) {
  353. X                            sprintf (file, "%s/%s.%s%s", save[i].archive, save[i].archive, LONG_PATH_PATCH, save[i].patch);
  354. X                        } else {
  355. X                            sprintf (file, "%s.%s%s", save[i].archive, LONG_PATH_PATCH, save[i].patch);
  356. X                        }
  357. X                    }
  358. X                } else {
  359. X                    if (! save_separate || save_num == 1) {
  360. X                        sprintf (file, "%s", save[i].file);
  361. X                    } else {
  362. X                        sprintf (file, "%s.%02d", save[i].file, i+1);
  363. X                    }
  364. X                }
  365. X                return (file);
  366. X            }
  367. X        }
  368. X    }
  369. X    return ((char *) 0);
  370. }
  371. X
  372. X
  373. int post_process_files (proc_type_ch)
  374. X    char proc_type_ch;
  375. {
  376. X    if (save_num) {
  377. X        wait_message (txt_post_processing);
  378. X
  379. X        set_real_uid_gid();
  380. X
  381. X        switch (proc_type_ch) {
  382. X            case 's':
  383. X                post_process_sh ();
  384. X                break;
  385. X                
  386. X            case 'u':
  387. X                post_process_uud (POST_PROC_UUDECODE);
  388. X                break;
  389. X
  390. X            case 'U':
  391. X                if (post_proc_type == POST_PROC_UUD_EXT_ZOO) {
  392. X                    post_process_uud (POST_PROC_UUD_EXT_ZOO);
  393. X                } else {
  394. X                    post_process_uud (POST_PROC_UUD_LST_ZOO);
  395. X                }
  396. X                break;
  397. X        }
  398. X
  399. X        info_message (txt_post_processing_finished);
  400. X        sleep (1);
  401. X        return TRUE;
  402. X    }
  403. X    return FALSE;
  404. }
  405. X
  406. X
  407. void post_process_uud (pp)
  408. X    int pp;
  409. {
  410. X    char s[LEN], t[LEN], u[LEN];
  411. X    char buf[LEN], *file;
  412. X    char file_out[LEN];
  413. X    char file_out_dir[LEN];
  414. X    FILE *fp_in, *fp_out;
  415. X    int i, state = INITIAL;
  416. X    int file_size = 0;
  417. X    struct stat st;
  418. X    
  419. X    t[0] = '\0';
  420. X    u[0] = '\0';
  421. X
  422. X    my_strncpy (file_out_dir, save_filename (0), LEN);
  423. X    for (i=strlen(file_out_dir) ; i > 0 ; i--) {
  424. X        if (file_out_dir[i] == '/') {
  425. X            file_out_dir[i] = '\0';
  426. X            break;
  427. X        }
  428. X    }
  429. X
  430. X    sprintf (file_out, "%s/tin.%05d", file_out_dir, getpid ());
  431. X    
  432. X    if ((fp_out = fopen (file_out, "a+")) == NULL) {
  433. X        error_message (txt_cannot_open, file_out);
  434. X    }
  435. X
  436. X
  437. X    for (i=0 ; i < save_num ; i++) {
  438. X        my_strncpy (buf, save_filename (i), LEN);
  439. X
  440. X        if ((fp_in = fopen (buf, "r")) != NULL) {
  441. X            if (fgets (s, sizeof s, fp_in) == NULL) {
  442. X                fclose (fp_in);
  443. X                continue;
  444. X            }
  445. X            while (state != END) { 
  446. X                switch (state) {
  447. X                    case INITIAL:
  448. X                        if (! strncmp ("begin", s, 5)) {
  449. X                            state = MIDDLE;
  450. X                            fprintf (fp_out, "%s", s);
  451. X                        }
  452. X                        break;
  453. X
  454. X                    case MIDDLE:
  455. X                        if (s[0] == 'M') {
  456. X                            fprintf (fp_out, "%s", s);
  457. X                        } else if (strncmp("end", s, 3)) {
  458. X                            state = OFF;
  459. X                        } else { /* end */
  460. X                            state = END;
  461. X                            if (u[0] != 'M') {
  462. X                                fprintf (fp_out, "%s", u);
  463. X                            }
  464. X                            if (t[0] != 'M') {
  465. X                                fprintf (fp_out, "%s", t);
  466. X                            }
  467. X                            fprintf (fp_out, "%s\n", s);
  468. X                        }
  469. X                        break;
  470. X
  471. X                    case OFF:
  472. X                        if ((s[0] == 'M') && (t[0] == 'M') && (u[0] == 'M')) {
  473. X                            fprintf (fp_out, "%s", u);
  474. X                            fprintf (fp_out, "%s", t);
  475. X                            fprintf (fp_out, "%s", s);
  476. X                            state = MIDDLE;
  477. X                        } else if (! strncmp ("end", s, 3)) {
  478. X                            state = END;
  479. X                            if (u[0] != 'M') {
  480. X                                fprintf (fp_out, "%s", u);
  481. X                            }
  482. X                            if (t[0] != 'M') {
  483. X                                fprintf (fp_out, "%s", t);
  484. X                            }
  485. X                            fprintf (fp_out, "%s\n", s);
  486. X                        }
  487. X                        break;
  488. X
  489. X                    case END:
  490. X                        break;
  491. X
  492. X                    default:
  493. X                        fprintf (stderr, "\r\nerror: ASSERT - default state\n");
  494. X                        fclose (fp_in);
  495. X                        fclose (fp_out);
  496. X                        unlink (file_out);
  497. X                        return;
  498. X                }
  499. X                strcpy (u,t);
  500. X                strcpy (t,s);
  501. X                /*
  502. X                 *  read next line & if error goto next file in save array
  503. X                 */
  504. X                if (fgets (s, sizeof s, fp_in) == NULL) {
  505. X                    break;
  506. X                }
  507. X            }
  508. X            fclose (fp_in);
  509. X        }
  510. X    }
  511. X    fclose (fp_out);
  512. X
  513. X    /*
  514. X     *  uudecode file
  515. X     */
  516. X    wait_message (txt_uudecoding);
  517. X    
  518. X    sprintf (buf, "cd %s; uudecode %s", file_out_dir, file_out); 
  519. X    if (invoke_cmd (buf)) {
  520. X        set_real_uid_gid ();
  521. X        /*
  522. X         *  sum file
  523. X         */
  524. X        if ((file = get_archive_file (file_out_dir, "*")) != NULL) { 
  525. X            sprintf (buf, "%s %s", DEFAULT_SUM, file); 
  526. X            printf ("\r\n\r\nChecksum of %s...\r\n\r\n", file); 
  527. X            fflush (stdout);
  528. X            if ((fp_in = popen (buf, "r")) == NULL) {
  529. X                printf ("Cannot execute %s\r\n", buf); 
  530. X                fflush (stdout);
  531. X            } else {
  532. X                if (stat (file, &st) != -1) {
  533. X                    file_size = (int) st.st_size;
  534. X                }
  535. X                if (fgets (buf, sizeof buf, fp_in) != NULL) {
  536. X                    buf[strlen (buf)-1] = '\0';
  537. X                }
  538. X                fclose (fp_in);
  539. X                printf ("%s  %8d bytes\r\n", buf, file_size); 
  540. X                fflush (stdout);
  541. X            }
  542. X            if (file != (char *) 0) {
  543. X                free (file);
  544. X                file = (char *) 0;
  545. X            }
  546. X        }
  547. X    }
  548. X
  549. X    set_real_uid_gid ();
  550. X
  551. X    if (pp > POST_PROC_UUDECODE) {
  552. X        sprintf (buf, "*.%s", archiver[pp].ext); 
  553. X        if ((file = get_archive_file (file_out_dir, buf)) != NULL) {
  554. X            if (pp == POST_PROC_UUD_EXT_ZOO) {
  555. X                sprintf (buf, "cd %s; %s %s %s", file_out_dir,
  556. X                    archiver[pp].name, archiver[pp].extract, file);
  557. X                printf ("\r\n\r\nListing %s archive...\r\n", file); 
  558. X            } else {
  559. X                sprintf (buf, "cd %s; %s %s %s", file_out_dir,
  560. X                    archiver[pp].name, archiver[pp].list, file);
  561. X                printf ("\r\n\r\nExtracting %s archive...\r\n", file);
  562. X            }
  563. X            fflush (stdout);
  564. X            if (file != (char *) 0) {
  565. X                free (file);
  566. X                file = (char *) 0;
  567. X            }
  568. X            if (! invoke_cmd (buf)) {
  569. X                set_real_uid_gid ();
  570. X                error_message ("Post processing failed", "");
  571. X            }
  572. X            set_real_uid_gid ();
  573. X        }
  574. X    }
  575. X    delete_processed_files ();
  576. X
  577. X    unlink (file_out);
  578. }
  579. X
  580. /*
  581. X *  Unpack /bin/sh archives
  582. X */
  583. X 
  584. void post_process_sh ()
  585. {
  586. X    char buf[LEN];
  587. X    char file_in[LEN];
  588. X    char file_out[LEN];
  589. X    char file_out_dir[LEN];
  590. X    char *ptr1, *ptr2;
  591. X    char sh_pattern_1[16];
  592. X    char sh_pattern_2[16];
  593. X    FILE *fp_in, *fp_out;
  594. X    int found_header;
  595. X    int i, j;
  596. X    int patlen1, patlen2;
  597. X
  598. X    strcpy (sh_pattern_1, "#! /bin/sh");
  599. X    strcpy (sh_pattern_2, "#!/bin/sh");
  600. X
  601. X    my_strncpy (file_out_dir, save_filename (0), LEN);
  602. X    for (i=strlen(file_out_dir) ; i > 0 ; i--) {
  603. X        if (file_out_dir[i] == '/') {
  604. X            file_out_dir[i] = '\0';
  605. X            break;
  606. X        }
  607. X    }
  608. X
  609. X    sprintf (file_out, "%s/tin.%05d", file_out_dir, getpid ());
  610. X
  611. X    for (j=0 ; j < save_num ; j++) {
  612. X        my_strncpy (file_in, save_filename (j), LEN);
  613. X
  614. X        printf ("\r\nExtracting %s...\r\n", file_in);
  615. X        fflush (stdout);
  616. X
  617. X        found_header = FALSE;
  618. X        
  619. X        if ((fp_out = fopen (file_out, "w")) != NULL) {
  620. X            if ((fp_in = fopen (file_in, "r")) != NULL) {
  621. X                ptr1 = sh_pattern_1;
  622. X                ptr2 = sh_pattern_2;
  623. X                patlen1 = strlen (sh_pattern_1);
  624. X                patlen2 = strlen (sh_pattern_2);
  625. X                while (! feof (fp_in)) {
  626. X                    if (fgets (buf, sizeof buf, fp_in)) {
  627. X                        /*
  628. X                         *  find #!/bin/sh or #! /bin/sh pattern
  629. X                         */
  630. X                        if (!found_header) {
  631. X                            if (str_str (buf, ptr1, patlen1) != 0 ||
  632. X                                str_str (buf, ptr2, patlen2) != 0) {
  633. X                                found_header = TRUE;
  634. X                            }
  635. X                        }
  636. X                    
  637. X                        /*
  638. X                         *  Write to temp file
  639. X                         */
  640. X                        if (found_header) {
  641. X                            fputs (buf, fp_out);
  642. X                        }
  643. X                    }
  644. X                }
  645. X                fclose (fp_in);
  646. X            }
  647. X            fclose (fp_out);
  648. X
  649. X            sprintf (buf, "cd %s; sh %s", file_out_dir, file_out); 
  650. X            printf ("\r\n");
  651. X            fflush (stdout);
  652. X            Raw (FALSE);
  653. X            invoke_cmd (buf);
  654. X            set_real_uid_gid ();
  655. X            Raw (TRUE);
  656. X            unlink (file_out);
  657. X        }
  658. X    }
  659. X    delete_processed_files ();
  660. }
  661. X
  662. X
  663. char *get_archive_file (dir, ext)
  664. X    char *dir;
  665. X    char *ext;
  666. {
  667. X    char buf[LEN];
  668. X    char *file = NULL;
  669. X    FILE *fp;
  670. X    
  671. X    sprintf (buf, "ls -t %s/%s", dir, ext);
  672. X
  673. X    if ((fp = popen (buf, "r")) == NULL) {
  674. X        return (char *) 0;
  675. X    }
  676. X
  677. X    if (fgets (buf, sizeof buf, fp) != NULL) {
  678. X        file = str_dup (buf);
  679. X        file[strlen (file)-1] = '\0';
  680. X    }
  681. X    
  682. X    fclose (fp);
  683. X
  684. X    return (file);
  685. }
  686. X
  687. X
  688. void delete_processed_files ()
  689. {
  690. X    int i;
  691. X
  692. X    printf ("\r\n");
  693. X    fflush (stdout);
  694. X    
  695. X    if (prompt_yn (LINES, "Delete saved files that have been post processed? (y/n): ", 'y')) {
  696. X        wait_message (txt_deleting);
  697. X
  698. X        for (i=0 ; i < save_num ; i++) {
  699. X            unlink (save_filename (i));
  700. X        }
  701. X    }
  702. }
  703. SHAR_EOF
  704. echo 'File save.c is complete' &&
  705. chmod 0600 save.c ||
  706. echo 'restore of save.c failed'
  707. Wc_c="`wc -c < 'save.c'`"
  708. test 24939 -eq "$Wc_c" ||
  709.     echo 'save.c: original size 24939, current size' "$Wc_c"
  710. rm -f _shar_wnt_.tmp
  711. fi
  712. # ============= screen.c ==============
  713. if test -f 'screen.c' -a X"$1" != X"-c"; then
  714.     echo 'x - skipping screen.c (File already exists)'
  715.     rm -f _shar_wnt_.tmp
  716. else
  717. > _shar_wnt_.tmp
  718. echo 'x - extracting screen.c (Text)'
  719. sed 's/^X//' << 'SHAR_EOF' > 'screen.c' &&
  720. /*
  721. X *  Project   : tin - a threaded Netnews reader
  722. X *  Module    : screen.c
  723. X *  Author    : R.Skrenta / I.Lea
  724. X *  Created   : 01-04-91
  725. X *  Updated   : 15-12-91
  726. X *  Notes     :
  727. X *  Copyright : (c) Copyright 1991-92 by Rich Skrenta & Iain Lea
  728. X *                You may  freely  copy or  redistribute  this software,
  729. X *              so  long as there is no profit made from its use, sale
  730. X *              trade or  reproduction.  You may not change this copy-
  731. X *              right notice, and it must be included in any copy made
  732. X */
  733. X
  734. #include    "tin.h"
  735. X
  736. extern int errno;
  737. X
  738. char msg[LEN];
  739. struct screen_t *screen;
  740. X
  741. X
  742. void info_message (str)
  743. X    char *str;
  744. {
  745. X    clear_message ();                /* Clear any old messages hanging around */
  746. X    center_line (LINES, FALSE, str);    /* center the message at screen bottom */
  747. X    if (! cmd_line) {
  748. X        MoveCursor (LINES, 0);
  749. X    }
  750. }
  751. X
  752. X
  753. void wait_message (str)
  754. X    char *str;
  755. {
  756. X    clear_message ();      /* Clear any old messages hanging around */
  757. X    printf ("%s", str);
  758. X    fflush (stdout);
  759. }
  760. X
  761. X
  762. void error_message (template, str)
  763. X    char *template;
  764. X    char *str;
  765. {
  766. X    errno = 0;
  767. X
  768. X    clear_message ();      /* Clear any old messages hanging around */
  769. X    
  770. X    fprintf (stderr, template, str);
  771. X    fflush (stderr);
  772. X
  773. X    if (cmd_line) {
  774. X        fprintf (stderr, "\n");
  775. X        fflush (stderr);
  776. X    } else {
  777. X        MoveCursor (LINES, 0);
  778. X        sleep (2);
  779. X    }
  780. }
  781. X
  782. X
  783. void clear_message ()
  784. {
  785. X    if (! cmd_line) {
  786. X        MoveCursor (LINES, 0);
  787. X        CleartoEOLN ();
  788. X    }
  789. }
  790. X
  791. X
  792. void center_line (line, inverse, str)
  793. X    int line;
  794. X    int inverse;
  795. X    char *str;
  796. {
  797. X    int pos;
  798. X
  799. X    if (! cmd_line) {
  800. X        pos = (COLS - (int) strlen (str)) / 2;
  801. X        MoveCursor (line, pos);
  802. X        if (inverse) {
  803. X            StartInverse ();
  804. X        }
  805. X    }
  806. X
  807. X    printf ("%s", str);
  808. X    fflush (stdout);
  809. X
  810. X    if (! cmd_line) {
  811. X        if (inverse) {
  812. X            EndInverse ();
  813. X        }
  814. X    }
  815. }
  816. X
  817. X
  818. void draw_arrow (line)
  819. X    int line;
  820. {
  821. X    MoveCursor (line, 0);
  822. X
  823. X    if (draw_arrow_mark) {
  824. X        printf ("->");
  825. X        fflush (stdout);
  826. X    } else {
  827. X        StartInverse ();
  828. X        printf ("%s", screen[line-INDEX_TOP].col);
  829. X        fflush (stdout);
  830. X        EndInverse ();
  831. X    }
  832. X    MoveCursor (LINES, 0);
  833. }
  834. X
  835. X
  836. void erase_arrow (line)
  837. X    int line;
  838. {
  839. X    MoveCursor (line, 0);
  840. X
  841. X    if (draw_arrow_mark) {
  842. X        printf ("  ");
  843. X    } else {
  844. X        EndInverse ();
  845. X        printf ("%s", screen[line-INDEX_TOP].col);
  846. X    }
  847. X    fflush (stdout);
  848. }
  849. X
  850. X
  851. void show_title (title)
  852. X    char *title;
  853. {    
  854. X    int col;
  855. X    
  856. X    col = (COLS - (int) strlen (txt_type_h_for_help))+1;
  857. X    if (col) {
  858. X        MoveCursor (0, 0);
  859. X        if (kill_articles) {        /* display KILL on screen */
  860. X            printf ("KILL ON");
  861. X        }
  862. X        
  863. X        MoveCursor (0, col);
  864. X        if (mail_check ()) {        /* you have mail message in */
  865. X            printf (txt_you_have_mail);
  866. X        } else {
  867. X            printf (txt_type_h_for_help);
  868. X        }
  869. X    }
  870. X    center_line (0, TRUE, title);
  871. }
  872. X
  873. X
  874. void ring_bell ()
  875. {
  876. X    fputc ('\007', stdout);
  877. X    fflush (stdout);
  878. }
  879. SHAR_EOF
  880. chmod 0600 screen.c ||
  881. echo 'restore of screen.c failed'
  882. Wc_c="`wc -c < 'screen.c'`"
  883. test 2661 -eq "$Wc_c" ||
  884.     echo 'screen.c: original size 2661, current size' "$Wc_c"
  885. rm -f _shar_wnt_.tmp
  886. fi
  887. # ============= search.c ==============
  888. if test -f 'search.c' -a X"$1" != X"-c"; then
  889.     echo 'x - skipping search.c (File already exists)'
  890.     rm -f _shar_wnt_.tmp
  891. else
  892. > _shar_wnt_.tmp
  893. echo 'x - extracting search.c (Text)'
  894. sed 's/^X//' << 'SHAR_EOF' > 'search.c' &&
  895. /*
  896. X *  Project   : tin - a threaded Netnews reader
  897. X *  Module    : search.c
  898. X *  Author    : R.Skrenta / I.Lea
  899. X *  Created   : 01-04-91
  900. X *  Updated   : 31-01-92
  901. X *  Notes     :
  902. X *  Copyright : (c) Copyright 1991-92 by Rich Skrenta & Iain Lea
  903. X *              You may  freely  copy or  redistribute  this software,
  904. X *              so  long as there is no profit made from its use, sale
  905. X *              trade or  reproduction.  You may not change this copy-
  906. X *              right notice, and it must be included in any copy made
  907. X */
  908. X
  909. #include    "tin.h"
  910. X
  911. extern FILE *note_fp;
  912. extern int cur_groupnum;
  913. extern int first_group_on_screen;
  914. extern int last_group_on_screen;
  915. extern int first_subj_on_screen;
  916. extern int last_subj_on_screen;
  917. extern int index_point;
  918. extern int note_line;
  919. extern int note_page;
  920. extern int note_end;
  921. extern long note_mark[MAX_PAGES];
  922. X
  923. /*
  924. X * last search patterns
  925. X */
  926. X
  927. char author_search_string[LEN];
  928. char group_search_string[LEN];
  929. char subject_search_string[LEN];
  930. char art_search_string[LEN];
  931. X
  932. X
  933. /*
  934. X *  group.c & page.c
  935. X */
  936. X 
  937. int search_author (max_art, current_art, forward)
  938. X    int max_art;
  939. X    int current_art;
  940. X    int forward;
  941. {
  942. X    char buf[LEN];
  943. X    char buf2[LEN];
  944. X    int i, patlen;
  945. X
  946. X    clear_message ();
  947. X
  948. X    if (forward) {
  949. X        sprintf (buf2, txt_author_search_forwards, author_search_string);
  950. X    } else {
  951. X        sprintf (buf2, txt_author_search_backwards, author_search_string);
  952. X    }
  953. X    
  954. X    if (! prompt_string (buf2, buf)) {
  955. X        return -1;
  956. X    }
  957. X    
  958. X    if (strlen (buf)) {
  959. X        strcpy (author_search_string, buf);
  960. X    } else {
  961. X        if (author_search_string[0]) {
  962. X            strcpy (buf, author_search_string);
  963. X        } else {
  964. X            info_message (txt_no_search_string);    
  965. X            return -1;
  966. X        }
  967. X    }
  968. X
  969. X    wait_message (txt_searching);
  970. X
  971. X    make_lower (author_search_string, buf);
  972. X
  973. X    patlen = strlen (author_search_string);
  974. X
  975. X    i = current_art;
  976. X
  977. X    do {
  978. X        if (forward) {
  979. X            i = next_response (i);
  980. X            if (i < 0)
  981. X                i = 0;
  982. X        } else {
  983. X            i = prev_response (i);
  984. X            if (i < 0)
  985. X                i = max_art - 1;
  986. X        }
  987. X
  988. X        if (arts[i].name == (char *) 0) {
  989. X            make_lower (arts[i].from, buf2);
  990. X        } else {
  991. X            sprintf (msg, "%s (%s)", arts[i].from, arts[i].name);
  992. X            make_lower (msg, buf2);
  993. X        }
  994. X
  995. X        if (str_str (buf2, buf, patlen) != 0) {
  996. X            clear_message ();
  997. X            return i;
  998. X        }
  999. X    } while (i != current_art);
  1000. X
  1001. X    info_message (txt_no_match);
  1002. X    return -1;
  1003. }
  1004. X
  1005. /*
  1006. X * select.c
  1007. X */
  1008. X 
  1009. void search_group (forward)
  1010. X    int forward;
  1011. {
  1012. X    char buf[LEN];
  1013. X    char buf2[LEN];
  1014. X    int i, patlen;
  1015. X
  1016. X    clear_message ();
  1017. X
  1018. X    if (forward) {
  1019. X        sprintf (buf2, txt_search_forwards, group_search_string);
  1020. X    } else {
  1021. X        sprintf (buf2, txt_search_backwards, group_search_string);
  1022. X    }
  1023. X
  1024. X    if (! prompt_string (buf2, buf)) {
  1025. X        return;
  1026. X    }
  1027. X
  1028. X    if (strlen (buf)) {
  1029. X        strcpy (group_search_string, buf);
  1030. X    } else {
  1031. X        if (group_search_string[0]) {
  1032. X            strcpy (buf, group_search_string);
  1033. X        } else {
  1034. X            info_message (txt_no_search_string);    
  1035. X            return;
  1036. X        }
  1037. X    }
  1038. X
  1039. X    wait_message (txt_searching);
  1040. X
  1041. X    make_lower (group_search_string, buf);
  1042. X
  1043. X    patlen = strlen (group_search_string);
  1044. X
  1045. X    i = cur_groupnum;
  1046. X
  1047. X    do {
  1048. X        if (forward)
  1049. X            i++;
  1050. X        else
  1051. X            i--;
  1052. X
  1053. X        if (i >= group_top)
  1054. X            i = 0;
  1055. X        if (i < 0)
  1056. X            i = group_top - 1;
  1057. X
  1058. X        make_lower (active[my_group[i]].name, buf2);
  1059. X
  1060. X        if (str_str (buf2, buf, patlen) != 0) {
  1061. X            if (i >= first_group_on_screen
  1062. X            &&  i < last_group_on_screen) {
  1063. X                clear_message ();
  1064. X                erase_group_arrow ();
  1065. X                cur_groupnum = i;
  1066. X                draw_group_arrow ();
  1067. X            } else {
  1068. X                cur_groupnum = i;
  1069. X                group_selection_page ();
  1070. X            }
  1071. X            return;
  1072. X        }
  1073. X    } while (i != cur_groupnum);
  1074. X
  1075. X    info_message (txt_no_match);
  1076. }
  1077. X
  1078. /*
  1079. X * group.c
  1080. X */
  1081. X
  1082. void search_subject (forward, group)
  1083. X    int forward;
  1084. X    char *group;
  1085. {
  1086. X    char buf[LEN];
  1087. X    char buf2[LEN];
  1088. X    int i, j, patlen;
  1089. X
  1090. X    if (index_point < 0) {
  1091. X        info_message (txt_no_arts);
  1092. X        return;
  1093. X    }
  1094. X    
  1095. X    clear_message ();
  1096. X
  1097. X    if (forward) {
  1098. X        sprintf (buf2, txt_search_forwards, subject_search_string);
  1099. X    } else {
  1100. X        sprintf (buf2, txt_search_backwards, subject_search_string);
  1101. X    }
  1102. X
  1103. X    if (! prompt_string (buf2, buf)) {
  1104. X        return;
  1105. X    }
  1106. X
  1107. X    if (strlen (buf)) {
  1108. X        strcpy (subject_search_string, buf);
  1109. X    } else {
  1110. X        if (subject_search_string[0]) {
  1111. X            strcpy (buf, subject_search_string);
  1112. X        } else {
  1113. X            info_message (txt_no_search_string);    
  1114. X            return;
  1115. X        }
  1116. X    }
  1117. X
  1118. X    wait_message (txt_searching);
  1119. X
  1120. X    make_lower (subject_search_string, buf);
  1121. X
  1122. X    patlen = strlen (subject_search_string);
  1123. X
  1124. X    i = index_point;
  1125. X
  1126. X    do {
  1127. X        if (forward)
  1128. X            i++;
  1129. X        else
  1130. X            i--;
  1131. X
  1132. X        if (i >= top_base)
  1133. X            i = 0;
  1134. X        if (i < 0)
  1135. X            i = top_base - 1;
  1136. X
  1137. X        j = (int) base[i];
  1138. X
  1139. X        make_lower (arts[j].subject, buf2);
  1140. X
  1141. X        if (str_str (buf2, buf, patlen) != 0) {
  1142. X            if (i >= first_subj_on_screen
  1143. X                &&  i < last_subj_on_screen) {
  1144. X                clear_message ();
  1145. X                erase_subject_arrow ();
  1146. X                index_point = i;
  1147. X                draw_subject_arrow ();
  1148. X            } else {
  1149. X                index_point = i;
  1150. X                show_group_page (group);
  1151. X            }
  1152. X            return;
  1153. X        }
  1154. X    } while (i != index_point);
  1155. X
  1156. X    info_message (txt_no_match);
  1157. }
  1158. X
  1159. /*
  1160. X *  page.c (search article body)
  1161. X */
  1162. X
  1163. int search_article (forward)
  1164. X    int forward;
  1165. {
  1166. X    char buf[LEN];
  1167. X    char buf2[LEN];
  1168. X    char string[LEN];
  1169. X    char pattern[LEN];
  1170. X    char *p, *q;
  1171. X    int ctrl_L;
  1172. X    int i, j, patlen;
  1173. X    int orig_note_end;
  1174. X    int orig_note_page;
  1175. X
  1176. X    clear_message ();
  1177. X
  1178. X    if (forward) {
  1179. X        sprintf (buf2, txt_search_forwards, art_search_string);
  1180. X    } else {
  1181. X        sprintf (buf2, txt_search_backwards, art_search_string);
  1182. X    }
  1183. X
  1184. X    if (! prompt_string (buf2, buf)) {
  1185. X        return FALSE;
  1186. X    }
  1187. X
  1188. X    if (strlen (buf)) {
  1189. X        strcpy (art_search_string, buf);
  1190. X    } else {
  1191. X        if (art_search_string[0]) {
  1192. X            strcpy (buf, art_search_string);
  1193. X        } else {
  1194. X            info_message (txt_no_search_string);    
  1195. X            return FALSE;
  1196. X        }
  1197. X    }
  1198. X
  1199. X    wait_message (txt_searching);
  1200. X    
  1201. X    make_lower (art_search_string, pattern);
  1202. X
  1203. X    patlen = strlen (art_search_string);
  1204. X
  1205. X    /*
  1206. X     *  save current position in article
  1207. X     */
  1208. X    orig_note_end = note_end;
  1209. X    orig_note_page = note_page;
  1210. X    
  1211. X    while (! note_end) {
  1212. X        note_line = 1;
  1213. X        ctrl_L = FALSE;
  1214. X
  1215. X        if (note_page == 0) {
  1216. X            note_line += 4;
  1217. X        } else {
  1218. X            note_line += 2;
  1219. X        }
  1220. X        while (note_line < LINES) {
  1221. X            if (fgets (buf, sizeof buf, note_fp) == NULL) {
  1222. X                note_end = TRUE;
  1223. X                break;
  1224. X            }
  1225. X            buf[LEN-1] = '\0';
  1226. X            for (p = buf, q = buf2;    *p && *p != '\n' && q<&buf2[LEN]; p++) {
  1227. X                if (*p == '\b' && q > buf2) {
  1228. X                    q--;
  1229. X                } else if (*p == '\f') {        /* ^L */
  1230. X                    *q++ = '^';
  1231. X                    *q++ = 'L';
  1232. X                    ctrl_L = TRUE;
  1233. X                } else if (*p == '\t') {
  1234. X                    i = q - buf2;
  1235. X                    j = (i|7) + 1;
  1236. X
  1237. X                    while (i++ < j) {
  1238. X                        *q++ = ' ';
  1239. X                    }
  1240. X                } else if (((*p) & 0xFF) < ' ') {
  1241. X                    *q++ = '^';
  1242. X                    *q++ = ((*p) & 0xFF) + '@';
  1243. X                } else {
  1244. X                    *q++ = *p;
  1245. X                }
  1246. X            }
  1247. X            *q = '\0';
  1248. X
  1249. X            make_lower (buf2, string);
  1250. X
  1251. X            if (str_str (string, pattern, patlen) != 0) {
  1252. X                fseek (note_fp, note_mark[note_page], 0);
  1253. X                return TRUE;
  1254. X            }
  1255. X
  1256. X            note_line += ((int) strlen(buf2) / COLS) + 1;
  1257. X
  1258. X            if (ctrl_L) {
  1259. X                break;
  1260. X            }
  1261. X        }
  1262. X        if (! note_end) {
  1263. X            note_mark[++note_page] = ftell (note_fp);
  1264. X        }
  1265. X    }
  1266. X
  1267. X    note_end = orig_note_end;
  1268. X    note_page = orig_note_page;
  1269. X    fseek (note_fp, note_mark[note_page], 0);
  1270. X    info_message (txt_no_match);
  1271. X    return FALSE;
  1272. }
  1273. X
  1274. X
  1275. void make_lower (s, t)
  1276. X    char *s;
  1277. X    char *t;
  1278. {
  1279. X
  1280. X    while (*s) {
  1281. X        if (isupper(*s))
  1282. X            *t = tolower(*s);
  1283. X        else
  1284. X            *t = *s;
  1285. X        s++;
  1286. X        t++;
  1287. X    }
  1288. X    *t = 0;
  1289. }
  1290. SHAR_EOF
  1291. chmod 0600 search.c ||
  1292. echo 'restore of search.c failed'
  1293. Wc_c="`wc -c < 'search.c'`"
  1294. test 7006 -eq "$Wc_c" ||
  1295.     echo 'search.c: original size 7006, current size' "$Wc_c"
  1296. rm -f _shar_wnt_.tmp
  1297. fi
  1298. # ============= select.c ==============
  1299. if test -f 'select.c' -a X"$1" != X"-c"; then
  1300.     echo 'x - skipping select.c (File already exists)'
  1301.     rm -f _shar_wnt_.tmp
  1302. else
  1303. > _shar_wnt_.tmp
  1304. echo 'x - extracting select.c (Text)'
  1305. sed 's/^X//' << 'SHAR_EOF' > 'select.c' &&
  1306. /*
  1307. X *  Project   : tin - a threaded Netnews reader
  1308. X *  Module    : select.c
  1309. X *  Author    : R.Skrenta / I.Lea
  1310. X *  Created   : 01-04-91
  1311. X *  Updated   : 31-01-92
  1312. X *  Notes     :
  1313. X *  Copyright : (c) Copyright 1991-92 by Rich Skrenta & Iain Lea
  1314. X *                You may  freely  copy or  redistribute  this software,
  1315. X *              so  long as there is no profit made from its use, sale
  1316. X *              trade or  reproduction.  You may not change this copy-
  1317. X *              right notice, and it must be included in any copy made
  1318. X */
  1319. X
  1320. #include    "tin.h"
  1321. X
  1322. X
  1323. extern char cvers[LEN];
  1324. extern int index_point;
  1325. X
  1326. int cur_groupnum = 0;
  1327. int first_group_on_screen;
  1328. int last_group_on_screen;
  1329. int reread_active_file = TRUE;
  1330. int space_mode;
  1331. X
  1332. X
  1333. void selection_index (start_groupnum)
  1334. X    int start_groupnum;
  1335. {
  1336. X    char buf[LEN];
  1337. X    char post_group[LEN];
  1338. X    char ch;
  1339. X    int i, n;
  1340. X    int patlen;
  1341. X    int posted;
  1342. X    int scroll_lines;
  1343. X    int subscribe_num;
  1344. X
  1345. X    cur_groupnum = start_groupnum;
  1346. X    
  1347. X    mail_setup ();        /* record mailbox size for "you have mail" */
  1348. X
  1349. #ifndef USE_CLEARSCREEN
  1350. X    ClearScreen();
  1351. #endif
  1352. X
  1353. X    group_selection_page ();        /* display group selection page */
  1354. X
  1355. X    while (TRUE) {
  1356. X        num_of_killed_files = 0;
  1357. X        num_of_tagged_files = 0;
  1358. X        ch = (char) ReadCh();
  1359. X
  1360. X        if (ch > '0' && ch <= '9') {
  1361. X            prompt_group_num (ch);
  1362. X        } else switch (ch) {
  1363. X            case ESC:    /* (ESC) common arrow keys */
  1364. X                switch (get_arrow_key ()) {
  1365. X                    case KEYMAP_UP:
  1366. X                        goto select_up;
  1367. X
  1368. X                    case KEYMAP_DOWN:
  1369. X                        goto select_down;
  1370. X
  1371. X                    case KEYMAP_PAGE_UP:
  1372. X                        goto select_page_up;
  1373. X
  1374. X                    case KEYMAP_PAGE_DOWN:
  1375. X                        goto select_page_down;
  1376. X
  1377. X                    case KEYMAP_HOME:
  1378. X                        if (cur_groupnum != 0) {
  1379. X                            cur_groupnum = 0;
  1380. X                            group_selection_page ();
  1381. X                        }
  1382. X                        break;
  1383. X                    
  1384. X                    case KEYMAP_END:
  1385. X                        goto end_of_list;
  1386. X                }
  1387. X                break;
  1388. X
  1389. #ifndef NO_SHELL_ESCAPE
  1390. X            case '!':
  1391. X                shell_escape ();
  1392. X                group_selection_page ();
  1393. X                break;
  1394. #endif
  1395. X
  1396. X            case '$':    /* show last page of groups */
  1397. end_of_list:
  1398. X                if (cur_groupnum != group_top - 1) {
  1399. X                    cur_groupnum = group_top - 1;
  1400. X                    group_selection_page ();
  1401. X                }
  1402. X                break;
  1403. X
  1404. X            case '/':    /* search forward */
  1405. X            case '?':    /* search backward */
  1406. X                i = (ch == '/');
  1407. X                search_group (i);
  1408. X                break;
  1409. X
  1410. X            case '\r':    /* go into group */
  1411. X            case '\n':
  1412. X                if (group_top == 0) {
  1413. X                    info_message (txt_no_groups);
  1414. X                    break;
  1415. X                }
  1416. X                
  1417. X                n = my_group[cur_groupnum];
  1418. X                if (active[n].min <= active[n].max) {
  1419. X                    space_mode = pos_first_unread;
  1420. X                    clear_message();
  1421. X                    index_point = -1;
  1422. X                    do {
  1423. X                        n = my_group[cur_groupnum];
  1424. X                        group_page (active[n].name);
  1425. X                    } while (index_point == -3);
  1426. X                    group_selection_page ();
  1427. X                } else {
  1428. X                    info_message (txt_no_arts);
  1429. X                }
  1430. X                break;
  1431. X
  1432. X            case '\t':    /* enter next group containing unread articles */
  1433. X            case 'n':
  1434. X                next_unread_group (TRUE);
  1435. X                break;
  1436. X
  1437. X            case ' ':            /* page down */
  1438. X            case ctrl('D'):        /* vi style */
  1439. X            case ctrl('V'):        /* emacs style */
  1440. select_page_down:
  1441. X                if (group_top == 0) {
  1442. X                    break;
  1443. X                }
  1444. X                if (cur_groupnum == group_top - 1) {
  1445. X                    break;
  1446. X                }
  1447. X                erase_group_arrow ();
  1448. X                scroll_lines = (full_page_scroll ? NOTESLINES : NOTESLINES / 2);
  1449. X                cur_groupnum = ((cur_groupnum + scroll_lines) / scroll_lines) * scroll_lines;
  1450. X                if (cur_groupnum >= group_top) {
  1451. X                    cur_groupnum = (group_top / scroll_lines) * scroll_lines;
  1452. X                    if (cur_groupnum < group_top - 1) {
  1453. X                        cur_groupnum = group_top - 1;
  1454. X                    }
  1455. X                }
  1456. X
  1457. X                if (cur_groupnum <= first_group_on_screen
  1458. X                ||  cur_groupnum >= last_group_on_screen)
  1459. X                    group_selection_page ();
  1460. X                else
  1461. X                    draw_group_arrow ();
  1462. X                break;
  1463. X
  1464. X            case ctrl('K'):
  1465. X                if (group_top <= 0) {
  1466. X                    info_message (txt_no_groups_to_delete);
  1467. X                    break;
  1468. X                }
  1469. X
  1470. X                sprintf (buf, active[my_group[cur_groupnum]].name);
  1471. X                sprintf (msg, txt_del_group_in_newsrc, buf);
  1472. X                if (prompt_yn (LINES, msg, 'y')) {
  1473. X                    delete_group (active[my_group[cur_groupnum]].name);
  1474. X                    active[my_group[cur_groupnum]].flag = UNSUBSCRIBED;    
  1475. X
  1476. X                    group_top--;
  1477. X                    for (i = cur_groupnum; i < group_top; i++) {
  1478. X                        my_group[i] = my_group[i+1];
  1479. X                        unread[i] = unread[i+1];
  1480. X                    }
  1481. X                    if (cur_groupnum >= group_top)
  1482. X                        cur_groupnum = group_top - 1;    
  1483. X
  1484. X                    group_selection_page ();
  1485. X                    sprintf (msg, txt_group_deleted, buf);
  1486. X                    info_message (msg);
  1487. X                }
  1488. X                break;
  1489. X
  1490. X            case ctrl('L'):        /* redraw */
  1491. #ifndef USE_CLEARSCREEN
  1492. X                ClearScreen ();
  1493. #endif
  1494. X                group_selection_page();
  1495. X                break;
  1496. X
  1497. X            case ctrl('N'):        /* line down */
  1498. X            case 'j':
  1499. select_down:
  1500. X                if (cur_groupnum + 1 >= group_top) {
  1501. X                    break;
  1502. X                }
  1503. X                if (cur_groupnum + 1 >= last_group_on_screen) {
  1504. #ifndef USE_CLEARSCREEN
  1505. X                    erase_group_arrow();
  1506. #endif                    
  1507. X                    cur_groupnum++;
  1508. X                    group_selection_page();
  1509. X                } else {
  1510. X                    erase_group_arrow();
  1511. X                    cur_groupnum++;
  1512. X                    draw_group_arrow();
  1513. X                }
  1514. X                break;
  1515. X
  1516. X            case ctrl('P'):        /* line up */
  1517. X            case 'k':
  1518. select_up:
  1519. X                if (cur_groupnum == 0) {
  1520. X                    break;
  1521. X                }
  1522. X                if (cur_groupnum <= first_group_on_screen) {
  1523. X                    cur_groupnum--;
  1524. X                    group_selection_page();
  1525. X                } else {
  1526. X                    erase_group_arrow();
  1527. X                    cur_groupnum--;
  1528. X                    draw_group_arrow();
  1529. X                }
  1530. X                break;
  1531. X
  1532. X            case ctrl('R'):    /* reset .newsrc */
  1533. X                if (prompt_yn (LINES, txt_reset_newsrc, 'n')) {
  1534. X                    reset_newsrc ();
  1535. X                    cur_groupnum = 0;
  1536. X                    group_selection_page ();
  1537. X                }
  1538. X                break;
  1539. X
  1540. X            case ctrl('U'):        /* page up */
  1541. X            case 'b':
  1542. select_page_up:
  1543. X                if (group_top == 0) {
  1544. X                    break;
  1545. X                }
  1546. X                if (cur_groupnum == 0) {
  1547. X                    break;
  1548. X                }
  1549. X                erase_group_arrow ();
  1550. X                scroll_lines = (full_page_scroll ? NOTESLINES : NOTESLINES / 2);
  1551. X                if ((n = cur_groupnum % scroll_lines) > 0) {
  1552. X                    cur_groupnum = cur_groupnum - n;
  1553. X                } else {
  1554. X                    cur_groupnum = ((cur_groupnum - scroll_lines) / scroll_lines) * scroll_lines;
  1555. X                }
  1556. X                if (cur_groupnum < 0) {
  1557. X                    cur_groupnum = 0;
  1558. X                }
  1559. X                if (cur_groupnum < first_group_on_screen
  1560. X                ||  cur_groupnum >= last_group_on_screen)
  1561. X                    group_selection_page ();
  1562. X                else
  1563. X                    draw_group_arrow ();
  1564. X                break;
  1565. X
  1566. X            case 'B':    /* bug/gripe/comment mailed to author */
  1567. X                mail_bug_report ();
  1568. #ifndef USE_CLEARSCREEN
  1569. X                ClearScreen ();
  1570. #endif
  1571. X                group_selection_page();
  1572. X                break;
  1573. X                
  1574. X            case 'c':    /* catchup--mark all articles as read */
  1575. X            case 'C':    /* catchup & goto next unread group */
  1576. X                if (group_top == 0) {
  1577. X                    break;
  1578. X                }
  1579. X                catchup_group ((ch == 'C'));
  1580. X                break;
  1581. X
  1582. X            case 'g':    /* prompt for a new group name */
  1583. X                if ((n = choose_new_group ()) >= 0) {
  1584. X                    if (active[my_group[n]].flag != SUBSCRIBED) {
  1585. X                        subscribe (active[my_group[n]].name, ':',
  1586. X                            my_group[n], FALSE);
  1587. X                    }
  1588. X                    erase_group_arrow();
  1589. X                    cur_groupnum = reposition_group (active[my_group[n]].name,
  1590. X                                                    (n ? n : cur_groupnum));
  1591. X                    if (cur_groupnum < first_group_on_screen ||
  1592. X                        cur_groupnum >= last_group_on_screen ||
  1593. X                        cur_groupnum != n) {
  1594. X                        group_selection_page();
  1595. X                    } else {
  1596. X                        clear_message ();
  1597. X                        draw_group_arrow();
  1598. X                    }
  1599. X                }
  1600. X                break;
  1601. X
  1602. X            case 'h':    /* help */
  1603. X                show_info_page (HELP_INFO, help_select, txt_group_select_com);
  1604. X                group_selection_page ();
  1605. X                break;
  1606. X
  1607. X            case 'I':    /* toggle inverse video */
  1608. X                erase_group_arrow ();
  1609. X                toggle_inverse_video ();
  1610. X                group_selection_page ();
  1611. X                break;
  1612. X
  1613. X            case 'm':    /* reposition group within group list */
  1614. X                if (active[my_group[cur_groupnum]].flag == SUBSCRIBED) {
  1615. X                    n = cur_groupnum;
  1616. X                    erase_group_arrow ();
  1617. X                    cur_groupnum = reposition_group (active[my_group[n]].name, n);
  1618. X                    if (cur_groupnum < first_group_on_screen ||
  1619. X                        cur_groupnum >= last_group_on_screen ||
  1620. X                        cur_groupnum != n) {
  1621. X                        group_selection_page ();
  1622. X                    } else {
  1623. X                        clear_message ();
  1624. X                        draw_group_arrow ();
  1625. X                    }
  1626. X                }
  1627. X                break;
  1628. X
  1629. X            case 'M':    /* options menu */
  1630. X                change_rcfile ("", TRUE);
  1631. X                group_selection_page ();
  1632. X                break;
  1633. X
  1634. X            case 'N':    /* goto next unread group */
  1635. X                next_unread_group (FALSE);
  1636. X                break;
  1637. X
  1638. X            case 'q':    /* quit */
  1639. X                tin_done (0);
  1640. X                break;
  1641. X
  1642. X            case 's':    /* subscribe to current group */
  1643. X                if (group_top == 0) {
  1644. X                    break;
  1645. X                }
  1646. X                if (active[my_group[cur_groupnum]].flag != SUBSCRIBED) {
  1647. X                    MoveCursor (INDEX_TOP + (cur_groupnum-first_group_on_screen), 3);
  1648. X                    if (draw_arrow_mark) {
  1649. X                        putchar (' ');
  1650. X                    } else {
  1651. X                        screen[cur_groupnum-first_group_on_screen].col[3] = ' ';
  1652. X                        draw_group_arrow ();
  1653. X                    }
  1654. X                    fflush (stdout);
  1655. X                    MoveCursor (LINES, 0);    
  1656. X
  1657. X                    subscribe (active[my_group[cur_groupnum]].name,
  1658. X                        ':', my_group[cur_groupnum], FALSE);
  1659. X                    sprintf (buf, txt_subscribed_to, active[my_group[cur_groupnum]].name);
  1660. X                    info_message (buf);
  1661. X                }
  1662. X                break;
  1663. X
  1664. X            case 'S':    /* subscribe to groups matching pattern */
  1665. X                if (prompt_string (txt_subscribe_pattern, buf) && buf[0]) {
  1666. X                    wait_message (txt_subscribing);
  1667. X                    patlen = strlen (buf);
  1668. X                    for (subscribe_num=0, i=0 ; i < group_top ; i++) {
  1669. #ifdef NO_REGEX 
  1670. X                        if (str_str (active[my_group[i]].name, buf, patlen)) {
  1671. #else        
  1672. X                        if (wildmat (active[my_group[i]].name, buf)) {
  1673. #endif        
  1674. X                                if (active[my_group[i]].flag != SUBSCRIBED) {
  1675. #ifndef SLOW_SCREEN_UPDATE
  1676. X                                sprintf (msg, txt_subscribing_to, active[my_group[i]].name);
  1677. X                                wait_message (msg);
  1678. #endif                                
  1679. X                                subscribe (active[my_group[i]].name,
  1680. X                                    ':', my_group[i], FALSE);
  1681. X                            }
  1682. X                            subscribe_num++;
  1683. X                        }
  1684. X                    }
  1685. X                    if (subscribe_num) {
  1686. X                        group_selection_page ();    
  1687. X                        sprintf (buf, txt_subscribed_num_groups, subscribe_num);
  1688. X                        info_message (buf);
  1689. X                    } else {
  1690. X                        info_message (txt_no_match);
  1691. X                    }
  1692. X                } else {
  1693. X                    clear_message ();
  1694. X                }
  1695. X                break;
  1696. X
  1697. X            case 'u':    /* unsubscribe to current group */
  1698. X                if (group_top == 0) {
  1699. X                    break;
  1700. X                }
  1701. X                if (active[my_group[cur_groupnum]].flag == SUBSCRIBED) {
  1702. X                    MoveCursor(INDEX_TOP + (cur_groupnum-first_group_on_screen), 3);
  1703. X                    if (draw_arrow_mark) {
  1704. X                        putchar('u');
  1705. X                    } else {
  1706. X                        screen[cur_groupnum-first_group_on_screen].col[3] = 'u';
  1707. X                        draw_group_arrow ();
  1708. X                    }
  1709. X                    fflush(stdout);
  1710. X                    MoveCursor(LINES, 0);
  1711. X
  1712. X                    subscribe(active[my_group[cur_groupnum]].name,
  1713. X                        '!', my_group[cur_groupnum], FALSE);
  1714. X                    sprintf(buf, txt_unsubscribed_to,active[my_group[cur_groupnum]].name);
  1715. X                    info_message(buf);
  1716. X                }
  1717. X                break;
  1718. X
  1719. X            case 'U':    /* unsubscribe to groups matching pattern */
  1720. X                if (prompt_string (txt_unsubscribe_pattern, buf) && buf[0]) {    
  1721. X                    wait_message (txt_unsubscribing);
  1722. X                    patlen = strlen (buf);    
  1723. X                    for (subscribe_num=0, i=0 ; i < group_top ; i++) {        
  1724. #ifdef NO_REGEX
  1725. X                        if (str_str (active[my_group[i]].name, buf, patlen)) {
  1726. #else        
  1727. X                        if (wildmat (active[my_group[i]].name, buf)) {
  1728. #endif        
  1729. X                                if (active[my_group[i]].flag == SUBSCRIBED) {
  1730. #ifndef SLOW_SCREEN_UPDATE
  1731. X                                sprintf (msg, txt_unsubscribing_from, active[my_group[i]].name);
  1732. X                                wait_message (msg);
  1733. #endif                                
  1734. X                                subscribe (active[my_group[i]].name,
  1735. X                                    '!', my_group[i], FALSE);
  1736. X                            }
  1737. X                            subscribe_num++;
  1738. X                        }
  1739. X                    }
  1740. X                    if (subscribe_num) {
  1741. X                        group_selection_page ();    
  1742. X                        sprintf (buf, txt_unsubscribed_num_groups, subscribe_num);
  1743. X                        info_message (buf);
  1744. X                    } else {
  1745. X                        info_message (txt_no_match);
  1746. X                    }
  1747. X                } else {
  1748. X                    clear_message ();
  1749. X                }
  1750. X                break;
  1751. X
  1752. X            case 'v':    /* show tin version */
  1753. X                info_message (cvers);
  1754. X                break;
  1755. X
  1756. X            case 'w':    /* post a basenote */
  1757. X                if (! can_post) {
  1758. X                    info_message (txt_cannot_post);
  1759. X                    break;
  1760. X                }
  1761. X                if (group_top == 0) {
  1762. X                    if (! prompt_string (txt_post_newsgroup, buf)) 
  1763. X                        break;
  1764. X                    if (buf[0] == '\0')
  1765. X                        break;
  1766. X                    strcpy (post_group, buf);
  1767. X                } else {
  1768. X                    strcpy (post_group, active[my_group[cur_groupnum]].name);
  1769. X                }
  1770. X                if (post_base (post_group, &posted)) {
  1771. X                    group_selection_page ();
  1772. X                }
  1773. X                break;
  1774. X
  1775. X            case 'W':    /* display messages posted by user */
  1776. X                if (user_posted_messages ()) {
  1777. X                    group_selection_page ();
  1778. X                }
  1779. X                break;
  1780. X
  1781. X            case 'y':    /* pull in rest of groups from active */
  1782. X                if (reread_active_file) {
  1783. X                    wait_message (txt_yanking_all_groups);
  1784. X                    n = group_top;
  1785. X                    for (i = 0; i < num_active; i++) {
  1786. X                        active[i].flag = UNSUBSCRIBED;
  1787. X                    }
  1788. X                    read_newsrc (FALSE);
  1789. X                    for (i = 0; i < num_active; i++) {
  1790. X                        if (active[i].flag & UNSUBSCRIBED) {
  1791. X                            active[i].flag &= ~UNSUBSCRIBED;
  1792. X                            my_group[group_top] = i;
  1793. X                            unread[group_top] = -1;
  1794. X                            group_top++;
  1795. X                        }
  1796. X                    }
  1797. X                    if (n < group_top) {
  1798. X                        sprintf(buf, txt_added_groups, group_top - n,
  1799. X                            group_top - n == 1 ? "" : txt_plural);
  1800. X                        group_selection_page();
  1801. X                        info_message(buf);
  1802. X                    } else {
  1803. X                        info_message(txt_no_groups_to_yank_in);
  1804. X                    }
  1805. X                    reread_active_file = FALSE;
  1806. X                } else {
  1807. X                    wait_message (txt_yanking_sub_groups);
  1808. X                    read_newsrc (TRUE);
  1809. X                    cur_groupnum = group_top - 1;
  1810. X                    group_selection_page();
  1811. X                    reread_active_file = TRUE;
  1812. X                }
  1813. X                break;
  1814. X
  1815. X            case 'Y':    /* reread .newsrc, no unsub groups */
  1816. X                wait_message (txt_yanking_sub_groups);
  1817. X                cur_groupnum = 0;
  1818. X                group_top = 0;
  1819. X                for (i = 0; i < num_active; i++) {
  1820. X                    active[i].flag = UNSUBSCRIBED;
  1821. X                }
  1822. X                read_newsrc (TRUE);
  1823. X                group_selection_page ();
  1824. X                break;
  1825. X
  1826. X            case 'z':    /* mark group unread */
  1827. X                if (group_top == 0) {
  1828. X                    break;
  1829. X                }
  1830. X                n = cur_groupnum;
  1831. X                update_newsrc (active[my_group[n]].name, my_group[n], TRUE);
  1832. X                cur_groupnum = 0;
  1833. X                group_top = 0;
  1834. X                read_newsrc (TRUE);            
  1835. X                cur_groupnum = n;
  1836. X                group_selection_page ();
  1837. X                break;
  1838. X
  1839. X            case 'Z':    /* undelete groups deleted by ctrl-K */
  1840. X                if (undel_group ()) {
  1841. X                    group_selection_page ();
  1842. X                    info_message (txt_group_undeleted);
  1843. X                }
  1844. X                break;
  1845. X
  1846. X            default:
  1847. X                info_message(txt_bad_command);
  1848. X        }
  1849. X    }
  1850. }
  1851. X
  1852. X
  1853. void group_selection_page ()
  1854. {
  1855. X    char buf[LEN];
  1856. X    char new[10];
  1857. X    char subs;
  1858. X    int col, i, j, n;
  1859. X
  1860. X    set_signals_select ();
  1861. X
  1862. #ifdef USE_CLEARSCREEN
  1863. X    ClearScreen ();
  1864. #else
  1865. X    MoveCursor (0, 0);        /* top left corner */
  1866. X    CleartoEOLN ();
  1867. #endif
  1868. X
  1869. X    sprintf (buf, "%s (%d)", txt_group_selection, group_top);
  1870. X    show_title (buf);
  1871. X
  1872. #ifndef USE_CLEARSCREEN
  1873. X    MoveCursor (1, 0);
  1874. X    CleartoEOLN ();
  1875. #endif
  1876. X
  1877. X    MoveCursor (INDEX_TOP, 0);
  1878. X
  1879. X    if (cur_groupnum >= group_top) {
  1880. X        cur_groupnum = group_top - 1;
  1881. X    }
  1882. X    if (cur_groupnum < 0) {
  1883. X        cur_groupnum = 0;
  1884. X    }
  1885. X 
  1886. X    if (NOTESLINES <= 0) {
  1887. X        first_group_on_screen = 0;
  1888. X    } else {
  1889. X        first_group_on_screen = (cur_groupnum / NOTESLINES) * NOTESLINES;
  1890. X        if (first_group_on_screen < 0) {
  1891. X            first_group_on_screen = 0;
  1892. X        }
  1893. X    }
  1894. X
  1895. X    last_group_on_screen = first_group_on_screen + NOTESLINES;
  1896. X
  1897. X    if (last_group_on_screen >= group_top) {
  1898. X        last_group_on_screen = group_top;
  1899. X        first_group_on_screen = (cur_groupnum / NOTESLINES) * NOTESLINES;
  1900. X
  1901. X        if (first_group_on_screen == last_group_on_screen ||
  1902. X            first_group_on_screen < 0) {
  1903. X            if (first_group_on_screen < 0) {
  1904. X                first_group_on_screen = 0;
  1905. X            } else {
  1906. X                first_group_on_screen = last_group_on_screen - NOTESLINES;    
  1907. X            }
  1908. X        }    
  1909. X    }
  1910. X
  1911. X    if (group_top == 0) {
  1912. X        first_group_on_screen = 0;
  1913. X        last_group_on_screen = 0;
  1914. X    }
  1915. X
  1916. X    for (j=0, i = first_group_on_screen; i < last_group_on_screen; i++,j++) {
  1917. X        switch (unread[i]) {
  1918. X            case -2:
  1919. X                sprintf (new, "?    ");
  1920. X                break;
  1921. X
  1922. X            case -1:
  1923. X                sprintf (new, "-    ");
  1924. X                break;
  1925. X
  1926. X            case 0:
  1927. X                sprintf (new, "     ");
  1928. X                break;
  1929. X
  1930. X            default:
  1931. X                sprintf (new, "%-5d", unread[i]);
  1932. X        }
  1933. X        
  1934. X        n = my_group[i];
  1935. X        if (active[n].flag & SUBSCRIBED)    /* subscribed? */
  1936. X            subs = ' ';
  1937. X        else
  1938. X            subs = 'u';    /* u next to unsubscribed groups */
  1939. X
  1940. X        if (draw_arrow_mark) {
  1941. X            printf ("   %c %4d  %-40s %s\r\n",
  1942. X                   subs, i+1, active[n].name, new);
  1943. X        } else {
  1944. X            sprintf (screen[j].col, "   %c %4d  %-40s %s%*s\r\n",
  1945. X                subs, i+1, active[n].name, new, COLS-BLANK_SELECT_COLS, " ");
  1946. X            printf ("%s", screen[j].col);
  1947. X        }
  1948. X    }
  1949. #ifndef USE_CLEARSCREEN
  1950. X    CleartoEOS ();
  1951. #endif
  1952. X
  1953. X    if (group_top <= 0) {
  1954. X        info_message (txt_no_groups);
  1955. X        return;
  1956. X    } else if (last_group_on_screen == group_top) {
  1957. X        info_message (txt_end_of_groups);
  1958. X    }
  1959. X    
  1960. X    draw_group_arrow ();
  1961. }
  1962. X
  1963. X
  1964. int prompt_group_num (ch)
  1965. X    char ch;
  1966. {
  1967. X    int num;
  1968. X
  1969. X    clear_message ();
  1970. X
  1971. X    if ((num = prompt_num (ch, txt_select_group)) == -1) {
  1972. X        clear_message ();
  1973. X        return FALSE;
  1974. X    }
  1975. X    num--;        /* index from 0 (internal) vs. 1 (user) */
  1976. X
  1977. X    if (num < 0) {
  1978. X        num = 0;
  1979. X    }
  1980. X    if (num >= group_top) {
  1981. X        num = group_top - 1;
  1982. X    }
  1983. X
  1984. X    if (num >= first_group_on_screen
  1985. X    &&  num < last_group_on_screen) {
  1986. X        erase_group_arrow ();
  1987. X        cur_groupnum = num;
  1988. X        draw_group_arrow ();
  1989. X    } else {
  1990. #ifndef USE_CLEARSCREEN
  1991. X        erase_group_arrow ();
  1992. #endif        
  1993. X        cur_groupnum = num;
  1994. X        group_selection_page ();
  1995. X    }
  1996. X
  1997. X    return TRUE;
  1998. }
  1999. X
  2000. X
  2001. void erase_group_arrow ()
  2002. {
  2003. X    erase_arrow (INDEX_TOP + (cur_groupnum-first_group_on_screen));
  2004. }
  2005. X
  2006. X
  2007. void draw_group_arrow()
  2008. {
  2009. X    draw_arrow (INDEX_TOP + (cur_groupnum-first_group_on_screen));
  2010. }
  2011. X
  2012. X
  2013. int choose_new_group ()
  2014. {
  2015. X    char buf[LEN];
  2016. X    char *p;
  2017. X    int ret;
  2018. X
  2019. X    if (! prompt_string (txt_newsgroup, buf))
  2020. X        return -1;
  2021. X
  2022. X    for (p = buf; *p && (*p == ' ' || *p == '\t'); p++)
  2023. X        continue;
  2024. X    if (*p == '\0')
  2025. X        return -1;
  2026. X
  2027. X    clear_message ();
  2028. X
  2029. X    if ((ret = add_group (p, TRUE)) < 0) {
  2030. X        sprintf (msg, txt_not_in_active_file, p);
  2031. X        info_message (msg);
  2032. X    }
  2033. X
  2034. X    return ret;
  2035. }
  2036. X
  2037. /*
  2038. X *  Add a group to the selection list (my_group[])
  2039. X *  Return the index of my_group[] if group is added or was already
  2040. X *  there.  Return -1 if named group is not in active[].
  2041. X */
  2042. X
  2043. int add_group (s, get_unread)
  2044. X    char *s;
  2045. X    int get_unread;            /* look in .newsrc for sequencer unread info? */
  2046. {
  2047. X    long h;
  2048. X    int i, j;
  2049. X
  2050. X    h = hash_groupname (s);
  2051. X
  2052. X    for (i = group_hash[h]; i >= 0; i = active[i].next) {
  2053. X        if (strcmp (s, active[i].name) == 0) {
  2054. X            for (j = 0; j < group_top; j++) {
  2055. X                if (my_group[j] == i) {
  2056. X                    return j;
  2057. X                }
  2058. X            }
  2059. X
  2060. X            active[i].flag &= ~UNSUBSCRIBED;   /* mark that we got it */
  2061. X            my_group[group_top] = i;
  2062. X
  2063. X            if (get_unread)
  2064. X                unread[group_top] = get_line_unread (s, i);
  2065. X            else
  2066. X                unread[group_top] = -2;
  2067. X
  2068. X            group_top++;
  2069. X            return group_top - 1;
  2070. X        }
  2071. X    }
  2072. X
  2073. X    return -1;
  2074. }
  2075. X
  2076. X
  2077. int reposition_group (group, default_num)
  2078. X    char *group;
  2079. X    int default_num;
  2080. {
  2081. X    char buf[LEN];
  2082. X    char pos[LEN];
  2083. X    int pos_num = 0;
  2084. X
  2085. X    sprintf (buf, txt_newsgroup_position, group);
  2086. X    
  2087. X    if (! prompt_string (buf, pos)) 
  2088. X        return default_num;
  2089. X
  2090. X    if (pos[0] == '\0')
  2091. X        return default_num;
  2092. X        
  2093. X    if (pos[0] == '$') {
  2094. X        pos_num = group_top;
  2095. X    } else {
  2096. X        pos_num = atoi (pos);
  2097. X        if (pos_num > group_top) {
  2098. X            pos_num = group_top;
  2099. X        } else if (pos_num <= 0) {
  2100. X            pos_num = 1;
  2101. X        }
  2102. X    }
  2103. X
  2104. X    wait_message (txt_moving);
  2105. X    
  2106. X    if (pos_group_in_newsrc (group, pos_num)) {
  2107. X        read_newsrc (TRUE);
  2108. X        return (pos_num-1);
  2109. X    } else {
  2110. X        return (default_num);
  2111. X    }
  2112. }
  2113. X
  2114. X
  2115. void catchup_group (goto_next_unread_group)
  2116. X    int goto_next_unread_group;
  2117. {    
  2118. X    int i;
  2119. X    
  2120. X    if (prompt_yn (LINES, txt_mark_group_read, 'y')) {
  2121. X        unread[cur_groupnum] = 0;
  2122. X        mark_group_read (active[my_group[cur_groupnum]].name,
  2123. X                        my_group[cur_groupnum]);
  2124. X        if (draw_arrow_mark) {    
  2125. X            MoveCursor (INDEX_TOP+(cur_groupnum - first_group_on_screen), 51);
  2126. X            printf ("     ");
  2127. X            MoveCursor (LINES, 0);
  2128. X            fflush (stdout);
  2129. X        } else {
  2130. X            i = cur_groupnum - first_group_on_screen;
  2131. X            screen[i].col[51] = ' ';
  2132. X            screen[i].col[52] = ' ';
  2133. X            screen[i].col[53] = ' ';
  2134. X            screen[i].col[54] = ' ';
  2135. X            screen[i].col[55] = ' ';
  2136. X        }
  2137. X        erase_group_arrow ();
  2138. X        if (cur_groupnum+1 < last_group_on_screen) {
  2139. X            cur_groupnum++;
  2140. X        }
  2141. X        draw_group_arrow ();
  2142. X
  2143. X        if (goto_next_unread_group) {
  2144. X            next_unread_group (FALSE);    
  2145. X        }
  2146. X    }
  2147. }
  2148. X
  2149. X
  2150. void next_unread_group (enter_group)
  2151. X    int enter_group;
  2152. {
  2153. X    int i;
  2154. X    
  2155. X    for (i = cur_groupnum; i < group_top; i++) {
  2156. X        if (unread[i] != 0) {
  2157. X            break;
  2158. X        }
  2159. X    }
  2160. X    if (i >= group_top) {
  2161. X        info_message (txt_no_groups_to_read);
  2162. X        return;
  2163. X    }
  2164. X
  2165. X    erase_group_arrow ();
  2166. X    cur_groupnum = i;
  2167. X    if (cur_groupnum >= last_group_on_screen) {
  2168. X        group_selection_page ();
  2169. X    } else {
  2170. X        draw_group_arrow ();
  2171. X    }
  2172. X    space_mode = pos_first_unread;
  2173. X
  2174. X    if (enter_group) {
  2175. X        clear_message ();
  2176. X        index_point = -1;
  2177. X        do {
  2178. X            group_page (active[my_group[cur_groupnum]].name);
  2179. X        } while (index_point == -3);
  2180. X        group_selection_page ();
  2181. X    }
  2182. }
  2183. SHAR_EOF
  2184. chmod 0600 select.c ||
  2185. echo 'restore of select.c failed'
  2186. Wc_c="`wc -c < 'select.c'`"
  2187. test 19773 -eq "$Wc_c" ||
  2188.     echo 'select.c: original size 19773, current size' "$Wc_c"
  2189. rm -f _shar_wnt_.tmp
  2190. fi
  2191. # ============= signal.c ==============
  2192. if test -f 'signal.c' -a X"$1" != X"-c"; then
  2193.     echo 'x - skipping signal.c (File already exists)'
  2194.     rm -f _shar_wnt_.tmp
  2195. else
  2196. > _shar_wnt_.tmp
  2197. echo 'x - extracting signal.c (Text)'
  2198. sed 's/^X//' << 'SHAR_EOF' > 'signal.c' &&
  2199. /*
  2200. X *  Project   : tin - a threaded Netnews reader
  2201. X *  Module    : signal.c
  2202. X *  Author    : I.Lea
  2203. X *  Created   : 01-04-91
  2204. X *  Updated   : 22-01-92
  2205. X *  Notes     : signal handlers for different modes and window resizing
  2206. X *  Copyright : (c) Copyright 1991-92 by Iain Lea
  2207. X *                You may  freely  copy or  redistribute  this software,
  2208. X *              so  long as there is no profit made from its use, sale
  2209. X *              trade or  reproduction.  You may not change this copy-
  2210. X *              right notice, and it must be included in any copy made
  2211. X */
  2212. X
  2213. #include    "tin.h"
  2214. X
  2215. extern char *glob_art_group;
  2216. extern char *glob_group;
  2217. extern int glob_respnum;
  2218. extern char *glob_page_group;
  2219. X
  2220. #ifdef SIGTSTP
  2221. int do_sigtstp = 0;
  2222. #endif
  2223. X
  2224. #ifdef POSIX_JOB_CONTROL
  2225. struct sigaction art_act;
  2226. struct sigaction group_act;
  2227. struct sigaction kill_act;
  2228. struct sigaction main_act;
  2229. struct sigaction old_act;
  2230. struct sigaction page_act;
  2231. struct sigaction rcfile_act;
  2232. struct sigaction select_act;
  2233. struct sigaction thread_act;
  2234. #endif
  2235. X
  2236. X
  2237. void set_signal_handlers ()
  2238. {
  2239. X    signal (SIGINT, signal_handler);    /* ctrl-C */
  2240. X    signal (SIGQUIT, signal_handler);    /* ctrl-\ */
  2241. X    signal (SIGILL, signal_handler);
  2242. X    signal (SIGBUS, signal_handler);
  2243. X    signal (SIGSEGV, signal_handler);
  2244. X     
  2245. X    signal (SIGPIPE, SIG_IGN);
  2246. X
  2247. #if defined(SIGTSTP) && ! defined(MINIX)
  2248. X    {
  2249. X        SIGTYPE (*ptr)();
  2250. X        ptr = signal (SIGTSTP, SIG_DFL);
  2251. X        signal (SIGTSTP, ptr);
  2252. X        if (ptr != SIG_IGN) {
  2253. X            /*
  2254. X             *  SIGTSTP is ignored when starting from shells
  2255. X             *  without job-control
  2256. X             */
  2257. X            do_sigtstp = 1; 
  2258. X            signal (SIGTSTP, main_suspend);
  2259. X        }
  2260. X    }
  2261. #endif
  2262. X
  2263. #ifdef SIGWINCH
  2264. X    signal (SIGWINCH, main_resize);
  2265. #endif
  2266. }
  2267. X
  2268. X
  2269. void signal_handler (sig)
  2270. X    int sig;
  2271. {
  2272. X    char *sigtext;
  2273. X
  2274. X    switch (sig) {
  2275. X        case SIGINT:
  2276. X            if (update) {
  2277. X                sigtext = "SIGINT ";
  2278. X            } else {
  2279. X                signal (SIGINT, signal_handler);
  2280. X                return;
  2281. X            }
  2282. X            break;
  2283. X        case SIGQUIT:
  2284. X            sigtext = "SIGQUIT ";
  2285. X            break;
  2286. X        case SIGBUS:
  2287. X            sigtext = "SIGBUS ";
  2288. X            break;
  2289. X        case SIGSEGV:
  2290. X            sigtext = "SIGSEGV ";
  2291. X            break;
  2292. X        default:
  2293. X            sigtext = "";
  2294. X            break;
  2295. X    }
  2296. X    Raw (FALSE);
  2297. X    EndWin ();
  2298. X    fprintf (stderr, "\n%s: signal handler caught signal %s(%d).\n",
  2299. X        progname, sigtext, sig);
  2300. X    if (sig != SIGINT && sig != SIGQUIT) {
  2301. SHAR_EOF
  2302. true || echo 'restore of signal.c failed'
  2303. fi
  2304. echo 'End of tin1.1 part 9'
  2305. echo 'File signal.c is continued in part 10'
  2306. echo 10 > _shar_seq_.tmp
  2307. exit 0
  2308.  
  2309. --
  2310. NAME   Iain Lea
  2311. EMAIL  iain%estevax.uucp@unido.Informatik.Uni-Dortmund.DE
  2312. SNAIL  Bruecken Strasse 12, 8500 Nuernberg 90, Germany
  2313. PHONE  +49-911-331963 (home)  +49-911-3089-407 (work)
  2314. -- 
  2315.  Dr. med. dipl.-math Dieter Becker           Tel.: (0 / +49) 6841 - 16 3046
  2316.  Medizinische Universitaets- und Poliklinik  Fax.: (0 / +49) 6841 - 16 3369
  2317.  Innere Medizin III                         
  2318.  D - 6650 Homburg / Saar                     Email: becker@med-in.uni-sb.de
  2319. exit 0 # Just in case...
  2320.