![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to timefix.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / support|
Return to timefix.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / support |
1.1 root 1: # include <fcntl.h>
2: # include <sccs.h>
3:
4: SCCSID(@(#)timefix.c 8.2 1/18/85)
5:
6: /*
7: ** TIMEFIX -- patch binary program to correct for timezone changes.
8: **
9: ** Timefix is compiled with the ctime(III) variables:
10: ** daylight,
11: ** timezone,
12: ** tzname[]
13: **
14: ** Each file specified is examined to see if it contains
15: ** all of these variables. If it does then the current values
16: ** of those variables for that file are given. If the "-u" flag
17: ** is specified then the values are not overwritten.
18: **
19: ** The other flags can be used to override the values of the
20: ** variables; specifically:
21: ** -sxxx --> timezone (xxx converted from ascii to binary)
22: ** -dx --> daylight (x converted from ascii to binary)
23: ** -tXXXYYY -> tzname[0] = "XXX" and tzname[1] = "YYY"
24: */
25:
26: struct header
27: {
28: int magic;
29: int tsize;
30: int dsize;
31: int bss;
32: int ssize;
33: int start_ad;
34: int unused;
35: int reloc_flag;
36: };
37:
38: struct sym
39: {
40: char symname[8];
41: int type;
42: int value;
43: };
44:
45:
46: /* these values are defined in the unix ctime() routine */
47: extern int daylight;
48: extern int timezone;
49: extern char *tzname[];
50:
51: int Noupdate;
52:
53: main(argc, argv)
54: int argc;
55: char *argv[];
56: {
57:
58: if (argc < 2)
59: {
60: printf("usage: timefix filename ...\n");
61: exit (1);
62: }
63:
64: argc--;
65: argv++;
66:
67: if (checkflags(&argc, argv))
68: exit (1);
69:
70: pr_values("your installation", timezone, tzname[0], tzname[1], daylight);
71:
72: while (argc--)
73: newtime(*argv++);
74: }
75: /*
76: ** NEWTIME
77: */
78:
79: newtime(filename)
80: char *filename;
81: {
82: struct sym timez, name_st, name_dy, dayflag;
83: struct header head;
84: register int i, fdes;
85: int adr, secs;
86: char std[4], dyl[4];
87:
88: if ((fdes = openheader(&head, filename)) < 0)
89: return (-1);
90:
91: bmove("_timezon", timez.symname, 8);
92: bmove("_tzname\0", name_st.symname, 8);
93: bmove("_dayligh", dayflag.symname, 8);
94:
95: /* pick up addresses from symbol table */
96: i = findsymbol(&head, fdes, &timez);
97: i |= findsymbol(&head, fdes, &name_st);
98: i |= findsymbol(&head, fdes, &dayflag);
99:
100: if (i)
101: {
102: printf("File %s does not need to be corrected\n", filename);
103: close(fdes);
104: return (-2);
105: }
106:
107: /* form entries for pointer to "PST" and "PDT" */
108: i = getvalue(&head, fdes, &name_st, &adr, 2);
109: name_st.value += 2;
110: i |= getvalue(&head, fdes, &name_st, &name_dy.value, 2);
111: name_dy.type = name_st.type;
112: name_st.value = adr;
113:
114: if (i)
115: {
116: printf("can't find pointers to timezone names in %s\n", filename);
117: close(fdes);
118: return (-3);
119: }
120:
121: /* now print out current values */
122: i = getvalue(&head, fdes, &timez, &secs, 2);
123: i |= getvalue(&head, fdes, &name_st, std, 4);
124: i |= getvalue(&head, fdes, &name_dy, dyl, 4);
125: i |= getvalue(&head, fdes, &dayflag, &adr, 2);
126:
127: if (i)
128: {
129: printf("one or more symbols cannot be read from %s\n", filename);
130: close(fdes);
131: return (-4);
132: }
133:
134: pr_values(filename, secs, std, dyl, adr);
135:
136: if (!Noupdate)
137: {
138: if (putvalue(&head, fdes, &timez, &timezone, 2)
139: || putvalue(&head, fdes, &name_st, tzname[0], 4)
140: || putvalue(&head, fdes, &name_dy, tzname[1], 4)
141: || putvalue(&head, fdes, &dayflag, &daylight, 2))
142: {
143: printf("cannot update %s with new values\n", filename);
144: close(fdes);
145: return (-2);
146: }
147: else
148: printf("File %s updated.\n", filename);
149: }
150:
151:
152: close(fdes);
153:
154: return (0);
155: }
156: /*
157: ** Open the indicated file and read & verify header
158: */
159:
160: openheader(hd, filename)
161: struct header *hd;
162: char *filename;
163: {
164: register int fd, i;
165:
166: if ((fd = open(filename, O_RDWR)) < 0)
167: {
168: printf("can't open file %s\n", filename);
169: return (-1);
170: }
171:
172: if ((i = read(fd, hd, sizeof (*hd))) != sizeof (*hd))
173: {
174: printf("can't read in header\n");
175: close(fd);
176: return (-2);
177: }
178:
179: switch (hd->magic)
180: {
181:
182: case 0407:
183: case 0410:
184: case 0411:
185: if (hd->ssize)
186: break;
187: printf("File %s does not have a symbol table.\n", filename);
188: return (-4);
189:
190: default:
191: printf("%s not an object file\n", filename);
192: return (-3);
193: }
194:
195: return (fd);
196: }
197: /*
198: ** Seek to beginning of symbol table
199: */
200:
201: startsymbol(hd, fdx)
202: struct header *hd;
203: int fdx;
204: {
205: register int i, fd;
206: register struct header *h;
207: long offset;
208: long itol();
209:
210: h = hd;
211: fd = fdx;
212:
213: /* seek past header */
214: i = lseek(fd, 16L, 0);
215:
216: /* seek to start of symbol table */
217: offset = itol(h->tsize);
218: offset = offset + itol(h->dsize);
219: if (h->reloc_flag == 0)
220: offset += offset;
221:
222: i |= lseek(fd, offset, 1);
223:
224: if (i < 0)
225: {
226: printf("can't seek to symbol table\n");
227: return (-1);
228: }
229:
230: return (0);
231: }
232: /*
233: ** Locate symbol in symbol table and return sucess-failure
234: */
235:
236: findsymbol(hd, fd, s)
237: struct header *hd;
238: int fd;
239: struct sym *s;
240: {
241: register int i, j;
242: struct sym next;
243:
244: if (startsymbol(hd, fd))
245: return (-1);
246:
247: for (i = hd->ssize; i--; )
248: {
249: j = read(fd, &next, sizeof (next));
250:
251: if (j != sizeof (next))
252: {
253: if (j)
254: printf("symbol table error %d,%d,%d\n", hd->ssize, i, j);
255: return (-1);
256: }
257:
258: if (bequal(next.symname, s->symname, sizeof (next.symname)))
259: {
260: s->type = next.type;
261: s->value = next.value;
262: return (0);
263: }
264: }
265:
266: return (1);
267: }
268: /*
269: ** GETVALUE
270: */
271:
272: getvalue(hd, fd, s, cp, len)
273: struct header *hd;
274: int fd;
275: struct sym *s;
276: char *cp;
277: int len;
278: {
279: register int i;
280: long getaddr(), addr;
281:
282: addr = getaddr(hd, s);
283: if (addr == -1)
284: return (-1);
285:
286: if (lseek(fd, addr, 0) < 0)
287: return (-1);
288:
289: if ((i = read(fd, cp, len)) != len)
290: return (-1);
291:
292: return (0);
293: }
294: /*
295: ** PUTVALUE
296: */
297:
298:
299: putvalue(hd, fd, s, loc, len)
300: struct header *hd;
301: int fd;
302: struct sym *s;
303: char *loc;
304: int len;
305: {
306: long adr, getaddr();
307:
308: adr = getaddr(hd, s);
309: if (adr == -1)
310: return (-1);
311:
312: if (lseek(fd, adr, 0) < 0)
313: return (-1);
314:
315: if (write(fd, loc, len) != len)
316: return (-2);
317:
318: return (0);
319: }
320: /*
321: ** PR_VALUES
322: */
323:
324: pr_values(str, secs, std, dyl, flag)
325: char *str;
326: int secs;
327: char *std;
328: char *dyl;
329: int flag;
330: {
331: printf("\nCurrent values for %s are:\n\t# seconds past greenwich: %d\n", str, secs);
332: printf("\ttimezones: %.4s and %.4s\n\tdaylight saving flag: %d\n", std, dyl, flag);
333: }
334: /*
335: ** CHECKFLAGS
336: */
337:
338: checkflags(argc, argv)
339: int *argc;
340: char *argv[];
341: {
342: register char *cp, **nargv;
343: register int cnt;
344: int ret;
345:
346: ret = 0;
347: cnt = *argc;
348: nargv = argv;
349: while (cnt--)
350: {
351: cp = *argv++;
352: if (*cp == '-')
353: {
354: (*argc)--;
355: cp++;
356: switch (*cp++)
357: {
358:
359: case 's':
360: timezone = atoi(cp);
361: break;
362:
363: case 't':
364: bmove(cp, tzname[0], 3);
365: bmove(cp+3, tzname[1], 3);
366: break;
367:
368: case 'd':
369: daylight = atoi(cp);
370: break;
371:
372: case 'u':
373: Noupdate++;
374: break;
375:
376: default:
377: printf("bad flag %s\n", cp - 2);
378: ret = -1;
379: }
380: }
381: else
382: *nargv++ = cp;
383: }
384:
385: return (ret);
386: }
387:
388:
389: bmove(src, dst, len)
390: char *src;
391: char *dst;
392: int len;
393: {
394: register int i;
395: register char *s, *d;
396:
397: s = src;
398: d = dst;
399: i = len;
400:
401: while (i--)
402: *d++ = *s++;
403: }
404:
405:
406: bequal(s1, s2, len)
407: char *s1;
408: char *s2;
409: int len;
410: {
411: register int i;
412: register char *s, *d;
413:
414: s = s1;
415: d = s2;
416: i = len;
417:
418: while (i--)
419: if (*s++ != *d++)
420: return (0);
421:
422: return (1);
423: }
424: /*
425: ** GETADDR
426: */
427:
428: long
429: getaddr(hd, s)
430: struct header *hd;
431: struct sym *s;
432: {
433: long addr;
434: int i;
435: long l;
436: long itol();
437:
438: addr = s->value + 16; /* offset past header */
439:
440: switch (s->type)
441: {
442:
443: /* extern text segment */
444: case 042:
445: return (addr);
446:
447: /* data segment extern */
448: case 043:
449: switch (hd->magic)
450: {
451:
452: case 0407:
453: return (addr);
454:
455: case 0410:
456: /* subtract space between text and data */
457: l = itol(hd->tsize) + 017777;
458: l &= ~017777;
459:
460: return (addr - (l - itol(hd->tsize)));
461:
462: case 0411:
463: return (addr + itol(hd->tsize));
464:
465: }
466: default:
467: printf("Invalid symbol type %o\n", s->type);
468: return (-1);
469: }
470: }
471:
472:
473: long itol(value)
474: int value;
475: {
476: long ret;
477: int *ip;
478:
479: ret = value;
480: ip = &ret;
481: *ip = 0;
482:
483: return (ret);
484: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.