oledecod.c

harvest是一个下载html网页得机器人

          printf (" -\n");
          continue;
	   }
	printf ("%08lx ", pps_list[i].ppsnumber);
	printf ("%d ", pps_list[i].type);
	printf ("%08lx ", pps_list[i].previous);
	printf ("%08lx ", pps_list[i].next);
	printf ("%08lx ", pps_list[i].dir);
	printf ("%08lx ", pps_list[i].start);
	printf ("%04x ", pps_list[i].level);
	printf ("%08lx ", pps_list[i].size);
	printf ("'%c", !isprint (pps_list[i].name[0]) ? ' ' : pps_list[i].name[0]);
	printf ("%s\n", pps_list[i].name+1);
	 }
  }

  /* NEXT IS VERBOSE verbose */
  verbosePPSTree (pps_list, *root, 0);
#endif


  /* generates pps real files */
  /* NOTE: by this moment, the pps tree,
	wich is made with pps_list entries, is reordered */
  verbose ("create pps files");
  {
    U8 *Depot;
    FILE *OLEfile, *infile;
    U16 BlockSize, Offset;
    size_t bytes_to_read;
    U32 pps_size, pps_start;

    assert (num_of_pps >= 1);
    /* i < 1 --- before i < num_of_pps --- changed so not to generate the
	  real files by now --- cole 2.0.0 */
    /* may be later we can rewrite this code in order to only extract the
	  sbfile, may be using __cole_extract_file call to avoid duplicated
	  code --- cole 2.0.0 */
    for (i = 0; i < 1; i++)
	 {
	pps_list[i].filename[0] = 0;

	/* storage pps and non-valid-pps (except root) does not need files */
	/* because FlashPix file format have a root of type 5 but with no name,
	   we must to check if the non-valid-pps is root */
	if (pps_list[i].type == 1
	    || (!pps_list[i].name[0] && pps_list[i].type != 5))
	    continue;
	/* pps that have level > max_level will not be extracted */
	if (max_level != 0 && pps_list[i].level > max_level)
	    continue;

	pps_size = pps_list[i].size;
	pps_start = pps_list[i].start;
/* FIXME MARK 2 */
	/* How we get sure pps_start doesn't point to a block bigger than the
	   real file (input of sbfile) have? */

	/* create the new file */
	if (pps_list[i].type == 5)
	/* root entry, sbfile must be generated */
	{
	    if (SDepot == NULL) {
		/* if there are not small blocks, not generate sbfile */
		*_sbfilename = NULL;
		*_sbfile = NULL;
		break;
	    }
	    assert (i == *root);
	    assert (i == 0);
	    /* tmpnam (sbfile) and next calls --- commented out so not to
		  generate the real files by now --- sbfilename is stored in
		  *_sbfilename instead --- cole 2.0.0
		*/
	    /*
		 tmpnam (sbfilename);
		 test_exitf (sbfilename[0], 7, ends ());
		 sbfile = OLEfile = fopen (sbfilename, "wb+");
		 test_exitf (OLEfile != NULL, 7, ends ());
		 verboseS (sbfilename);
		*/
#if defined( __WIN32__ ) || defined( __BORLANDC__ )
	    *_sbfilename = (U8 *)malloc (TMPNAM_LEN);
	    test_exitf (*_sbfilename != NULL, 10, ends ());
	    tmpnam (*_sbfilename);
	    test_exitf (*_sbfilename[0], 7, ends ());
	    sbfile = OLEfile = fopen (*_sbfilename, "w+b");
#else
	{
		int ret;

		*_sbfilename = (U8 *)malloc (TMPNAM_LEN);
		test_exitf (*_sbfilename != NULL, 10, ends ());

		strcpy(*_sbfilename, "/tmp/xlHtmlXXXXXX");
		ret = mkstemp(*_sbfilename);
		if (ret == -1)	{
			free(*_sbfilename);
			test_exitf (ret == -1, 7, ends ());
		}

		sbfile = OLEfile = fdopen(ret, "w+b");
		/* unlink() is called so this file deletes when we are done with it */
		unlink(*_sbfilename);
	}
#endif
	    *_sbfile = sbfile;
	    test_exitf (OLEfile != NULL, 7, ends ());
	    verboseS (*_sbfilename);
	}
	else
	/* other entry, save in a file */
	{
	    /* this branch is never executed now */
#if defined( __WIN32__ ) || defined( __BORLANDC__ )
		tmpnam (pps_list[i].filename);
		test_exitf (pps_list[i].filename[0], 7, ends ());
		verbose(pps_list[i].name + (!isprint(pps_list[i].name[0]) ? 1 : 0));
		OLEfile = fopen (pps_list[i].filename, "wb");
#else
		int ret;

		strcpy(pps_list[i].filename, "/tmp/xlHtmlXXXXXX");
		ret = mkstemp(pps_list[i].filename);
		test_exitf (ret == -1, 7, ends ());
		OLEfile = fdopen(ret, "wb");
#endif
		test_exitf (OLEfile != NULL, 7, ends ());
		verbose (pps_list[i].filename);
	}

	if (pps_size >= 0x1000 /*is in bbd */  ||
	    OLEfile == sbfile /*is root */ )
	{
	    /* read from big block depot */
	    Offset = 1;
	    BlockSize = 0x0200;
	    assert (input != NULL);
	    assert (BDepot != NULL);
	    infile = input;
	    Depot = BDepot;
	}
	else
	{
	    /* read from small block file */
	    Offset = 0;
	    BlockSize = 0x40;
	    assert (sbfile != NULL);
	    assert (SDepot != NULL);
	    infile = sbfile;
	    Depot = SDepot;
	}

	/* -2 signed long int == 0xfffffffe unsinged long int */
	while (pps_start != 0xfffffffeUL)
	{
#ifdef VERBOSE
	    printf ("reading pps %08lx block %08lx from %s\n",
		    pps_list[i].ppsnumber, pps_start,
		 Depot == BDepot ? "big block depot" : "small block depot");
#endif
	    FilePos = (pps_start + Offset) * BlockSize;
	    assert (FilePos >= 0);
	    bytes_to_read = MIN ((U32)BlockSize, pps_size);
	    fseek (infile, FilePos, SEEK_SET);
	    fread (Block, bytes_to_read, 1, infile);
	    test_exitf (!ferror (infile), 5, ends ());
	    fwrite (Block, bytes_to_read, 1, OLEfile);
	    test_exitf (!ferror (infile), 5, ends ());
	    pps_start = fil_sreadU32 (Depot + (pps_start * 4));
	    pps_size -= MIN ((U32)BlockSize, pps_size);
	    if (pps_size == 0)
		 pps_start = 0xfffffffeUL;
	}
	if (OLEfile == sbfile)
	  /* if small block file generated */
	  rewind (OLEfile);	/* rewind because we will read it later */
	/*else if (!fclose (OLEfile))*/	/* close the pps file */
	  /* don't know what to do here */
	  /*;*/
	}
    /* if (sbfile != NULL) --- commented out so conservate sbfile
	  open --- cole 2.0.0 */
    /*
    if (sbfile != NULL)
	 {
	fclose (sbfile);
	  if (!remove (sbfilename)) ;
	sbfile = NULL;
	 }
	*/
  }
  ends ();
  return 0;
}


