javascript.c

Bug Summary

File:	s/cmd/signtool/javascript.c
Warning:	line 310, column 14 Access to field 'type' results in a dereference of a null pointer (loaded from variable 'ti')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name javascript.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nss/cmd/signtool -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/var/lib/jenkins/workspace/nss-scan-build/nss/cmd/signtool -resource-dir /usr/lib/llvm-18/lib/clang/18 -D HAVE_STRERROR -D LINUX -D linux -D XP_UNIX -D XP_UNIX -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D NSS_DISABLE_SSE3 -D NSS_NO_INIT_SUPPORT -D USE_UTIL_DIRECTLY -D NO_NSPR_10_SUPPORT -D SSL_DISABLE_DEPRECATED_CIPHER_SUITE_NAMES -I ../../../dist/Linux4.19_x86_64_gcc_glibc_PTH_64_DBG.OBJ/include -I ../../../dist/public/nss -I ../../../dist/private/nss -I ../../../dist/public/seccmd -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=c99 -ferror-limit 19 -fgnuc-version=4.2.1 -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-05-18-082241-28900-1 -x c javascript.c
1/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

5#include "signtool.h"
6#include <prmem.h>
7#include <prio.h>
8#include <prenv.h>

10static int javascript_fn(char *relpath, char *basedir, char *reldir,
                       char *filename, void *arg);
12static int extract_js(char *filename);
13static int copyinto(char *from, char *to);
14static PRStatus ensureExists(char *base, char *path);
15static int make_dirs(char *path, PRInt32 file_perms);

17static char *jartree = NULL((void*)0);
18static int idOrdinal;
19static PRBool dumpParse = PR_FALSE0;

21static char *event_handlers[] = {
  "onAbort",
  "onBlur",
  "onChange",
  "onClick",
  "onDblClick",
  "onDragDrop",
  "onError",
  "onFocus",
  "onKeyDown",
  "onKeyPress",
  "onKeyUp",
  "onLoad",
  "onMouseDown",
  "onMouseMove",
  "onMouseOut",
  "onMouseOver",
  "onMouseUp",
  "onMove",
  "onReset",
  "onResize",
  "onSelect",
  "onSubmit",
  "onUnload"
45};

47static int num_handlers = 23;

49/*
*  I n l i n e J a v a S c r i p t
*
*  Javascript signing. Instead of passing an archive to signtool,
*  a directory containing html files is given. Archives are created
*  from the archive= and src= tag attributes inside the html,
*  as appropriate. Then the archives are signed.
*
*/
58int
59InlineJavaScript(char *dir, PRBool recurse)
60{
  jartree = dir;
  if (verbosity >= 0) {
      PR_fprintf(outputFD, "\nGenerating inline signatures from HTML files in: %s\n",
                 dir);
  }
  if (PR_GetEnvSecure("SIGNTOOL_DUMP_PARSE")) {
      dumpParse = PR_TRUE1;
  }

  return foreach (dir, "", javascript_fn, recurse, PR_FALSE0 /*include dirs*/,
                  (void *)NULL((void*)0));
72}

74/************************************************************************
*
* j a v a s c r i p t _ f n
*/
78static int
79javascript_fn(char *relpath, char *basedir, char *reldir, char *filename, void *arg)
80{
  char fullname[FNSIZE256];

  /* only process inline scripts from .htm, .html, and .shtml*/

  if (!(PL_strcaserstr(filename, ".htm") == filename + strlen(filename) - 4) &&
      !(PL_strcaserstr(filename, ".html") == filename + strlen(filename) - 5) &&
      !(PL_strcaserstr(filename, ".shtml") == filename + strlen(filename) - 6)) {
      return 0;
  }

  /* don't process scripts that signtool has already
   extracted (those that are inside .arc directories) */

  if (PL_strcaserstr(filename, ".arc") == filename + strlen(filename) - 4)
      return 0;

  if (verbosity >= 0) {
      PR_fprintf(outputFD, "Processing HTML file: %s\n", relpath);
  }

  /* reset firstArchive at top of each HTML file */

  /* skip directories that contain extracted scripts */

  if (PL_strcaserstr(reldir, ".arc") == reldir + strlen(reldir) - 4)
      return 0;

  snprintf(fullname, sizeof(fullname), "%s/%s", basedir, relpath);
  return extract_js(fullname);
110}

112/*===========================================================================
=
= D A T A   S T R U C T U R E S
=
116*/
117typedef enum {
  TEXT_HTML_STATE = 0,
  SCRIPT_HTML_STATE
120}

122HTML_STATE;

124typedef enum {
  /* we start in the start state */
  START_STATE,

  /* We are looking for or reading in an attribute */
  GET_ATT_STATE,

  /* We're burning ws before finding an attribute */
  PRE_ATT_WS_STATE,

  /* We're burning ws after an attribute.  Looking for an '='. */
  POST_ATT_WS_STATE,

  /* We're burning ws after an '=', waiting for a value */
  PRE_VAL_WS_STATE,

  /* We're reading in a value */
  GET_VALUE_STATE,

  /* We're reading in a value that's inside quotes */
  GET_QUOTED_VAL_STATE,

  /* We've encountered the closing '>' */
  DONE_STATE,

  /* Error state */
  ERR_STATE
151}

153TAG_STATE;

155typedef struct AVPair_Str {
  char *attribute;
  char *value;
  unsigned int valueLine; /* the line that the value ends on */
  struct AVPair_Str *next;
160} AVPair;

162typedef enum {
  APPLET_TAG,
  SCRIPT_TAG,
  LINK_TAG,
  STYLE_TAG,
  COMMENT_TAG,
  OTHER_TAG
169}

171TAG_TYPE;

173typedef struct {
  TAG_TYPE type;
  AVPair *attList;
  AVPair *attListTail;
  char *text;
178} TagItem;

180typedef enum {
  TAG_ITEM,
  TEXT_ITEM
183}

185ITEM_TYPE;

187typedef struct HTMLItem_Str {
  unsigned int startLine;
  unsigned int endLine;
  ITEM_TYPE type;
  union {
      TagItem *tag;
      char *text;
  } item;
  struct HTMLItem_Str *next;
196} HTMLItem;

198typedef struct {
  PRFileDesc *fd;
  PRInt32 curIndex;
  PRBool IsEOF;
202#define FILE_BUFFER_BUFSIZE512 512
  char buf[FILE_BUFFER_BUFSIZE512];
  PRInt32 startOffset;
  PRInt32 maxIndex;
  unsigned int lineNum;
207} FileBuffer;

209/*===========================================================================
=
= F U N C T I O N S
=
213*/
214static HTMLItem *CreateTextItem(char *text, unsigned int startline,
                              unsigned int endline);
216static HTMLItem *CreateTagItem(TagItem *ti, unsigned int startline,
                             unsigned int endline);
