home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume31 / tin / part10 < prev    next >
Encoding:
Text File  |  1992-07-07  |  53.8 KB  |  2,304 lines
  1. Newsgroups: comp.sources.misc
  2. From: iain%anl433.uucp@Germany.EU.net (Iain Lea)
  3. Subject:  v31i010:  tin - threaded full screen newsreader v1.1 PL4, Part10/15
  4. Message-ID: <1992Jul7.181822.7725@sparky.imd.sterling.com>
  5. X-Md4-Signature: b096bd8401d054652e5b19cf0bd3153d
  6. Date: Tue, 7 Jul 1992 18:18:22 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: iain%anl433.uucp@Germany.EU.net (Iain Lea)
  10. Posting-number: Volume 31, Issue 10
  11. Archive-name: tin/part10
  12. Environment: BSD, SCO, ISC, SUNOS, SYSVR3, SYSVR4, ULTRIX, XENIX
  13. Supersedes: tin: Volume 30, Issue 1-14
  14.  
  15. #! /bin/sh
  16. # This is a shell archive.  Remove anything before this line, then feed it
  17. # into a shell via "sh file" or similar.  To overwrite existing files,
  18. # type "sh file -c".
  19. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  20. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  21. # Contents:  init.c newsrc.c nntplib.c
  22. # Wrapped by kent@sparky on Mon Jun 29 23:35:13 1992
  23. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  24. echo If this archive is complete, you will see the following message:
  25. echo '          "shar: End of archive 10 (of 15)."'
  26. if test -f 'init.c' -a "${1}" != "-c" ; then 
  27.   echo shar: Will not clobber existing file \"'init.c'\"
  28. else
  29.   echo shar: Extracting \"'init.c'\" \(15082 characters\)
  30.   sed "s/^X//" >'init.c' <<'END_OF_FILE'
  31. X/*
  32. X *  Project   : tin - a threaded Netnews reader
  33. X *  Module    : init.c
  34. X *  Author    : I.Lea
  35. X *  Created   : 01-04-91
  36. X *  Updated   : 20-06-92
  37. X *  Notes     :
  38. X *  Copyright : (c) Copyright 1991-92 by Iain Lea
  39. X *              You may  freely  copy or  redistribute  this software,
  40. X *              so  long as there is no profit made from its use, sale
  41. X *              trade or  reproduction.  You may not change this copy-
  42. X *              right notice, and it must be included in any copy made
  43. X */
  44. X
  45. X#include    "tin.h"
  46. X
  47. Xchar rcdir[PATH_LEN];
  48. Xchar rcfile[PATH_LEN];
  49. Xchar indexdir[PATH_LEN];
  50. Xchar killfile[PATH_LEN];
  51. Xchar postfile[PATH_LEN];
  52. Xchar unthreadfile[PATH_LEN];
  53. Xchar cvers[LEN];
  54. Xchar nntp_server[LEN];
  55. Xchar active_file[PATH_LEN];
  56. Xchar newsgroups_file[PATH_LEN];
  57. Xchar subscriptions_file[PATH_LEN];
  58. Xchar homedir[PATH_LEN];
  59. Xchar userid[LEN];
  60. Xchar delgroups[LEN];
  61. Xchar default_maildir[PATH_LEN];            /* mailbox dir where = saves are stored */
  62. Xchar newsrc[PATH_LEN];
  63. Xchar newnewsrc[PATH_LEN];
  64. Xchar add_addr[LEN];            /* address to add to rR reply to author with mail */
  65. Xchar bug_addr[LEN];            /* address to add send bug reports to */
  66. Xchar txt_help_bug_report[LEN];    /* address to add send bug reports to */
  67. Xchar reply_to[LEN];            /* Reply-To: address */
  68. Xchar my_org[LEN];            /* Organization: */
  69. Xchar my_distribution[LEN];        /* Distribution: */
  70. Xchar default_select_pattern[LEN];
  71. Xchar default_sigfile[PATH_LEN];
  72. Xchar default_signature[PATH_LEN];
  73. Xchar default_shell_command[LEN];    /* offers user default choice */
  74. Xchar killsubj[LEN];            /* contains Subject:'s not to be shown */
  75. Xchar killfrom[LEN];            /* conatins From:'s not to be shown */
  76. Xchar page_header[LEN];        /* page header of pgm name and version */
  77. Xchar default_savedir[PATH_LEN];            /* directory to save articles to */
  78. Xchar spooldir[PATH_LEN];        /* directory where news is */
  79. Xchar spooldir_alias[PATH_LEN];        /* alias of spooldir being used */
  80. Xchar mail_news_user[LEN];    /* mail new news to this user address */
  81. Xchar mailer[PATH_LEN];            /* mail program */
  82. Xchar mailbox[PATH_LEN];            /* system mailbox for each user */
  83. Xchar printer[LEN];            /* printer program specified from tinrc */
  84. Xchar cmd_line_printer[LEN];    /* printer program specified on cmd line */
  85. Xchar article[PATH_LEN];            /* ~/.article file */
  86. Xchar dead_article[PATH_LEN];    /* ~/dead.article file */
  87. Xchar progname[PATH_LEN];        /* program name */
  88. Xchar redirect_output[LEN];    /* /dev/null or nothing if -D option */
  89. X
  90. Xint xindex_supported = FALSE;
  91. Xint xuser_supported = FALSE;
  92. Xint xspooldir_supported = FALSE;
  93. Xint NOTESLINES;                        /* set in set_win_size () */
  94. Xint RIGHT_POS;                        /* set in set_win_size () */
  95. Xint MORE_POS;                        /* set in set_win_size () */
  96. Xint confirm_action;
  97. Xint max_subj = 0;
  98. Xint max_from = 0;
  99. Xint max_active;
  100. Xint num_active;                        /* one past top of active */
  101. Xint group_top;                        /* one past top of my_group */
  102. Xint groupname_len = 0;                    /* one past top of my_group */
  103. Xint catchup = FALSE;                /* mark all arts read in all subscribed groups */
  104. Xint update_fork = FALSE;            /* update index files by forked tin -u */
  105. Xint verbose = FALSE;                /* update index files only mode */
  106. Xint start_line_offset;                /* used by invoke_editor for line no. */
  107. Xint inn_nntp_server = FALSE;            /* read news via INN NNTP */
  108. Xint read_news_via_nntp = FALSE;        /* read news locally or via NNTP */
  109. Xint local_index;                    /* do private indexing? */
  110. Xint max_art;
  111. Xint real_gid;
  112. Xint real_uid;
  113. Xint real_umask;
  114. Xint show_description;
  115. Xint start_editor_offset;
  116. Xint tin_uid;
  117. Xint tin_gid;
  118. Xint top = 0;
  119. Xint top_base;
  120. Xint check_any_unread = FALSE;
  121. Xint notify_new_groups = FALSE;
  122. Xint start_any_unread = FALSE;
  123. X
  124. Xint catchup_read_groups;    /* ask if read groups are to be marked read */
  125. Xint cmd_line;                /* batch / interactive mode */
  126. Xint created_rcdir;            /* checks if first time tin is started */
  127. Xint default_printer;        /* set to false if user give a printer with -p switch */
  128. Xint default_show_author;    /* show_author value from 'M' menu in tinrc */
  129. Xint draw_arrow_mark;        /* draw -> or highlighted bar */
  130. Xint full_page_scroll;        /* page half/full screen of articles/groups */
  131. Xint killed_articles;        /* killed / auto-selected hot articles */
  132. Xint mark_saved_read;        /* mark saved article/thread as read */
  133. Xint num_of_hot_arts;
  134. Xint num_of_killed_arts;
  135. Xint num_of_tagged_arts;
  136. Xint process_id;
  137. Xint pos_first_unread;        /* position cursor at first/last unread article */
  138. Xint post_proc_type;            /* type of post processing to be performed */
  139. Xint print_header;            /* print all of mail header or just Subject: & From lines */
  140. Xint save_archive_name;        /* save thread with name from Archive-name: field */
  141. Xint mail_news;                /* mail all arts to specified user */
  142. Xint save_news;                /* save all arts to savedir structure */
  143. Xint show_author;            /* show Subject & From or only Subject in group menu */
  144. Xint show_only_unread;        /* show only new/unread arts or all arts */
  145. Xint spooldir_is_active;            /* set TRUE if current spooldir is active news feed */
  146. Xint sort_art_type;            /* sort arts[] array by subject,from or date field */
  147. Xint thread_arts;            /* thread/unthread articles for viewing */
  148. Xint system_status;
  149. X
  150. X#ifdef INDEX_DAEMON
  151. Xint update = TRUE;                    /* update index files only mode */
  152. X#else
  153. Xint update = FALSE;                    /* update index files only mode */
  154. X#endif
  155. X
  156. Xstruct passwd *myentry;
  157. X
  158. X
  159. X/*
  160. X * Get users home directory, userid, and a bunch of other stuff!
  161. X */
  162. X
  163. Xvoid init_selfinfo ()
  164. X{
  165. X    extern char *getlogin ();
  166. X    extern struct passwd *getpwnam ();
  167. X    char nam[LEN];
  168. X    char *p;
  169. X    FILE *fp;
  170. X    struct stat sb;
  171. X
  172. X    process_id = getpid ();
  173. X    
  174. X    tin_uid = geteuid ();
  175. X    tin_gid = getegid ();
  176. X    real_uid = getuid ();
  177. X    real_gid = getgid ();
  178. X
  179. X    real_umask = umask (0);
  180. X    umask (real_umask);
  181. X    
  182. X#ifdef SVR4
  183. X    setlocale (LC_ALL, "");
  184. X#endif
  185. X        
  186. X    /*
  187. X     * we're setuid, so index in /usr/spool/news even if user root
  188. X     * This is quite essential if non local index files are 
  189. X     * to be updated during the night from crontab by root.
  190. X     */
  191. X    if (tin_uid != real_uid) {
  192. X        local_index = FALSE;
  193. X        set_real_uid_gid ();
  194. X
  195. X    } else {    /* index in users home directory ~/.tin/.index */
  196. X        local_index = TRUE;
  197. X    }
  198. X
  199. X    myentry = (struct passwd *) 0;
  200. X    if (((p = getlogin ()) != (char *) 0) && strlen (p)) {
  201. X        myentry = getpwnam (p);
  202. X    } else {
  203. X        myentry = getpwuid (getuid ());
  204. X    }
  205. X
  206. X    strcpy (userid, myentry->pw_name);
  207. X
  208. X    if ((p = (char *) getenv ("HOME")) != NULL) {
  209. X        strcpy (homedir, p);
  210. X    } else {
  211. X        strcpy (homedir, myentry->pw_dir);
  212. X    }
  213. X
  214. X    catchup_read_groups = FALSE;
  215. X    confirm_action = TRUE;
  216. X    created_rcdir = FALSE;
  217. X#ifdef USE_INVERSE_HACK
  218. X    inverse_okay = FALSE;
  219. X    draw_arrow_mark = TRUE;
  220. X#else
  221. X    draw_arrow_mark = FALSE;
  222. X#endif
  223. X    default_move_group = 0;
  224. X#ifdef BSD
  225. X    default_printer = TRUE;
  226. X#else    
  227. X    default_printer = FALSE;
  228. X#endif
  229. X    default_show_author = SHOW_FROM_NAME;
  230. X    full_page_scroll = TRUE;
  231. X    killed_articles = FALSE;
  232. X    mark_saved_read = TRUE;
  233. X    num_of_hot_arts = 0;
  234. X    num_of_killed_arts = 0;
  235. X    num_of_tagged_arts = 0;
  236. X    post_proc_type = POST_PROC_NONE;
  237. X    pos_first_unread = TRUE;
  238. X    print_header = FALSE;
  239. X    save_archive_name = TRUE;
  240. X    save_news = FALSE;
  241. X    show_only_unread = FALSE;
  242. X    show_description = TRUE;
  243. X    sort_art_type = SORT_BY_DATE_ASCEND;
  244. X    start_editor_offset = TRUE;
  245. X    thread_arts = TRUE;
  246. X    
  247. X    killsubj[0] = '\0';
  248. X    killfrom[0] = '\0';
  249. X    
  250. X    cmd_line_printer[0] = '\0';
  251. X    default_author_search[0] = '\0';
  252. X    default_goto_group[0] = '\0';
  253. X    default_group_search[0] = '\0';
  254. X    default_subject_search[0] = '\0';
  255. X    default_art_search[0] = '\0';
  256. X    default_crosspost_group[0] = '\0';
  257. X    default_mail_address[0] = '\0';
  258. X    default_pipe_command[0] = '\0';
  259. X    default_post_subject[0] = '\0';
  260. X    default_regex_pattern[0] = '\0';
  261. X    default_save_file[0] = '\0';
  262. X    default_select_pattern[0] = '\0';
  263. X    default_shell_command[0] = '\0';
  264. X    nntp_server[0] = '\0';
  265. X    proc_ch_default = 'n';
  266. X
  267. X    /*
  268. X     * set start spooldir to active newsfeed
  269. X     */
  270. X    strcpy (spooldir_alias, "news");
  271. X    strcpy (spooldir, SPOOLDIR);
  272. X
  273. X    set_tindir ();    
  274. X
  275. X    sprintf (active_file, "%s/active", LIBDIR);
  276. X    sprintf (article, "%s/.article", homedir);
  277. X    sprintf (dead_article, "%s/dead.article", homedir);
  278. X    sprintf (delgroups, "%s/.delgroups", homedir);
  279. X    sprintf (mailbox, "%s/%s", DEFAULT_MAILBOX, userid);
  280. X    sprintf (default_maildir, "%s/%s", homedir, DEFAULT_MAILDIR);
  281. X    sprintf (default_savedir, "%s/News", homedir);
  282. X    sprintf (default_sigfile, "%s/.Sig", homedir);
  283. X    sprintf (default_signature, "%s/.signature", homedir);
  284. X    sprintf (newsgroups_file, "%s/newsgroups", LIBDIR);
  285. X    sprintf (subscriptions_file, "%s/subscriptions", LIBDIR);
  286. X
  287. X    strcpy (mailer, get_val ("MAILER", DEFAULT_MAILER));
  288. X    strcpy (printer, DEFAULT_PRINTER);
  289. X    strcpy (spooldir, SPOOLDIR);
  290. X    strcpy (bug_addr, BUG_REPORT_ADDRESS);
  291. X    strcpy (redirect_output, "> /dev/null 2>&1");
  292. X
  293. X#ifdef INDEX_DAEMON
  294. X    /*
  295. X     * Check for lock file to stop multiple copies of tind running and
  296. X     * if it does not exist create it so this is the only copy running
  297. X     */
  298. X    if (stat (LOCK_FILE, &sb) == 0) {
  299. X        if ((fp = fopen (LOCK_FILE, "r")) != (FILE *) 0) {
  300. X            fgets (nam, sizeof (nam), fp);
  301. X            fclose (fp);
  302. X            fprintf(stderr, "%s: Already started pid=[%d] on %s", 
  303. X                progname, atoi(nam), nam+8);
  304. X            exit (1);
  305. X        }
  306. X    } else {
  307. X        {
  308. X            long epoch;
  309. X            
  310. X            if ((fp = fopen (LOCK_FILE, "w")) != (FILE *) 0) {
  311. X                time (&epoch);
  312. X                fprintf (fp, "%6d  %s", process_id, ctime (&epoch));
  313. X                fclose (fp);
  314. X                chmod (LOCK_FILE, 0600);
  315. X            }
  316. X        }    
  317. X    }
  318. X     
  319. X    strcpy (newsrc, active_file);    /* so that all groups are indexed */
  320. X    sprintf (indexdir, "%s/.index", spooldir);
  321. X
  322. X    if (stat (indexdir, &sb) == -1) {
  323. X        mkdir (indexdir, 0777);
  324. X    }
  325. X#else
  326. X    if (stat (rcdir, &sb) == -1) {
  327. X        created_rcdir = TRUE;
  328. X        mkdir (rcdir, 0755);
  329. X    }
  330. X    if (tin_uid != real_uid) {
  331. X        sprintf (indexdir, "%s/.index", spooldir);
  332. X
  333. X        set_tin_uid_gid ();
  334. X        if (stat (indexdir, &sb) == -1) {
  335. X            mkdir (indexdir, 0777);
  336. X        }
  337. X        set_real_uid_gid ();
  338. X    } else if (stat (indexdir, &sb) == -1) {
  339. X        mkdir (indexdir, 0755);
  340. X    }
  341. X    if (stat (postfile, &sb) == -1) {
  342. X        if ((fp = fopen (postfile, "w")) != NULL) {
  343. X            fclose (fp);
  344. X        }
  345. X    }
  346. X    if (stat (unthreadfile, &sb) == -1) {
  347. X        if ((fp = fopen (unthreadfile, "w")) != NULL) {
  348. X            fclose (fp);
  349. X        }
  350. X    }
  351. X
  352. X    read_rcfile ();
  353. X
  354. X    show_author = default_show_author;
  355. X
  356. X#endif /* INDEX_DAEMON */    
  357. X
  358. X    if (stat (active_file, &sb) >= 0)
  359. X        goto got_active;
  360. X
  361. X    /*
  362. X     *  I hate forgetting to define LIBDIR correctly.  Guess a couple
  363. X     *  of the likely places if it's not where LIBDIR says it is.
  364. X     */
  365. X
  366. X    strcpy (active_file, "/usr/lib/news/active");
  367. X    if (stat (active_file, &sb) >= 0)
  368. X        goto got_active;
  369. X
  370. X    strcpy (active_file, "/usr/local/lib/news/active");
  371. X    if (stat (active_file, &sb) >= 0)
  372. X        goto got_active;
  373. X
  374. X    strcpy (active_file, "/usr/public/lib/news/active");
  375. X    if (stat (active_file, &sb) >= 0)
  376. X        goto got_active;
  377. X
  378. X    /*
  379. X     *  Oh well. Revert to what LIBDIR says it is to produce a useful
  380. X     *  error message when read_active_file () fails later.
  381. X     */
  382. X
  383. X    sprintf (active_file, "%s/active", LIBDIR);
  384. X
  385. Xgot_active:
  386. X
  387. X    /*
  388. X     *  check enviroment for ORGANIZATION / NEWSORG
  389. X     */
  390. X    my_org[0] = '\0';
  391. X#ifdef apollo
  392. X    if ((p = (char *) getenv ("NEWSORG")) != NULL) {
  393. X#else    
  394. X    if ((p = (char *) getenv ("ORGANIZATION")) != NULL) {
  395. X#endif
  396. X        my_strncpy (my_org, p, sizeof (my_org));
  397. X        goto got_org;
  398. X    }
  399. X
  400. X    /*
  401. X     *  check ~/.tin/organization for organization
  402. X     */
  403. X    sprintf (nam, "%s/organization", rcdir);
  404. X    fp = fopen (nam, "r");
  405. X
  406. X    /*
  407. X     *  check LIBDIR/organization for system wide organization
  408. X     */
  409. X    if (fp == NULL) {
  410. X        sprintf (nam, "%s/organization", LIBDIR);
  411. X        fp = fopen (nam, "r");
  412. X    }
  413. X
  414. X    if (fp == NULL) {
  415. X        sprintf (nam, "/usr/lib/news/organization");
  416. X        fp = fopen (nam, "r");
  417. X    }
  418. X
  419. X    if (fp == NULL) {
  420. X        sprintf (nam, "/usr/local/lib/news/organization");
  421. X        fp = fopen (nam, "r");
  422. X    }
  423. X
  424. X    if (fp == NULL) {
  425. X        sprintf (nam, "/usr/public/lib/news/organization");
  426. X        fp = fopen (nam, "r");
  427. X    }
  428. X
  429. X    if (fp == NULL) {
  430. X        sprintf (nam, "/etc/organization");
  431. X        fp = fopen (nam, "r");
  432. X    }
  433. X
  434. X    if (fp != NULL) {
  435. X        if (fgets (my_org, sizeof (my_org), fp) != NULL) {
  436. X            for (p = my_org; *p && *p != '\n'; p++)
  437. X                continue;
  438. X            *p = '\0';
  439. X        }
  440. X        fclose (fp);
  441. X    }
  442. X
  443. Xgot_org:;
  444. X
  445. X    /*
  446. X     *  check enviroment for REPLYTO
  447. X     */
  448. X    reply_to[0] = '\0';
  449. X    if ((p = (char *) getenv ("REPLYTO")) != NULL) {
  450. X        my_strncpy (reply_to, p, sizeof (reply_to));
  451. X        goto got_reply;
  452. X    }
  453. X
  454. X    sprintf (nam, "%s/replyto", rcdir);
  455. X    if ((fp = fopen (nam, "r")) != NULL) {
  456. X        if (fgets (reply_to, sizeof (reply_to), fp) != NULL) {
  457. X            reply_to[strlen (reply_to)-1] = '\0';
  458. X        }
  459. X        fclose (fp);
  460. X    }
  461. X
  462. Xgot_reply:;
  463. X
  464. X    /*
  465. X     *  check enviroment for DISTRIBUTION
  466. X     */
  467. X    my_distribution[0] = '\0';
  468. X    if ((p = (char *) getenv ("DISTRIBUTION")) != NULL) {
  469. X        my_strncpy (my_distribution, p, sizeof (my_distribution));
  470. X    }
  471. X
  472. X    /*
  473. X     *  check enviroment for ADD_ADDRESS
  474. X      */
  475. X    add_addr[0] = '\0';
  476. X    if ((p = (char *) getenv ("ADD_ADDRESS")) != NULL) {
  477. X        my_strncpy (add_addr, p, sizeof (add_addr));
  478. X        goto got_add_addr;
  479. X    }
  480. X
  481. X    sprintf (nam, "%s/add_address", rcdir);
  482. X    if ((fp = fopen (nam, "r")) != NULL) {
  483. X        if (fgets (add_addr, sizeof (add_addr), fp) != NULL) {
  484. X            add_addr[strlen (add_addr)-1] = '\0';
  485. X        }
  486. X        fclose (fp);
  487. X    }
  488. X
  489. Xgot_add_addr:;
  490. X
  491. X    /*
  492. X     *  check enviroment for BUG_ADDRESS
  493. X     */
  494. X    if ((p = (char *) getenv ("BUG_ADDRESS")) != NULL) {
  495. X        my_strncpy (bug_addr, p, sizeof (bug_addr));
  496. X        goto got_bug_addr;
  497. X    }
  498. X
  499. X    sprintf (nam, "%s/bug_address", rcdir);
  500. X    if ((fp = fopen (nam, "r")) != NULL) {
  501. X        if (fgets (bug_addr, sizeof (bug_addr), fp) != NULL) {
  502. X            bug_addr[strlen (bug_addr)-1] = '\0';
  503. X        }
  504. X        fclose (fp);
  505. X    }
  506. X
  507. Xgot_bug_addr:;
  508. X    sprintf (txt_help_bug_report, txt_help_bug, bug_addr);
  509. X}
  510. X
  511. X/*
  512. X * Set up ~/.tin directory & support files depending on where the news
  513. X * is being read from (ie. active news / CD-ROM spooldir).  Note that
  514. X * any control files which may be specific to a given spooldir (various
  515. X * CD issues versus live news) should be under the spooldir_alias 
  516. X * subdirectory also.
  517. X */
  518. X 
  519. Xvoid set_tindir ()
  520. X{
  521. X    struct stat sb;
  522. X    
  523. X    if (strcmp (spooldir_alias, "news") != 0) {
  524. X        sprintf (rcdir,  "%s/%s", get_val ("TINDIR", homedir), RCDIR);
  525. X        /*
  526. X         * Create directories
  527. X         */
  528. X        if (stat (rcdir, &sb) == -1) {
  529. X            mkdir (rcdir, 0755);
  530. X        }
  531. X        sprintf (rcdir, "%s/%s", rcdir, spooldir_alias); 
  532. X        if (stat (rcdir, &sb) == -1) {
  533. X            created_rcdir = TRUE;
  534. X            mkdir (rcdir, 0755);
  535. X        }
  536. X        /*
  537. X         * Use a separate .newsrc file for every spooldir 
  538. X         */
  539. X        sprintf (newsrc, "%s/.newsrc", rcdir);
  540. X        sprintf (newnewsrc, "%s/.newnewsrc", rcdir);
  541. X
  542. X        spooldir_is_active = FALSE;
  543. X        reread_active_file = FALSE;
  544. X        alarm (0);
  545. X    } else {
  546. X        if (stat (rcdir, &sb) == -1) {
  547. X            mkdir (rcdir, 0755);
  548. X        }
  549. X        sprintf (rcdir,  "%s/%s", get_val ("TINDIR", homedir), RCDIR);
  550. X        sprintf (rcfile,   "%s/%s", rcdir, RCFILE);
  551. X        sprintf (killfile, "%s/%s", rcdir, KILLFILE);
  552. X        sprintf (postfile, "%s/%s", rcdir, POSTFILE);
  553. X        sprintf (unthreadfile, "%s/%s", rcdir, UNTHREADFILE);
  554. X        sprintf (newsrc, "%s/.newsrc", homedir);
  555. X        sprintf (newnewsrc, "%s/.newnewsrc", homedir);
  556. X
  557. X        spooldir_is_active = TRUE;
  558. X        reread_active_file = TRUE;
  559. X    }
  560. X    sprintf (indexdir, "%s/%s", rcdir, INDEXDIR);
  561. X    if (stat (indexdir, &sb) == -1) {
  562. X        mkdir (indexdir, 0755);
  563. X    }
  564. X}
  565. X
  566. X
  567. Xint create_mail_save_dirs ()
  568. X{
  569. X    int created = FALSE;
  570. X    struct stat sb;
  571. X    
  572. X    if (stat (default_maildir, &sb) == -1) {
  573. X        mkdir (default_maildir, 0755);
  574. X        created = TRUE;
  575. X    }
  576. X    if (stat (default_savedir, &sb) == -1) {
  577. X        mkdir (default_savedir, 0755);
  578. X        created = TRUE;
  579. X    }
  580. X    
  581. X    return (created);
  582. X}
  583. END_OF_FILE
  584.   if test 15082 -ne `wc -c <'init.c'`; then
  585.     echo shar: \"'init.c'\" unpacked with wrong size!
  586.   fi
  587.   # end of 'init.c'
  588. fi
  589. if test -f 'newsrc.c' -a "${1}" != "-c" ; then 
  590.   echo shar: Will not clobber existing file \"'newsrc.c'\"
  591. else
  592.   echo shar: Extracting \"'newsrc.c'\" \(20406 characters\)
  593.   sed "s/^X//" >'newsrc.c' <<'END_OF_FILE'
  594. X/*
  595. X *  Project   : tin - a threaded Netnews reader
  596. X *  Module    : newsrc.c
  597. X *  Author    : I.Lea & R.Skrenta
  598. X *  Created   : 01-04-91
  599. X *  Updated   : 19-04-92
  600. X *  Notes     :
  601. X *  Copyright : (c) Copyright 1991-92 by Iain Lea & Rich Skrenta
  602. X *              You may  freely  copy or  redistribute  this software,
  603. X *              so  long as there is no profit made from its use, sale
  604. X *              trade or  reproduction.  You may not change this copy-
  605. X *              right notice, and it must be included in any copy made
  606. X */
  607. X
  608. X#include    "tin.h"
  609. X
  610. X
  611. X/*
  612. X * Automatically subscribe user to newsgroups specified in
  613. X * /usr/lib/news/subscribe (locally) or same file but from
  614. X * NNTP server (LIST AUTOSUBSCRIBE) and create .newsrc
  615. X */
  616. X
  617. Xint auto_subscribe_groups ()
  618. X{
  619. X    char buf[LEN];
  620. X    FILE *fp_newsrc;
  621. X    FILE *fp_subs;
  622. X    int len;
  623. X    int ret_code = FALSE;
  624. X    
  625. X    if ((fp_subs = open_subscription_fp ()) != NULL) {
  626. X        if ((fp_newsrc = fopen (newsrc, "w")) != NULL) {
  627. X            while (fgets (buf, sizeof (buf), fp_subs) != NULL) {
  628. X                len = strlen (buf);
  629. X                if (len > 1) {
  630. X                    buf[len-1] = '\0';
  631. X                    fprintf (fp_newsrc, "%s:\n", buf);
  632. X                }    
  633. X            }    
  634. X            fclose (fp_newsrc);
  635. X            ret_code = TRUE;
  636. X        }    
  637. X        fclose (fp_subs);
  638. X    }
  639. X
  640. X    return (ret_code);
  641. X}
  642. X
  643. X/*
  644. X * make a backup of users .newsrc in case of the bogie man
  645. X */
  646. X
  647. Xvoid backup_newsrc ()
  648. X{
  649. X    char buf[8192];
  650. X    FILE *fp_newsrc, *fp_backup;
  651. X    
  652. X    if ((fp_newsrc = fopen (newsrc, "r")) != NULL) {
  653. X        sprintf (buf, "%s/.oldnewsrc", homedir);
  654. X        unlink (buf);    /* because rn makes a link of .newsrc -> .oldnewsrc */
  655. X        if ((fp_backup = fopen (buf, "w")) != NULL) {
  656. X            while (fgets (buf, sizeof (buf), fp_newsrc) != NULL) {
  657. X                fputs (buf, fp_backup);
  658. X            }
  659. X            fclose (fp_backup);
  660. X        }
  661. X        fclose (fp_newsrc);
  662. X    }
  663. X}
  664. X
  665. X/*
  666. X *  Read $HOME/.newsrc into my_group[]. my_group[] ints point to
  667. X *  active[] entries.  Sub_only determines  whether to just read
  668. X *  subscribed groups or all of them.
  669. X */
  670. X
  671. Xvoid read_newsrc (sub_only)
  672. X    int sub_only;        /* TRUE=subscribed groups only, FALSE=all groups */
  673. X{
  674. X    char c, *p, buf[8192];
  675. X    char old_groups[LEN];
  676. X    FILE *fp = (FILE *) 0;
  677. X    FILE *fp_old = (FILE *) 0;
  678. X    int i;
  679. X    int remove_old_groups = FALSE;
  680. X
  681. X    group_top = 0;
  682. X
  683. Xreread_newsrc:
  684. X
  685. X    if ((fp = fopen (newsrc, "r")) == NULL) {    /* attempt to make a .newsrc */
  686. X        if (auto_subscribe_groups ()) {        /* attempt to auto create newsrc */
  687. X            goto reread_newsrc;
  688. X        }    
  689. X        for (i = 0; i < num_active; i++) {
  690. X            if (group_top >= max_active) {
  691. X                expand_active ();
  692. X            }
  693. X            my_group[group_top] = i;
  694. X            active[i].flag = 0;
  695. X            unread[group_top] = -1;
  696. X            group_top++;
  697. X        }
  698. X        write_newsrc ();
  699. X        return;
  700. X    }
  701. X
  702. X    sprintf (old_groups, "%s/.newsrc.%d", homedir, process_id);
  703. X
  704. X    while (fgets (buf, sizeof buf, fp) != NULL) {
  705. X        p = buf;
  706. X        while (*p && *p != '\n' && *p != ' ' && *p != ':' && *p != '!')
  707. X            p++;
  708. X        c = *p;
  709. X        *p++ = '\0';
  710. X
  711. X        if (c == '!' && sub_only)
  712. X            continue;        /* unsubscribed */
  713. X
  714. X        if ((i = add_group (buf, FALSE)) < 0) {
  715. X            if (! remove_old_groups) {
  716. X                if ((fp_old = fopen (old_groups, "w")) == NULL) {
  717. X                    perror_message (txt_cannot_open, old_groups);
  718. X                    continue;
  719. X                }
  720. X                remove_old_groups = TRUE;
  721. X            }
  722. X            fprintf (fp_old, "%s\n", buf);
  723. X            continue;
  724. X        }
  725. X
  726. X        if (c != '!')        /* if we're subscribed to it */
  727. X            active[my_group[i]].flag |= SUBSCRIBED;
  728. X
  729. X        unread[i] = parse_unread (p, my_group[i]);
  730. X    }
  731. X    fclose (fp);
  732. X
  733. X    /*
  734. X     *  rewrite newsrc to get rid of any non-existant groups 
  735. X     */
  736. X    if (remove_old_groups) {
  737. X        fclose (fp_old);
  738. X        rewrite_newsrc ();
  739. X    }
  740. X}
  741. X
  742. X/*
  743. X *  Write a new newsrc from my_group[] and active[] mygroup if
  744. X *  rewriting to get rid of groups that don't exist any longer. Used
  745. X *  to a create a new .newsrc if there isn't one already, or when
  746. X *  the newsrc is reset.
  747. X */
  748. X
  749. Xvoid write_newsrc ()
  750. X{
  751. X    FILE *fp;
  752. X    int i;
  753. X
  754. X    if ((fp = fopen (newsrc, "w")) == NULL) {
  755. X        return;
  756. X    }
  757. X
  758. X    wait_message (txt_creating_newsrc);
  759. X
  760. X    for (i=0 ; i < num_active ; i++) {
  761. X        fprintf (fp, "%s! \n", active[i].name);
  762. X    }
  763. X
  764. X    fclose (fp);
  765. X}
  766. X
  767. X/*
  768. X *  Rewrite newsrc to get rid of groups that don't exist any longer.
  769. X */
  770. X
  771. Xvoid rewrite_newsrc ()
  772. X{
  773. X    char buf[8192], old[LEN];
  774. X    char old_groups[LEN];
  775. X    FILE *fp, *fp_old, *fp_new;
  776. X    int found_old_group, len;    
  777. X
  778. X    sprintf (old_groups, "%s/.newsrc.%d", homedir, process_id);
  779. X
  780. X    if ((fp = fopen (newsrc, "r")) == NULL)
  781. X        goto removed_old_groups_done;
  782. X
  783. X    if ((fp_old = fopen (old_groups, "r")) == NULL)
  784. X        goto removed_old_groups_done;
  785. X
  786. X    if ((fp_new = fopen (newnewsrc, "w")) == NULL)
  787. X        goto removed_old_groups_done;
  788. X
  789. X    while (fgets (buf, sizeof buf, fp) != NULL) {            /* read group from newsrc */
  790. X        rewind (fp_old);
  791. X        found_old_group = FALSE;    
  792. X        while (fgets (old, sizeof old, fp_old) != NULL) {    /* read group from oldgroups */
  793. X            len = strlen (old)-1;
  794. X            if ((buf[len] == ':' || buf[len] == '!') &&
  795. X                strncmp (buf, old, len) == 0) {
  796. X                old[len] = '\0';
  797. X                sprintf (msg, txt_deleting_from_newsrc, old);
  798. X                wait_message (msg);
  799. X                if (cmd_line) {
  800. X                    wait_message ("\n");
  801. X                }    
  802. X                found_old_group = TRUE;    
  803. X            }
  804. X        }
  805. X        if (! found_old_group) {
  806. X            fprintf (fp_new, "%s", buf);
  807. X        }
  808. X    }
  809. X    
  810. X    fclose (fp);
  811. X    fclose (fp_old);
  812. X    fclose (fp_new);
  813. X
  814. X    rename_file (newnewsrc, newsrc);
  815. X
  816. Xremoved_old_groups_done:
  817. X    unlink (old_groups);
  818. X}
  819. X
  820. X/*
  821. X *  Load the sequencer rang lists and mark arts[] according to the
  822. X *  .newsrc info for a particular group.  i.e.  rec.arts.comics: 1-94,97
  823. X */
  824. X
  825. Xvoid read_newsrc_line (group)
  826. X    char *group;
  827. X{
  828. X    FILE *fp;
  829. X    char buf[8192];
  830. X    char *p;
  831. X
  832. X    if ((fp = fopen (newsrc, "r")) == NULL)
  833. X        return;
  834. X
  835. X    while (fgets (buf, sizeof buf, fp) != NULL) {
  836. X        p = buf;
  837. X        while (*p && *p != '\n' && *p != ' ' && *p != ':' && *p != '!')
  838. X            p++;
  839. X        *p++ = '\0';
  840. X        if (strcmp (buf, group) != 0)
  841. X            continue;
  842. X        parse_seq (p);
  843. X        break;
  844. X    }
  845. X
  846. X    fclose (fp);
  847. X}
  848. X
  849. X/*
  850. X *  For our current group, update the sequencer information in .newsrc
  851. X */
  852. X
  853. Xvoid update_newsrc (group, groupnum, mark_unread)
  854. X    char *group;
  855. X    int groupnum;            /* index into active[] for this group */
  856. X    int mark_unread;
  857. X{
  858. X    FILE *fp;
  859. X    FILE *newfp;
  860. X    char buf[8192];
  861. X    char *p;
  862. X    char c;
  863. X
  864. X    if ((newfp = fopen (newnewsrc, "w")) == NULL) {
  865. X        goto update_done;
  866. X    }
  867. X
  868. X    if ((fp = fopen (newsrc, "r")) != NULL) {
  869. X        while (fgets (buf, sizeof buf, fp) != NULL) {
  870. X            for (p = buf; *p; p++)
  871. X                if (*p == '\n') {
  872. X                    *p = '\0';
  873. X                    break;
  874. X                }
  875. X
  876. X            p = buf;
  877. X            while (*p && *p != ' ' && *p != ':' && *p != '!')
  878. X                    p++;
  879. X            c = *p;
  880. X            if (c != '\0')
  881. X                *p++ = '\0';
  882. X
  883. X            if (c != '!' && c != ' ')
  884. X                c = ':';
  885. X
  886. X            if (strcmp (buf, group) == 0) {
  887. X                if (mark_unread) {
  888. X                    fprintf (newfp, "%s%c\n", buf, c);
  889. X                } else {
  890. X                    fprintf (newfp, "%s%c ", buf, c);
  891. X                    print_seq (newfp, groupnum);
  892. X                    fprintf (newfp, "\n");
  893. X                }
  894. X            } else
  895. X                fprintf (newfp, "%s%c%s\n", buf, c, p);
  896. X        }
  897. X        fclose (fp);
  898. X    }
  899. X
  900. X    fclose (newfp);
  901. X    rename_file (newnewsrc, newsrc);
  902. X
  903. Xupdate_done:
  904. X    ;
  905. X}
  906. X
  907. X/*
  908. X *  Subscribe/unsubscribe to a group in .newsrc.  ch should either be
  909. X *  '!' to unsubscribe or ':' to subscribe.  num is the group's index
  910. X *  in active[].
  911. X */
  912. X
  913. Xvoid subscribe (group, ch, num, out_seq)
  914. X    char *group;
  915. X    char ch;
  916. X    int num;
  917. X    int out_seq;                /* output sequencer info? */
  918. X{
  919. X    FILE *fp;
  920. X    FILE *newfp;
  921. X    char buf[8192];
  922. X    char *p;
  923. X    char c;
  924. X    int gotit = FALSE;
  925. X
  926. X    if (ch == '!')
  927. X        active[num].flag &= ~SUBSCRIBED;
  928. X    else
  929. X        active[num].flag |= SUBSCRIBED;
  930. X
  931. X    if ((newfp = fopen (newnewsrc, "w")) == NULL)
  932. X        goto subscribe_done;
  933. X
  934. X    if ((fp = fopen (newsrc, "r")) != NULL) {
  935. X        while (fgets (buf, sizeof buf, fp) != NULL) {
  936. X            if (strncmp ("options ", buf, 8) == 0) {
  937. X                fprintf (newfp, buf);
  938. X            } else {
  939. X                for (p = buf; *p; p++) {
  940. X                    if (*p == '\n') {
  941. X                        *p = '\0';
  942. X                        break;
  943. X                    }
  944. X                }    
  945. X
  946. X                p = buf;
  947. X                while (*p && *p != ' ' && *p != ':' && *p != '!')
  948. X                        p++;
  949. X                c = *p;
  950. X                if (c != '\0')
  951. X                    *p++ = '\0';
  952. X
  953. X                if (c != '!')
  954. X                    c = ':';
  955. X
  956. X                if (strcmp (buf, group) == 0) {
  957. X                    fprintf (newfp, "%s%c%s\n", buf, ch, p);
  958. X                    gotit = TRUE;
  959. X                } else {
  960. X                    fprintf (newfp, "%s%c%s\n", buf, c, p);
  961. X                }
  962. X            }
  963. X        }
  964. X        fclose (fp);
  965. X    }
  966. X
  967. X    if (! gotit) {
  968. X        if (out_seq) {
  969. X            fprintf (newfp, "%s%c ", group, ch);
  970. X            print_seq (newfp, num);
  971. X            fprintf (newfp, "\n");
  972. X        } else
  973. X            fprintf (newfp, "%s%c\n", group, ch);
  974. X    }
  975. X
  976. X    fclose (newfp);
  977. X    rename_file (newnewsrc, newsrc);
  978. X
  979. Xsubscribe_done:
  980. X    ;
  981. X}
  982. X
  983. X
  984. Xvoid reset_newsrc ()
  985. X{
  986. X    FILE *fp;
  987. X    FILE *newfp;
  988. X    char buf[8192];
  989. X    char *p;
  990. X    char c;
  991. X    int i;
  992. X
  993. X    if ((newfp = fopen (newnewsrc, "w")) == NULL)
  994. X        goto update_done;
  995. X
  996. X    if ((fp = fopen (newsrc, "r")) != NULL) {
  997. X        while (fgets (buf, sizeof (buf), fp) != NULL) {
  998. X            for (p = buf; *p && *p != '\n'; p++)
  999. X                continue;
  1000. X            *p = '\0';
  1001. X
  1002. X            p = buf;
  1003. X            while (*p && *p != ' ' && *p != ':' && *p != '!')
  1004. X                    p++;
  1005. X            c = *p;
  1006. X            if (c != '\0')
  1007. X                *p++ = '\0';
  1008. X
  1009. X            if (c != '!')
  1010. X                c = ':';
  1011. X
  1012. X            fprintf (newfp, "%s%c\n", buf, c);
  1013. X        }
  1014. X        fclose (fp);
  1015. X    }
  1016. X
  1017. X    fclose (newfp);
  1018. X    rename_file (newnewsrc, newsrc);
  1019. X
  1020. Xupdate_done:
  1021. X    for (i = 0; i < group_top; i++)
  1022. X        unread[i] = -1;
  1023. X}
  1024. X
  1025. X
  1026. Xvoid delete_group (group)
  1027. X    char *group;
  1028. X{
  1029. X    FILE *fp;
  1030. X    FILE *newfp;
  1031. X    char buf[8192];
  1032. X    char *p;
  1033. X    char c;
  1034. X    int gotit = FALSE;
  1035. X    FILE *del;
  1036. X
  1037. X    if ((newfp = fopen (newnewsrc, "w")) == NULL)
  1038. X        goto del_done;
  1039. X
  1040. X    if ((del = fopen (delgroups, "a+")) == NULL)
  1041. X        goto del_done;
  1042. X
  1043. X    if ((fp = fopen (newsrc, "r")) != NULL) {
  1044. X        while (fgets (buf, sizeof (buf), fp) != NULL) {
  1045. X            for (p = buf; *p && *p != '\n'; p++)
  1046. X                continue;
  1047. X            *p = '\0';
  1048. X
  1049. X            p = buf;
  1050. X            while (*p && *p != ' ' && *p != ':' && *p != '!')
  1051. X                    p++;
  1052. X            c = *p;
  1053. X            if (c != '\0')
  1054. X                *p++ = '\0';
  1055. X
  1056. X            if (c != '!')
  1057. X                c = ':';
  1058. X
  1059. X            if (strcmp (buf, group) == 0) {
  1060. X                fprintf (del, "%s%c%s\n", buf, c, p);
  1061. X                gotit = TRUE;
  1062. X            } else
  1063. X                fprintf (newfp, "%s%c%s\n", buf, c, p);
  1064. X        }
  1065. X        fclose (fp);
  1066. X    }
  1067. X
  1068. X    fclose (newfp);
  1069. X
  1070. X    if (! gotit)
  1071. X        fprintf (del, "%s! \n", group);
  1072. X
  1073. X    fclose (del);
  1074. X    rename_file (newnewsrc, newsrc);
  1075. X
  1076. Xdel_done:
  1077. X    ;
  1078. X}
  1079. X
  1080. X
  1081. Xint undel_group ()
  1082. X{
  1083. X    FILE *del;
  1084. X    FILE *newfp;
  1085. X    FILE *fp;
  1086. X    char buf[2][8192];
  1087. X    char *p;
  1088. X    int which = 0;
  1089. X    long h;
  1090. X    extern int cur_groupnum;
  1091. X    int i, j;
  1092. X    char c;
  1093. X
  1094. X    if ((del = fopen(delgroups, "r")) == NULL) {
  1095. X        return FALSE;
  1096. X    }
  1097. X
  1098. X    unlink(delgroups);
  1099. X    
  1100. X    if ((newfp = fopen(delgroups, "w")) == NULL) {
  1101. X        return FALSE;
  1102. X    }
  1103. X
  1104. X    buf[0][0] = '\0';
  1105. X    buf[1][0] = '\0';
  1106. X
  1107. X    while (fgets(buf[which], sizeof (buf[which]), del) != NULL) {
  1108. X        which = !which;
  1109. X        if (*buf[which])
  1110. X            fputs(buf[which], newfp);
  1111. X    }
  1112. X
  1113. X    fclose(del);
  1114. X    fclose(newfp);
  1115. X    which = !which;
  1116. X
  1117. X    if (!*buf[which]) {
  1118. X        return FALSE;
  1119. X    }
  1120. X
  1121. X    for (p = buf[which]; *p && *p != '\n'; p++)
  1122. X        continue;
  1123. X    *p = '\0';
  1124. X
  1125. X    p = buf[which];
  1126. X    while (*p && *p != ' ' && *p != ':' && *p != '!')
  1127. X        p++;
  1128. X    c = *p;
  1129. X    if (c != '\0')
  1130. X        *p++ = '\0';
  1131. X
  1132. X    if (c != '!')
  1133. X        c = ':';
  1134. X
  1135. X    h = hash_groupname (buf[which]);
  1136. X
  1137. X    for (i = group_hash[h]; i >= 0; i = active[i].next) {
  1138. X        if (strcmp(buf[which], active[i].name) == 0) {
  1139. X            for (j = 0; j < group_top; j++)
  1140. X                if (my_group[j] == i) {
  1141. X                    return j;
  1142. X                }
  1143. X
  1144. X            active[i].flag &= ~UNSUBSCRIBED;   /* mark that we got it */
  1145. X            if (c != '!')
  1146. X                active[i].flag |= SUBSCRIBED;
  1147. X
  1148. X            if (group_top >= max_active)
  1149. X                expand_active ();
  1150. X            group_top++;
  1151. X            for (j = group_top; j > cur_groupnum; j--) {
  1152. X                my_group[j] = my_group[j-1];
  1153. X                unread[j] = unread[j-1];
  1154. X            }
  1155. X            my_group[cur_groupnum] = i;
  1156. X            unread[cur_groupnum] = parse_unread(p, i);
  1157. X
  1158. X            if ((fp = fopen(newsrc, "r")) == NULL) {
  1159. X                return FALSE;
  1160. X            }
  1161. X            if ((newfp = fopen(newnewsrc, "w")) == NULL) {
  1162. X                fclose(fp);
  1163. X                return FALSE;
  1164. X            }
  1165. X            i = 0;
  1166. X            while (fgets(buf[!which], sizeof (buf[!which]), fp) != NULL) {
  1167. X                for (p = buf[!which]; *p && *p != '\n'; p++)
  1168. X                    continue;
  1169. X                *p = '\0';
  1170. X
  1171. X                p = buf[!which];
  1172. X                while (*p && *p!=' ' && *p != ':' && *p != '!')
  1173. X                    p++;
  1174. X                c = *p;
  1175. X                if (c != '\0')
  1176. X                    *p++ = '\0';
  1177. X
  1178. X                if (c != '!')
  1179. X                    c = ':';
  1180. X
  1181. X                while (i < cur_groupnum) {
  1182. X                    if (strcmp(buf[!which],
  1183. X                      active[my_group[i]].name) == 0) {
  1184. X                        fprintf(newfp, "%s%c%s\n",
  1185. X                            buf[!which], c, p);
  1186. X                        goto foo_cont;
  1187. X                    }
  1188. X                    i++;
  1189. X                }
  1190. X                fprintf(newfp, "%s%c%s\n", buf[which], c, p);
  1191. X                fprintf(newfp, "%s%c%s\n", buf[!which], c, p);
  1192. X                break;
  1193. Xfoo_cont:;
  1194. X            }
  1195. X
  1196. X            while (fgets (buf[!which], sizeof (buf[!which]), fp) != NULL)
  1197. X                fputs (buf[!which], newfp);
  1198. X
  1199. X            fclose (newfp);
  1200. X            fclose (fp);
  1201. X            rename_file (newnewsrc, newsrc);
  1202. X            return TRUE;
  1203. X        }
  1204. X    }
  1205. X    return FALSE;
  1206. X}
  1207. X
  1208. X
  1209. Xvoid mark_group_read (group, groupnum)
  1210. X    char *group;
  1211. X    int groupnum;            /* index into active[] for this group */
  1212. X{
  1213. X    FILE *fp;
  1214. X    FILE *newfp;
  1215. X    char buf[8192];
  1216. X    char *p;
  1217. X    char c;
  1218. X
  1219. X    if (active[groupnum].max < 2)
  1220. X        return;
  1221. X
  1222. X    if ((newfp = fopen (newnewsrc, "w")) == NULL)
  1223. X        goto mark_group_read_done;
  1224. X
  1225. X    if ((fp = fopen (newsrc, "r")) != NULL) {
  1226. X        while (fgets(buf, sizeof (buf), fp) != NULL) {
  1227. X            for (p = buf; *p; p++)
  1228. X                if (*p == '\n') {
  1229. X                    *p = '\0';
  1230. X                    break;
  1231. X                }
  1232. X
  1233. X            p = buf;
  1234. X            while (*p && *p != ' ' && *p != ':' && *p != '!')
  1235. X                    p++;
  1236. X            c = *p;
  1237. X            if (c != '\0')
  1238. X                *p++ = '\0';
  1239. X
  1240. X            if (c != '!')
  1241. X                c = ':';
  1242. X
  1243. X            if (strcmp (buf, group) == 0) {
  1244. X                fprintf (newfp, "%s%c 1-%ld\n", buf, c, active[groupnum].max);
  1245. X            } else
  1246. X                fprintf(newfp, "%s%c%s\n", buf, c, p);
  1247. X        }
  1248. X        fclose (fp);
  1249. X    }
  1250. X
  1251. X    fclose (newfp);
  1252. X    rename_file (newnewsrc, newsrc);
  1253. X
  1254. Xmark_group_read_done:
  1255. X    ;
  1256. X}
  1257. X
  1258. X
  1259. Xvoid parse_seq(s)
  1260. X    char *s;
  1261. X{
  1262. X    long low, high;
  1263. X    int i;
  1264. X
  1265. X    while (*s) {
  1266. X        while (*s && (*s < '0' || *s > '9'))
  1267. X            s++;
  1268. X
  1269. X        if (*s && *s >= '0' && *s <= '9') {
  1270. X            low = (long) atol (s);
  1271. X            while (*s && *s >= '0' && *s <= '9')
  1272. X                s++;
  1273. X            if (*s == '-') {
  1274. X                s++;
  1275. X                high = (long) atol (s);
  1276. X                while (*s && *s >= '0' && *s <= '9')
  1277. X                    s++;
  1278. X            }  else
  1279. X                high = low;
  1280. X
  1281. X            for (i = 0; i < top; i++)
  1282. X                if (arts[i].artnum >= low && arts[i].artnum <= high)
  1283. X                    arts[i].unread = ART_READ;
  1284. X        }
  1285. X    }
  1286. X}
  1287. X
  1288. X/*
  1289. X *  Read the first range from the .newsrc sequencer information.
  1290. X *  If the top of the first range is higher than what the active
  1291. X *  file claims is the bottom, use it as the new bottom instead.
  1292. X */
  1293. X
  1294. Xint parse_unread (s, groupnum)
  1295. X    char *s;
  1296. X    int groupnum;            /* index for group in active[] */
  1297. X{
  1298. X    long low, high;
  1299. X    long last_high;
  1300. X    int sum = 0;
  1301. X    int gotone = FALSE;
  1302. X    int n;
  1303. X
  1304. X    high = 0;
  1305. X
  1306. X    if (*s) {
  1307. X        while (*s && (*s < '0' || *s > '9')) {
  1308. X            s++;
  1309. X        }    
  1310. X
  1311. X        if (*s && *s >= '0' && *s <= '9') {
  1312. X            low = (long) atol (s);
  1313. X            while (*s && *s >= '0' && *s <= '9')
  1314. X                s++;
  1315. X            if (*s == '-') {
  1316. X                s++;
  1317. X                high = (long) atol (s);
  1318. X                while (*s && *s >= '0' && *s <= '9')
  1319. X                    s++;
  1320. X            }  else
  1321. X                high = low;
  1322. X            gotone = TRUE;
  1323. X        }
  1324. X    }
  1325. X
  1326. X    /* Note that in the active file min will be one greater than max
  1327. X     * when there are no articles in the spool directory. ie., it is
  1328. X      * always true that "max - min + 1 = article count (including
  1329. X      * expired articles)"
  1330. X      */
  1331. X
  1332. X    if (high < active[groupnum].min - 1)
  1333. X        high = active[groupnum].min - 1;
  1334. X
  1335. X    while (*s) {
  1336. X        last_high = high;
  1337. X
  1338. X        while (*s && (*s < '0' || *s > '9'))
  1339. X            s++;
  1340. X
  1341. X        if (*s && *s >= '0' && *s <= '9') {
  1342. X            low = (long) atol (s);
  1343. X            while (*s && *s >= '0' && *s <= '9')
  1344. X                s++;
  1345. X            if (*s == '-') {
  1346. X                s++;
  1347. X                high = (long) atol (s);
  1348. X                while (*s && *s >= '0' && *s <= '9')
  1349. X                    s++;
  1350. X            }  else
  1351. X                high = low;
  1352. X
  1353. X            if (low > last_high)    /* otherwise seq out of order */
  1354. X                sum += (low - last_high) - 1;
  1355. X        }
  1356. X    }
  1357. X
  1358. X    if (gotone) {
  1359. X        if (active[groupnum].max > high)
  1360. X            sum += active[groupnum].max - high;
  1361. X        return sum;
  1362. X    }
  1363. X
  1364. X    n = (int) (active[groupnum].max - active[groupnum].min) + 1;
  1365. X    
  1366. X    if (n < 0)
  1367. X        return -1;
  1368. X    else
  1369. X        return (n);
  1370. X}
  1371. X
  1372. X
  1373. Xint get_line_unread(group, groupnum)
  1374. X    char *group;
  1375. X    int groupnum;                /* index for group in active[] */
  1376. X{
  1377. X    FILE *fp;
  1378. X    char buf[8192];
  1379. X    char *p;
  1380. X    int ret = -1;
  1381. X
  1382. X    if ((fp = fopen(newsrc, "r")) == NULL)
  1383. X        return -1;
  1384. X
  1385. X    while (fgets(buf, sizeof (buf), fp) != NULL) {
  1386. X        p = buf;
  1387. X        while (*p && *p != '\n' && *p != ' ' && *p != ':' && *p != '!')
  1388. X            p++;
  1389. X        *p++ = '\0';
  1390. X        
  1391. X        if (strcmp (buf, group) != 0)
  1392. X            continue;
  1393. X            
  1394. X        ret = parse_unread (p, groupnum);
  1395. X        break;
  1396. X    }
  1397. X
  1398. X    fclose (fp);
  1399. X    return ret;
  1400. X}
  1401. X
  1402. X
  1403. Xvoid print_seq (fp, groupnum)
  1404. X    FILE *fp;
  1405. X    int groupnum;            /* index into active[] for this group */
  1406. X{
  1407. X    long int artnum, last_read, artmax;
  1408. X    int i;
  1409. X    int flag = FALSE;
  1410. X    
  1411. X    assert(top >= 0);
  1412. X
  1413. X      /*
  1414. X       *  sort into the same order as in the spool area for writing
  1415. X       *  read article numbers to ~/.newsrc
  1416. X       */
  1417. X     if (top > 0)
  1418. X         qsort ((char *) arts, top, sizeof (struct article_t), artnum_comp);
  1419. X  
  1420. X     /*
  1421. X      * Note that killed and expired articles do not appear in arts[].
  1422. X      * So, even if top is 0 there may be sequencer info to output.
  1423. X     */
  1424. X     if (top > 0 && arts[top-1].artnum > active[groupnum].max)
  1425. X         artmax = arts[top-1].artnum;
  1426. X     else
  1427. X         artmax = active[groupnum].max;
  1428. X     for (artnum=1, i=0; artnum <= artmax; ++artnum, ++i) {
  1429. X         assert(i<=top);
  1430. X         if (i==top || arts[i].unread == ART_READ || artnum != arts[i].artnum) {
  1431. X              if (flag)
  1432. X                  fprintf(fp, ",");
  1433. X              else
  1434. X                  flag = TRUE;
  1435. X             fprintf (fp, "%ld", artnum);
  1436. X 
  1437. X             while (i < top && arts[i].unread == ART_READ)
  1438. X                 ++i;
  1439. X 
  1440. X             last_read = (i<top ? arts[i].artnum - 1 : artmax);
  1441. X 
  1442. X             if (last_read != artnum) {
  1443. X                 fprintf(fp, "-%ld", last_read);
  1444. X              }
  1445. X
  1446. X             assert(i <= top);
  1447. X             if (i == top)
  1448. X                 break;
  1449. X             artnum = arts[i].artnum;
  1450. X          }
  1451. X      }
  1452. X  
  1453. X      fflush (fp);
  1454. X     if (top == 0)
  1455. X         return;
  1456. X
  1457. X    /*
  1458. X     *  resort into required sort order
  1459. X     */
  1460. X    switch (sort_art_type) {
  1461. X        case SORT_BY_NOTHING:        /* already sorted above */
  1462. X            break;
  1463. X        case SORT_BY_SUBJ_DESCEND:
  1464. X        case SORT_BY_SUBJ_ASCEND:
  1465. X            qsort ((char *) arts, top, sizeof (struct article_t), subj_comp);
  1466. X            break;
  1467. X        case SORT_BY_FROM_DESCEND:
  1468. X        case SORT_BY_FROM_ASCEND:
  1469. X            qsort ((char *) arts, top, sizeof (struct article_t), from_comp);
  1470. X            break;
  1471. X        case SORT_BY_DATE_DESCEND:
  1472. X        case SORT_BY_DATE_ASCEND:
  1473. X            qsort ((char *) arts, top, sizeof (struct article_t), date_comp);
  1474. X            break;
  1475. X    }
  1476. X}
  1477. X
  1478. X/*
  1479. X *  rewrite .newsrc and position group at specifed position
  1480. X */
  1481. X
  1482. Xint pos_group_in_newsrc (group, pos)
  1483. X    char *group;
  1484. X    int pos;
  1485. X{
  1486. X    char sub[1024];
  1487. X    char unsub[1024];
  1488. X    char buf[1024];
  1489. X    char newsgroup[1024];
  1490. X    extern int cur_groupnum;
  1491. X    FILE *fp_in, *fp_out;
  1492. X    FILE *fp_sub, *fp_unsub;
  1493. X    int repositioned = FALSE;
  1494. X    int subscribed_pos = 1;
  1495. X    int group_len;
  1496. X    int option_line = FALSE;
  1497. X    int ret_code = FALSE;
  1498. X
  1499. X    if ((fp_in = fopen (newsrc, "r")) == NULL) {
  1500. X        goto rewrite_group_done;
  1501. X    }
  1502. X    if ((fp_out = fopen (newnewsrc, "w")) == NULL) {
  1503. X        goto rewrite_group_done;
  1504. X    }
  1505. X
  1506. X    sprintf (sub, "/tmp/.subrc.%d", process_id);
  1507. X    sprintf (unsub, "/tmp/.unsubrc.%d", process_id);
  1508. X
  1509. X    if ((fp_sub = fopen (sub, "w")) == NULL) {
  1510. X        goto rewrite_group_done;
  1511. X    }
  1512. X    if ((fp_unsub = fopen (unsub, "w")) == NULL) {
  1513. X        goto rewrite_group_done;
  1514. X    }
  1515. X
  1516. X    /*
  1517. X     *  split newsrc into subscribed and unsubscribed to files
  1518. X     */
  1519. X    group_len = strlen (group);
  1520. X
  1521. X    while (fgets (buf, sizeof (buf), fp_in) != NULL) {
  1522. X        if (strncmp (group, buf, group_len) == 0 && buf[group_len] == ':') {
  1523. X            my_strncpy (newsgroup, buf, sizeof (newsgroup));
  1524. X        } else if (strchr (buf, ':') != NULL) {
  1525. X            fprintf (fp_sub, "%s", buf);
  1526. X        } else if (strchr (buf, '!') != NULL) {
  1527. X            fprintf (fp_unsub, "%s", buf);
  1528. X        } else {    /* options line at beginning of .newsrc */
  1529. X            fprintf (fp_sub, "%s", buf);
  1530. X            option_line = TRUE;
  1531. X        }
  1532. X    }
  1533. X
  1534. X    fclose (fp_in);
  1535. X    fclose (fp_sub);
  1536. X    fclose (fp_unsub);
  1537. X
  1538. X    /*
  1539. X     *  write subscribed groups & position group to newnewsrc
  1540. X     */
  1541. X    if ((fp_sub = fopen (sub, "r")) == NULL) {
  1542. X        unlink (sub);
  1543. X        goto rewrite_group_done;
  1544. X    }
  1545. X    while (fgets (buf, sizeof (buf), fp_sub) != NULL) {
  1546. X        if (option_line) {
  1547. X            if (strchr (buf, ':') == NULL && strchr (buf, '!') == NULL) {
  1548. X                fprintf (fp_out, "%s", buf);
  1549. X                continue;
  1550. X            } else {
  1551. X                option_line = FALSE;
  1552. X            }
  1553. X        }
  1554. X
  1555. X        if (pos == subscribed_pos) {
  1556. X            fprintf (fp_out, "%s\n", newsgroup);
  1557. X            repositioned = TRUE;
  1558. X        }
  1559. X        
  1560. X        fprintf (fp_out, "%s", buf);
  1561. X
  1562. X        subscribed_pos++;
  1563. X    }
  1564. X    if (! repositioned) {
  1565. X        fprintf (fp_out, "%s\n", newsgroup);
  1566. X        repositioned = TRUE;
  1567. X    }
  1568. X    
  1569. X    fclose (fp_sub);
  1570. X     unlink (sub);
  1571. X
  1572. X    /*
  1573. X     *  write unsubscribed groups to newnewsrc
  1574. X     */
  1575. X    if ((fp_unsub = fopen (unsub, "r")) == NULL) {
  1576. X        unlink (unsub);
  1577. X        goto rewrite_group_done;
  1578. X    }
  1579. X    while (fgets (buf, sizeof (buf), fp_unsub) != NULL) {
  1580. X        fprintf (fp_out, "%s", buf);
  1581. X    }
  1582. X
  1583. X    fclose (fp_unsub);
  1584. X    unlink (unsub);
  1585. X    fclose (fp_out);
  1586. X
  1587. X    if (repositioned) {
  1588. X        cur_groupnum = pos;
  1589. X        rename_file (newnewsrc, newsrc);
  1590. X        ret_code = TRUE;
  1591. X    }
  1592. X
  1593. Xrewrite_group_done:
  1594. X    return ret_code;
  1595. X}
  1596. X
  1597. X/*
  1598. X *  mark all orther Xref: articles as read when one article read
  1599. X *  Xref: sitename newsgroup:artnum newsgroup:artnum [newsgroup:artnum ...]
  1600. X */
  1601. X 
  1602. Xvoid mark_all_xref_read (xref_line)
  1603. X    char *xref_line; 
  1604. X{
  1605. X/*
  1606. X    char group[LEN];
  1607. X    long artnum;
  1608. X*/    
  1609. X    if (xref_line == (char *) 0) {
  1610. X        return;
  1611. X    }
  1612. X
  1613. X    /*
  1614. X     *  check sitename macthes nodename of current machine
  1615. X     */
  1616. X
  1617. X    /*
  1618. X     *  tokenize each pair and update that newsgroup if it
  1619. X     *  is in users my_group[].
  1620. X     */
  1621. X     
  1622. X}
  1623. END_OF_FILE
  1624.   if test 20406 -ne `wc -c <'newsrc.c'`; then
  1625.     echo shar: \"'newsrc.c'\" unpacked with wrong size!
  1626.   fi
  1627.   # end of 'newsrc.c'
  1628. fi
  1629. if test -f 'nntplib.c' -a "${1}" != "-c" ; then 
  1630.   echo shar: Will not clobber existing file \"'nntplib.c'\"
  1631. else
  1632.   echo shar: Extracting \"'nntplib.c'\" \(14736 characters\)
  1633.   sed "s/^X//" >'nntplib.c' <<'END_OF_FILE'
  1634. X/*
  1635. X *  Project   : tin - a threaded Netnews reader
  1636. X *  Module    : nntplib.c
  1637. X *  Author    : S.Barber & I.Lea
  1638. X *  Created   : 12-01-91
  1639. X *  Updated   : 06-05-92
  1640. X *  Notes     : NNTP client routines taken from clientlib.c v1.6
  1641. X *              1.5.11 (10 February 1991)
  1642. X *  Copyright : (c) Copyright 1991-92 by Stan Barber & Iain Lea
  1643. X *              Permission is hereby granted to copy, reproduce, redistribute
  1644. X *              or otherwise use this software  as long as: there is no
  1645. X *              monetary  profit  gained  specifically  from the use or
  1646. X *              reproduction or this software, it is not  sold, rented,
  1647. X *              traded or otherwise marketed, and this copyright notice
  1648. X *              is included prominently in any copy made. 
  1649. X */
  1650. X
  1651. X#include "tin.h"
  1652. X
  1653. X#ifdef NNTP_ONLY
  1654. X#    define    NNTP_ABLE
  1655. X#endif
  1656. X
  1657. X#ifndef CDROM_ABLE
  1658. X
  1659. XFILE    *ser_rd_fp = NULL;
  1660. XFILE    *ser_wr_fp = NULL;
  1661. X
  1662. X#ifdef NNTP_ABLE
  1663. X#    ifdef TLI
  1664. X#        include    <fcntl.h>
  1665. X#        include    <tiuser.h>
  1666. X#        include    <stropts.h>
  1667. X#        include    <sys/socket.h>
  1668. X#        ifdef WIN_TCP
  1669. X#            include    <sys/in.h>
  1670. X#        else
  1671. X#            include    <netinet/in.h>
  1672. X#        endif
  1673. X#        define    IPPORT_NNTP    ((unsigned short) 119)
  1674. X#        include     <netdb.h>    /* All TLI implementations may not have this */
  1675. X#    else
  1676. X#        ifdef apollo
  1677. X#            include </bsd4.3/usr/include/sys/socket.h>
  1678. X#            include </bsd4.3/usr/include/netinet/in.h>
  1679. X#            include </bsd4.3/usr/include/netdb.h>
  1680. X#        else
  1681. X#            include <sys/socket.h>
  1682. X#            include <netinet/in.h>
  1683. X#            ifndef EXCELAN
  1684. X#                include <netdb.h>
  1685. X#            endif
  1686. X#        endif
  1687. X#    endif /* !TLI */
  1688. X
  1689. X#    ifndef BSD
  1690. X#        define    index(a,b)    strchr(a,b)
  1691. X#        define    bcopy(a,b,c)    memcpy(b,a,c)
  1692. X#        define    bzero(a,b)    memset(a,'\0',b)
  1693. X#    endif
  1694. X
  1695. X#    ifdef EXCELAN
  1696. X#        define    IPPORT_NNTP    ((unsigned short) 119)
  1697. X#        if __STDC__
  1698. X            int connect (int, struct sockaddr *);
  1699. X            unsigned short htons (unsigned short);
  1700. X            unsigned long rhost (char **);
  1701. X            int rresvport (int);
  1702. X            int socket (int, struct sockproto *, struct sockaddr_in *, int);
  1703. X#        endif
  1704. X#    endif
  1705. X
  1706. X#    ifdef DECNET
  1707. X#        include <netdnet/dn.h>
  1708. X#        include <netdnet/dnetdb.h>
  1709. X#    endif
  1710. X
  1711. X#endif /* NNTP_ABLE */
  1712. X
  1713. X/*
  1714. X * getserverbyfile    Get the name of a server from a named file.
  1715. X *            Handle white space and comments.
  1716. X *            Use NNTPSERVER environment variable if set.
  1717. X *
  1718. X *    Parameters:    "file" is the name of the file to read.
  1719. X *
  1720. X *    Returns:    Pointer to static data area containing the
  1721. X *            first non-ws/comment line in the file.
  1722. X *            NULL on error (or lack of entry in file).
  1723. X *
  1724. X *    Side effects:    None.
  1725. X */
  1726. X
  1727. Xchar *getserverbyfile (file)
  1728. X    char    *file;
  1729. X{
  1730. X#ifdef NNTP_ABLE
  1731. X    extern int debug;
  1732. X    register FILE    *fp;
  1733. X    register char    *cp;
  1734. X    static char    buf[256];
  1735. X
  1736. X    if (debug == 1) {
  1737. X        wait_message ("USING BUILTIN NNTP");
  1738. X    }
  1739. X    
  1740. X    if (cp = (char *) getenv ("NNTPSERVER")) {
  1741. X        (void) strcpy (buf, cp);
  1742. X        return (buf);
  1743. X    }
  1744. X
  1745. X    if (file == NULL)
  1746. X        return (NULL);
  1747. X
  1748. X    if ((fp = fopen (file, "r")) == NULL)
  1749. X        return (NULL);
  1750. X
  1751. X    while (fgets (buf, sizeof (buf), fp) != NULL) {
  1752. X        if (*buf == '\n' || *buf == '#') {
  1753. X            continue;
  1754. X        }
  1755. X        cp = (char *) index(buf, '\n');
  1756. X        if (cp) {
  1757. X            *cp = '\0';
  1758. X        }
  1759. X        (void) fclose (fp);
  1760. X        return (buf);
  1761. X    }
  1762. X
  1763. X    (void) fclose (fp);
  1764. X#endif /* NNTP_ABLE */
  1765. X    return (NULL);             /* No entry */
  1766. X}
  1767. X
  1768. X/*
  1769. X * server_init  Get a connection to the remote news server.
  1770. X *
  1771. X *    Parameters:    "machine" is the machine to connect to.
  1772. X *
  1773. X *    Returns:    -1 on error
  1774. X *            server's initial response code on success.
  1775. X *
  1776. X *    Side effects:    Connects to server.
  1777. X *            "ser_rd_fp" and "ser_wr_fp" are fp's
  1778. X *            for reading and writing to server.
  1779. X */
  1780. X
  1781. Xint server_init (machine)
  1782. X    char    *machine;
  1783. X{
  1784. X#ifdef NNTP_ABLE
  1785. X    int    sockt_rd, sockt_wr;
  1786. X    char    line[256];
  1787. X#ifdef DECNET
  1788. X    char    *cp;
  1789. X
  1790. X    cp = (char *) index(machine, ':');
  1791. X
  1792. X    if (cp && cp[1] == ':') {
  1793. X        *cp = '\0';
  1794. X        sockt_rd = get_dnet_socket (machine);
  1795. X    } else {
  1796. X        sockt_rd = get_tcp_socket (machine);
  1797. X    }
  1798. X#else
  1799. X    sockt_rd = get_tcp_socket (machine);
  1800. X#endif
  1801. X
  1802. X    if (sockt_rd < 0)
  1803. X        return (-1);
  1804. X
  1805. X    /*
  1806. X     * Now we'll make file pointers (i.e., buffered I/O) out of
  1807. X     * the socket file descriptor.  Note that we can't just
  1808. X     * open a fp for reading and writing -- we have to open
  1809. X     * up two separate fp's, one for reading, one for writing.
  1810. X     */
  1811. X
  1812. X    if ((ser_rd_fp = (FILE *) fdopen (sockt_rd, "r")) == NULL) {
  1813. X        perror ("server_init: fdopen #1");
  1814. X        return (-1);
  1815. X    }
  1816. X
  1817. X    sockt_wr = dup (sockt_rd);
  1818. X#ifdef TLI
  1819. X    if (t_sync (sockt_rd) < 0) {    /* Sync up new fd with TLI */
  1820. X            t_error ("server_init: t_sync");
  1821. X        ser_rd_fp = NULL;        /* from above */
  1822. X        return (-1);
  1823. X    }
  1824. X#endif
  1825. X    if ((ser_wr_fp = (FILE *) fdopen (sockt_wr, "w")) == NULL) {
  1826. X        perror ("server_init: fdopen #2");
  1827. X        ser_rd_fp = NULL;        /* from above */
  1828. X        return (-1);
  1829. X    }
  1830. X
  1831. X    /*
  1832. X     * Now get the server's signon message
  1833. X     */
  1834. X
  1835. X    (void) get_server (line, sizeof (line));
  1836. X    return (atoi (line));
  1837. X#else
  1838. X    return (-1);
  1839. X#endif /* NNTP_ABLE */
  1840. X}
  1841. X
  1842. X/*
  1843. X * get_tcp_socket -- get us a socket connected to the news server.
  1844. X *
  1845. X *    Parameters:    "machine" is the machine the server is running on.
  1846. X *
  1847. X *    Returns:    Socket connected to the news server if
  1848. X *            all is ok, else -1 on error.
  1849. X *
  1850. X *    Side effects:    Connects to server.
  1851. X *
  1852. X *    Errors:        Printed via perror.
  1853. X */
  1854. X
  1855. Xint get_tcp_socket (machine)
  1856. X    char    *machine;    /* remote host */
  1857. X{
  1858. X#ifdef NNTP_ABLE
  1859. X    int    s = -1;
  1860. X    struct    sockaddr_in sin;
  1861. X#ifdef TLI 
  1862. X    struct    hostent *gethostbyname (), *hp;
  1863. X    struct    t_call    *callptr;
  1864. X
  1865. X    /*
  1866. X     * Create a TCP transport endpoint.
  1867. X     */
  1868. X    if ((s = t_open ("/dev/tcp", O_RDWR, (struct t_info*) 0)) < 0){
  1869. X        t_error ("t_open: can't t_open /dev/tcp");
  1870. X        return (-1);
  1871. X    }
  1872. X    if (t_bind (s, (struct t_bind *) 0, (struct t_bind *) 0) < 0) {
  1873. X           t_error ("t_bind");
  1874. X        t_close (s);
  1875. X        return (-1);
  1876. X    }
  1877. X    bzero((char *) &sin, sizeof (sin));    
  1878. X    sin.sin_family = AF_INET;
  1879. X    sin.sin_port = htons (IPPORT_NNTP);
  1880. X    if (!isdigit(*machine) ||
  1881. X        (long)(sin.sin_addr.s_addr = inet_addr (machine)) == -1) {
  1882. X        if((hp = gethostbyname (machine)) == NULL) {
  1883. X            fprintf (stderr, "gethostbyname: %s: host unknown\n", machine);
  1884. X            t_close (s);
  1885. X            return (-1);
  1886. X        }
  1887. X        bcopy(hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  1888. X    }
  1889. X    
  1890. X    /*
  1891. X     * Allocate a t_call structure and initialize it.
  1892. X     * Let t_alloc() initialize the addr structure of the t_call structure.
  1893. X     */
  1894. X    if ((callptr = (struct t_call *) t_alloc (s,T_CALL,T_ADDR)) == NULL){
  1895. X        t_error ("t_alloc");
  1896. X        t_close (s);
  1897. X        return (-1);
  1898. X    }
  1899. X
  1900. X    callptr->addr.maxlen = sizeof (sin);
  1901. X    callptr->addr.len = sizeof (sin);
  1902. X    callptr->addr.buf = (char *) &sin;
  1903. X    callptr->opt.len = 0;            /* no options */
  1904. X    callptr->udata.len = 0;            /* no user data with connect */
  1905. X
  1906. X    /*
  1907. X     * Connect to the server.
  1908. X     */
  1909. X    if (t_connect (s, callptr, (struct t_call *) 0) < 0) {
  1910. X        t_error ("t_connect");
  1911. X        t_close (s);
  1912. X        return (-1);
  1913. X    }
  1914. X
  1915. X    /*
  1916. X     * Now replace the timod module with the tirdwr module so that
  1917. X     * standard read() and write() system calls can be used on the
  1918. X     * descriptor.
  1919. X     */
  1920. X
  1921. X    if (ioctl (s,  I_POP,  (char *) 0) < 0) {
  1922. X        perror ("I_POP(timod)");
  1923. X        t_close (s);
  1924. X        return (-1);
  1925. X    }
  1926. X
  1927. X    if (ioctl (s,  I_PUSH, "tirdwr") < 0) {
  1928. X        perror ("I_PUSH(tirdwr)");
  1929. X        t_close (s);
  1930. X        return (-1);
  1931. X    }
  1932. X    
  1933. X#else /* !TLI */
  1934. X#ifndef EXCELAN
  1935. X    struct    servent *getservbyname(), *sp;
  1936. X    struct    hostent *gethostbyname(), *hp;
  1937. X#ifdef h_addr
  1938. X    int    x = 0;
  1939. X    register char **cp;
  1940. X    static char *alist[1];
  1941. X#endif /* h_addr */
  1942. X    unsigned long inet_addr();
  1943. X    static struct hostent def;
  1944. X    static struct in_addr defaddr;
  1945. X    static char namebuf[256];
  1946. X
  1947. X    if ((sp = getservbyname ("nntp", "tcp")) ==  NULL) {
  1948. X        fprintf (stderr, "nntp/tcp: Unknown service.\n");
  1949. X        return (-1);
  1950. X    }
  1951. X    /* If not a raw ip address, try nameserver */
  1952. X    if (!isdigit(*machine) ||
  1953. X        (long)(defaddr.s_addr = inet_addr (machine)) == -1)
  1954. X        hp = gethostbyname (machine);
  1955. X    else {
  1956. X        /* Raw ip address, fake  */
  1957. X        (void) strcpy (namebuf, machine);
  1958. X        def.h_name = namebuf;
  1959. X#ifdef h_addr
  1960. X        def.h_addr_list = alist;
  1961. X#endif
  1962. X        def.h_addr = (char *) &defaddr;
  1963. X        def.h_length = sizeof (struct in_addr);
  1964. X        def.h_addrtype = AF_INET;
  1965. X        def.h_aliases = 0;
  1966. X        hp = &def;
  1967. X    }
  1968. X    if (hp == NULL) {
  1969. X        fprintf (stderr, "%s: Unknown host.\n", machine);
  1970. X        return (-1);
  1971. X    }
  1972. X
  1973. X    bzero((char *) &sin, sizeof (sin));
  1974. X    sin.sin_family = hp->h_addrtype;
  1975. X    sin.sin_port = sp->s_port;
  1976. X#else /* EXCELAN */
  1977. X    bzero((char *) &sin, sizeof (sin));
  1978. X    sin.sin_family = AF_INET;
  1979. X#endif /* EXCELAN */
  1980. X
  1981. X    /*
  1982. X     * The following is kinda gross.  The name server under 4.3
  1983. X     * returns a list of addresses, each of which should be tried
  1984. X     * in turn if the previous one fails.  However, 4.2 hostent
  1985. X     * structure doesn't have this list of addresses.
  1986. X     * Under 4.3, h_addr is a #define to h_addr_list[0].
  1987. X     * We use this to figure out whether to include the NS specific
  1988. X     * code...
  1989. X     */
  1990. X
  1991. X#ifdef h_addr
  1992. X    /*
  1993. X     * get a socket and initiate connection -- use multiple addresses
  1994. X     */
  1995. X
  1996. X    for (cp = hp->h_addr_list; cp && *cp; cp++) {
  1997. X        s = socket (hp->h_addrtype, SOCK_STREAM, 0);
  1998. X        if (s < 0) {
  1999. X            perror ("socket");
  2000. X            return (-1);
  2001. X        }
  2002. X        bcopy(*cp, (char *) &sin.sin_addr, hp->h_length);
  2003. X        
  2004. X        if (x < 0) {
  2005. X            fprintf (stderr, "trying %s\n", (char *) inet_ntoa (sin.sin_addr));
  2006. X        }
  2007. X        x = connect (s, (struct sockaddr *) &sin, sizeof (sin));
  2008. X        if (x == 0) {
  2009. X            break;
  2010. X        }
  2011. X        fprintf (stderr, "connection to %s: ", (char *) inet_ntoa (sin.sin_addr));
  2012. X        perror ("");
  2013. X        (void) close (s);
  2014. X    }
  2015. X    if (x < 0) {
  2016. X        fprintf (stderr, "giving up...\n");
  2017. X        return (-1);
  2018. X    }
  2019. X#else    /* no name server */
  2020. X#ifdef EXCELAN
  2021. X    if ((s = socket (SOCK_STREAM,(struct sockproto *)NULL,&sin,SO_KEEPALIVE)) < 0) {
  2022. X        /* Get the socket */
  2023. X        perror ("socket");
  2024. X        return (-1);
  2025. X    }
  2026. X    bzero((char *) &sin, sizeof (sin));
  2027. X    sin.sin_family = AF_INET;
  2028. X    sin.sin_port = htons (IPPORT_NNTP);
  2029. X    /* set up addr for the connect */
  2030. X
  2031. X    if ((sin.sin_addr.s_addr = rhost (&machine)) == -1) {
  2032. X        fprintf (stderr, "%s: Unknown host.\n", machine);
  2033. X        return (-1);
  2034. X    }
  2035. X    /* And then connect */
  2036. X
  2037. X    if (connect (s, (struct sockaddr *)&sin) < 0) {
  2038. X        perror ("connect");
  2039. X        (void) close (s);
  2040. X        return (-1);
  2041. X    }
  2042. X#else /* not EXCELAN */
  2043. X    if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
  2044. X        perror ("socket");
  2045. X        return (-1);
  2046. X    }
  2047. X
  2048. X    /* And then connect */
  2049. X
  2050. X    bcopy (hp->h_addr, (char *) &sin.sin_addr, hp->h_length);
  2051. X    if (connect (s, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
  2052. X        perror ("connect");
  2053. X        (void) close (s);
  2054. X        return (-1);
  2055. X    }
  2056. X
  2057. X#endif /* !EXCELAN */
  2058. X#endif /* !h_addr */
  2059. X#endif /* !TLI */
  2060. X    return (s);
  2061. X#else
  2062. X    return (-1);
  2063. X#endif /* NNTP_ABLE */
  2064. X}
  2065. X
  2066. X#ifdef DECNET
  2067. X/*
  2068. X * get_dnet_socket -- get us a socket connected to the news server.
  2069. X *
  2070. X *    Parameters:    "machine" is the machine the server is running on.
  2071. X *
  2072. X *    Returns:    Socket connected to the news server if
  2073. X *            all is ok, else -1 on error.
  2074. X *
  2075. X *    Side effects:    Connects to server.
  2076. X *
  2077. X *    Errors:        Printed via nerror.
  2078. X */
  2079. X
  2080. Xint get_dnet_socket (machine)
  2081. X    char    *machine;
  2082. X{
  2083. X#ifdef NNTP_ABLE
  2084. X    int    s, area, node;
  2085. X    struct    sockaddr_dn sdn;
  2086. X    struct    nodeent *getnodebyname(), *np;
  2087. X
  2088. X    bzero((char *) &sdn, sizeof (sdn));
  2089. X
  2090. X    switch (s = sscanf (machine, "%d%*[.]%d", &area, &node)) {
  2091. X        case 1: 
  2092. X            node = area;
  2093. X            area = 0;
  2094. X        case 2: 
  2095. X            node += area*1024;
  2096. X            sdn.sdn_add.a_len = 2;
  2097. X            sdn.sdn_family = AF_DECnet;
  2098. X            sdn.sdn_add.a_addr[0] = node % 256;
  2099. X            sdn.sdn_add.a_addr[1] = node / 256;
  2100. X            break;
  2101. X        default:
  2102. X            if ((np = getnodebyname (machine)) == NULL) {
  2103. X                fprintf (stderr, "%s: Unknown host.\n", machine);
  2104. X                return (-1);
  2105. X            } else {
  2106. X                bcopy(np->n_addr, (char *) sdn.sdn_add.a_addr, np->n_length);
  2107. X                sdn.sdn_add.a_len = np->n_length;
  2108. X                sdn.sdn_family = np->n_addrtype;
  2109. X            }
  2110. X            break;
  2111. X    }
  2112. X    sdn.sdn_objnum = 0;
  2113. X    sdn.sdn_flags = 0;
  2114. X    sdn.sdn_objnamel = strlen ("NNTP");
  2115. X    bcopy("NNTP", &sdn.sdn_objname[0], sdn.sdn_objnamel);
  2116. X
  2117. X    if ((s = socket (AF_DECnet, SOCK_STREAM, 0)) < 0) {
  2118. X        nerror ("socket");
  2119. X        return (-1);
  2120. X    }
  2121. X
  2122. X    /* And then connect */
  2123. X
  2124. X    if (connect (s, (struct sockaddr *) &sdn, sizeof (sdn)) < 0) {
  2125. X        nerror ("connect");
  2126. X        close (s);
  2127. X        return (-1);
  2128. X    }
  2129. X
  2130. X    return (s);
  2131. X#else
  2132. X    return (-1);
  2133. X#endif /* NNTP_ABLE */
  2134. X}
  2135. X#endif
  2136. X
  2137. X/*
  2138. X * handle_server_response
  2139. X *
  2140. X *    Print some informative messages based on the server's initial
  2141. X *    response code.  This is here so inews, rn, etc. can share
  2142. X *    the code.
  2143. X *
  2144. X *    Parameters:    "response" is the response code which the
  2145. X *            server sent us, presumably from "server_init",
  2146. X *            above.
  2147. X *            "nntpserver" is the news server we got the
  2148. X *            response code from.
  2149. X *
  2150. X *    Returns:    -1 if the error is fatal (and we should exit).
  2151. X *            0 otherwise.
  2152. X *
  2153. X *    Side effects:    None.
  2154. X */
  2155. X
  2156. Xint handle_server_response (response, nntpserver)
  2157. X    int    response;
  2158. X    char    *nntpserver;
  2159. X{
  2160. X#ifdef NNTP_ABLE
  2161. X    switch (response) {
  2162. X        case OK_NOPOST:        /* fall through */
  2163. X                printf ("NOTE: This machine does not have permission to post articles.\n");
  2164. X            printf ("      Please don't waste your time trying.\n\n");
  2165. X
  2166. X        case OK_CANPOST:
  2167. X            return (0);
  2168. X            break;
  2169. X
  2170. X        case ERR_ACCESS:
  2171. X            printf ("This machine does not have permission to use the %s news server.\n", nntpserver);
  2172. X            return (-1);
  2173. X            break;
  2174. X
  2175. X        default:
  2176. X            printf ("Unexpected response code from %s news server: %d\n",
  2177. X                nntpserver, response);
  2178. X            return (-1);
  2179. X            break;
  2180. X    }
  2181. X    /*NOTREACHED*/
  2182. X#else
  2183. X    return (-1);
  2184. X#endif /* NNTP_ABLE */
  2185. X}
  2186. X
  2187. X/*
  2188. X * put_server -- send a line of text to the server, terminating it
  2189. X * with CR and LF, as per ARPA standard.
  2190. X *
  2191. X *    Parameters:    "string" is the string to be sent to the
  2192. X *            server.
  2193. X *
  2194. X *    Returns:    Nothing.
  2195. X *
  2196. X *    Side effects:    Talks to the server.
  2197. X *
  2198. X *    Note:    This routine flushes the buffer each time
  2199. X *            it is called.  For large transmissions
  2200. X *            (i.e., posting news) don't use it.  Instead,
  2201. X *            do the fprintf's yourself, and then a final
  2202. X *            fflush.
  2203. X */
  2204. X
  2205. Xvoid put_server (string)
  2206. X    char *string;
  2207. X{
  2208. X#ifdef NNTP_ABLE
  2209. X    fprintf (ser_wr_fp, "%s\r\n", string);
  2210. X    (void) fflush (ser_wr_fp);
  2211. X#endif /* NNTP_ABLE */
  2212. X}
  2213. X
  2214. X/*
  2215. X * get_server -- get a line of text from the server.  Strips
  2216. X * CR's and LF's.
  2217. X *
  2218. X *    Parameters:    "string" has the buffer space for the
  2219. X *            line received.
  2220. X *            "size" is the size of the buffer.
  2221. X *
  2222. X *    Returns:    -1 on error, 0 otherwise.
  2223. X *
  2224. X *    Side effects:    Talks to server, changes contents of "string".
  2225. X */
  2226. X
  2227. Xint get_server (string, size)
  2228. X    char    *string;
  2229. X    int    size;
  2230. X{
  2231. X#ifdef NNTP_ABLE
  2232. X    register char *cp;
  2233. X
  2234. X    if (fgets (string, size, ser_rd_fp) == NULL) {
  2235. X        return (-1);
  2236. X    }
  2237. X
  2238. X    if ((cp = (char *) index(string, '\r')) != NULL) {
  2239. X        *cp = '\0';
  2240. X    } else if ((cp = (char *) index(string, '\n')) != NULL) {
  2241. X        *cp = '\0';
  2242. X    }
  2243. X
  2244. X    return (0);
  2245. X#else
  2246. X    return (-1);
  2247. X#endif /* NNTP_ABLE */
  2248. X}
  2249. X
  2250. X/*
  2251. X * close_server -- close the connection to the server, after sending
  2252. X *        the "quit" command.
  2253. X *
  2254. X *    Parameters:    None.
  2255. X *
  2256. X *    Returns:    Nothing.
  2257. X *
  2258. X *    Side effects:    Closes the connection with the server.
  2259. X *            You can't use "put_server" or "get_server"
  2260. X *            after this routine is called.
  2261. X */
  2262. X
  2263. Xvoid close_server ()
  2264. X{
  2265. X#ifdef NNTP_ABLE
  2266. X    char    ser_line[256];
  2267. X
  2268. X    if (ser_wr_fp == NULL || ser_rd_fp == NULL)
  2269. X        return;
  2270. X
  2271. X    put_server ("QUIT");
  2272. X    (void) get_server (ser_line, sizeof (ser_line));
  2273. X
  2274. X    (void) fclose (ser_wr_fp);
  2275. X    (void) fclose (ser_rd_fp);
  2276. X#endif /* NNTP_ABLE */
  2277. X}
  2278. X
  2279. X#endif /* CDROM_ABLE */
  2280. X
  2281. END_OF_FILE
  2282.   if test 14736 -ne `wc -c <'nntplib.c'`; then
  2283.     echo shar: \"'nntplib.c'\" unpacked with wrong size!
  2284.   fi
  2285.   # end of 'nntplib.c'
  2286. fi
  2287. echo shar: End of archive 10 \(of 15\).
  2288. cp /dev/null ark10isdone
  2289. MISSING=""
  2290. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 ; do
  2291.     if test ! -f ark${I}isdone ; then
  2292.     MISSING="${MISSING} ${I}"
  2293.     fi
  2294. done
  2295. if test "${MISSING}" = "" ; then
  2296.     echo You have unpacked all 15 archives.
  2297.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2298. else
  2299.     echo You still must unpack the following archives:
  2300.     echo "        " ${MISSING}
  2301. fi
  2302. exit 0
  2303. exit 0 # Just in case...
  2304.