/* reorder pps tree and write levels */
/* not sure if it is safe declare last_next_link_visited
   inside reorder_pps_tree function */
static U32 *last_next_link_visited;
static int reorder_pps_tree (pps_entry * node, U16 level)
{
  /* NOTE: in next, previous and dir link,
	0xffffffff means point to nowhere (NULL) */

  node->level = level;

  /* reorder subtrees, if there's any */
  if (node->dir != 0xffffffffUL)
  {
    if (node->dir > num_of_pps || !pps_list[node->dir].name[0])
	 return 0;
    else if (!reorder_pps_tree (&pps_list[node->dir], (U16)(level + 1)))
	 return 0;
  }

  /* reorder next-link subtree, saving the most next link visited */
  if (node->next != 0xffffffffUL)
    {
	 if (node->next > num_of_pps || !pps_list[node->next].name[0])
	return 0;
	 else if (!reorder_pps_tree (&pps_list[node->next], level))
	return 0;
    }
  else
    last_next_link_visited = &node->next;

  /* move the prev child to the next link and reorder it, if there's any */
  if (node->previous != 0xffffffffUL)
  {
    if (node->previous > num_of_pps || !pps_list[node->previous].name[0])
	 return 0;
    else
	 {
	*last_next_link_visited = node->previous;
	node->previous = 0xffffffffUL;
	if (!reorder_pps_tree (&pps_list[*last_next_link_visited], level))
	  return 0;
	 }
  }
  return 1;
}