218static TagItem *ProcessTag(FileBuffer *fb, char **errStr);
219static void DestroyHTMLItem(HTMLItem *item);
220static void DestroyTagItem(TagItem *ti);
221static TAG_TYPE GetTagType(char *att);
222static FileBuffer *FB_Create(PRFileDesc *fd);
223static int FB_GetChar(FileBuffer *fb);
224static PRInt32 FB_GetPointer(FileBuffer *fb);
225static PRInt32 FB_GetRange(FileBuffer *fb, PRInt32 start, PRInt32 end,
                         char **buf);
227static unsigned int FB_GetLineNum(FileBuffer *fb);
228static void FB_Destroy(FileBuffer *fb);
229static void PrintTagItem(PRFileDesc *fd, TagItem *ti);
230static void PrintHTMLStream(PRFileDesc *fd, HTMLItem *head);

232/************************************************************************
*
* C r e a t e T e x t I t e m
*/
236static HTMLItem *
237CreateTextItem(char *text, unsigned int startline, unsigned int endline)
238{
  HTMLItem *item;

  item = PR_Malloc(sizeof(HTMLItem));
  if (!item) {
      return NULL((void*)0);
  }

  item->type = TEXT_ITEM;
  item->item.text = text;
  item->next = NULL((void*)0);
  item->startLine = startline;
  item->endLine = endline;

  return item;
253}

255/************************************************************************
*
* C r e a t e T a g I t e m
*/
259static HTMLItem *
260CreateTagItem(TagItem *ti, unsigned int startline, unsigned int endline)
261{
  HTMLItem *item;

  item = PR_Malloc(sizeof(HTMLItem));
  if (!item) {
      return NULL((void*)0);
  }

  item->type = TAG_ITEM;
  item->item.tag = ti;
  item->next = NULL((void*)0);
  item->startLine = startline;
  item->endLine = endline;

  return item;
276}

278static PRBool
279isAttChar(int c)
280{
  return (isalnum(c)((*__ctype_b_loc ())[(int) ((c))] & (unsigned short int) _ISalnum
) || c == '/' || c == '-');
282}

284/************************************************************************
*
* P r o c e s s T a g
*/
288static TagItem *
289ProcessTag(FileBuffer *fb, char **errStr)
290{
  TAG_STATE state;
  PRInt32 startText, startID, curPos;
  PRBool firstAtt;
  int curchar;
  TagItem *ti = NULL((void*)0);
  AVPair *curPair = NULL((void*)0);
  char quotechar = '\0';
  unsigned int linenum;
  unsigned int startline;

  state = START_STATE;

  startID = FB_GetPointer(fb);
  startText = startID;
  firstAtt = PR_TRUE1;

  ti = (TagItem *)PR_Malloc(sizeof(TagItem));
1
Value assigned to 'ti'→
  if (!ti)
2
←
Assuming 'ti' is null→
3
←
Taking true branch→
      out_of_memory();
  ti->type = OTHER_TAG;
4
←
Access to field 'type' results in a dereference of a null pointer (loaded from variable 'ti')
  ti->attList = NULL((void*)0);
  ti->attListTail = NULL((void*)0);
  ti->text = NULL((void*)0);

  startline = FB_GetLineNum(fb);

  while (state != DONE_STATE && state != ERR_STATE) {
      linenum = FB_GetLineNum(fb);
      curchar = FB_GetChar(fb);
      if (curchar == EOF(-1)) {
          *errStr = PR_smprintf(
              "line %d: Unexpected end-of-file while parsing tag starting at line %d.\n",
              linenum, startline);
          state = ERR_STATE;
          continue;
      }

      switch (state) {
          case START_STATE:
              if (curchar == '!') {
                  /*
                   * SGML tag or comment
                   * Here's the general rule for SGML tags.  Everything from
                   * <! to > is the tag.  Inside the tag, comments are
                   * delimited with --.  So we are looking for the first '>'
                   * that is not commented out, that is, not inside a pair
                   * of --: <!DOCTYPE --this is a comment >(psyche!)   -->
                   */

                  PRBool inComment = PR_FALSE0;
                  short hyphenCount = 0; /* number of consecutive hyphens */

                  while (1) {
                      linenum = FB_GetLineNum(fb);
                      curchar = FB_GetChar(fb);
                      if (curchar == EOF(-1)) {
                          /* Uh oh, EOF inside comment */
                          *errStr = PR_smprintf(
                              "line %d: Unexpected end-of-file inside comment starting at line %d.\n",
                              linenum, startline);
                          state = ERR_STATE;
                          break;
                      }
                      if (curchar == '-') {
                          if (hyphenCount == 1) {
                              /* This is a comment delimiter */
                              inComment = !inComment;
                              hyphenCount = 0;
                          } else {
                              /* beginning of a comment delimiter? */
                              hyphenCount = 1;
                          }
                      } else if (curchar == '>') {
                          if (!inComment) {
                              /* This is the end of the tag */
                              state = DONE_STATE;
                              break;
                          } else {
                              /* The > is inside a comment, so it's not
                                                       * really the end of the tag */
                              hyphenCount = 0;
                          }
                      } else {
                          hyphenCount = 0;
                      }
                  }
                  ti->type = COMMENT_TAG;
                  break;
              }
          /* fall through */
          case GET_ATT_STATE:
              if (isspace(curchar)((*__ctype_b_loc ())[(int) ((curchar))] & (unsigned short
 int) _ISspace) || curchar == '=' || curchar == '>') {
                  /* end of the current attribute */
                  curPos = FB_GetPointer(fb) - 2;
                  if (curPos >= startID) {
                      /* We have an attribute */
                      curPair = (AVPair *)PR_Malloc(sizeof(AVPair));
                      if (!curPair)
                          out_of_memory();
                      curPair->value = NULL((void*)0);
                      curPair->next = NULL((void*)0);
                      FB_GetRange(fb, startID, curPos,
                                  &curPair->attribute);

                      /* Stick this attribute on the list */
                      if (ti->attListTail) {
                          ti->attListTail->next = curPair;
                          ti->attListTail = curPair;
                      } else {
                          ti->attList = ti->attListTail =
                              curPair;
                      }

                      /* If this is the first attribute, find the type of tag
                       * based on it. Also, start saving the text of the tag. */
                      if (firstAtt) {
                          ti->type = GetTagType(curPair->attribute);
                          startText = FB_GetPointer(fb) -
                                      1;
                          firstAtt = PR_FALSE0;
                      }
                  } else {
                      if (curchar == '=') {
                          /* If we don't have any attribute but we do have an
                       * equal sign, that's an error */
                          *errStr = PR_smprintf("line %d: Malformed tag starting at line %d.\n",
                                                linenum, startline);
                          state = ERR_STATE;
                          break;
                      }
                  }

                  /* Compute next state */
                  if (curchar == '=') {
                      startID = FB_GetPointer(fb);
                      state = PRE_VAL_WS_STATE;
                  } else if (curchar == '>') {
                      state = DONE_STATE;
                  } else if (curPair) {
                      state = POST_ATT_WS_STATE;
                  } else {
                      state = PRE_ATT_WS_STATE;
                  }
              } else if (isAttChar(curchar)) {
                  /* Just another char in the attribute. Do nothing */
                  state = GET_ATT_STATE;
              } else {
                  /* bogus char */
                  *errStr = PR_smprintf("line %d: Bogus chararacter '%c' in tag.\n",
                                        linenum, curchar);
                  state = ERR_STATE;
                  break;
              }
              break;
          case PRE_ATT_WS_STATE:
              if (curchar == '>') {
                  state = DONE_STATE;
              } else if (isspace(curchar)((*__ctype_b_loc ())[(int) ((curchar))] & (unsigned short
 int) _ISspace)) {
                  /* more whitespace, do nothing */
              } else if (isAttChar(curchar)) {
                  /* starting another attribute */
                  startID = FB_GetPointer(fb) - 1;
                  state = GET_ATT_STATE;
              } else {
                  /* bogus char */
                  *errStr = PR_smprintf("line %d: Bogus character '%c' in tag.\n",
                                        linenum, curchar);
                  state = ERR_STATE;
                  break;
              }
              break;
          case POST_ATT_WS_STATE:
              if (curchar == '>') {
                  state = DONE_STATE;
              } else if (isspace(curchar)((*__ctype_b_loc ())[(int) ((curchar))] & (unsigned short
 int) _ISspace)) {
                  /* more whitespace, do nothing */
              } else if (isAttChar(curchar)) {
                  /* starting another attribute */
                  startID = FB_GetPointer(fb) - 1;
                  state = GET_ATT_STATE;
              } else if (curchar == '=') {
                  /* there was whitespace between the attribute and its equal
                   * sign, which means there's a value coming up */
                  state = PRE_VAL_WS_STATE;
              } else {
                  /* bogus char */
                  *errStr = PR_smprintf("line %d: Bogus character '%c' in tag.\n",
                                        linenum, curchar);
                  state = ERR_STATE;
                  break;
              }
              break;
          case PRE_VAL_WS_STATE:
              if (curchar == '>') {
                  /* premature end-of-tag (sounds like a personal problem). */
                  *errStr = PR_smprintf(
                      "line %d: End of tag while waiting for value.\n",
                      linenum);
                  state = ERR_STATE;
                  break;
              } else if (isspace(curchar)((*__ctype_b_loc ())[(int) ((curchar))] & (unsigned short
 int) _ISspace)) {
                  /* more whitespace, do nothing */
                  break;
              } else {
                  /* this must be some sort of value. Fall through
                               * to GET_VALUE_STATE */
                  startID = FB_GetPointer(fb) - 1;
                  state = GET_VALUE_STATE;
              }
          /* Fall through if we didn't break on '>' or whitespace */
          case GET_VALUE_STATE:
              if (isspace(curchar)((*__ctype_b_loc ())[(int) ((curchar))] & (unsigned short
 int) _ISspace) || curchar == '>') {
                  /* end of value */
                  curPos = FB_GetPointer(fb) - 2;
                  if (curPos >= startID) {
                      /* Grab the value */
                      FB_GetRange(fb, startID, curPos,
                                  &curPair->value);
                      curPair->valueLine = linenum;
                  } else {
                      /* empty value, leave as NULL */
                  }
                  if (isspace(curchar)((*__ctype_b_loc ())[(int) ((curchar))] & (unsigned short
 int) _ISspace)) {
                      state = PRE_ATT_WS_STATE;
                  } else {
                      state = DONE_STATE;
                  }
              } else if (curchar == '\"' || curchar == '\'') {
                  /* quoted value.  Start recording the value inside the quote*/
                  startID = FB_GetPointer(fb);
                  state = GET_QUOTED_VAL_STATE;
                  PORT_Assert(quotechar == '\0')((quotechar == '\0')?((void)0):PR_Assert("quotechar == '\\0'"
,"javascript.c",522));
                  quotechar = curchar; /* look for matching quote type */
              } else {
                  /* just more value */
              }
              break;
          case GET_QUOTED_VAL_STATE:
              PORT_Assert(quotechar != '\0')((quotechar != '\0')?((void)0):PR_Assert("quotechar != '\\0'"
,"javascript.c",529));
              if (curchar == quotechar) {
                  /* end of quoted value */
                  curPos = FB_GetPointer(fb) - 2;
                  if (curPos >= startID) {
                      /* Grab the value */
                      FB_GetRange(fb, startID, curPos,
                                  &curPair->value);
                      curPair->valueLine = linenum;
                  } else {
                      /* empty value, leave it as NULL */
                  }
                  state = GET_ATT_STATE;
                  quotechar = '\0';
                  startID = FB_GetPointer(fb);
              } else {
                  /* more quoted value, continue */
              }
              break;
          case DONE_STATE:
          case ERR_STATE:
          default:; /* should never get here */
      }
  }

  if (state == DONE_STATE) {
      /* Get the text of the tag */
      curPos = FB_GetPointer(fb) - 1;
      FB_GetRange(fb, startText, curPos, &ti->text);

      /* Return the tag */
      return ti;
  }

  /* Uh oh, an error.  Kill the tag item*/
  DestroyTagItem(ti);
  return NULL((void*)0);
566}

