home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume36 / chiaro / part02 < prev    next >
Encoding:
Text File  |  1993-03-24  |  55.1 KB  |  1,849 lines
  1. Newsgroups: comp.sources.misc
  2. From: jwbirdsa@picarefy.picarefy.com (James W. Birdsall)
  3. Subject: v36i072:  chiaro - Image Utilities, Part02/18
  4. Message-ID: <1993Mar25.180932.19878@sparky.imd.sterling.com>
  5. X-Md4-Signature: e3dad866687630cb75736edd0e8a4bd1
  6. Date: Thu, 25 Mar 1993 18:09:32 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: jwbirdsa@picarefy.picarefy.com (James W. Birdsall)
  10. Posting-number: Volume 36, Issue 72
  11. Archive-name: chiaro/part02
  12. Environment: UNIX, Sun, DECstation, 3B1
  13.  
  14. #! /bin/sh
  15. # This is a shell archive.  Remove anything before this line, then feed it
  16. # into a shell via "sh file" or similar.  To overwrite existing files,
  17. # type "sh file -c".
  18. # Contents:  src/Makefile src/gifstrip.c
  19. # Wrapped by kent@sparky on Thu Mar 25 11:20:00 1993
  20. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin ; export PATH
  21. echo If this archive is complete, you will see the following message:
  22. echo '          "shar: End of archive 2 (of 18)."'
  23. if test -f 'src/Makefile' -a "${1}" != "-c" ; then 
  24.   echo shar: Will not clobber existing file \"'src/Makefile'\"
  25. else
  26.   echo shar: Extracting \"'src/Makefile'\" \(4530 characters\)
  27.   sed "s/^X//" >'src/Makefile' <<'END_OF_FILE'
  28. X#
  29. X# Makefile for the Chiaro suite.
  30. X#
  31. X# Copyright (c) 1993 by James W. Birdsall, all rights reserved.
  32. X#
  33. X
  34. Xinclude template.mk
  35. X
  36. XCCC    = $(CC) $(CFLAGS) $(CINC)
  37. XLLL    = $(LINK) $(LFLAGS)
  38. X
  39. X
  40. Xall:    chils$(EXE) gifstrip$(EXE) gifcheck$(EXE)
  41. X
  42. X
  43. Xclean:
  44. X    $(RM) core *.$O chils$(EXE) gifstrip$(EXE) gifcheck$(EXE)
  45. X    $(RM) fbro.c gifnofb.c gldc.c gldm.c pgm.c ppm.c
  46. X
  47. X
  48. Xchils$(EXE):    chils.$O depend.$O comsrch.$O fbro.$O chidisp.$O \
  49. X        formats.$O re.$O token.$O \
  50. X        gifnofb.$O img.$O jfif.$O sr.$O tga.$O pbm.$O pgm.$O \
  51. X        ppm.$O xbm.$O bmp.$O pcx.$O
  52. X    $(LLL) -o $@ $(LOBJS) chils.$O depend.$O comsrch.$O fbro.$O chidisp.$O \
  53. X        formats.$O re.$O token.$O gifnofb.$O img.$O jfif.$O sr.$O \
  54. X        tga.$O pbm.$O pgm.$O ppm.$O xbm.$O bmp.$O pcx.$O $(LLIBS)
  55. X    $(POST_CHILS)
  56. X
  57. Xgifstrip$(EXE):    gifstrip.$O depend.$O stdinarg.$O gif.$O fb.$O mf.$O
  58. X    $(LLL) -o $@ $(LOBJS) gifstrip.$O depend.$O stdinarg.$O gif.$O fb.$O \
  59. X         mf.$O $(LLIBS)
  60. X    $(POST_GIFSTRIP)
  61. X
  62. Xgifcheck$(EXE):    gifcheck.$O depend.$O stdinarg.$O fb.$O colors.$O blocproc.$O \
  63. X        gif.$O gldm.$O 
  64. X    $(LLL) -o $@ $(LOBJS) gifcheck.$O depend.$O stdinarg.$O fb.$O \
  65. X        colors.$O blocproc.$O gif.$O gldm.$O $(LLIBS)
  66. X    $(POST_GIFCHECK)
  67. X
  68. X
  69. Xblocproc.$O:    blocproc.c config.h depend.h fb.h formats.h gif.h gld.h \
  70. X        colors.h gifcheck.h blocproc.h
  71. X    $(CCC) blocproc.c
  72. X
  73. Xbmp.$O:        bmp.c config.h depend.h formats.h bmp.h
  74. X    $(CCC) bmp.c
  75. X
  76. Xchidisp.$O:    chidisp.c config.h depend.h fb.h formats.h gif.h img.h \
  77. X        jfif.h sr.h tga.h pnm.h xbm.h bmp.h pcx.h chils.h chidisp.h
  78. X    $(CCC) chidisp.c
  79. X
  80. Xchils.$O:    chils.c config.h depend.h chils.h fb.h formats.h gif.h \
  81. X        img.h jfif.h sr.h tga.h pnm.h xbm.h bmp.h pcx.h comsrch.h \
  82. X        patchlevel.h
  83. X    $(CCC) chils.c
  84. X
  85. Xcolors.$O:    colors.c config.h depend.h formats.h colors.h
  86. X    $(CCC) colors.c
  87. X
  88. Xcomsrch.$O:    comsrch.c config.h depend.h formats.h comsrch.h
  89. X    $(CCC) comsrch.c
  90. X
  91. Xdepend.$O:    depend.c config.h depend.h
  92. X    $(CCC) depend.c
  93. X
  94. Xfb.$O:        fb.c config.h fb.h depend.h
  95. X    $(CCC) fb.c
  96. X
  97. Xfbro.$O:    fb.c config.h fb.h depend.h
  98. X    $(RM) fbro.c
  99. X    $(LN) fb.c fbro.c
  100. X    $(CCC) -DREADONLY fbro.c
  101. X    $(RM) fbro.c
  102. X
  103. Xformats.$O:    formats.c config.h depend.h fb.h formats.h gif.h img.h \
  104. X        jfif.h sr.h tga.h pnm.h xbm.h bmp.h pcx.h
  105. X    $(CCC) formats.c
  106. X
  107. Xgif.$O:        gif.c config.h depend.h fb.h formats.h gif.h
  108. X    $(CCC) gif.c
  109. X
  110. Xgifnofb.$O:    gif.c config.h depend.h fb.h formats.h gif.h
  111. X    $(RM) gifnofb.c
  112. X    $(LN) gif.c gifnofb.c
  113. X    $(CCC) -DNO_FB gifnofb.c
  114. X    $(RM) gifnofb.c
  115. X
  116. Xgifcheck.$O:    gifcheck.c config.h depend.h fb.h formats.h gif.h gld.h \
  117. X        colors.h gifcheck.h blocproc.h stdinarg.h patchlevel.h
  118. X    $(CCC) gifcheck.c
  119. X
  120. Xgifstrip.$O:    gifstrip.c config.h depend.h fb.h mf.h formats.h gif.h \
  121. X        stdinarg.h patchlevel.h
  122. X    $(CCC) gifstrip.c
  123. X
  124. Xgldc.$O:    gld.c config.h depend.h gld.h
  125. X    $(RM) gldc.c
  126. X    $(LN) gld.c gldc.c
  127. X    $(CCC) -DCODE_CHECK gldc.c
  128. X    $(RM) gldc.c
  129. X
  130. Xgldm.$O:    gld.c config.h depend.h gld.h
  131. X    $(RM) gldm.c
  132. X    $(LN) gld.c gldm.c
  133. X    $(CCC) -DMINIMAL gldm.c
  134. X    $(RM) gldm.c
  135. X
  136. Ximg.$O:        img.c config.h depend.h formats.h img.h
  137. X    $(CCC) img.c
  138. X
  139. Xjfif.$O:    jfif.c config.h depend.h fb.h formats.h jfif.h
  140. X    $(CCC) jfif.c
  141. X
  142. Xmf.$O:        mf.c config.h depend.h mf.h fb.h
  143. X    $(CCC) mf.c
  144. X
  145. Xpbm.$O:        pbm.c config.h depend.h formats.h token.h pnm.h
  146. X    $(CCC) pbm.c
  147. X
  148. Xpcx.$O:        pcx.c config.h depend.h formats.h pcx.h
  149. X    $(CCC) pcx.c
  150. X
  151. Xpgm.$O:        pgmppm.c depend.h formats.h token.h pnm.h
  152. X    $(RM) pgm.c
  153. X    $(LN) pgmppm.c pgm.c
  154. X    $(CCC) -DPGM pgm.c
  155. X    $(RM) pgm.c
  156. X
  157. Xppm.$O:        pgmppm.c depend.h formats.h token.h pnm.h
  158. X    $(RM) ppm.c
  159. X    $(LN) pgmppm.c ppm.c
  160. X    $(CCC) ppm.c
  161. X    $(RM) ppm.c
  162. X
  163. Xre.$O:        re.c config.h depend.h formats.h re.h fb.h gif.h img.h \
  164. X        jfif.h sr.h tga.h pnm.h xbm.h bmp.h pcx.h
  165. X    $(CCC) re.c
  166. X
  167. Xsr.$O:        sr.c config.h depend.h formats.h sr.h
  168. X    $(CCC) sr.c
  169. X
  170. Xstdinarg.$O:    stdinarg.c config.h depend.h stdinarg.h
  171. X    $(CCC) stdinarg.c
  172. X
  173. Xtga.$O:        tga.c config.h depend.h formats.h tga.h
  174. X    $(CCC) tga.c
  175. X
  176. Xtoken.$O:    token.c config.h depend.h formats.h token.h
  177. X    $(CCC) token.c
  178. X
  179. Xxbm.$O:        xbm.c config.h depend.h formats.h xbm.h token.h
  180. X    $(CCC) xbm.c
  181. X
  182. X
  183. Xbmp.h:    status.h
  184. X
  185. Xfb.h:    status.h
  186. X
  187. Xformats.h:    re.h
  188. X
  189. Xgif.h:    status.h
  190. X
  191. Xgld.h:    status.h
  192. X
  193. Ximg.h:    status.h
  194. X
  195. Xjfif.h:    status.h
  196. X
  197. Xmf.h:    status.h
  198. X
  199. Xpbm.h:    status.h
  200. X
  201. Xpcx.h:    status.h
  202. X
  203. Xpgm.h:    status.h
  204. X
  205. Xpnm.h:    status.h pbm.h pgm.h ppm.h
  206. X
  207. Xppm.h:    status.h
  208. X
  209. Xre.h:    status.h
  210. X
  211. Xsr.h:    status.h
  212. X
  213. Xtga.h:    status.h
  214. X
  215. Xxbm.h:    status.h
  216. X
  217. X
  218. X#
  219. X# WARNING: THESE TARGETS ARE FOR TEST USE ONLY.
  220. X#
  221. Xgldtest3$(EXE):    gldtest3.$O gif.$O gldc.$O fb.$O depend.$O
  222. X    $(LLL) -o $@ $(LOBJS) gldtest3.$O gif.$O gldc.$O fb.$O depend.$O \
  223. X        $(LLIBS)
  224. X
  225. Xgldtest3.$O:    gldtest3.c config.h depend.h fb.h formats.h gif.h gld.h
  226. X    $(CCC) gldtest3.c
  227. X
  228. Xgldtest3.c:    ../masters/gldtest3.c
  229. X    $(CP) ../masters/gldtest3.c .
  230. END_OF_FILE
  231.   if test 4530 -ne `wc -c <'src/Makefile'`; then
  232.     echo shar: \"'src/Makefile'\" unpacked with wrong size!
  233.   fi
  234.   # end of 'src/Makefile'
  235. fi
  236. if test -f 'src/gifstrip.c' -a "${1}" != "-c" ; then 
  237.   echo shar: Will not clobber existing file \"'src/gifstrip.c'\"
  238. else
  239.   echo shar: Extracting \"'src/gifstrip.c'\" \(47919 characters\)
  240.   sed "s/^X//" >'src/gifstrip.c' <<'END_OF_FILE'
  241. X/***************************************************************************
  242. X*   GIFSTRIP.C                                                             *
  243. X*   MODULE:  -                                                             *
  244. X*   OS:      UNIX                                                          *
  245. X*                                                                          *
  246. X*   Copyright (c) 1993 James W. Birdsall. All Rights Reserved.             *
  247. X*                                                                          *
  248. X*   The Graphics Interchange Format(c) is the Copyright property of        *
  249. X*   CompuServe Incorporated. GIF(sm) is a Service Mark property of         *
  250. X*   CompuServe Incorporated.                                               *
  251. X*                                                                          *
  252. X*   $Id: gifstrip.c,v 1.10 1993/03/02 00:49:36 jwbirdsa Exp $
  253. X*                                                                          *
  254. X*   Chiaro suite GIF rebuild program.                                      *
  255. X*                                                                          *
  256. X***************************************************************************/
  257. X
  258. X#include "config.h"
  259. X
  260. X/*
  261. X** system includes <>
  262. X*/
  263. X
  264. X#include <stdio.h>
  265. X#include <ctype.h>
  266. X#include <sys/types.h>
  267. X#include <sys/stat.h>
  268. X#ifndef NO_STDLIB
  269. X#include <stdlib.h>
  270. X#endif
  271. X#ifndef NO_MALLOCHDR
  272. X#include <malloc.h>
  273. X#endif
  274. X#ifndef NO_STR_INC
  275. X#ifdef STRING_PLURAL
  276. X#include <strings.h>
  277. X#else
  278. X#include <string.h>
  279. X#endif
  280. X#endif
  281. X#ifdef UTIME_HDR
  282. X#include <utime.h>
  283. X#endif
  284. X
  285. X
  286. X/*
  287. X** custom includes ""
  288. X*/
  289. X
  290. X#include "depend.h"
  291. X
  292. X#include "fb.h"
  293. X#include "mf.h"
  294. X
  295. X#include "formats.h"
  296. X#include "gif.h"
  297. X
  298. X#include "stdinarg.h"
  299. X
  300. X#include "patchlevel.h"
  301. X
  302. X
  303. X/*
  304. X** local #defines
  305. X*/
  306. X
  307. X#define FB_TABLESIZE         5
  308. X#ifdef SMALL_MEM
  309. X#define FB_BUFSIZE           4096
  310. X#else
  311. X#define FB_BUFSIZE           30000
  312. X#endif
  313. X
  314. X#define TBUFSIZ              15
  315. X
  316. X#define EARLY                0
  317. X#define LATE                 1
  318. X
  319. X/* Returns from strip(). */
  320. X
  321. X#define EXIT_OK              0
  322. X#define EXIT_NOTGIF          1
  323. X#define EXIT_UNEOF           2
  324. X#define EXIT_ERROR           3
  325. X
  326. X
  327. X/*
  328. X** misc: copyright strings, version macros, etc.
  329. X*/
  330. X
  331. Xstatic char CONST copyright[] = "Copyright (c) 1992 James W. Birdsall. All Rights Reserved";
  332. Xstatic char CONST rcsid[] = "$Id: gifstrip.c,v 1.10 1993/03/02 00:49:36 jwbirdsa Exp $";
  333. X
  334. X#define VERS                 "2.0"
  335. X
  336. X
  337. X/*
  338. X** typedefs
  339. X*/
  340. X
  341. X#ifndef UTIME_HDR
  342. Xstruct utimbuf
  343. X{
  344. X    time_t actime;
  345. X    time_t modtime;
  346. X};
  347. X#endif
  348. X
  349. X/*
  350. X** global variables
  351. X*/
  352. X
  353. X/*
  354. X** static globals
  355. X*/
  356. X
  357. X/* Default: use memory and disk. */
  358. X
  359. Xstatic int mf_flags = (USE_CONMEM | USE_DISKMEM);
  360. X
  361. X/* Default: no recopy if no extra bytes or no format violations. */
  362. X
  363. Xstatic int forced_copy = 0;
  364. X
  365. X/* Default: strict format -- report and recopy on format violations. */
  366. X
  367. Xstatic int strict = 1;
  368. X
  369. X/* Default: assume no leading junk. */
  370. X
  371. Xstatic int nolead = 1;
  372. X
  373. X/* Default: late unlink. */
  374. X
  375. Xstatic int unlinktime = LATE;
  376. X
  377. X/* File handles for standard and error output. */
  378. X
  379. Xstatic FILE *outstr = stdout;
  380. Xstatic FILE *outerr = stdout;
  381. X
  382. X/* Temporary file path. */
  383. X
  384. Xstatic char *tpath = (char *) NULL;
  385. X
  386. X/* Global scratch space. */
  387. X
  388. Xstatic char scratch[80];
  389. X
  390. X
  391. X/*
  392. X** function prototypes
  393. X*/
  394. X
  395. X#ifdef  __STDC__
  396. X# define P_(s) s
  397. X#else
  398. X# define P_(s) ()
  399. X#endif
  400. X
  401. Xstatic int strip P_((char *filename));
  402. X
  403. Xstatic VOID usage();
  404. Xstatic char *errxlate P_((ULONG errcode));
  405. X
  406. X#undef P_
  407. X
  408. X#ifdef NO_STR_INC
  409. X#ifndef NO_STRDUP
  410. Xextern char *strdup();
  411. X#endif
  412. X#endif
  413. X
  414. X
  415. X/*
  416. X** functions
  417. X*/
  418. X
  419. X
  420. X/***************************************************************************
  421. X *   FUNCTION MAIN                                                         *
  422. X ***************************************************************************/
  423. X#ifdef __STDC__
  424. Xmain(int argc, char *argv[])
  425. X#else
  426. Xmain(argc, argv)
  427. Xint argc;
  428. Xchar *argv[];
  429. X#endif
  430. X{
  431. X    int loop, loop2;
  432. X    int onlyflags = 1;
  433. X    int argcc;
  434. X    char **argvv;
  435. X    char **namelist;
  436. X    char separator;
  437. X    char *temp;
  438. X    int stdinkey = 1;    /* Nonzero = stdin is keyboard, zero = redirected. */
  439. X    int errorlevel;
  440. X
  441. X    /* Search for option and parse if found. */
  442. X
  443. X    for(loop = 1; loop < argc; loop++)
  444. X    {
  445. X        if ('-' == argv[loop][0])
  446. X        {
  447. X            switch (argv[loop][1])
  448. X            {
  449. X                /* Don't use memory. */
  450. X                case 'c':
  451. X                    mf_flags &= (~(USE_CONMEM));
  452. X                    if ((mf_flags & USE_MASK) == 0)
  453. X                    {
  454. X                        fprintf(outerr, "ERROR: Cannot process files unless some form of temporary storage is\n");
  455. X                        fprintf(outerr, "available and allowed. Type GIFSTRIP -h for usage.\n");
  456. X                        exit(EXIT_ERROR);
  457. X                    }
  458. X                    break;
  459. X
  460. X                /* Don't use disk. */
  461. X                case 'd':
  462. X                    mf_flags &= (~(USE_DISKMEM));
  463. X                    if ((mf_flags & USE_MASK) == 0)
  464. X                    {
  465. X                        fprintf(outerr, "ERROR: Cannot process files unless some form of temporary storage is\n");
  466. X                        fprintf(outerr, "available and allowed. Type GIFSTRIP -h for usage.\n");
  467. X                        exit(EXIT_ERROR);
  468. X                    }
  469. X                    break;
  470. X
  471. X                /* Safety mode, use only disk. */
  472. X                case 's':
  473. X                    mf_flags &= (~(USE_CONMEM));
  474. X                    if ((mf_flags & USE_MASK) == 0)
  475. X                    {
  476. X                        fprintf(outerr, "ERROR: Cannot process files unless some form of temporary storage is\n");
  477. X                        fprintf(outerr, "available and allowed. Type GIFSTRIP -h for usage.\n");
  478. X                        exit(EXIT_ERROR);
  479. X                    }
  480. X                    break;
  481. X
  482. X                /* Batch mode option. */
  483. X                case 'b': 
  484. X                    if ((outstr = fopen(NULL_DEVICE, "w")) == (FILE *) NULL)
  485. X                    {
  486. X                        fprintf(stderr, "ERROR: Cannot open %s\n", NULL_DEVICE);
  487. X                        exit(EXIT_ERROR);
  488. X                    }
  489. X                    outerr = outstr;
  490. X                    break;
  491. X
  492. X                /* Force rebuild of file. */
  493. X                case 'f':
  494. X                    forced_copy = 1;
  495. X                    break;
  496. X
  497. X                /* Disable strict format enforcement. */
  498. X                case 'n':
  499. X                    strict = 0;
  500. X                    break;
  501. X
  502. X                /* Allow handling of leading junk. */
  503. X                case 'm':
  504. X                    nolead = 0;
  505. X                    break;
  506. X 
  507. X                /* Redirect errors to stderr. */
  508. X                case 'r':
  509. X                    outerr = stderr;
  510. X                    break;
  511. X
  512. X                /* Overwrite original file early. */
  513. X                case 'o':
  514. X                    unlinktime = EARLY;
  515. X                    break;
  516. X
  517. X                /* Specify temporary path. */
  518. X                case 't':
  519. X                    if ((tpath = strdup(&(argv[loop][2]))) == (char *) NULL)
  520. X                    {
  521. X                        fprintf(stderr, "ERROR: Out of memory.\n");
  522. X                        exit(EXIT_ERROR);
  523. X                    }
  524. X                    break;
  525. X
  526. X                /* Take filenames from stdin. */
  527. X                case '-':
  528. X                    stdinkey = 0;
  529. X                    break;
  530. X
  531. X                /* Help option. */
  532. X                case 'h':
  533. X                /* Unknown option. */
  534. X                default:
  535. X                    usage();
  536. X                    break;
  537. X            }
  538. X        }
  539. X        else
  540. X        {
  541. X            /*
  542. X            ** onlyflags == 1 when the command line contains only options.
  543. X            ** If this clause is executed, means there is at least one arg
  544. X            ** which is not an option and therefore is a target.
  545. X            */
  546. X
  547. X            onlyflags = 0;
  548. X        }
  549. X    }
  550. X
  551. X    /* If no target(s) specified and stdin not redirected, error. */
  552. X
  553. X    if ((onlyflags != 0) && (stdinkey != 0))
  554. X    {
  555. X        usage();
  556. X    }
  557. X
  558. X    /* Initialize file buffering package. */
  559. X
  560. X    if (fb_init(FB_TABLESIZE, FB_BUFSIZE) != 0)
  561. X    {
  562. X        fprintf(outerr, "%s\n", fb_errstring(fb_error));
  563. X        exit(EXIT_ERROR);
  564. X    }
  565. X
  566. X    /* Check for stdin redirection -- load targets from stdin if redirected. */
  567. X
  568. X    if (stdinkey != 0)
  569. X    {
  570. X        argcc = argc;
  571. X        argvv = argv;
  572. X    }
  573. X    else
  574. X    {
  575. X        argvv = stdinload(&argcc);
  576. X        argvv[0] = argv[0];
  577. X    }
  578. X
  579. X    /* Loop through targets, processing. */
  580. X
  581. X    for(loop = 1; loop < argcc; loop++)
  582. X    {
  583. X        if (argvv[loop][0] != '-')
  584. X        {
  585. X            /* Extract an argument from the command line and expand it. */
  586. X
  587. X            if ((namelist = scand(argvv[loop])) == NULL)
  588. X            {
  589. X                fprintf(outerr, "ERROR: bad target %s\n", argvv[loop]);
  590. X                continue;
  591. X            }
  592. X            else if (NULL == namelist[0])
  593. X            {
  594. X                fprintf(outerr, "WARNING: No files matching %s found.\n",
  595. X                        argvv[loop]);
  596. X                continue;
  597. X            }
  598. X
  599. X            /* Strip each file. */
  600. X
  601. X            for(loop2 = 0; namelist[loop2]; loop2++)
  602. X            {
  603. X                fprintf(outstr, "\nProcessing %s...\n", namelist[loop2]);
  604. X                errorlevel = strip(namelist[loop2]);
  605. X            }
  606. X
  607. X            /* Cleanup. */
  608. X
  609. X            for(loop2 = 0; namelist[loop2]; loop2++)
  610. X            {
  611. X                free(namelist[loop2]);
  612. X            }
  613. X            free(namelist);
  614. X            if (0 == stdinkey)
  615. X            {
  616. X                free(argvv[loop]);
  617. X            }
  618. X        }
  619. X    }
  620. X
  621. X    /* Cleanup. */
  622. X
  623. X    if (0 == stdinkey)
  624. X    {
  625. X        free(argvv);
  626. X    }
  627. X
  628. X    exit(errorlevel);
  629. X} /* end of main */
  630. X
  631. X
  632. X/***************************************************************************
  633. X*   FUNCTION:    strip  STATIC                                             *
  634. X*                                                                          *
  635. X*   DESCRIPTION:                                                           *
  636. X*                                                                          *
  637. X*       This function rebuilds the named file, if necessary.               *
  638. X*                                                                          *
  639. X*   ENTRY:                                                                 *
  640. X*                                                                          *
  641. X*       filename - name of file to be rebuilt. May include drive and/or    *
  642. X*                  path.                                                   *
  643. X*                                                                          *
  644. X*   EXIT:                                                                  *
  645. X*                                                                          *
  646. X*       Returns EXIT_OK, EXIT_NOTGIF, or EXIT_ERROR, depending.            *
  647. X*                                                                          *
  648. X*   CONSTRAINTS/SIDE EFFECTS:                                              *
  649. X*                                                                          *
  650. X***************************************************************************/
  651. Xstatic int
  652. X#ifdef __STDC__
  653. Xstrip(char *filename)
  654. X#else
  655. Xstrip(filename)
  656. Xchar *filename;
  657. X#endif
  658. X{
  659. X    FILE *origfile, *stampset;
  660. X    FB *infile, *outfile;
  661. X    ULONG status;
  662. X    long size;
  663. X    int colors;
  664. X    int viol_copy = 0;
  665. X    ULONG skip;
  666. X    ULONG newbytes = 0L;
  667. X    ULONG blockbytes;
  668. X    unsigned int blocks;
  669. X    UCHAR *rebuf;
  670. X    struct stat statbuf;
  671. X    struct utimbuf times;
  672. X    char *tname;
  673. X    int myuid;
  674. X    int fileuid;
  675. X
  676. X    UCHAR tempbuf[TBUFSIZ];
  677. X    int loop;
  678. X
  679. X    GIF_LSD lsd;
  680. X    RGB_TRIPLET *ctable;
  681. X    int blocktype;
  682. X    int extype;
  683. X    GIF_IMD imd;
  684. X    UCHAR codesize;
  685. X    UCHAR *data;
  686. X    int datalen;
  687. X
  688. X    /* Open original GIF and perform other startup functions. */
  689. X
  690. X    if ((origfile = fopen(filename, FOPEN_READ_BINARY)) == (FILE *) NULL)
  691. X    {
  692. X        fprintf(outerr, "ERROR: Cannot open file %s\n", filename);
  693. X        return EXIT_ERROR;
  694. X    }
  695. X    mf_locked = 0;
  696. X
  697. X    /* Get the size and other data (owner, group, timestamps, mode). */
  698. X
  699. X    if (fstat(fileno(origfile), &statbuf) == -1)
  700. X    {
  701. X        fprintf(outerr, "ERROR: Error in fstat() on %s\n", filename);
  702. X        fclose(origfile);
  703. X        return EXIT_ERROR;
  704. X    }
  705. X    size = statbuf.st_size;
  706. X
  707. X    /* Open memory file and make sure there is enough space. */
  708. X
  709. X    if ((status = mf_open(mf_flags, (ULONG) size, tpath)) != 0)
  710. X    {
  711. X        fprintf(outerr, "%s\n", errxlate(status));
  712. X        fclose(origfile);
  713. X        return EXIT_ERROR;
  714. X    }
  715. X
  716. X    /* Get GIF logical screen descriptor. */
  717. X
  718. X    if (nolead != 0)
  719. X    {
  720. X        if ((status = gif_lsdget(origfile, &lsd)) != ST_SUCCESS)
  721. X        {
  722. X            fprintf(outerr, "%s\n", errxlate(status));
  723. X            fclose(origfile);
  724. X            mf_close();
  725. X            switch (ERRSEV(status))
  726. X            {
  727. X                case ERRSEV(GIF_NOTGIF_E):
  728. X                    return EXIT_NOTGIF;
  729. X
  730. X                case ERRSEV(GIF_UNEOF_E):
  731. X                    return EXIT_UNEOF;
  732. X
  733. X                default:
  734. X                    return EXIT_ERROR;
  735. X            }
  736. X        }
  737. X
  738. X        /* Attach buffering to original GIF file. */
  739. X
  740. X        infile = fb_retrofit(origfile, 'r');
  741. X        if (fb_error != 0)
  742. X        {
  743. X            fprintf(outerr, "%s\n", errxlate(fb_error));
  744. X            fclose(origfile);
  745. X            mf_close();
  746. X            return EXIT_ERROR;
  747. X        }
  748. X
  749. X    }
  750. X    else
  751. X    {
  752. X        /* Attach buffering to original GIF file. */
  753. X        infile = fb_retrofit(origfile, 'r');
  754. X        if (fb_error != 0)
  755. X        {
  756. X            fprintf(outerr, "%s\n", errxlate(fb_error));
  757. X            fclose(origfile);
  758. X            mf_close();
  759. X            return EXIT_ERROR;
  760. X        }
  761. X
  762. X        /* Search for potentially buried LSD. */
  763. X
  764. X        if ((status = gif_searchlsd(infile, &lsd, &skip)) != ST_SUCCESS)
  765. X        {
  766. X            fprintf(outerr, "%s\n", errxlate(status));
  767. X            fb_close(infile);
  768. X            mf_close();
  769. X            switch (ERRSEV(status))
  770. X            {
  771. X                case ERRSEV(GIF_NOTGIF_E):
  772. X                case ERRSEV(GIF_UNEOF_E):
  773. X                    return EXIT_NOTGIF;
  774. X
  775. X                default:
  776. X                    return EXIT_ERROR;
  777. X            }
  778. X        }
  779. X        if (skip != 0)
  780. X        {
  781. X            fprintf(outstr, "FYI: Skipped %lu leading junk bytes.\n", skip);
  782. X        }
  783. X    }
  784. X
  785. X    /* Print some info. */
  786. X
  787. X    fprintf(outstr, ((GIF_89A == lsd.version) ? "GIF89A  " : "GIF87A  "));
  788. X    fprintf(outstr, ((lsd.gct_flag) ? "G" : "-"));
  789. X    if (GIF_89A == lsd.version)
  790. X    {
  791. X        fprintf(outstr, ((lsd.sort_flag) ? "S" : "-"));
  792. X        fprintf(outstr, ((lsd.aspect) ? "A" : "-"));
  793. X    }
  794. X    else
  795. X    {
  796. X        fprintf(outstr, "--");
  797. X    }
  798. X    fprintf(outstr, "%8ld  %5u x %5u @ ", size, lsd.scr_wid, lsd.scr_hi);
  799. X    if (lsd.gct_flag)
  800. X    {
  801. X        colors = (0x1 << lsd.gct_size);
  802. X        fprintf(outstr, "%3d", colors);
  803. X    }
  804. X    else
  805. X    {
  806. X        fprintf(outstr, "---");
  807. X    }
  808. X    fprintf(outstr, "   %s\n", filename);
  809. X
  810. X    /* Reconstruct GIF header and logical screen descriptor. */
  811. X
  812. X    /* Output signatures. */
  813. X
  814. X    if ((status = mf_write(GIF_SIGNATURE, GIF_SIGNATURE_LEN)) != 0)
  815. X    {
  816. X        fprintf(outerr, "%s\n", errxlate(status));
  817. X        fb_close(infile);
  818. X        mf_close();
  819. X        return EXIT_ERROR;
  820. X    }
  821. X    newbytes += GIF_SIGNATURE_LEN;
  822. X
  823. X    /* Output version signature. */
  824. X
  825. X    if ((status = mf_write(((GIF_89A == lsd.version) ? GIF_VERS89A_SIG :
  826. X                                                       GIF_VERS87A_SIG),
  827. X                           GIF_VERS_SIG_LEN)) != 0)
  828. X    {
  829. X        fprintf(outerr, "%s\n", errxlate(status));
  830. X        fb_close(infile);
  831. X        mf_close();
  832. X        return EXIT_ERROR;
  833. X    }
  834. X    newbytes += GIF_VERS_SIG_LEN;
  835. X
  836. X    /* Create new logical screen descriptor. */
  837. X
  838. X    tempbuf[GIF_LSD_SCRWID_OFF] = (UCHAR) (lsd.scr_wid & 0x00FF);
  839. X    tempbuf[GIF_LSD_SCRWID_OFF + 1] = (UCHAR) (lsd.scr_wid >> 8);
  840. X    tempbuf[GIF_LSD_SCRHI_OFF] = (UCHAR) (lsd.scr_hi & 0x00FF);
  841. X    tempbuf[GIF_LSD_SCRHI_OFF + 1] = (UCHAR) (lsd.scr_hi >> 8);
  842. X    if (0 == strict)
  843. X    {
  844. X        tempbuf[GIF_LSD_PACKED_OFF] = lsd.raw_packed;
  845. X    }
  846. X    else
  847. X    {
  848. X        tempbuf[GIF_LSD_PACKED_OFF] = 0;
  849. X        if (lsd.gct_flag)
  850. X        {
  851. X            tempbuf[GIF_LSD_PACKED_OFF] |= GIF_LSD_GCTFLAG_MASK;
  852. X        }
  853. X        tempbuf[GIF_LSD_PACKED_OFF] |= (UCHAR)
  854. X           (((lsd.clr_res - 1) << GIF_LSD_CLRRES_SHIFT) & GIF_LSD_CLRRES_MASK);
  855. X        if (lsd.sort_flag != 0)
  856. X        {
  857. X            if (GIF_89A == lsd.version)
  858. X            {
  859. X                tempbuf[GIF_LSD_PACKED_OFF] |= GIF_LSD_SORTFLAG_MASK;
  860. X            }
  861. X            else
  862. X            {
  863. X                /*
  864. X                ** Can only get here if version is 87A, strict is on,
  865. X                ** and sort flag is set. This is illegal combination.
  866. X                */
  867. X
  868. X                fprintf(outstr,
  869. X                 "FYI: Ignoring illegal global color table sorted flag.\n   ");
  870. X
  871. X                /*
  872. X                ** Turn on viol_copy so that file is rebuilt
  873. X                ** even if size is same.
  874. X                */
  875. X
  876. X                viol_copy = 1;
  877. X            }
  878. X        }
  879. X        tempbuf[GIF_LSD_PACKED_OFF] |=
  880. X                           (UCHAR) ((lsd.gct_size - 1) & GIF_LSD_GCTSIZE_MASK);
  881. X    }
  882. X    tempbuf[GIF_LSD_BACKGROUND_OFF] = (UCHAR) (lsd.background);
  883. X    if ((GIF_89A == lsd.version) || (0 == strict))
  884. X    {
  885. X        tempbuf[GIF_LSD_ASPECT_OFF] = (UCHAR) (lsd.aspect);
  886. X    }
  887. X    else
  888. X    {
  889. X        tempbuf[GIF_LSD_ASPECT_OFF] = 0;
  890. X        if (lsd.aspect != 0)
  891. X        {
  892. X            fprintf(outstr, "FYI: Ignoring illegal aspect ratio value.   \n");
  893. X
  894. X            /* Turn on viol_copy so that file is rebuilt even if size same. */
  895. X            viol_copy = 1;
  896. X        }
  897. X    }
  898. X
  899. X    /* Write new logical screen descriptor. */
  900. X
  901. X    if ((status = mf_write(tempbuf, GIF_LSD_LEN)) != 0)
  902. X    {
  903. X        fprintf(outerr, "%s\n", errxlate(status));
  904. X        fb_close(infile);
  905. X        mf_close();
  906. X        return EXIT_ERROR;
  907. X    }
  908. X    newbytes += GIF_LSD_LEN;
  909. X
  910. X    /* Get and write global color table, if any. */
  911. X
  912. X    if (lsd.gct_flag)
  913. X    {
  914. X        if ((status = gif_gctget(infile, &ctable, colors)) != 0)
  915. X        {
  916. X            fprintf(outerr, "%s\n", errxlate(status));
  917. X            fb_close(infile);
  918. X            mf_close();
  919. X            return ((GIF_UNEOF_E == status) ? EXIT_UNEOF : EXIT_ERROR);
  920. X        }
  921. X
  922. X        for (loop = 0; loop < colors; loop++)
  923. X        {
  924. X            tempbuf[0] = ctable[loop].red;
  925. X            tempbuf[1] = ctable[loop].green;
  926. X            tempbuf[2] = ctable[loop].blue;
  927. X            if ((status = mf_write(tempbuf, 3)) != 0)
  928. X            {
  929. X                fprintf(outerr, "%s\n", errxlate(status));
  930. X                fb_close(infile);
  931. X                mf_close();
  932. X                return EXIT_ERROR;
  933. X            }
  934. X            newbytes += 3;
  935. X        }
  936. X
  937. X        free(ctable);
  938. X    }
  939. X
  940. X    /* Loop through data blocks. */
  941. X
  942. X    blocktype = 0;
  943. X    while (blocktype != GIF_TERMINATOR)
  944. X    {
  945. X        fprintf(outstr, "   ");
  946. X
  947. X        /* Find next block. */
  948. X
  949. X        if ((status = gif_findnext(infile, &blocktype, &skip, &extype)) != 0)
  950. X        {
  951. X            fprintf(outerr, "%s\n", errxlate(status));
  952. X            fb_close(infile);
  953. X            mf_close();
  954. X            return ((GIF_UNEOF_E == status) ? EXIT_UNEOF : EXIT_ERROR);
  955. X        }
  956. X
  957. X        /* If skipped characters, FYI. */
  958. X
  959. X        if (skip != 0)
  960. X        {
  961. X            fprintf(outstr, "FYI: %lu garbage characters skipped\n   ", skip);
  962. X        }
  963. X
  964. X        /* Process by type of block. */
  965. X
  966. X        switch (blocktype)
  967. X        {
  968. X            case GIF_IMAGE:
  969. X                /* Write image header. */
  970. X
  971. X                tempbuf[0] = GIF_IMAGE;
  972. X                if ((status = mf_write(tempbuf, 1)) != 0)
  973. X                {
  974. X                    fprintf(outerr, "%s\n", errxlate(status));
  975. X                    fb_close(infile);
  976. X                    mf_close();
  977. X                    return EXIT_ERROR;
  978. X                }
  979. X                newbytes++;
  980. X
  981. X                /* Get image descriptor. */
  982. X
  983. X                if ((status = gif_imdget(infile, &imd)) != 0)
  984. X                {
  985. X                    fprintf(outerr, "%s\n", errxlate(status));
  986. X                    fb_close(infile);
  987. X                    mf_close();
  988. X                    return ((GIF_UNEOF_E == status) ? EXIT_UNEOF : EXIT_ERROR);
  989. X                }
  990. X
  991. X                /* Create new image descriptor. */
  992. X
  993. X                tempbuf[GIF_IMD_IMLEFT_OFF] = (UCHAR) (imd.im_left & 0x00FF);
  994. X                tempbuf[GIF_IMD_IMLEFT_OFF + 1] = (UCHAR) (imd.im_left >> 8);
  995. X                tempbuf[GIF_IMD_IMTOP_OFF] = (UCHAR) (imd.im_top & 0x00FF);
  996. X                tempbuf[GIF_IMD_IMTOP_OFF + 1] = (UCHAR) (imd.im_top >> 8);
  997. X                tempbuf[GIF_IMD_IMWID_OFF] = (UCHAR) (imd.im_wid & 0x00FF);
  998. X                tempbuf[GIF_IMD_IMWID_OFF + 1] = (UCHAR) (imd.im_wid >> 8);
  999. X                tempbuf[GIF_IMD_IMHI_OFF] = (UCHAR) (imd.im_hi & 0x00FF);
  1000. X                tempbuf[GIF_IMD_IMHI_OFF + 1] = (UCHAR) (imd.im_hi >> 8);
  1001. X                if (0 == strict)
  1002. X                {
  1003. X                    tempbuf[GIF_IMD_PACKED_OFF] = imd.raw_packed;
  1004. X                }
  1005. X                else
  1006. X                {
  1007. X                    tempbuf[GIF_IMD_PACKED_OFF] = 0;
  1008. X                    if (imd.lct_flag)
  1009. X                    {
  1010. X                        tempbuf[GIF_IMD_PACKED_OFF] |= GIF_IMD_LCTFLAG_MASK;
  1011. X                        tempbuf[GIF_IMD_PACKED_OFF] |= (UCHAR)
  1012. X                                   ((imd.lct_size - 1) & GIF_IMD_LCTSIZE_MASK);
  1013. X                    }
  1014. X                    else if ((imd.lct_size - 1) != 0)
  1015. X                    {
  1016. X                        fprintf(outstr, "FYI: Ignoring illegal local color table size (no local color table).\n   ");
  1017. X
  1018. X                        /*
  1019. X                        ** Turn on viol_copy so that file is rebuilt
  1020. X                        ** even if size is same.
  1021. X                        */
  1022. X
  1023. X                        viol_copy = 1;
  1024. X                    }
  1025. X                    if (imd.interlace_flag)
  1026. X                    {
  1027. X                        tempbuf[GIF_IMD_PACKED_OFF] |=
  1028. X                                                     GIF_IMD_INTRLACEFLAG_MASK;
  1029. X                    }
  1030. X                    if (imd.sort_flag)
  1031. X                    {
  1032. X                        if ((GIF_89A == lsd.version) && (imd.lct_flag))
  1033. X                        {
  1034. X                            tempbuf[GIF_IMD_PACKED_OFF] |=
  1035. X                                                         GIF_IMD_SORTFLAG_MASK;
  1036. X                        }
  1037. X                        else
  1038. X                        {
  1039. X                            fprintf(outstr,
  1040. X                                "FYI: Ignoring illegal local color table sorted flag");
  1041. X                            if (0 == imd.lct_flag)
  1042. X                            {
  1043. X                                fprintf(outstr, " (no local color table)");
  1044. X                            }
  1045. X                            fprintf(outstr, ".\n   ");
  1046. X
  1047. X                            /*
  1048. X                            ** Turn on viol_copy so that file is rebuilt
  1049. X                            ** even if size is same.
  1050. X                            */
  1051. X
  1052. X                            viol_copy = 1;
  1053. X                        }
  1054. X                    }
  1055. X                }
  1056. X
  1057. X                /* Write new image descriptor. */
  1058. X
  1059. X                if ((status = mf_write(tempbuf, GIF_IMD_LEN)) != 0)
  1060. X                {
  1061. X                    fprintf(outerr, "%s\n", errxlate(status));
  1062. X                    fb_close(infile);
  1063. X                    mf_close();
  1064. X                    return EXIT_ERROR;
  1065. X                }
  1066. X                newbytes += GIF_IMD_LEN;
  1067. X
  1068. X                /* Print some info. */
  1069. X
  1070. X                fprintf(outstr, ((imd.lct_flag) ? "L" : "G"));
  1071. X                if (GIF_89A == lsd.version)
  1072. X                {
  1073. X                    fprintf(outstr, ((imd.sort_flag) ? "S" : "-"));
  1074. X                }
  1075. X                else
  1076. X                {
  1077. X                    fprintf(outstr, "-");
  1078. X                }
  1079. X                fprintf(outstr, ((imd.interlace_flag) ? "I" : "S"));
  1080. X                fprintf(outstr, "  (%3u,%3u)", imd.im_left, imd.im_top);
  1081. X                fprintf(outstr, "  %5u x %5u", imd.im_wid, imd.im_hi);
  1082. X                fprintf(outstr, " @ %3d  ", (0x1 << ((imd.lct_flag) ?
  1083. X                                            imd.lct_size : lsd.gct_size)));
  1084. X
  1085. X                /* Read and write local color table, if any. */
  1086. X
  1087. X                if (imd.lct_flag)
  1088. X                {
  1089. X                    if ((status = gif_lctget(infile, &ctable,
  1090. X                                             (0x1 << imd.lct_size))) != 0)
  1091. X                    {
  1092. X                        fprintf(outerr, "%s\n", errxlate(status));
  1093. X                        fb_close(infile);
  1094. X                        mf_close();
  1095. X                        return ((GIF_UNEOF_E == status) ? EXIT_UNEOF :
  1096. X                                                          EXIT_ERROR);
  1097. X                    }
  1098. X
  1099. X                    for (loop = 0; loop < (0x1 << imd.lct_size); loop++)
  1100. X                    {
  1101. X                        tempbuf[0] = ctable[loop].red;
  1102. X                        tempbuf[1] = ctable[loop].green;
  1103. X                        tempbuf[2] = ctable[loop].blue;
  1104. X                        if ((status = mf_write(tempbuf, 3)) != 0)
  1105. X                        {
  1106. X                            fprintf(outerr, "%s\n", errxlate(status));
  1107. X                            fb_close(infile);
  1108. X                            mf_close();
  1109. X                            return EXIT_ERROR;
  1110. X                        }
  1111. X                        newbytes += 3;
  1112. X                    }
  1113. X
  1114. X                    free(ctable);
  1115. X                }
  1116. X
  1117. X                /* Read and write codesize. */
  1118. X
  1119. X                codesize = (UCHAR) fb_getc(infile);
  1120. X                if (fb_error != 0)
  1121. X                {
  1122. X                    fprintf(outerr, "%s\n", errxlate(fb_error));
  1123. X                    fb_close(infile);
  1124. X                    mf_close();
  1125. X                    return ((FB_EOF_W == status) ? EXIT_UNEOF : EXIT_ERROR);
  1126. X                }
  1127. X                if ((status = mf_write(&codesize, 1)) != 0)
  1128. X                {
  1129. X                    fprintf(outerr, "%s\n", errxlate(status));
  1130. X                    fb_close(infile);
  1131. X                    mf_close();
  1132. X                    return EXIT_ERROR;
  1133. X                }
  1134. X                newbytes++;
  1135. X
  1136. X                /* Read and write data blocks until done. */
  1137. X
  1138. X                blockbytes = 0;
  1139. X                blocks = 0;
  1140. X                while (1)
  1141. X                {
  1142. X                    /* Read block. */
  1143. X
  1144. X                    if ((status = gif_readblock(infile, &data, &datalen)) != 0)
  1145. X                    {
  1146. X                        fprintf(outerr, "%s\n", errxlate(status));
  1147. X                        fb_close(infile);
  1148. X                        mf_close();
  1149. X                        return ((GIF_UNEOF_E == status) ? EXIT_UNEOF :
  1150. X                                                          EXIT_ERROR);
  1151. X                    }
  1152. X
  1153. X                    /* Check length. */
  1154. X
  1155. X                    if (0 == datalen)
  1156. X                    {
  1157. X                        /* If zero length, at end. */
  1158. X
  1159. X                        break;
  1160. X                    }
  1161. X                    blockbytes += (ULONG) datalen;
  1162. X                    blocks++;
  1163. X
  1164. X                    /* Write block length. */
  1165. X
  1166. X                    tempbuf[0] = (UCHAR) datalen;
  1167. X                    if ((status = mf_write(tempbuf, 1)) != 0)
  1168. X                    {
  1169. X                        fprintf(outerr, "%s\n", errxlate(status));
  1170. X                        fb_close(infile);
  1171. X                        mf_close();
  1172. X                        return EXIT_ERROR;
  1173. X                    }
  1174. X                    newbytes++;
  1175. X
  1176. X                    /* Write block. */
  1177. X
  1178. X                    if ((status = mf_write(data, (unsigned int) datalen)) != 0)
  1179. X                    {
  1180. X                        fprintf(outerr, "%s\n", errxlate(status));
  1181. X                        fb_close(infile);
  1182. X                        mf_close();
  1183. X                        return EXIT_ERROR;
  1184. X                    }
  1185. X                    newbytes += (ULONG) datalen;
  1186. X
  1187. X                    /* Free block. */
  1188. X
  1189. X                    free(data);
  1190. X                }
  1191. X
  1192. X                /* Write terminating block. */
  1193. X
  1194. X                tempbuf[0] = '\0';
  1195. X                if ((status = mf_write(tempbuf, 1)) != 0)
  1196. X                {
  1197. X                    fprintf(outerr, "%s\n", errxlate(status));
  1198. X                    fb_close(infile);
  1199. X                    mf_close();
  1200. X                    return EXIT_ERROR;
  1201. X                }
  1202. X                newbytes++;
  1203. X
  1204. X                /* Print more info. */
  1205. X
  1206. X                fprintf(outstr, "%6luBY  %4uBL\n", blockbytes, blocks);
  1207. X
  1208. X                break;
  1209. X
  1210. X            case GIF_EXTBLOCK:
  1211. X                /* Write out extension block header and type. */
  1212. X
  1213. X                tempbuf[0] = GIF_EXTBLOCK;
  1214. X                tempbuf[1] = (UCHAR) extype;
  1215. X                if ((status = mf_write(tempbuf, 2)) != 0)
  1216. X                {
  1217. X                    fprintf(outerr, "%s\n", errxlate(status));
  1218. X                    fb_close(infile);
  1219. X                    mf_close();
  1220. X                    return EXIT_ERROR;
  1221. X                }
  1222. X                newbytes += 2;
  1223. X
  1224. X                /* Print some info. */
  1225. X
  1226. X                if (GIF_89A == lsd.version)
  1227. X                {
  1228. X                    switch (extype)
  1229. X                    {
  1230. X                        case GIF_EXT_PLAIN_TEXT:
  1231. X                            fprintf(outstr, "Plain Text Extension Block");
  1232. X                            break;
  1233. X
  1234. X                        case GIF_EXT_GRAPHIC_CONTROL:
  1235. X                            fprintf(outstr, "Graphic Control Extension Block");
  1236. X                            break;
  1237. X
  1238. X                        case GIF_EXT_COMMENT:
  1239. X                            fprintf(outstr, "Comment Extension Block");
  1240. X                            break;
  1241. X
  1242. X                        case GIF_EXT_APPLICATION:
  1243. X                            fprintf(outstr, "Application Extension Block");
  1244. X                            break;
  1245. X
  1246. X                        default:
  1247. X                            fprintf(outstr, "Type %3d Extension Block", extype);
  1248. X                            break;
  1249. X                    }
  1250. X                }
  1251. X                else
  1252. X                {
  1253. X                    fprintf(outstr, "Type %3d Extension Block", extype);
  1254. X                }
  1255. X
  1256. X                /* Read and write data blocks until done. */
  1257. X
  1258. X                blockbytes = 0;
  1259. X                blocks = 0;
  1260. X                while (1)
  1261. X                {
  1262. X                    /* Read block. */
  1263. X
  1264. X                    if ((status = gif_readblock(infile, &data, &datalen)) != 0)
  1265. X                    {
  1266. X                        fprintf(outerr, "%s\n", errxlate(status));
  1267. X                        fb_close(infile);
  1268. X                        mf_close();
  1269. X                        return ((GIF_UNEOF_E == status) ? EXIT_UNEOF :
  1270. X                                                          EXIT_ERROR);
  1271. X                    }
  1272. X
  1273. X                    /* Check length. */
  1274. X
  1275. X                    if (0 == datalen)
  1276. X                    {
  1277. X                        /* If zero length, at end. */
  1278. X
  1279. X                        break;
  1280. X                    }
  1281. X                    blockbytes += (ULONG) datalen;
  1282. X                    blocks++;
  1283. X
  1284. X                    /* Write block length. */
  1285. X
  1286. X                    tempbuf[0] = (UCHAR) datalen;
  1287. X                    if ((status = mf_write(tempbuf, 1)) != 0)
  1288. X                    {
  1289. X                        fprintf(outerr, "%s\n", errxlate(status));
  1290. X                        fb_close(infile);
  1291. X                        mf_close();
  1292. X                        return EXIT_ERROR;
  1293. X                    }
  1294. X                    newbytes++;
  1295. X                    /* Write block. */
  1296. X
  1297. X                    if ((status = mf_write(data, (unsigned int) datalen)) != 0)
  1298. X                    {
  1299. X                        fprintf(outerr, "%s\n", errxlate(status));
  1300. X                        fb_close(infile);
  1301. X                        mf_close();
  1302. X                        return EXIT_ERROR;
  1303. X                    }
  1304. X                    newbytes += (ULONG) datalen;
  1305. X
  1306. X                    /* Free block. */
  1307. X
  1308. X                    free(data);
  1309. X                }
  1310. X
  1311. X                /* Write terminating block. */
  1312. X
  1313. X                tempbuf[0] = '\0';
  1314. X                if ((status = mf_write(tempbuf, 1)) != 0L)
  1315. X                {
  1316. X                    fprintf(outerr, "%s\n", errxlate(status));
  1317. X                    fb_close(infile);
  1318. X                    mf_close();
  1319. X                    return EXIT_ERROR;
  1320. X                }
  1321. X                newbytes++;
  1322. X
  1323. X                /* Print more info. */
  1324. X
  1325. X                fprintf(outstr, "%6luBY  %4uBL\n", blockbytes, blocks);
  1326. X
  1327. X                break;
  1328. X
  1329. X            case GIF_TERMINATOR:
  1330. X                /* Print info. */
  1331. X
  1332. X                fprintf(outstr, "GIF Terminator\n");
  1333. X
  1334. X                /* Write terminator. */
  1335. X
  1336. X                tempbuf[0] = GIF_TERMINATOR;
  1337. X                if ((status = mf_write(tempbuf, 1)) != 0)
  1338. X                {
  1339. X                    fprintf(outerr, "%s\n", errxlate(status));
  1340. X                    fb_close(infile);
  1341. X                    mf_close();
  1342. X                    return EXIT_ERROR;
  1343. X                }
  1344. X                newbytes++;
  1345. X
  1346. X                break;
  1347. X
  1348. X            default:
  1349. X                fprintf(outerr, "FATAL ERROR: Internal error.\n");
  1350. X                break;
  1351. X
  1352. X        } /* end of switch (blocktype) */
  1353. X    } /* end of while (blocktype != GIF_TERMINATOR) */
  1354. X
  1355. X    /* Read all good data from file, clean up. */
  1356. X
  1357. X    if ((status = fb_close(infile)) != 0)
  1358. X    {
  1359. X        fprintf(outerr, "%s\n", errxlate(status));
  1360. X        mf_close();
  1361. X        return EXIT_ERROR;
  1362. X    }
  1363. X    if ((status = mf_reset()) != 0)
  1364. X    {
  1365. X        fprintf(outerr, "%s\n", errxlate(status));
  1366. X        mf_close();
  1367. X        return EXIT_ERROR;
  1368. X    }
  1369. X
  1370. X    /* Check for change in file size. */
  1371. X
  1372. X    if ((newbytes == size) && (0 == forced_copy) && (0 == viol_copy))
  1373. X    {
  1374. X        fprintf(outstr, "   No work to be done. File unchanged.\n");
  1375. X        if ((status = mf_close()) != 0)
  1376. X        {
  1377. X            fprintf(outerr, "%s\n", errxlate(status));
  1378. X            return EXIT_ERROR;
  1379. X        }
  1380. X        return EXIT_OK;
  1381. X    }
  1382. X
  1383. X    /* Prepare to recopy. */
  1384. X
  1385. X    fprintf(outstr, "   New size: %6lu   Bytes removed: %6lu\n", newbytes,
  1386. X             (size - newbytes));
  1387. X
  1388. X    /* Lock temporary file, if there is one. */
  1389. X
  1390. X    mf_locked = 1;
  1391. X
  1392. X    if (EARLY == unlinktime)
  1393. X    {
  1394. X        /* Delete original file. */
  1395. X
  1396. X        if (unlink(filename) != 0)
  1397. X        {
  1398. X            fprintf(outerr, "   FATAL ERROR: Cannot remove original file.\n");
  1399. X            mf_locked = 0;
  1400. X            mf_close();
  1401. X            return EXIT_ERROR;
  1402. X        }
  1403. X
  1404. X        /* Open output file. */
  1405. X
  1406. X        outfile = fb_open(filename, 'w', &size);
  1407. X        if (fb_error != 0)
  1408. X        {
  1409. X            fprintf(outerr, "%s\n", errxlate(fb_error));
  1410. X            mf_close();
  1411. X            return EXIT_ERROR;
  1412. X        }
  1413. X    }
  1414. X    else
  1415. X    {
  1416. X        /* Check free space. */
  1417. X
  1418. X        if (dfree(filename) < newbytes)
  1419. X        {
  1420. X            fprintf(outerr, "   ERROR: Insufficient space on disk for recopy. Try using -o\n");
  1421. X            mf_locked = 0;
  1422. X            mf_close();
  1423. X            return EXIT_ERROR;
  1424. X        }
  1425. X
  1426. X        /* Get a name for a temporary file in the current directory. */
  1427. X
  1428. X        tname = tempname(".", "GIF.");
  1429. X        if (NULL == tname)
  1430. X        {
  1431. X            fprintf(outerr, "Cannot get name for temporary file.\n");
  1432. X            mf_close();
  1433. X            return EXIT_ERROR;
  1434. X        }
  1435. X
  1436. X        /* Open temporary file. */
  1437. X
  1438. X        outfile = fb_open(tname, 'w', &size);
  1439. X        if (fb_error != 0L)
  1440. X        {
  1441. X            fprintf(outerr, "%s\n", errxlate(fb_error));
  1442. X            mf_close();
  1443. X            free(tname);
  1444. X            return EXIT_ERROR;
  1445. X        }
  1446. X    }
  1447. X
  1448. X    /* Allocate recopy buffer. */
  1449. X
  1450. X    blockbytes = FB_BUFSIZE;
  1451. X    while ((rebuf = (UCHAR *) malloc((unsigned int) blockbytes)) ==
  1452. X           (UCHAR *) NULL)
  1453. X    {
  1454. X        blockbytes /= 2;
  1455. X        if (blockbytes < TBUFSIZ)
  1456. X        {
  1457. X            rebuf = tempbuf;
  1458. X            blockbytes = TBUFSIZ;
  1459. X            break;
  1460. X        }
  1461. X    }
  1462. X
  1463. X    /* Recopy.  */
  1464. X
  1465. X    fprintf(outstr, "Recopying... ");
  1466. X    for (; newbytes != 0; newbytes -= blockbytes)
  1467. X    {
  1468. X        if (newbytes < blockbytes)
  1469. X        {
  1470. X            blockbytes = newbytes;
  1471. X        }
  1472. X        if ((status = mf_read(rebuf, (unsigned int) blockbytes, &blocks)) != 0)
  1473. X        {
  1474. X            fprintf(outerr, "%s\n", errxlate(status));
  1475. X            fb_close(outfile);
  1476. X            mf_close();
  1477. X            if (rebuf != tempbuf)
  1478. X            {
  1479. X                free(rebuf);
  1480. X            }
  1481. X            unlink(tname);
  1482. X            if (LATE == unlinktime)
  1483. X            {
  1484. X                free(tname);
  1485. X            }
  1486. X            return EXIT_ERROR;
  1487. X        }
  1488. X        if ((status = fb_write(outfile, rebuf, (int) blockbytes)) != 0)
  1489. X        {
  1490. X            fprintf(outerr, "%s\n", errxlate(status));
  1491. X            fb_close(outfile);
  1492. X            mf_close();
  1493. X            if (rebuf != tempbuf)
  1494. X            {
  1495. X                free(rebuf);
  1496. X            }
  1497. X            unlink(tname);
  1498. X            if (LATE == unlinktime)
  1499. X            {
  1500. X                free(tname);
  1501. X            }
  1502. X            return EXIT_ERROR;
  1503. X        }
  1504. X    }
  1505. X    fprintf(outstr, "done.\n");
  1506. X
  1507. X    /* Close all, clean up. */
  1508. X
  1509. X    /* Close rebuilt file. */
  1510. X
  1511. X    if ((status = fb_close(outfile)) != 0)
  1512. X    {
  1513. X        fprintf(outerr, "%s\n", errxlate(status));
  1514. X        mf_close();
  1515. X        if (rebuf != tempbuf)
  1516. X        {
  1517. X            free(rebuf);
  1518. X        }
  1519. X        unlink(tname);
  1520. X        if (LATE == unlinktime)
  1521. X        {
  1522. X            free(tname);
  1523. X        }
  1524. X        return EXIT_ERROR;
  1525. X    }
  1526. X
  1527. X    /* Close memory file. */
  1528. X
  1529. X    mf_locked = 0;
  1530. X    if ((status = mf_close()) != 0)
  1531. X    {
  1532. X        fprintf(outerr, "%s\n", errxlate(status));
  1533. X        if (rebuf != tempbuf)
  1534. X        {
  1535. X            free(rebuf);
  1536. X        }
  1537. X        unlink(tname);
  1538. X        if (LATE == unlinktime)
  1539. X        {
  1540. X            free(tname);
  1541. X        }
  1542. X        return EXIT_ERROR;
  1543. X    }
  1544. X
  1545. X    /* Release recopy buffer. */
  1546. X
  1547. X    if (rebuf != tempbuf)
  1548. X    {
  1549. X        free(rebuf);
  1550. X    }
  1551. X
  1552. X    if (LATE == unlinktime)
  1553. X    {
  1554. X        /* Now remove original file. */
  1555. X
  1556. X        if (unlink(filename) != 0)
  1557. X        {
  1558. X            fprintf(outerr, "   FATAL ERROR: Cannot remove original file.\n");
  1559. X            unlink(tname);
  1560. X            free(tname);
  1561. X            return EXIT_ERROR;
  1562. X        }
  1563. X
  1564. X        /* And rename temporary file. */
  1565. X
  1566. X        if (rename(tname, filename) != 0)
  1567. X        {
  1568. X            fprintf(outerr, "   FATAL ERROR: Cannot move %s to %s.\n", tname, filename);
  1569. X            unlink(tname);
  1570. X            free(tname);
  1571. X            return EXIT_ERROR;
  1572. X        }
  1573. X        free(tname);
  1574. X    }
  1575. X
  1576. X    /* Reset the time stamp, owner, mode, etc. of the recopied file. */
  1577. X
  1578. X    /* First, update mode. */
  1579. X
  1580. X    if (chmod(filename, (statbuf.st_mode & 07777)) == -1)
  1581. X    {
  1582. X        fprintf(outerr, "ERROR: Error setting mode of recopied file!\n");
  1583. X        return EXIT_ERROR;
  1584. X    }
  1585. X
  1586. X    /* Next, try to change owner, but only if necessary. */
  1587. X
  1588. X    fileuid = myuid = getuid();
  1589. X    if (myuid != statbuf.st_uid)
  1590. X    {
  1591. X#ifdef ROOT_CHOWN
  1592. X        if (myuid != 0)
  1593. X        {
  1594. X            /* If ROOT_CHOWN, only root can give away files with chown(). */
  1595. X
  1596. X            fprintf(outerr, "WARNING: Cannot reset owner of recopied file!\n");
  1597. X        }
  1598. X        else
  1599. X        {
  1600. X#endif
  1601. X            if (chown(filename, statbuf.st_uid, statbuf.st_gid) == -1)
  1602. X            {
  1603. X                fprintf(outerr,
  1604. X                        "ERROR: Error setting owner of recopied file!\n");
  1605. X                return EXIT_ERROR;
  1606. X            }
  1607. X            else
  1608. X            {
  1609. X                fileuid = statbuf.st_uid;
  1610. X            }
  1611. X#ifdef ROOT_CHOWN
  1612. X        }
  1613. X#endif
  1614. X    }
  1615. X    else if (getgid() != statbuf.st_gid)
  1616. X    {
  1617. X        /*
  1618. X        ** Owner is same, group is not. since owner is same, can
  1619. X        ** change group no problem.
  1620. X        */
  1621. X
  1622. X        if (chown(filename, statbuf.st_uid, statbuf.st_gid) == -1)
  1623. X        {
  1624. X            fprintf(outerr, "ERROR: Error setting group of recopied file!\n");
  1625. X            return EXIT_ERROR;
  1626. X        }
  1627. X    }
  1628. X
  1629. X    /* Finally, reset timestamps. */
  1630. X
  1631. X    if (myuid != fileuid)
  1632. X    {
  1633. X        /* We're not owner of file anymore, but are we root? */
  1634. X
  1635. X        if (0 == myuid)
  1636. X        {
  1637. X            /* We're root, so we can still update file timestamp. */
  1638. X
  1639. X            times.actime = statbuf.st_atime;
  1640. X            times.modtime = statbuf.st_mtime;
  1641. X            if (utime(filename, ×) == -1)
  1642. X            {
  1643. X                fprintf(outerr,
  1644. X                        "ERROR: Error setting timestamp on recopied file!\n");
  1645. X                return EXIT_ERROR;
  1646. X            }
  1647. X        }
  1648. X        else
  1649. X        {
  1650. X            fprintf(outerr, 
  1651. X                    "WARNING: Cannot set timestamp on recopied file!\n");
  1652. X        }
  1653. X    } 
  1654. X    else
  1655. X    {
  1656. X        /* We are owner, so can update timestamps no problem. */
  1657. X
  1658. X        times.actime = statbuf.st_atime;
  1659. X        times.modtime = statbuf.st_mtime;
  1660. X        if (utime(filename, ×) == -1)
  1661. X        {
  1662. X            fprintf(outerr, 
  1663. X                    "ERROR: Error setting timestamp on recopied file!\n");
  1664. X            return EXIT_ERROR;
  1665. X        }
  1666. X    }
  1667. X
  1668. X    /* All done, return OK. */
  1669. X
  1670. X    return EXIT_OK;
  1671. X} /* end of static strip() */
  1672. X
  1673. X
  1674. X/***************************************************************************
  1675. X*   FUNCTION:    usage  STATIC                                             *
  1676. X*                                                                          *
  1677. X*   DESCRIPTION:                                                           *
  1678. X*                                                                          *
  1679. X*      Prints out usage message.                                           *
  1680. X*                                                                          *
  1681. X*   ENTRY:                                                                 *
  1682. X*                                                                          *
  1683. X*      None.                                                               *
  1684. X*                                                                          *
  1685. X*   EXIT:                                                                  *
  1686. X*                                                                          *
  1687. X*      Never returns.                                                      *
  1688. X*                                                                          *
  1689. X*   CONSTRAINTS/SIDE EFFECTS:                                              *
  1690. X*                                                                          *
  1691. X*      Exit()s with errorlevel EXIT_ERROR.                                 *
  1692. X*                                                                          *
  1693. X***************************************************************************/
  1694. Xstatic VOID 
  1695. Xusage()
  1696. X{
  1697. X    fprintf(outstr, "\n");
  1698. X    fprintf(outstr, 
  1699. X            "GIFSTRIP version %s, patchlevel %d by James W. Birdsall.\n", 
  1700. X            VERS, PATCHLEVEL);
  1701. X    fprintf(outstr, "   Strips extraneous characters from GIF files.\n");
  1702. X    fprintf(outstr, "   usage: gifstrip [options] target [target ...]\n");
  1703. X    fprintf(outstr, "     target       filename or directory. If a directory, all files in that\n");
  1704. X    fprintf(outstr, "                   directory will be processed. If no targets are given,\n");
  1705. X    fprintf(outstr, "                   this usage message is displayed.\n");
  1706. X
  1707. X    fprintf(outstr, "     -b           BATCH: suppresses all console output. Should be first on the\n");
  1708. X    fprintf(outstr, "                   line. Returns 0 if OK or stripped OK, 1 if a non-GIF file\n");
  1709. X    fprintf(outstr, "                   was found, 2 if unexpected EOF in a GIF file, or 3 on error.\n");
  1710. X    fprintf(outstr, "     -r           Sends error messages to stderr instead of stdout.\n");
  1711. X    fprintf(outstr, "     --           Take targets from stdin. For use with -f option of CHILS.\n");
  1712. X    fprintf(outstr, "                   Targets must be separated by newlines. Directories are\n");
  1713. X    fprintf(outstr, "                   expanded but wildcards are not. Command-line targets are\n");
  1714. X    fprintf(outstr, "                   ignored if this option is given.\n");
  1715. X
  1716. X    fprintf(outstr, "     -f           Forces rebuild. Normally file is not rebuilt if no extra\n");
  1717. X    fprintf(outstr, "                   characters are found and file meets format requirements.\n");
  1718. X    fprintf(outstr, "     -n           Disables strict format requirements.\n");
  1719. X    fprintf(outstr, "     -m           Enables checking for leading junk characters (from a Mac,\n");
  1720. X    fprintf(outstr, "                   for example).\n");
  1721. X    fprintf(outstr, "     -o           OVERWRITE: erases original before recopying.\n");
  1722. X
  1723. X    fprintf(outstr, "     -c           Do not use memory for temporary storage.\n");
  1724. X    fprintf(outstr, "     -d           Do not use DISK for temporary storage.\n");
  1725. X    fprintf(outstr, "     -s           Use ONLY DISK for temporary storage. Equivalent to -c\n");
  1726. X    fprintf(outstr, "     -tpath       Specify path for DISK temporary storage.\n");
  1727. X    fprintf(outstr, "     -h           HELP: Prints this message.\n");
  1728. X
  1729. X    fprintf(outstr, "   Note that at least one of memory or disk must be allowed.\n");
  1730. X    fprintf(outstr, "\n");
  1731. X    fprintf(outstr, "   Options may not be combined.\n");
  1732. X    fprintf(outstr, "\n");
  1733. X
  1734. X    exit(EXIT_ERROR);
  1735. X} /* end of static usage() */
  1736. X
  1737. X
  1738. X/***************************************************************************
  1739. X*   FUNCTION: errxlate STATIC                                              *
  1740. X*                                                                          *
  1741. X*   DESCRIPTION:                                                           *
  1742. X*                                                                          *
  1743. X*       Translates an error code into a string.                            *
  1744. X*                                                                          *
  1745. X*   ENTRY:                                                                 *
  1746. X*                                                                          *
  1747. X*       errcode - code to be translated                                    *
  1748. X*                                                                          *
  1749. X*   EXIT:                                                                  *
  1750. X*                                                                          *
  1751. X*       Returns a pointer to the appropriate string.                       *
  1752. X*                                                                          *
  1753. X*   CONSTRAINTS/SIDE EFFECTS:                                              *
  1754. X*                                                                          *
  1755. X***************************************************************************/
  1756. Xstatic char *
  1757. X#ifdef __STDC__
  1758. Xerrxlate(ULONG errcode)
  1759. X#else
  1760. Xerrxlate(errcode)
  1761. XULONG errcode;
  1762. X#endif
  1763. X{
  1764. X    char *errstring;
  1765. X    char *sever;
  1766. X
  1767. X    /* Determine severity of error. */
  1768. X
  1769. X    switch (SEVERITY(errcode))
  1770. X    {
  1771. X        case SEVERITY(ST_SUCCESS):
  1772. X            sever = "SUCCESS";
  1773. X            break;
  1774. X
  1775. X        case SEVERITY(ST_WARNING):
  1776. X            sever = "WARNING";
  1777. X            break;
  1778. X
  1779. X        case SEVERITY(ST_ERROR):
  1780. X            sever = "ERROR";
  1781. X            break;
  1782. X
  1783. X        case SEVERITY(ST_FATAL):
  1784. X        default:
  1785. X            sever = "FATAL";
  1786. X            break;
  1787. X    }
  1788. X
  1789. X    /* Get error string from module. */
  1790. X
  1791. X    switch (MODULE(errcode))
  1792. X    {
  1793. X        case MODULE(GIF_MODULE):
  1794. X            errstring = gif_errstring(errcode);
  1795. X            break;
  1796. X
  1797. X        case MODULE(FB_MODULE):
  1798. X            errstring = fb_errstring(errcode);
  1799. X            break;
  1800. X
  1801. X        case MODULE(MF_MODULE):
  1802. X            errstring = mf_errstring(errcode);
  1803. X            break;
  1804. X
  1805. X        default:
  1806. X            errstring = NULL;
  1807. X            break;
  1808. X    }
  1809. X
  1810. X    /* Composite strings. */
  1811. X
  1812. X    if (errstring != NULL)
  1813. X    {
  1814. X        sprintf(scratch, "%s: %s", sever, errstring);
  1815. X    }
  1816. X    else
  1817. X    {
  1818. X        /* Error not recognized by any module. */
  1819. X
  1820. X        sprintf(scratch, "%s: %08lX.", sever, errcode);
  1821. X    }
  1822. X
  1823. X    return scratch;
  1824. X} /* end of static errxlate() */
  1825. X
  1826. END_OF_FILE
  1827.   if test 47919 -ne `wc -c <'src/gifstrip.c'`; then
  1828.     echo shar: \"'src/gifstrip.c'\" unpacked with wrong size!
  1829.   fi
  1830.   # end of 'src/gifstrip.c'
  1831. fi
  1832. echo shar: End of archive 2 \(of 18\).
  1833. cp /dev/null ark2isdone
  1834. MISSING=""
  1835. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 ; do
  1836.     if test ! -f ark${I}isdone ; then
  1837.     MISSING="${MISSING} ${I}"
  1838.     fi
  1839. done
  1840. if test "${MISSING}" = "" ; then
  1841.     echo You have unpacked all 18 archives.
  1842.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  1843. else
  1844.     echo You still must unpack the following archives:
  1845.     echo "        " ${MISSING}
  1846. fi
  1847. exit 0
  1848. exit 0 # Just in case...
  1849.