4.3BSD - /usr/ingres/source/support/timefix.c

   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: }

Defined functions

Defined variables

Defined struct's