568/************************************************************************
*
* D e s t r o y H T M L I t e m
*/
572static void
573DestroyHTMLItem(HTMLItem *item)
574{
  if (item->type == TAG_ITEM) {
      DestroyTagItem(item->item.tag);
  } else {
      if (item->item.text) {
          PR_Free(item->item.text);
      }
  }
582}

584/************************************************************************
*
* D e s t r o y T a g I t e m
*/
588static void
589DestroyTagItem(TagItem *ti)
590{
  AVPair *temp;

  if (ti->text) {
      PR_Free(ti->text);
      ti->text = NULL((void*)0);
  }

  while (ti->attList) {
      temp = ti->attList;
      ti->attList = ti->attList->next;

      if (temp->attribute) {
          PR_Free(temp->attribute);
          temp->attribute = NULL((void*)0);
      }
      if (temp->value) {
          PR_Free(temp->value);
          temp->value = NULL((void*)0);
      }
      PR_Free(temp);
  }

  PR_Free(ti);
614}

616/************************************************************************
*
* G e t T a g T y p e
*/
620static TAG_TYPE
621GetTagType(char *att)
622{
  if (!PORT_StrcasecmpPL_strcasecmp(att, "APPLET")) {
      return APPLET_TAG;
  }
  if (!PORT_StrcasecmpPL_strcasecmp(att, "SCRIPT")) {
      return SCRIPT_TAG;
  }
  if (!PORT_StrcasecmpPL_strcasecmp(att, "LINK")) {
      return LINK_TAG;
  }
  if (!PORT_StrcasecmpPL_strcasecmp(att, "STYLE")) {
      return STYLE_TAG;
  }
  return OTHER_TAG;
636}

