![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rcln.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 rcln.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / rn |
1.1 root 1: /* $Header: rcln.c,v 4.3.1.3 86/11/04 15:57:03 lwall Exp $
2: *
3: * $Log: rcln.c,v $
4: * Revision 4.3.1.3 86/11/04 15:57:03 lwall
5: * realloc attempted on unalloced area.
6: *
7: * Revision 4.3.1.2 85/07/23 17:39:08 lwall
8: * Oops, was freeing a static buf on -c in checkexpired.
9: *
10: * Revision 4.3.1.1 85/05/10 11:37:08 lwall
11: * Branch for patches.
12: *
13: * Revision 4.3 85/05/01 11:45:36 lwall
14: * Baseline for release with 4.3bsd.
15: *
16: */
17:
18: #include "EXTERN.h"
19: #include "common.h"
20: #include "util.h"
21: #include "rcstuff.h"
22: #include "ngdata.h"
23: #include "INTERN.h"
24: #include "rcln.h"
25:
26: void
27: rcln_init()
28: {
29: ;
30: }
31:
32: #ifdef CATCHUP
33: void
34: catch_up(ngx)
35: NG_NUM ngx;
36: {
37: char tmpbuf[128];
38:
39: #ifdef VERBOSE
40: IF(verbose)
41: printf("\nMarking %s as all read.\n",rcline[ngx]) FLUSH;
42: ELSE
43: #endif
44: #ifdef TERSE
45: fputs("\nMarked read\n",stdout) FLUSH;
46: #endif
47: sprintf(tmpbuf,"%s: 1-%ld", rcline[ngx],(long)getngsize(ngx));
48: free(rcline[ngx]);
49: rcline[ngx] = savestr(tmpbuf);
50: *(rcline[ngx] + rcnums[ngx] - 1) = '\0';
51: write_rc();
52: }
53: #endif
54:
55: /* add an article number to a newsgroup, if it isn't already read */
56:
57: int
58: addartnum(artnum,ngnam)
59: ART_NUM artnum;
60: char *ngnam;
61: {
62: register NG_NUM ngnum = find_ng(ngnam);
63: register char *s, *t, *maxt = Nullch;
64: ART_NUM min = 0, max = -1, lastnum = 0;
65: char *mbuf;
66: bool morenum;
67:
68: if (!artnum)
69: return 0;
70: if (ngnum == nextrcline || !rcnums[ngnum])
71: /* not found in newsrc? */
72: return 0;
73: #ifdef CACHEFIRST
74: if (!abs1st[ngnum])
75: #else
76: if (!toread[ngnum])
77: #endif
78: /* now is a good time to trim down */
79: set_toread(ngnum); /* the list due to expires if we */
80: /* have not yet. */
81: #ifdef DEBUGGING
82: if (artnum > ngmax[ngnum] + 10 /* allow for incoming articles */
83: ) {
84: printf("\nCorrupt Xref line!!! %ld --> %s(1..%ld)\n",
85: artnum,ngnam,
86: ngmax[ngnum]) FLUSH;
87: paranoid = TRUE; /* paranoia reigns supreme */
88: return -1; /* hope this was the first newsgroup */
89: }
90: #endif
91:
92: if (toread[ngnum] == TR_BOGUS)
93: return 0;
94: #ifdef DEBUGGING
95: if (debug & DEB_XREF_MARKER) {
96: printf("%ld->\n%s%c%s\n",(long)artnum,rcline[ngnum],rcchar[ngnum],
97: rcline[ngnum] + rcnums[ngnum]) FLUSH;
98: }
99: #endif
100: s = rcline[ngnum] + rcnums[ngnum];
101: while (*s == ' ') s++; /* skip spaces */
102: t = s;
103: while (isdigit(*s) && artnum >= (min = atol(s))) {
104: /* while it might have been read */
105: for (t = s; isdigit(*t); t++) ; /* skip number */
106: if (*t == '-') { /* is it a range? */
107: t++; /* skip to next number */
108: if (artnum <= (max = atol(t)))
109: return 0; /* it is in range => already read */
110: lastnum = max; /* remember it */
111: maxt = t; /* remember position in case we */
112: /* want to overwrite the max */
113: while (isdigit(*t)) t++; /* skip second number */
114: }
115: else {
116: if (artnum == min) /* explicitly a read article? */
117: return 0;
118: lastnum = min; /* remember what the number was */
119: maxt = Nullch; /* last one was not a range */
120: }
121: while (*t && !isdigit(*t)) t++; /* skip comma and any spaces */
122: s = t;
123: }
124:
125: /* we have not read it, so insert the article number before s */
126:
127: morenum = isdigit(*s); /* will it need a comma after? */
128: *(rcline[ngnum] + rcnums[ngnum] - 1) = rcchar[ngnum];
129: mbuf = safemalloc((MEM_SIZE)(strlen(s) + (s-rcline[ngnum]) + 8));
130: strcpy(mbuf,rcline[ngnum]); /* make new rc line */
131: if (maxt && lastnum && artnum == lastnum+1)
132: /* can we just extend last range? */
133: t = mbuf + (maxt-rcline[ngnum]);/* then overwrite previous max */
134: else {
135: t = mbuf + (t-rcline[ngnum]); /* point t into new line instead */
136: if (lastnum) { /* have we parsed any line? */
137: if (!morenum) /* are we adding to the tail? */
138: *t++ = ','; /* supply comma before */
139: if (!maxt && artnum == lastnum+1 && *(t-1) == ',')
140: /* adjacent singletons? */
141: *(t-1) = '-'; /* turn them into a range */
142: }
143: }
144: if (morenum) { /* is there more to life? */
145: if (min == artnum+1) { /* can we consolidate further? */
146: bool range_before = (*(t-1) == '-');
147: bool range_after;
148: char *nextmax;
149:
150: for (nextmax = s; isdigit(*nextmax); nextmax++) ;
151: range_after = *nextmax++ == '-';
152:
153: if (range_before)
154: *t = '\0'; /* artnum is redundant */
155: else
156: sprintf(t,"%ld-",(long)artnum);/* artnum will be new min */
157:
158: if (range_after)
159: s = nextmax; /* *s is redundant */
160: /* else
161: s = s */ /* *s is new max */
162: }
163: else
164: sprintf(t,"%ld,",(long)artnum); /* put the number and comma */
165: }
166: else
167: sprintf(t,"%ld",(long)artnum); /* put the number there (wherever) */
168: strcat(t,s); /* copy remainder of line */
169: #ifdef DEBUGGING
170: if (debug & DEB_XREF_MARKER) {
171: printf("%s\n",mbuf) FLUSH;
172: }
173: #endif
174: free(rcline[ngnum]);
175: rcline[ngnum] = mbuf; /* pull the switcheroo */
176: *(rcline[ngnum] + rcnums[ngnum] - 1) = '\0';
177: /* wipe out : or ! */
178: if (toread[ngnum] > TR_NONE) /* lest we turn unsub into bogus */
179: --toread[ngnum];
180: return 0;
181: }
182:
183: #ifdef MCHASE
184: /* delete an article number from a newsgroup, if it is there */
185:
186: void
187: subartnum(artnum,ngnam)
188: register ART_NUM artnum;
189: char *ngnam;
190: {
191: register NG_NUM ngnum = find_ng(ngnam);
192: register char *s, *t;
193: register ART_NUM min, max;
194: char *mbuf;
195: int curlen;
196:
197: if (!artnum)
198: return;
199: if (ngnum == nextrcline || !rcnums[ngnum])
200: return; /* not found in newsrc? */
201: #ifdef DEBUGGING
202: if (debug & DEB_XREF_MARKER) {
203: printf("%ld<-\n%s%c%s\n",(long)artnum,rcline[ngnum],rcchar[ngnum],
204: rcline[ngnum] + rcnums[ngnum]) FLUSH;
205: }
206: #endif
207: s = rcline[ngnum] + rcnums[ngnum];
208: while (*s == ' ') s++; /* skip spaces */
209:
210: /* a little optimization, since it is almost always the last number */
211:
212: for (t=s; *t; t++) ; /* find end of string */
213: curlen = t-rcline[ngnum];
214: for (t--; isdigit(*t); t--) ; /* find previous delim */
215: if (*t == ',' && atol(t+1) == artnum) {
216: *t = '\0';
217: if (toread[ngnum] >= TR_NONE)
218: ++toread[ngnum];
219: #ifdef DEBUGGING
220: if (debug & DEB_XREF_MARKER)
221: printf("%s%c %s\n",rcline[ngnum],rcchar[ngnum],s) FLUSH;
222: #endif
223: return;
224: }
225:
226: /* not the last number, oh well, we may need the length anyway */
227:
228: while (isdigit(*s) && artnum >= (min = atol(s))) {
229: /* while it might have been read */
230: for (t = s; isdigit(*t); t++) ; /* skip number */
231: if (*t == '-') { /* is it a range? */
232: t++; /* skip to next number */
233: max = atol(t);
234: while (isdigit(*t)) t++; /* skip second number */
235: if (artnum <= max) {
236: /* it is in range => already read */
237: if (artnum == min) {
238: min++;
239: artnum = 0;
240: }
241: else if (artnum == max) {
242: max--;
243: artnum = 0;
244: }
245: *(rcline[ngnum] + rcnums[ngnum] - 1) = rcchar[ngnum];
246: mbuf = safemalloc((MEM_SIZE)(curlen + (artnum?15:2)));
247: *s = '\0';
248: strcpy(mbuf,rcline[ngnum]); /* make new rc line */
249: s = mbuf + (s-rcline[ngnum]);
250: /* point s into mbuf now */
251: if (artnum) { /* split into two ranges? */
252: prange(s,min,artnum-1);
253: s += strlen(s);
254: *s++ = ',';
255: prange(s,artnum+1,max);
256: }
257: else /* only one range */
258: prange(s,min,max);
259: s += strlen(s);
260: strcpy(s,t); /* copy remainder over */
261: #ifdef DEBUGGING
262: if (debug & DEB_XREF_MARKER) {
263: printf("%s\n",mbuf) FLUSH;
264: }
265: #endif
266: free(rcline[ngnum]);
267: rcline[ngnum] = mbuf; /* pull the switcheroo */
268: *(rcline[ngnum] + rcnums[ngnum] - 1) = '\0';
269: /* wipe out : or ! */
270: if (toread[ngnum] >= TR_NONE)
271: ++toread[ngnum];
272: return;
273: }
274: }
275: else {
276: if (artnum == min) { /* explicitly a read article? */
277: if (*t == ',') /* pick a comma, any comma */
278: t++;
279: else if (s[-1] == ',')
280: s--;
281: else if (s[-2] == ',') /* (in case of space) */
282: s -= 2;
283: strcpy(s,t); /* no need to realloc */
284: if (toread[ngnum] >= TR_NONE)
285: ++toread[ngnum];
286: #ifdef DEBUGGING
287: if (debug & DEB_XREF_MARKER) {
288: printf("%s%c%s\n",rcline[ngnum],rcchar[ngnum],
289: rcline[ngnum] + rcnums[ngnum]) FLUSH;
290: }
291: #endif
292: return;
293: }
294: }
295: while (*t && !isdigit(*t)) t++; /* skip comma and any spaces */
296: s = t;
297: }
298: }
299:
300: void
301: prange(where,min,max)
302: char *where;
303: ART_NUM min,max;
304: {
305: if (min == max)
306: sprintf(where,"%ld",(long)min);
307: else
308: sprintf(where,"%ld-%ld",(long)min,(long)max);
309: }
310: #endif
311:
312: /* calculate the number of unread articles for a newsgroup */
313:
314: void
315: set_toread(ngnum)
316: register NG_NUM ngnum;
317: {
318: register char *s, *c, *h;
319: char tmpbuf[64], *mybuf = tmpbuf;
320: char *nums;
321: int length;
322: #ifdef CACHEFIRST
323: bool virgin_ng = (!abs1st[ngnum]);
324: #endif
325: ART_NUM ngsize = getngsize(ngnum);
326: ART_NUM unread = ngsize;
327: ART_NUM newmax;
328:
329: #ifdef DEBUGGING
330: ngmax[ngnum] = ngsize; /* for checking out-of-range Xrefs */
331: #endif
332: if (ngsize == TR_BOGUS) {
333: printf("Warning! Bogus newsgroup: %s\n",rcline[ngnum]) FLUSH;
334: paranoid = TRUE;
335: toread[ngnum] = TR_BOGUS;
336: return;
337: }
338: #ifdef CACHEFIRST
339: if (virgin_ng)
340: #else
341: if (!toread[ngnum])
342: #endif
343: {
344: sprintf(tmpbuf," 1-%ld",(long)ngsize);
345: if (strNE(tmpbuf,rcline[ngnum]+rcnums[ngnum]))
346: checkexpired(ngnum,ngsize); /* this might realloc rcline */
347: }
348: nums = rcline[ngnum]+rcnums[ngnum];
349: length = strlen(nums);
350: if (length >= 60)
351: mybuf = safemalloc((MEM_SIZE)(length+5));
352: strcpy(mybuf,nums);
353: mybuf[length++] = ',';
354: mybuf[length] = '\0';
355: for (s = mybuf; isspace(*s); s++)
356: ;
357: for ( ; (c = index(s,',')) != Nullch ; s = ++c) {
358: /* for each range */
359: *c = '\0'; /* keep index from running off */
360: if ((h = index(s,'-')) != Nullch) /* find - in range, if any */
361: unread -= (newmax = atol(h+1)) - atol(s) + 1;
362: else if (newmax = atol(s))
363: unread--; /* recalculate length */
364: if (newmax > ngsize) { /* paranoia check */
365: unread = -1;
366: break;
367: }
368: }
369: if (unread >= 0) /* reasonable number? */
370: toread[ngnum] = (ART_UNREAD)unread;
371: /* remember how many are left */
372: else { /* SOMEONE RESET THE NEWSGROUP!!! */
373: toread[ngnum] = (ART_UNREAD)ngsize;
374: /* assume nothing carried over */
375: printf("Warning! Somebody reset %s--assuming nothing read.\n",
376: rcline[ngnum]) FLUSH;
377: *(rcline[ngnum] + rcnums[ngnum]) = '\0';
378: paranoid = TRUE; /* enough to make a guy paranoid */
379: }
380: if (mybuf != tmpbuf)
381: free(mybuf);
382: if (rcchar[ngnum] == NEGCHAR)
383: toread[ngnum] = TR_UNSUB;
384: }
385:
386: /* make sure expired articles are marked as read */
387:
388: void
389: checkexpired(ngnum,ngsize)
390: register NG_NUM ngnum;
391: ART_NUM ngsize;
392: {
393: register ART_NUM a1st = getabsfirst(ngnum,ngsize);
394: register char *s, *t;
395: register ART_NUM num, lastnum = 0;
396: char *mbuf, *newnum;
397:
398: if (a1st<=1)
399: return;
400: #ifdef DEBUGGING
401: if (debug & DEB_XREF_MARKER) {
402: printf("1-%ld->\n%s%c%s\n",(long)(a1st-1),rcline[ngnum],rcchar[ngnum],
403: rcline[ngnum] + rcnums[ngnum]) FLUSH;
404: }
405: #endif
406: for (s = rcline[ngnum] + rcnums[ngnum]; isspace(*s); s++);
407: while (*s && (num = atol(s)) <= a1st) {
408: while (isdigit(*s)) s++;
409: while (*s && !isdigit(*s)) s++;
410: lastnum = num;
411: }
412: if (*s) {
413: if (s[-1] == '-') { /* landed in a range? */
414: if (lastnum != 1)
415: sprintf(rcline[ngnum]+rcnums[ngnum]," 1-%s",s);
416: goto ret;
417: }
418: }
419: /* s now points to what should follow first range */
420: if (s - rcline[ngnum] > rcnums[ngnum] + 10)
421: mbuf = rcline[ngnum];
422: else {
423: mbuf = safemalloc((MEM_SIZE)(rcnums[ngnum] + strlen(s) + 10));
424: strcpy(mbuf,rcline[ngnum]);
425: }
426: newnum = t = mbuf+rcnums[ngnum];
427: sprintf(t," 1-%ld",(long)(a1st - (lastnum != a1st)));
428: if (*s) {
429: t += strlen(t);
430: *t++ = ',';
431: strcpy(t,s);
432: }
433: if (!checkflag && mbuf == rcline[ngnum]) {
434: rcline[ngnum] = saferealloc(rcline[ngnum],
435: (MEM_SIZE)(rcnums[ngnum] + strlen(newnum) + 1));
436: }
437: else {
438: if (!checkflag)
439: free(rcline[ngnum]);
440: rcline[ngnum] = mbuf;
441: }
442:
443: ret:; /* semicolon in case DEBUGGING undefined */
444: #ifdef DEBUGGING
445: if (debug & DEB_XREF_MARKER) {
446: printf("%s%c%s\n",rcline[ngnum],rcchar[ngnum],
447: rcline[ngnum] + rcnums[ngnum]) FLUSH;
448: }
449: #endif
450: }
451:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.