/* verbose pps tree */
static void verbosePPSTree (pps_entry * pps_list, U32 start_entry, int level)
{
  U32 entry;
  int i;
#if __GNUC__ == 2
static char cff[] = "cole235711";
#define nextff(var) static void * nextff_var = (&nextff_var); \
nextff_var=&var;
nextff (cff);
#endif


  for (entry = start_entry; entry != 0xffffffffUL; entry = pps_list[entry].next)
    {
	 if (pps_list[entry].type == 2)
	{
	  for (i = 0; i < level * 3; i++)
	    printf (" ");
	  printf ("FILE %02lx %8ld '%c%s'\n", pps_list[entry].ppsnumber,
		  pps_list[entry].size, !isprint((int)pps_list[entry].name[0]) ? ' ' : pps_list[entry].name[0], pps_list[entry].name+1);
	}
	 else
	{
	  for (i = 0; i < level * 3; i++)
	    printf (" ");
	  printf ("DIR  %02lx '%c%s'\n", pps_list[entry].ppsnumber,
		  !isprint((int)pps_list[entry].name[0]) ? ' ' : pps_list[entry].name[0], pps_list[entry].name+1);
	  verbosePPSTree (pps_list, pps_list[entry].dir, level + 1);
	}
    }
}


/* closeOLEtreefiles --- outdated because not to generate the
   real files by now --- cole 2.0.0 */
/*
#define freeNoNULL(x) { if ((x) != NULL) free (x); }
static int errorClosingTreeFiles;
void
closeOLEtreefiles (pps_entry * tree, U32 root)
{
#ifdef VERBOSE
  printf ("Visiting entry 0x%08lx to erase file\n",
	  tree[root].ppsnumber);
#endif
  if (tree[root].previous != 0xffffffffUL)
    closeOLEtreefiles (tree, tree[root].previous);
  if (tree[root].next != 0xffffffffUL)
    closeOLEtreefiles (tree, tree[root].next);
  if (tree[root].type != 2 && tree[root].dir != 0xffffffffUL)
    {
#ifdef VERBOSE
	 printf ("Going down to directory 0x%08lx to erase files\n",
		 tree[root].dir);
#endif
	 closeOLEtreefiles (tree, tree[root].dir);
    }
  else if (tree[root].type == 2)
    if (!remove (tree[root].filename))
    {
#ifdef VERBOSE
	 printf ("Success removing %s\n", tree[root].filename);
#endif
    }
  else
    {
#ifdef VERBOSE
	 printf ("Failed to remove %s\n", tree[root].filename);
#endif
	 errorClosingTreeFiles = 1;
    }
}
*/

/* freeOLEtree is now useless: it only free tree -- cole 2.0.0 */
/*
   Free all the memory allocated in the tree.
   Output: 0 = Sucess.
   .       6 = Error removing some temporal stream files.
 */
/*
int freeOLEtree (pps_entry * tree);
*/
/*
int
freeOLEtree (pps_entry * tree)
{
*/
  /* errorCloseingTreeFiles --- doesn't exists because closeOLEtreefiles
	was outdated because not to generate the real files by
	now --- cole 2.0.0 */
  /*
    errorClosingTreeFiles = 0;
  */
/*
  if (tree != NULL)
    {
*/
	 /* closeOLEtreefiles --- outdated because not to generate the
	    real files by now --- cole 2.0.0 */
	 /*
	   closeOLEtreefiles (tree, 0);
	  */
/*
	 free (tree);
    }
 */
  /* errorCloseingTreeFiles --- doesn't exists because closeOLEtreefiles
	was outdated because not to generate the real files by
	now --- cole 2.0.0 */
  /*return*/ /* errorClosingTreeFiles ? 6 : */ /*0;*/
/*}*/


/* free memory used (except the pps tree) */
#define freeNoNULL(x) { if ((x) != NULL) free (x); }
static void ends (void)
{
  /* if (input != NULL) and next lines --- commented out so conservate input
	file open --- cole 2.0.0 */
  /*
  if (input != NULL)
    fclose (input);
  */
  freeNoNULL (Block);
  freeNoNULL (Blockx);
  /* freeNoNULL (BDepot) and next line --- commented out so conservate
	depots --- cole 2.0.0 */
  /*
    freeNoNULL (BDepot);
    freeNoNULL (SDepot);
  */
  freeNoNULL (Root);
  freeNoNULL (sbd_list);
  freeNoNULL (root_list);
  /* if (sbfile != NULL) and next lines --- commented out so conservate sbfile
	open --- cole 2.0.0 */
  /*
  if (sbfile != NULL)
    {
	 fclose (sbfile);
	 if (!remove (sbfilename)) ;
    }
   */
}

#undef VERBOSE