638/************************************************************************
*
* F B _ C r e a t e
*/
642static FileBuffer *
643FB_Create(PRFileDesc *fd)
644{
  FileBuffer *fb;
  PRInt32 amountRead;
  PRInt32 storedOffset;

  fb = (FileBuffer *)PR_Malloc(sizeof(FileBuffer));
  fb->fd = fd;
  storedOffset = PR_Seek(fd, 0, PR_SEEK_CUR);
  PR_Seek(fd, 0, PR_SEEK_SET);
  fb->startOffset = 0;
  amountRead = PR_Read(fd, fb->buf, FILE_BUFFER_BUFSIZE512);
  if (amountRead == -1)
      goto loser;
  fb->maxIndex = amountRead - 1;
  fb->curIndex = 0;
  fb->IsEOF = (fb->curIndex > fb->maxIndex) ? PR_TRUE1 : PR_FALSE0;
  fb->lineNum = 1;

  PR_Seek(fd, storedOffset, PR_SEEK_SET);
  return fb;
664loser:
  PR_Seek(fd, storedOffset, PR_SEEK_SET);
  PR_Free(fb);
  return NULL((void*)0);
668}

670/************************************************************************
*
* F B _ G e t C h a r
*/
674static int
675FB_GetChar(FileBuffer *fb)
676{
  PRInt32 storedOffset;
  PRInt32 amountRead;
  int retval = -1;

  if (fb->IsEOF) {
      return EOF(-1);
  }

  storedOffset = PR_Seek(fb->fd, 0, PR_SEEK_CUR);

  retval = (unsigned char)fb->buf[fb->curIndex++];
  if (retval == '\n')
      fb->lineNum++;

  if (fb->curIndex > fb->maxIndex) {
      /* We're at the end of the buffer. Try to get some new data from the
               * file */
      fb->startOffset += fb->maxIndex + 1;
      PR_Seek(fb->fd, fb->startOffset, PR_SEEK_SET);
      amountRead = PR_Read(fb->fd, fb->buf, FILE_BUFFER_BUFSIZE512);
      if (amountRead == -1)
          goto loser;
      fb->maxIndex = amountRead - 1;
      fb->curIndex = 0;
  }

  fb->IsEOF = (fb->curIndex > fb->maxIndex) ? PR_TRUE1 : PR_FALSE0;

705loser:
  PR_Seek(fb->fd, storedOffset, PR_SEEK_SET);
  return retval;
708}

710/************************************************************************
*
* F B _ G e t L i n e N u m
*
*/
715static unsigned int
716FB_GetLineNum(FileBuffer *fb)
717{
  return fb->lineNum;
719}

721/************************************************************************
*
* F B _ G e t P o i n t e r
*
*/
726static PRInt32
727FB_GetPointer(FileBuffer *fb)
728{
  return fb->startOffset + fb->curIndex;
730}

732/************************************************************************
*
* F B _ G e t R a n g e
*
*/
737static PRInt32
738FB_GetRange(FileBuffer *fb, PRInt32 start, PRInt32 end, char **buf)
739{
  PRInt32 amountRead;
  PRInt32 storedOffset;

  *buf = PR_Malloc(end - start + 2);
  if (*buf == NULL((void*)0)) {
      return 0;
  }

  storedOffset = PR_Seek(fb->fd, 0, PR_SEEK_CUR);
  PR_Seek(fb->fd, start, PR_SEEK_SET);
  amountRead = PR_Read(fb->fd, *buf, end - start + 1);
  PR_Seek(fb->fd, storedOffset, PR_SEEK_SET);
  if (amountRead == -1) {
      PR_Free(*buf);
      *buf = NULL((void*)0);
      return 0;
  }

  (*buf)[end - start + 1] = '\0';
  return amountRead;
760}

762/************************************************************************
*
* F B _ D e s t r o y
*
*/
767static void
768FB_Destroy(FileBuffer *fb)
769{
  if (fb) {
      PR_Free(fb);
  }
773}

775/************************************************************************
*
* P r i n t T a g I t e m
*
*/
780static void
781PrintTagItem(PRFileDesc *fd, TagItem *ti)
782{
  AVPair *pair;

  PR_fprintf(fd, "TAG:\n----\nType: ");
  switch (ti->type) {
      case APPLET_TAG:
          PR_fprintf(fd, "applet\n");
          break;
      case SCRIPT_TAG:
          PR_fprintf(fd, "script\n");
          break;
      case LINK_TAG:
          PR_fprintf(fd, "link\n");
          break;
      case STYLE_TAG:
          PR_fprintf(fd, "style\n");
          break;
      case COMMENT_TAG:
          PR_fprintf(fd, "comment\n");
          break;
      case OTHER_TAG:
      default:
          PR_fprintf(fd, "other\n");
          break;
  }

  PR_fprintf(fd, "Attributes:\n");
  for (pair = ti->attList; pair; pair = pair->next) {
      PR_fprintf(fd, "\t%s=%s\n", pair->attribute,
                 pair->value ? pair->value : "");
  }
  PR_fprintf(fd, "Text:%s\n", ti->text ? ti->text : "");

  PR_fprintf(fd, "---End of tag---\n");
816}

818/************************************************************************
*
* P r i n t H T M L S t r e a m
*
*/
823static void
824PrintHTMLStream(PRFileDesc *fd, HTMLItem *head)
825{
  while (head) {
      if (head->type == TAG_ITEM) {
          PrintTagItem(fd, head->item.tag);
      } else {
          PR_fprintf(fd, "\nTEXT:\n-----\n%s\n-----\n\n", head->item.text);
      }
      head = head->next;
  }
834}

836/************************************************************************
*
* S a v e I n l i n e S c r i p t
*
*/
841static int
842SaveInlineScript(char *text, char *id, char *basedir, char *archiveDir)
843{
  char *filename = NULL((void*)0);
  PRFileDesc *fd = NULL((void*)0);
  int retval = -1;
  PRInt32 writeLen;
  char *ilDir = NULL((void*)0);

  if (!text || !id || !archiveDir) {
      return -1;
  }

  if (dumpParse) {
      PR_fprintf(outputFD, "SaveInlineScript: text=%s, id=%s, \n"
                           "basedir=%s, archiveDir=%s\n",
                 text, id, basedir, archiveDir);
  }

  /* Make sure the archive directory is around */
  if (ensureExists(basedir, archiveDir) != PR_SUCCESS) {
      PR_fprintf(errorFD,
                 "ERROR: Unable to create archive directory %s.\n", archiveDir);
      errorCount++;
      return -1;
  }

  /* Make sure the inline script directory is around */
  ilDir = PR_smprintf("%s/inlineScripts", archiveDir);
  scriptdir = "inlineScripts";
  if (ensureExists(basedir, ilDir) != PR_SUCCESS) {
      PR_fprintf(errorFD,
                 "ERROR: Unable to create directory %s.\n", ilDir);
      errorCount++;
      return -1;
  }

  filename = PR_smprintf("%s/%s/%s", basedir, ilDir, id);

  /* If the file already exists, give a warning, then blow it away */
  if (PR_Access(filename, PR_ACCESS_EXISTS) == PR_SUCCESS) {
      PR_fprintf(errorFD,
                 "warning: file \"%s\" already exists--will overwrite.\n",
                 filename);
      warningCount++;
      if (rm_dash_r(filename)) {
          PR_fprintf(errorFD, "ERROR: Unable to delete %s.\n", filename);
          errorCount++;
          goto finish;
      }
  }

  /* Write text into file with name id */
  fd = PR_Open(filename, PR_WRONLY0x02 | PR_CREATE_FILE0x08 | PR_TRUNCATE0x20, 0777);
  if (!fd) {
      PR_fprintf(errorFD, "ERROR: Unable to create file \"%s\".\n",
                 filename);
      errorCount++;
      goto finish;
  }
  writeLen = strlen(text);
  if (PR_Write(fd, text, writeLen) != writeLen) {
      PR_fprintf(errorFD, "ERROR: Unable to write to file \"%s\".\n",
                 filename);
      errorCount++;
      goto finish;
  }

  retval = 0;
910finish:
  if (filename) {
      PR_smprintf_free(filename);
  }
  if (ilDir) {
      PR_smprintf_free(ilDir);
  }
  if (fd) {
      PR_Close(fd);
  }
  return retval;
921}

