![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bits.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / rn|
Return to bits.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / rn |
1.1 root 1: /* $Header: bits.c,v 4.3.1.4 86/10/31 15:23:53 lwall Exp $
2: *
3: * $Log: bits.c,v $
4: * Revision 4.3.1.4 86/10/31 15:23:53 lwall
5: * Separated firstart into two variables so KILL on new articles won't
6: * accidentally mark articles read.
7: *
8: * Revision 4.3.1.3 86/09/09 16:01:43 lwall
9: * Fixed 'n more articles' bug.
10: *
11: * Revision 4.3.1.2 86/07/24 14:40:23 lwall
12: * Gets host name from path instead of relay-version for news 2.10.3.
13: *
14: * Revision 4.3.1.1 85/05/10 11:31:41 lwall
15: * Branch for patches.
16: *
17: * Revision 4.3 85/05/01 11:36:15 lwall
18: * Baseline for release with 4.3bsd.
19: *
20: */
21:
22: #include "EXTERN.h"
23: #include "common.h"
24: #include "rcstuff.h"
25: #include "head.h"
26: #include "util.h"
27: #include "final.h"
28: #include "rn.h"
29: #include "cheat.h"
30: #include "ng.h"
31: #include "artio.h"
32: #include "intrp.h"
33: #include "ngdata.h"
34: #include "rcln.h"
35: #include "kfile.h"
36: #include "INTERN.h"
37: #include "bits.h"
38:
39: #ifdef DBM
40: # ifdef NULL
41: # undef NULL
42: # endif NULL
43: # include <dbm.h>
44: #endif DBM
45: MEM_SIZE ctlsize; /* size of bitmap in bytes */
46:
47: void
48: bits_init()
49: {
50: #ifdef DELAYMARK
51: dmname = savestr(filexp(RNDELNAME));
52: #else
53: ;
54: #endif
55: }
56:
57: /* checkpoint the .newsrc */
58:
59: void
60: checkpoint_rc()
61: {
62: #ifdef DEBUGGING
63: if (debug & DEB_CHECKPOINTING) {
64: fputs("(ckpt)",stdout);
65: fflush(stdout);
66: }
67: #endif
68: if (doing_ng)
69: restore_ng(); /* do not restore M articles */
70: if (rc_changed)
71: write_rc();
72: #ifdef DEBUGGING
73: if (debug & DEB_CHECKPOINTING) {
74: fputs("(done)",stdout);
75: fflush(stdout);
76: }
77: #endif
78: }
79:
80: /* reconstruct the .newsrc line in a human readable form */
81:
82: void
83: restore_ng()
84: {
85: register char *s, *mybuf = buf;
86: register ART_NUM i;
87: ART_NUM count=0;
88: int safelen = LBUFLEN - 16;
89:
90: strcpy(buf,rcline[ng]); /* start with the newsgroup name */
91: s = buf + rcnums[ng] - 1; /* use s for buffer pointer */
92: *s++ = rcchar[ng]; /* put the requisite : or !*/
93: *s++ = ' '; /* put the not-so-requisite space */
94: for (i=1; i<=lastart; i++) { /* for each article in newsgroup */
95: if (s-mybuf > safelen) { /* running out of room? */
96: safelen *= 2;
97: if (mybuf == buf) { /* currently static? */
98: *s = '\0';
99: mybuf = safemalloc((MEM_SIZE)safelen + 16);
100: strcpy(mybuf,buf); /* so we must copy it */
101: s = mybuf + (s-buf);
102: /* fix the pointer, too */
103: }
104: else { /* just grow in place, if possible */
105: char *newbuf;
106:
107: newbuf = saferealloc(mybuf,(MEM_SIZE)safelen + 16);
108: s = newbuf + (s-mybuf);
109: mybuf = newbuf;
110: }
111: }
112: if (!was_read(i)) /* still unread? */
113: count++; /* then count it */
114: else { /* article was read */
115: ART_NUM oldi;
116:
117: sprintf(s,"%ld",(long)i); /* put out the min of the range */
118: s += strlen(s); /* keeping house */
119: oldi = i; /* remember this spot */
120: do i++; while (i <= lastart && was_read(i));
121: /* find 1st unread article or end */
122: i--; /* backup to last read article */
123: if (i > oldi) { /* range of more than 1? */
124: sprintf(s,"-%ld,",(long)i);
125: /* then it out as a range */
126: s += strlen(s); /* and housekeep */
127: }
128: else
129: *s++ = ','; /* otherwise, just a comma will do */
130: }
131: }
132: if (*(s-1) == ',') /* is there a final ','? */
133: s--; /* take it back */
134: *s++ = '\0'; /* and terminate string */
135: #ifdef DEBUGGING
136: if (debug & DEB_NEWSRC_LINE && !panic) {
137: printf("%s: %s\n",rcline[ng],rcline[ng]+rcnums[ng]) FLUSH;
138: printf("%s\n",mybuf) FLUSH;
139: }
140: #endif
141: free(rcline[ng]); /* return old rc line */
142: if (mybuf == buf) {
143: rcline[ng] = safemalloc((MEM_SIZE)(s-buf)+1);
144: /* grab a new rc line */
145: strcpy(rcline[ng], buf); /* and load it */
146: }
147: else {
148: mybuf = saferealloc(mybuf,(MEM_SIZE)(s-mybuf)+1);
149: /* be nice to the heap */
150: rcline[ng] = mybuf;
151: }
152: *(rcline[ng] + rcnums[ng] - 1) = '\0';
153: if (rcchar[ng] == NEGCHAR) { /* did they unsubscribe? */
154: printf(unsubto,ngname) FLUSH;
155: toread[ng] = TR_UNSUB; /* make line invisible */
156: }
157: else
158: /*NOSTRICT*/
159: toread[ng] = (ART_UNREAD)count; /* remember how many unread there are */
160: }
161:
162: /* mark an article unread, keeping track of toread[] */
163:
164: void
165: onemore(artnum)
166: ART_NUM artnum;
167: {
168: #ifdef DEBUGGING
169: if (debug && artnum < firstbit) {
170: printf("onemore: %d < %d\n",artnum,firstbit) FLUSH;
171: return;
172: }
173: #endif
174: if (ctl_read(artnum)) {
175: ctl_clear(artnum);
176: ++toread[ng];
177: }
178: }
179:
180: /* mark an article read, keeping track of toread[] */
181:
182: void
183: oneless(artnum)
184: ART_NUM artnum;
185: {
186: #ifdef DEBUGGING
187: if (debug && artnum < firstbit) {
188: printf("oneless: %d < %d\n",artnum,firstbit) FLUSH;
189: return;
190: }
191: #endif
192: if (!ctl_read(artnum)) {
193: ctl_set(artnum);
194: if (toread[ng] > TR_NONE)
195: --toread[ng];
196: }
197: }
198:
199: /* mark an article as unread, making sure that firstbit is properly handled */
200: /* cross-references are left as read in the other newsgroups */
201:
202: void
203: unmark_as_read(artnum)
204: ART_NUM artnum;
205: {
206: check_first(artnum);
207: onemore(artnum);
208: #ifdef MCHASE
209: if (!parse_maybe(artnum))
210: chase_xrefs(artnum,FALSE);
211: #endif
212: }
213:
214: #ifdef DELAYMARK
215: /* temporarily mark article as read. When newsgroup is exited, articles */
216: /* will be marked as unread. Called via M command */
217:
218: void
219: delay_unmark(artnum)
220: ART_NUM artnum;
221: {
222: if (dmfp == Nullfp) {
223: dmfp = fopen(dmname,"w");
224: if (dmfp == Nullfp) {
225: printf(cantcreate,dmname) FLUSH;
226: sig_catcher(0);
227: }
228: }
229: oneless(artnum); /* set the correct bit */
230: dmcount++;
231: fprintf(dmfp,"%ld\n",(long)artnum);
232: }
233: #endif
234:
235: /* mark article as read. If article is cross referenced to other */
236: /* newsgroups, mark them read there also. */
237:
238: void
239: mark_as_read(artnum)
240: ART_NUM artnum;
241: {
242: oneless(artnum); /* set the correct bit */
243: checkcount++; /* get more worried about crashes */
244: chase_xrefs(artnum,TRUE);
245: }
246:
247: /* make sure we have bits set correctly down to firstbit */
248:
249: void
250: check_first(min)
251: ART_NUM min;
252: {
253: register ART_NUM i = firstbit;
254:
255: if (min < absfirst)
256: min = absfirst;
257: if (min < i) {
258: for (i--; i>=min; i--)
259: ctl_set(i); /* mark as read */
260: firstart = firstbit = min;
261: }
262: }
263:
264: /* bring back articles marked with M */
265:
266: #ifdef DELAYMARK
267: void
268: yankback()
269: {
270: register ART_NUM anum;
271:
272: if (dmfp) { /* delayed unmarks pending? */
273: #ifdef VERBOSE
274: printf("\nReturning %ld Marked article%s...\n",(long)dmcount,
275: dmcount == 1 ? nullstr : "s") FLUSH;
276: #endif
277: fclose(dmfp);
278: if (dmfp = fopen(dmname,"r")) {
279: while (fgets(buf,sizeof buf,dmfp) != Nullch) {
280: anum = (ART_NUM)atol(buf);
281: /*NOSTRICT*/
282: onemore(anum); /* then unmark them */
283: #ifdef MCHASE
284: chase_xrefs(anum,FALSE);
285: #endif
286: }
287: fclose(dmfp);
288: dmfp = Nullfp;
289: UNLINK(dmname); /* and be tidy */
290: }
291: else {
292: printf(cantopen,dmname) FLUSH;
293: sig_catcher(0);
294: }
295: }
296: dmcount = 0;
297: }
298: #endif
299:
300: /* run down xref list and mark as read or unread */
301:
302: int
303: chase_xrefs(artnum,markread)
304: ART_NUM artnum;
305: int markread;
306: {
307: #ifdef ASYNC_PARSE
308: if (parse_maybe(artnum)) /* make sure we have right header */
309: return -1;
310: #endif
311: #ifdef DBM
312: {
313: datum lhs, rhs;
314: datum fetch();
315: register char *idp;
316: char *ident_buf;
317: static FILE * hist_file = Nullfp;
318: #else
319: if (
320: #ifdef DEBUGGING
321: debug & DEB_FEED_XREF ||
322: #endif
323: htype[XREF_LINE].ht_minpos >= 0) {
324: /* are there article# xrefs? */
325: #endif DBM
326: char *xref_buf, *curxref;
327: register char *xartnum;
328: char *rver_buf = Nullch;
329: static char *inews_site = Nullch;
330: register ART_NUM x;
331: char tmpbuf[128];
332:
333: #ifdef DBM
334: rver_buf = fetchlines(artnum,NGS_LINE);
335: /* get Newsgroups */
336: if (!index(rver_buf,',')) /* if no comma, no Xref! */
337: return 0;
338: if (hist_file == Nullfp) { /* Init. file accesses */
339: #ifdef DEBUGGING
340: if (debug)
341: printf ("chase_xref: opening files\n");
342: #endif
343: dbminit(filexp(ARTFILE));
344: if ((hist_file = fopen (filexp(ARTFILE), "r")) == Nullfp)
345: return 0;
346: }
347: xref_buf = safemalloc((MEM_SIZE)BUFSIZ);
348: ident_buf = fetchlines(artnum,MESSID_LINE);
349: /* get Message-ID */
350: #ifdef DEBUGGING
351: if (debug)
352: printf ("chase_xref: Message-ID: %s\n", ident_buf);
353: #endif
354: idp = ident_buf;
355: while (*++idp) /* make message-id case insensitive */
356: if (isupper(*idp))
357: *idp = tolower (*idp);
358: lhs.dptr = ident_buf; /* look up article by id */
359: lhs.dsize = strlen(lhs.dptr) + 1;
360: rhs = fetch(lhs); /* fetch the record */
361: if (rhs.dptr == NULL) /* if null, nothing there */
362: goto wild_goose;
363: fseek (hist_file, *((long *)rhs.dptr), 0);
364: /* datum returned is position in hist file */
365: fgets (xref_buf, BUFSIZ, hist_file);
366: #ifdef DEBUGGING
367: if (debug)
368: printf ("Xref from history: %s\n", xref_buf);
369: #endif
370: curxref = cpytill(tmpbuf, xref_buf, '\t') + 1;
371: curxref = cpytill(tmpbuf, curxref, '\t') + 1;
372: #ifdef DEBUGGING
373: if (debug)
374: printf ("chase_xref: curxref: %s\n", curxref);
375: #endif
376: #else !DBM
377: #ifdef DEBUGGING
378: if (htype[XREF_LINE].ht_minpos >= 0)
379: #endif
380: xref_buf = fetchlines(artnum,XREF_LINE);
381: /* get xrefs list */
382: #ifdef DEBUGGING
383: else {
384: xref_buf = safemalloc((MEM_SIZE)100);
385: printf("Give Xref: ") FLUSH;
386: gets(xref_buf);
387: }
388: #endif
389: #ifdef DEBUGGING
390: if (debug & DEB_XREF_MARKER)
391: printf("Xref: %s\n",xref_buf) FLUSH;
392: #endif
393: curxref = cpytill(tmpbuf,xref_buf,' ') + 1;
394:
395: /* Make sure site name on Xref matches what inews thinks site is.
396: * Check first against last inews_site. If it matches, fine.
397: * If not, fetch inews_site from current Relay-Version line and
398: * check again. This is so that if the new administrator decides
399: * to change the system name as known to inews, rn will still do
400: * Xrefs correctly--each article need only match itself to be valid.
401: */
402: if (inews_site == Nullch || strNE(tmpbuf,inews_site)) {
403: char *t;
404:
405: if (inews_site != Nullch)
406: free(inews_site);
407: #ifndef NORELAY
408: rver_buf = fetchlines(artnum,RVER_LINE);
409: if ((t = instr(rver_buf,"; site ")) == Nullch)
410: #else NORELAY
411: /* In version 2.10.3 of news or afterwards, the Relay-Version
412: * and Posting-Version header lines have been removed. For
413: * the code below to work as intended, I have modified it to
414: * extract the first component of the Path header line. This
415: * should give the same effect as did the old code with respect
416: * to the use of the Relay-Version site name.
417: */
418: rver_buf = fetchlines(artnum,PATH_LINE);
419: if ((t = instr(rver_buf,"!")) == Nullch)
420: #endif NORELAY
421: inews_site = savestr(nullstr);
422: else {
423: char new_site[128];
424:
425: #ifndef NORELAY
426: cpytill(new_site,t + 7,'.');
427: #else NORELAY
428: cpytill(new_site,rver_buf,'!');
429: #endif NORELAY
430: inews_site = savestr(new_site);
431: }
432: if (strNE(tmpbuf,inews_site)) {
433: #ifdef DEBUGGING
434: if (debug)
435: printf("Xref not from %s--ignoring\n",inews_site) FLUSH;
436: #endif
437: goto wild_goose;
438: }
439: }
440: #endif DBM
441: while (*curxref) {
442: /* for each newsgroup */
443: curxref = cpytill(tmpbuf,curxref,' ');
444: #ifdef DBM
445: xartnum = index(tmpbuf,'/');
446: #else
447: xartnum = index(tmpbuf,':');
448: #endif DBM
449: if (!xartnum) /* probably an old-style Xref */
450: break;
451: *xartnum++ = '\0';
452: if (strNE(tmpbuf,ngname)) {/* not the current newsgroup? */
453: x = atol(xartnum);
454: if (x)
455: if (markread) {
456: if (addartnum(x,tmpbuf))
457: goto wild_goose;
458: }
459: #ifdef MCHASE
460: else
461: subartnum(x,tmpbuf);
462: #endif
463: }
464: while (*curxref && isspace(*curxref))
465: curxref++;
466: }
467: wild_goose:
468: free(xref_buf);
469: #ifdef DBM
470: free(ident_buf);
471: #endif DBM
472: if (rver_buf != Nullch)
473: free(rver_buf);
474: }
475: return 0;
476: }
477:
478: int
479: initctl()
480: {
481: char *mybuf = buf; /* place to decode rc line */
482: register char *s, *c, *h;
483: register long i;
484: register ART_NUM unread;
485:
486: #ifdef DELAYMARK
487: dmcount = 0;
488: #endif
489: if ((lastart = getngsize(ng)) < 0) /* this cannot happen (laugh here) */
490: return -1;
491:
492: absfirst = getabsfirst(ng,lastart); /* remember first existing article */
493: if (!absfirst) /* no articles at all? */
494: absfirst = 1; /* pretend there is one */
495: #ifndef lint
496: ctlsize = (MEM_SIZE)(OFFSET(lastart)/BITSPERBYTE+20);
497: #endif lint
498: ctlarea = safemalloc(ctlsize); /* allocate control area */
499:
500: /* now modify ctlarea to reflect what has already been read */
501:
502: for (s = rcline[ng] + rcnums[ng]; *s == ' '; s++) ;
503: /* find numbers in rc line */
504: i = strlen(s);
505: #ifndef lint
506: if (i >= LBUFLEN-2) /* bigger than buf? */
507: mybuf = safemalloc((MEM_SIZE)(i+2));
508: #endif lint
509: strcpy(mybuf,s); /* make scratch copy of line */
510: mybuf[i++] = ','; /* put extra comma on the end */
511: mybuf[i] = '\0';
512: s = mybuf; /* initialize the for loop below */
513: if (strnEQ(s,"1-",2)) { /* can we save some time here? */
514: firstbit = atol(s+2)+1; /* ignore first range thusly */
515: s=index(s,',') + 1;
516: }
517: else
518: firstbit = 1; /* all the bits are valid for now */
519: if (absfirst > firstbit) { /* do we know already? */
520: firstbit = absfirst; /* no point calling getngmin again */
521: }
522: else if (artopen(firstbit) == Nullfp) {
523: /* first unread article missing? */
524: i = getngmin(".",firstbit); /* see if expire has been busy */
525: if (i) { /* avoid a bunch of extra opens */
526: firstbit = i;
527: }
528: }
529: firstart = firstbit; /* firstart > firstbit in KILL */
530: #ifdef PENDING
531: # ifdef CACHESUBJ
532: subj_to_get = firstbit;
533: # endif
534: #endif
535: unread = lastart - firstbit + 1; /* assume this range unread */
536: for (i=OFFSET(firstbit)/BITSPERBYTE; i<ctlsize; i++)
537: ctlarea[i] = 0; /* assume unread */
538: #ifdef DEBUGGING
539: if (debug & DEB_CTLAREA_BITMAP) {
540: printf("\n%s\n",mybuf) FLUSH;
541: for (i=1; i <= lastart; i++)
542: if (! was_read(i))
543: printf("%ld ",(long)i) FLUSH;
544: }
545: #endif
546: for ( ; (c = index(s,',')) != Nullch; s = ++c) {
547: /* for each range */
548: ART_NUM min, max;
549:
550: *c = '\0'; /* do not let index see past comma */
551: if ((h = index(s,'-')) != Nullch) { /* is there a -? */
552: min = atol(s);
553: max = atol(h+1);
554: if (min < firstbit) /* make sure range is in range */
555: min = firstbit;
556: if (max > lastart)
557: max = lastart;
558: if (min <= max) /* non-null range? */
559: unread -= max - min + 1;/* adjust unread count */
560: for (i=min; i<=max; i++) /* for all articles in range */
561: ctl_set(i); /* mark them read */
562: }
563: else if ((i = atol(s)) >= firstbit && i <= lastart) {
564: /* is single number reasonable? */
565: ctl_set(i); /* mark it read */
566: unread--; /* decrement articles to read */
567: }
568: #ifdef DEBUGGING
569: if (debug & DEB_CTLAREA_BITMAP) {
570: printf("\n%s\n",s) FLUSH;
571: for (i=1; i <= lastart; i++)
572: if (! was_read(i))
573: printf("%ld ",(long)i) FLUSH;
574: }
575: #endif
576: }
577: #ifdef DEBUGGING
578: if (debug & DEB_CTLAREA_BITMAP) {
579: fputs("\n(hit CR)",stdout) FLUSH;
580: gets(cmd_buf);
581: }
582: #endif
583: if (mybuf != buf)
584: free(mybuf);
585: toread[ng] = unread;
586: return 0;
587: }
588:
589: void
590: grow_ctl()
591: {
592: ART_NUM newlast;
593: ART_NUM tmpfirst;
594: MEM_SIZE newsize;
595: register ART_NUM i;
596:
597: forcegrow = FALSE;
598: newlast = getngsize(ng);
599: if (newlast > lastart) {
600: ART_NUM tmpart = art;
601: #ifndef lint
602: newsize = (MEM_SIZE)(OFFSET(newlast)/BITSPERBYTE+2);
603: #else
604: newsize = Null(MEM_SIZE);
605: #endif lint
606: if (newsize > ctlsize) {
607: newsize += 20;
608: ctlarea = saferealloc(ctlarea,newsize);
609: ctlsize = newsize;
610: }
611: toread[ng] += (ART_UNREAD)(newlast-lastart);
612: for (i=lastart+1; i<=newlast; i++)
613: ctl_clear(i); /* these articles are unread */
614: #ifdef CACHESUBJ
615: if (subj_list != Null(char**)) {
616: #ifndef lint
617: subj_list = (char**)saferealloc((char*)subj_list,
618: (MEM_SIZE)((OFFSET(newlast)+2)*sizeof(char *)) );
619: #endif lint
620: for (i=lastart+1; i<=newlast; i++)
621: subj_list[OFFSET(i)] = Nullch;
622: }
623: #endif
624: tmpfirst = lastart+1;
625: lastart = newlast;
626: #ifdef KILLFILES
627: #ifdef VERBOSE
628: IF(verbose)
629: sprintf(buf,
630: "%ld more article%s arrived--looking for more to kill...\n\n",
631: (long)(lastart - tmpfirst + 1),
632: (lastart > tmpfirst ? "s have" : " has" ) );
633: ELSE /* my, my, how clever we are */
634: #endif
635: #ifdef TERSE
636: strcpy(buf, "More news--killing...\n\n");
637: #endif
638: kill_unwanted(tmpfirst,buf,TRUE);
639: #endif
640: art = tmpart;
641: }
642: }
643:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.