923/************************************************************************
*
* S a v e U n n a m a b l e S c r i p t
*
*/
928static int
929SaveUnnamableScript(char *text, char *basedir, char *archiveDir,
                  char *HTMLfilename)
931{
  char *id = NULL((void*)0);
  char *ext = NULL((void*)0);
  char *start = NULL((void*)0);
  int retval = -1;

  if (!text || !archiveDir || !HTMLfilename) {
      return -1;
  }

  if (dumpParse) {
      PR_fprintf(outputFD, "SaveUnnamableScript: text=%s, basedir=%s,\n"
                           "archiveDir=%s, filename=%s\n",
                 text, basedir, archiveDir,
                 HTMLfilename);
  }

  /* Construct the filename */
  ext = PL_strrchr(HTMLfilename, '.');
  if (ext) {
      *ext = '\0';
  }
  for (start = HTMLfilename; strpbrk(start, "/\\");
       start = strpbrk(start, "/\\") + 1)
      /* do nothing */;
  if (*start == '\0')
      start = HTMLfilename;
  id = PR_smprintf("_%s%d", start, idOrdinal++);
  if (ext) {
      *ext = '.';
  }

  /* Now call SaveInlineScript to do the work */
  retval = SaveInlineScript(text, id, basedir, archiveDir);

  PR_Free(id);

  return retval;
969}

971/************************************************************************
*
* S a v e S o u r c e
*
*/
976static int
977SaveSource(char *src, char *codebase, char *basedir, char *archiveDir)
978{
  char *from = NULL((void*)0), *to = NULL((void*)0);
  int retval = -1;
  char *arcDir = NULL((void*)0);

  if (!src || !archiveDir) {
      return -1;
  }

  if (dumpParse) {
      PR_fprintf(outputFD, "SaveSource: src=%s, codebase=%s, basedir=%s,\n"
                           "archiveDir=%s\n",
                 src, codebase, basedir, archiveDir);
  }

  if (codebase) {
      arcDir = PR_smprintf("%s/%s/%s/", basedir, codebase, archiveDir);
  } else {
      arcDir = PR_smprintf("%s/%s/", basedir, archiveDir);
  }

  if (codebase) {
      from = PR_smprintf("%s/%s/%s", basedir, codebase, src);
      to = PR_smprintf("%s%s", arcDir, src);
  } else {
      from = PR_smprintf("%s/%s", basedir, src);
      to = PR_smprintf("%s%s", arcDir, src);
  }

  if (make_dirs(to, 0777)) {
      PR_fprintf(errorFD,
                 "ERROR: Unable to create archive directory %s.\n", archiveDir);
      errorCount++;
      goto finish;
  }

  retval = copyinto(from, to);
1015finish:
  if (from)
      PR_Free(from);
  if (to)
      PR_Free(to);
  if (arcDir)
      PR_Free(arcDir);
  return retval;
1023}

1025/************************************************************************
*
* T a g T y p e T o S t r i n g
*
*/
1030char *
1031TagTypeToString(TAG_TYPE type)
1032{
  switch (type) {
      case APPLET_TAG:
          return "APPLET";
      case SCRIPT_TAG:
          return "SCRIPT";
      case LINK_TAG:
          return "LINK";
      case STYLE_TAG:
          return "STYLE";
      default:
          break;
  }
  return "unknown";
1046}

1048/************************************************************************
*
* e x t r a c t _ j s
*
*/
1053static int
1054extract_js(char *filename)
1055{
  PRFileDesc *fd = NULL((void*)0);
  FileBuffer *fb = NULL((void*)0);
  HTMLItem *head = NULL((void*)0);
  HTMLItem *tail = NULL((void*)0);
  HTMLItem *curitem = NULL((void*)0);
  HTMLItem *styleList = NULL((void*)0);
  HTMLItem *styleListTail = NULL((void*)0);
  HTMLItem *entityList = NULL((void*)0);
  HTMLItem *entityListTail = NULL((void*)0);
  TagItem *tagp = NULL((void*)0);
  char *text = NULL((void*)0);
  char *tagerr = NULL((void*)0);
  char *archiveDir = NULL((void*)0);
  char *firstArchiveDir = NULL((void*)0);
  char *basedir = NULL((void*)0);
  PRInt32 textStart;
  PRInt32 curOffset;
  HTML_STATE state;
  int curchar;
  int retval = -1;
  unsigned int linenum, startLine;

  /* Initialize the implicit ID counter for each file */
  idOrdinal = 0;

  /*
   * First, parse the HTML into a stream of tags and text.
   */

  fd = PR_Open(filename, PR_RDONLY0x01, 0);
  if (!fd) {
      PR_fprintf(errorFD, "Unable to open %s for reading.\n", filename);
      errorCount++;
      return -1;
  }

  /* Construct base directory of filename. */
  {
      char *cp;

      basedir = PL_strdup(filename);

      /* Remove trailing slashes */
      while ((cp = PL_strprbrk(basedir, "/\\")) ==
             (basedir + strlen(basedir) - 1)) {
          *cp = '\0';
      }

      /* Now remove everything from the last slash (which will be followed
       * by a filename) to the end */
      cp = PL_strprbrk(basedir, "/\\");
      if (cp) {
          *cp = '\0';
      }
  }

  state = TEXT_HTML_STATE;

  fb = FB_Create(fd);

  textStart = 0;
  startLine = 0;
  while (linenum = FB_GetLineNum(fb), (curchar = FB_GetChar(fb)) != EOF(-1)) {
      switch (state) {
          case TEXT_HTML_STATE:
              if (curchar == '<') {
                  /*
                   * Found a tag
                   */
                  /* Save the text so far to a new text item */
                  curOffset = FB_GetPointer(fb) - 2;
                  if (curOffset >= textStart) {
                      if (FB_GetRange(fb, textStart, curOffset,
                                      &text) !=
                          curOffset - textStart + 1) {
                          PR_fprintf(errorFD,
                                     "Unable to read from %s.\n",
                                     filename);
                          errorCount++;
                          goto loser;
                      }
                      /* little fudge here.  If the first character on a line
                       * is '<', meaning a new tag, the preceding text item
                       * actually ends on the previous line.  In this case
                       * we will be saying that the text segment ends on the
                       * next line. I don't think this matters for text items. */
                      curitem = CreateTextItem(text, startLine,
                                               linenum);
                      text = NULL((void*)0);
                      if (tail == NULL((void*)0)) {
                          head = tail = curitem;
                      } else {
                          tail->next = curitem;
                          tail = curitem;
                      }
                  }

                  /* Process the tag */
                  tagp = ProcessTag(fb, &tagerr);
                  if (!tagp) {
                      if (tagerr) {
                          PR_fprintf(errorFD, "Error in file %s: %s\n",
                                     filename, tagerr);
                          errorCount++;
                      } else {
                          PR_fprintf(errorFD,
                                     "Error in file %s, in tag starting at line %d\n",
                                     filename, linenum);
                          errorCount++;
                      }
                      goto loser;
                  }
                  /* Add the tag to the list */
                  curitem = CreateTagItem(tagp, linenum, FB_GetLineNum(fb));
                  if (tail == NULL((void*)0)) {
                      head = tail = curitem;
                  } else {
                      tail->next = curitem;
                      tail = curitem;
                  }

                  /* What's the next state */
                  if (tagp->type == SCRIPT_TAG) {
                      state = SCRIPT_HTML_STATE;
                  }

                  /* Start recording text from the new offset */
                  textStart = FB_GetPointer(fb);
                  startLine = FB_GetLineNum(fb);
              } else {
                  /* regular character.  Next! */
              }
              break;
          case SCRIPT_HTML_STATE:
              if (curchar == '<') {
                  char *cp;
                  /*
                   * If this is a </script> tag, then we're at the end of the
                   * script.  Otherwise, ignore
                   */
                  curOffset = FB_GetPointer(fb) - 1;
                  cp = NULL((void*)0);
                  if (FB_GetRange(fb, curOffset, curOffset + 8, &cp) != 9) {
                      if (cp) {
                          PR_Free(cp);
                          cp = NULL((void*)0);
                      }
                  } else {
                      /* compare the strings */
                      if (!PORT_StrncasecmpPL_strncasecmp(cp, "</script>", 9)) {
                          /* This is the end of the script. Record the text. */
                          curOffset--;
                          if (curOffset >= textStart) {
                              if (FB_GetRange(fb, textStart, curOffset, &text) !=
                                  curOffset - textStart + 1) {
                                  PR_fprintf(errorFD, "Unable to read from %s.\n",
                                             filename);
                                  errorCount++;
                                  goto loser;
                              }
                              curitem = CreateTextItem(text, startLine, linenum);
                              text = NULL((void*)0);
                              if (tail == NULL((void*)0)) {
                                  head = tail = curitem;
                              } else {
                                  tail->next = curitem;
                                  tail = curitem;
                              }
                          }

                          /* Now parse the /script tag and put it on the list */
                          tagp = ProcessTag(fb, &tagerr);
                          if (!tagp) {
                              if (tagerr) {
                                  PR_fprintf(errorFD, "Error in file %s: %s\n",
                                             filename, tagerr);
                              } else {
                                  PR_fprintf(errorFD,
                                             "Error in file %s, in tag starting at"
                                             " line %d\n",
                                             filename, linenum);
                              }
                              errorCount++;
                              goto loser;
                          }
                          curitem = CreateTagItem(tagp, linenum,
                                                  FB_GetLineNum(fb));
                          if (tail == NULL((void*)0)) {
                              head = tail = curitem;
                          } else {
                              tail->next = curitem;
                              tail = curitem;
                          }

                          /* go back to text state */
                          state = TEXT_HTML_STATE;

                          textStart = FB_GetPointer(fb);
                          startLine = FB_GetLineNum(fb);
                      }
                  }
              }
              break;
      }
  }

  /* End of the file.  Wrap up any remaining text */
  if (state == SCRIPT_HTML_STATE) {
      if (tail && tail->type == TAG_ITEM) {
          PR_fprintf(errorFD, "ERROR: <SCRIPT> tag at %s:%d is not followed "
                              "by a </SCRIPT> tag.\n",
                     filename, tail->startLine);
      } else {
          PR_fprintf(errorFD, "ERROR: <SCRIPT> tag in file %s is not followed"
                              " by a </SCRIPT tag.\n",
                     filename);
      }
      errorCount++;
      goto loser;
  }
  curOffset = FB_GetPointer(fb) - 1;
  if (curOffset >= textStart) {
      text = NULL((void*)0);
      if (FB_GetRange(fb, textStart, curOffset, &text) !=
          curOffset - textStart + 1) {
          PR_fprintf(errorFD, "Unable to read from %s.\n", filename);
          errorCount++;
          goto loser;
      }
      curitem = CreateTextItem(text, startLine, linenum);
      text = NULL((void*)0);
      if (tail == NULL((void*)0)) {
          head = tail = curitem;
      } else {
          tail->next = curitem;
          tail = curitem;
      }
  }

  if (dumpParse) {
      PrintHTMLStream(outputFD, head);
  }

  /*
   * Now we have a stream of tags and text.  Go through and deal with each.
   */
  for (curitem = head; curitem; curitem = curitem->next) {
      AVPair *pairp = NULL((void*)0);
      char *src = NULL((void*)0), *id = NULL((void*)0), *codebase = NULL((void*)0);
      PRBool hasEventHandler = PR_FALSE0;
      int i;

      /* Reset archive directory for each tag */
      if (archiveDir) {
          PR_Free(archiveDir);
          archiveDir = NULL((void*)0);
      }

      /* We only analyze tags */
      if (curitem->type != TAG_ITEM) {
          continue;
      }

      tagp = curitem->item.tag;

      /* go through the attributes to get information */
      for (pairp = tagp->attList; pairp; pairp = pairp->next) {

          /* ARCHIVE= */
          if (!PL_strcasecmp(pairp->attribute, "archive")) {
              if (archiveDir) {
                  /* Duplicate attribute.  Print warning */
                  PR_fprintf(errorFD,
                             "warning: \"%s\" attribute overwrites previous attribute"
                             " in tag starting at %s:%d.\n",
                             pairp->attribute, filename, curitem->startLine);
                  warningCount++;
                  PR_Free(archiveDir);
              }
              archiveDir = PL_strdup(pairp->value);

              /* Substiture ".arc" for ".jar" */
              if ((PL_strlen(archiveDir) < 4) ||
                  PL_strcasecmp((archiveDir + strlen(archiveDir) - 4),
                                ".jar")) {
                  char *newArchiveDir = NULL((void*)0);
                  PR_fprintf(errorFD,
                             "warning: ARCHIVE attribute should end in \".jar\" in tag"
                             " starting on %s:%d.\n",
                             filename, curitem->startLine);
                  warningCount++;
                  newArchiveDir = PR_smprintf("%s.arc", archiveDir);
                  PR_Free(archiveDir);
                  archiveDir = newArchiveDir;
              } else {
                  PL_strcpy(archiveDir + strlen(archiveDir) - 4, ".arc");
              }

              /* Record the first archive.  This will be used later if
               * the archive is not specified */
              if (firstArchiveDir == NULL((void*)0)) {
                  firstArchiveDir = PL_strdup(archiveDir);
              }
          }
          /* CODEBASE= */
          else if (!PL_strcasecmp(pairp->attribute, "codebase")) {
              if (codebase) {
                  /* Duplicate attribute.  Print warning */
                  PR_fprintf(errorFD,
                             "warning: \"%s\" attribute overwrites previous attribute"
                             " in tag staring at %s:%d.\n",
                             pairp->attribute, filename, curitem->startLine);
                  warningCount++;
              }
              codebase = pairp->value;
          }
          /* SRC= and HREF= */
          else if (!PORT_StrcasecmpPL_strcasecmp(pairp->attribute, "src") ||
                   !PORT_StrcasecmpPL_strcasecmp(pairp->attribute, "href")) {
              if (src) {
                  /* Duplicate attribute.  Print warning */
                  PR_fprintf(errorFD,
                             "warning: \"%s\" attribute overwrites previous attribute"
                             " in tag staring at %s:%d.\n",
                             pairp->attribute, filename, curitem->startLine);
                  warningCount++;
              }
              src = pairp->value;
          }
          /* CODE= */
          else if (!PORT_StrcasecmpPL_strcasecmp(pairp->attribute, "code")) {
              /*!!!XXX Change PORT to PL all over this code !!! */
              if (src) {
                  /* Duplicate attribute.  Print warning */
                  PR_fprintf(errorFD,
                             "warning: \"%s\" attribute overwrites previous attribute"
                             " ,in tag staring at %s:%d.\n",
                             pairp->attribute, filename, curitem->startLine);
                  warningCount++;
              }
              src = pairp->value;

              /* Append a .class if one is not already present */
              if ((PL_strlen(src) < 6) ||
                  PL_strcasecmp((src + PL_strlen(src) - 6), ".class")) {
                  src = PR_smprintf("%s.class", src);
                  /* Put this string back into the data structure so it
                   * will be deallocated properly */
                  PR_Free(pairp->value);
                  pairp->value = src;
              }
          }
          /* ID= */
          else if (!PL_strcasecmp(pairp->attribute, "id")) {
              if (id) {
                  /* Duplicate attribute.  Print warning */
                  PR_fprintf(errorFD,
                             "warning: \"%s\" attribute overwrites previous attribute"
                             " in tag staring at %s:%d.\n",
                             pairp->attribute, filename, curitem->startLine);
                  warningCount++;
              }
              id = pairp->value;
          }

          /* STYLE= */
          /* style= attributes, along with JS entities, are stored into
           * files with dynamically generated names. The filenames are
           * based on the order in which the text is found in the file.
           * All JS entities on all lines up to and including the line
           * containing the end of the tag that has this style= attribute
           * will be processed before this style=attribute.  So we need
           * to record the line that this _tag_ (not the attribute) ends on.
           */
          else if (!PL_strcasecmp(pairp->attribute, "style") && pairp->value) {
              HTMLItem *styleItem;
              /* Put this item on the style list */
              styleItem = CreateTextItem(PL_strdup(pairp->value),
                                         curitem->startLine, curitem->endLine);
              if (styleListTail == NULL((void*)0)) {
                  styleList = styleListTail = styleItem;
              } else {
                  styleListTail->next = styleItem;
                  styleListTail = styleItem;
              }
          }
          /* Event handlers */
          else {
              for (i = 0; i < num_handlers; i++) {
                  if (!PL_strcasecmp(event_handlers[i], pairp->attribute)) {
                      hasEventHandler = PR_TRUE1;
                      break;
                  }
              }
          }

          /* JS Entity */
          {
              char *entityStart, *entityEnd;
              HTMLItem *entityItem;

              /* go through each JavaScript entity ( &{...}; ) and store it
               * in the entityList.  The important thing is to record what
               * line number it's on, so we can get it in the right order
               * in relation to style= attributes.
               * Apparently, these can't flow across lines, so the start and
               * end line will be the same.  That helps matters.
               */
              entityEnd = pairp->value;
              while (entityEnd &&
                     (entityStart = PL_strstr(entityEnd, "&{")) /*}*/ != NULL((void*)0)) {
                  entityStart += 2; /* point at beginning of actual entity */
                  entityEnd = PL_strchr(entityStart, '}');
                  if (entityEnd) {
                      /* Put this item on the entity list */
                      *entityEnd = '\0';
                      entityItem = CreateTextItem(PL_strdup(entityStart),
                                                  pairp->valueLine, pairp->valueLine);
                      *entityEnd = /* { */ '}';
                      if (entityListTail) {
                          entityListTail->next = entityItem;
                          entityListTail = entityItem;
                      } else {
                          entityList = entityListTail = entityItem;
                      }
                  }
              }
          }
      }

      /* If no archive was supplied, we use the first one of the file */
      if (!archiveDir && firstArchiveDir) {
          archiveDir = PL_strdup(firstArchiveDir);
      }

      /* If we have an event handler, we need to archive this tag */
      if (hasEventHandler) {
          if (!id) {
              PR_fprintf(errorFD,
                         "warning: tag starting at %s:%d has event handler but"
                         " no ID attribute.  The tag will not be signed.\n",
                         filename, curitem->startLine);
              warningCount++;
          } else if (!archiveDir) {
              PR_fprintf(errorFD,
                         "warning: tag starting at %s:%d has event handler but"
                         " no ARCHIVE attribute.  The tag will not be signed.\n",
                         filename, curitem->startLine);
              warningCount++;
          } else {
              if (SaveInlineScript(tagp->text, id, basedir, archiveDir)) {
                  goto loser;
              }
          }
      }

      switch (tagp->type) {
          case APPLET_TAG:
              if (!src) {
                  PR_fprintf(errorFD,
                             "error: APPLET tag starting on %s:%d has no CODE "
                             "attribute.\n",
                             filename, curitem->startLine);
                  errorCount++;
                  goto loser;
              } else if (!archiveDir) {
                  PR_fprintf(errorFD,
                             "error: APPLET tag starting on %s:%d has no ARCHIVE "
                             "attribute.\n",
                             filename, curitem->startLine);
                  errorCount++;
                  goto loser;
              } else {
                  if (SaveSource(src, codebase, basedir, archiveDir)) {
                      goto loser;
                  }
              }
              break;
          case SCRIPT_TAG:
          case LINK_TAG:
          case STYLE_TAG:
              if (!archiveDir) {
                  PR_fprintf(errorFD,
                             "error: %s tag starting on %s:%d has no ARCHIVE "
                             "attribute.\n",
                             TagTypeToString(tagp->type),
                             filename, curitem->startLine);
                  errorCount++;
                  goto loser;
              } else if (src) {
                  if (SaveSource(src, codebase, basedir, archiveDir)) {
                      goto loser;
                  }
              } else if (id) {
                  /* Save the next text item */
                  if (!curitem->next || (curitem->next->type !=
                                         TEXT_ITEM)) {
                      PR_fprintf(errorFD,
                                 "warning: %s tag starting on %s:%d is not followed"
                                 " by script text.\n",
                                 TagTypeToString(tagp->type),
                                 filename, curitem->startLine);
                      warningCount++;
                      /* just create empty file */
                      if (SaveInlineScript("", id, basedir, archiveDir)) {
                          goto loser;
                      }
                  } else {
                      curitem = curitem->next;
                      if (SaveInlineScript(curitem->item.text,
                                           id, basedir,
                                           archiveDir)) {
                          goto loser;
                      }
                  }
              } else {
                  /* No src or id tag--warning */
                  PR_fprintf(errorFD,
                             "warning: %s tag starting on %s:%d has no SRC or"
                             " ID attributes.  Will not sign.\n",
                             TagTypeToString(tagp->type), filename, curitem->startLine);
                  warningCount++;
              }
              break;
          default:
              /* do nothing for other tags */
              break;
      }
  }

  /* Now deal with all the unnamable scripts */
  if (firstArchiveDir) {
      HTMLItem *style, *entity;

      /* Go through the lists of JS entities and style attributes.  Do them
       * in chronological order within a list.  Pick the list with the lower
       * endLine. In case of a tie, entities come first.
       */
      style = styleList;
      entity = entityList;
      while (style || entity) {
          if (!entity || (style && (style->endLine < entity->endLine))) {
              /* Process style */
              SaveUnnamableScript(style->item.text, basedir, firstArchiveDir,
                                  filename);
              style = style->next;
          } else {
              /* Process entity */
              SaveUnnamableScript(entity->item.text, basedir, firstArchiveDir,
                                  filename);
              entity = entity->next;
          }
      }
  }

  retval = 0;
1612loser:
  /* Blow away the stream */
  while (head) {
      curitem = head;
      head = head->next;
      DestroyHTMLItem(curitem);
  }
  while (styleList) {
      curitem = styleList;
      styleList = styleList->next;
      DestroyHTMLItem(curitem);
  }
  while (entityList) {
      curitem = entityList;
      entityList = entityList->next;
      DestroyHTMLItem(curitem);
  }
  if (text) {
      PR_Free(text);
      text = NULL((void*)0);
  }
  if (fb) {
      FB_Destroy(fb);
      fb = NULL((void*)0);
  }
  if (fd) {
      PR_Close(fd);
  }
  if (tagerr) {
      PR_smprintf_free(tagerr);
      tagerr = NULL((void*)0);
  }
  if (archiveDir) {
      PR_Free(archiveDir);
      archiveDir = NULL((void*)0);
  }
  if (firstArchiveDir) {
      PR_Free(firstArchiveDir);
      firstArchiveDir = NULL((void*)0);
  }
  if (entityListTail) {
      PR_Free(entityListTail);
  }
  if (basedir) {
      PR_Free(basedir);
  }
  return retval;
1659}

1661/**********************************************************************
*
* e n s u r e E x i s t s
*
* Check for existence of indicated directory.  If it doesn't exist,
* it will be created.
* Returns PR_SUCCESS if the directory is present, PR_FAILURE otherwise.
*/
1669static PRStatus
1670ensureExists(char *basepath, char *path)
1671{
  char fn[FNSIZE256];
  PRDir *dir;
  int c = snprintf(fn, sizeof(fn), "%s/%s", basepath, path);
  if (c >= sizeof(fn)) {
      return PR_FAILURE;
  }

  /*PR_fprintf(outputFD, "Trying to open directory %s.\n", fn);*/

  if ((dir = PR_OpenDir(fn))) {
      PR_CloseDir(dir);
      return PR_SUCCESS;
  }
  return PR_MkDir(fn, 0777);
1686}

1688/***************************************************************************
*
* m a k e _ d i r s
*
* Ensure that the directory portion of the path exists.  This may require
* making the directory, and its parent, and its parent's parent, etc.
*/
1695static int
1696make_dirs(char *path, int file_perms)
1697{
  char *Path;
  char *start;
  char *sep;
  int ret = 0;
  PRFileInfo info;

  if (!path) {
      return 0;
  }

  Path = PL_strdup(path);
  if (!Path) {
      return 0;
  }

  start = strpbrk(Path, "/\\");
  if (!start) {
      goto loser;
  }
  start++; /* start right after first slash */

  /* Each time through the loop add one more directory. */
  while ((sep = strpbrk(start, "/\\"))) {
      *sep = '\0';

      if (PR_GetFileInfo(Path, &info) != PR_SUCCESS) {
          /* No such dir, we have to create it */
          if (PR_MkDir(Path, file_perms) != PR_SUCCESS) {
              PR_fprintf(errorFD, "ERROR: Unable to create directory %s.\n",
                         Path);
              errorCount++;
              ret = -1;
              goto loser;
          }
      } else {
          /* something exists by this name, make sure it's a directory */
          if (info.type != PR_FILE_DIRECTORY) {
              PR_fprintf(errorFD, "ERROR: Unable to create directory %s.\n",
                         Path);
              errorCount++;
              ret = -1;
              goto loser;
          }
      }

      start = sep + 1; /* start after the next slash */
      *sep = '/';
  }

1747loser:
  PR_Free(Path);
  return ret;
1750}

1752/*
*  c o p y i n t o
*
*  Function to copy file "from" to path "to".
*
*/
1758static int
1759copyinto(char *from, char *to)
1760{
  PRInt32 num;
  char buf[BUFSIZ8192];
  PRFileDesc *infp = NULL((void*)0), *outfp = NULL((void*)0);
  int retval = -1;

  if ((infp = PR_Open(from, PR_RDONLY0x01, 0777)) == NULL((void*)0)) {
      PR_fprintf(errorFD, "ERROR: Unable to open \"%s\" for reading.\n",
                 from);
      errorCount++;
      goto finish;
  }

  /* If to already exists, print a warning before deleting it */
  if (PR_Access(to, PR_ACCESS_EXISTS) == PR_SUCCESS) {
      PR_fprintf(errorFD, "warning: %s already exists--will overwrite\n", to);
      warningCount++;
      if (rm_dash_r(to)) {
          PR_fprintf(errorFD,
                     "ERROR: Unable to remove %s.\n", to);
          errorCount++;
          goto finish;
      }
  }

  if ((outfp = PR_Open(to, PR_WRONLY0x02 | PR_CREATE_FILE0x08 | PR_TRUNCATE0x20, 0777)) ==
      NULL((void*)0)) {
      char *errBuf = NULL((void*)0);

      errBuf = PR_Malloc(PR_GetErrorTextLength() + 1);
      PR_fprintf(errorFD, "ERROR: Unable to open \"%s\" for writing.\n", to);
      if (PR_GetErrorText(errBuf)) {
          PR_fprintf(errorFD, "Cause: %s\n", errBuf);
      }
      if (errBuf) {
          PR_Free(errBuf);
      }
      errorCount++;
      goto finish;
  }

  while ((num = PR_Read(infp, buf, BUFSIZ8192)) > 0) {
      if (PR_Write(outfp, buf, num) != num) {
          PR_fprintf(errorFD, "ERROR: Error writing to %s.\n", to);
          errorCount++;
          goto finish;
      }
  }

  retval = 0;
1810finish:
  if (infp)
      PR_Close(infp);
  if (outfp)
      PR_Close(outfp);

  return retval;
1817}