fs/hfsplus/blockiter.c

/*
 * libhfs - library for reading and writing Macintosh HFS volumes
 *
 * The iterator shown here iterates over the blocks of a fork.
 *
 * Copyright (C) 2000 Klaus Halfmann <klaus.halfmann@feri.de>
 * Original work by 1996-1998 Robert Leslie <rob@mars.org>
 * other work 2000 from Brad Boyer (flar@pants.nu)  
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

# ifdef HAVE_CONFIG_H
#  include "config.h"
# endif

# include <stdlib.h>
# include <stdio.h>
# include <string.h>
# include <time.h>
# include <errno.h>

# include "libhfsp.h"
# include "blockiter.h"
# include "volume.h"
# include "record.h"
# include "btree.h"
# include "os.h"
# include "hfstime.h"

/* Initialize iterator for a given fork */
void blockiter_init(blockiter* b, volume* vol, hfsp_fork_raw* f, 
                    UInt8 forktype, UInt32 fileId)
{
    b->vol          = vol;
    b->curr_block   = 0;
    b->block        = 0;
    b->max_block    = f->total_blocks;
    b->fileId       = fileId;
    b->index        = 0;
    b->file         = f->extents;
    b->e            = f->extents;
    b->forktype     = forktype;
    b->in_extent    = 0;
}

/* get next extent record when needed */
static int blockiter_next_extent(blockiter *b)
{
    btree*  extents_tree = volume_get_extents_tree(b->vol);
    int     err;

    b->index = 0;
    if (b->in_extent) // already using extents record ?
    {
        err = record_next_extent(&b->er);
        // Hope there is no need to check this ...
        // if (b->er.key.start_block != b->curr_block)
        //     HFSP_ERROR(ENOENT, 
        //      "Extents record inconistent");
    }
    else
    {
        err = record_init_file(&b->er, extents_tree, b->forktype,
                b->fileId, b->curr_block);
        b->in_extent = -1;  // true
    }
    b->e = b->er.extent;
    return err;
}

/* find next block of the fork iterating over */
int blockiter_next(blockiter *b)
{
    b->curr_block ++; 
    b->block ++;
    if (b->curr_block >= b->max_block)
        return -1; // end of Blocks, but no error
    // in current part of extent ?
    if (b->block >= b->e->block_count)
    {
        b->index++;
        b->block = 0;           // reset relative position
        b->e++;
        if (b -> index >= 8)    // need to fetch another extent
        {
            if (blockiter_next_extent(b))
                HFSP_ERROR(ENOENT, "Extends record not found.");
        }
    }
    return 0;

  fail:
    return -1;
}

/* skip the indicated number of blocks */
int blockiter_skip(blockiter *b, UInt32 skip)
{
    while (skip > 0)
    {
        // Skip to skip or end of current extent
        UInt32 diff = b->e->block_count - b->block;
        if (skip < diff)
        {
            diff = skip;
            skip = 0;
        }
        else
            skip -= diff;
        b->curr_block += diff; 
        b->block      += diff;
        if (b->curr_block >= b->max_block)
            return -1;  // end of Blocks, but no error
        if (b->block >= b->e->block_count)
        {
            b->index++;
            b->block = 0;               // reset relative position
            b->e++;
            if (b -> index >= 8)        // need to fetch another extent
            {
                if (blockiter_next_extent(b))
                    HFSP_ERROR(ENOENT, "Extends record not found.");
            }
        }
    } // we are here when skip was null, thats ok
    return 0;
  fail:
    return -1;
}

1	dpavlin	1	/*
2			* libhfs - library for reading and writing Macintosh HFS volumes
3			*
4			* The iterator shown here iterates over the blocks of a fork.
5			*
6			* Copyright (C) 2000 Klaus Halfmann <klaus.halfmann@feri.de>
7			* Original work by 1996-1998 Robert Leslie <rob@mars.org>
8			* other work 2000 from Brad Boyer (flar@pants.nu)
9			*
10			* This program is free software; you can redistribute it and/or modify
11			* it under the terms of the GNU General Public License as published by
12			* the Free Software Foundation; either version 2 of the License, or
13			* (at your option) any later version.
14			*
15			* This program is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU General Public License for more details.
19			*
20			* You should have received a copy of the GNU General Public License
21			* along with this program; if not, write to the Free Software
22			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23			*
24			*/
25
26			# ifdef HAVE_CONFIG_H
27			# include "config.h"
28			# endif
29
30			# include <stdlib.h>
31			# include <stdio.h>
32			# include <string.h>
33			# include <time.h>
34			# include <errno.h>
35
36			# include "libhfsp.h"
37			# include "blockiter.h"
38			# include "volume.h"
39			# include "record.h"
40			# include "btree.h"
41			# include "os.h"
42			# include "hfstime.h"
43
44			/* Initialize iterator for a given fork */
45			void blockiter_init(blockiter* b, volume* vol, hfsp_fork_raw* f,
46			UInt8 forktype, UInt32 fileId)
47			{
48			b->vol = vol;
49			b->curr_block = 0;
50			b->block = 0;
51			b->max_block = f->total_blocks;
52			b->fileId = fileId;
53			b->index = 0;
54			b->file = f->extents;
55			b->e = f->extents;
56			b->forktype = forktype;
57			b->in_extent = 0;
58			}
59
60			/* get next extent record when needed */
61			static int blockiter_next_extent(blockiter *b)
62			{
63			btree* extents_tree = volume_get_extents_tree(b->vol);
64			int err;
65
66			b->index = 0;
67			if (b->in_extent) // already using extents record ?
68			{
69			err = record_next_extent(&b->er);
70			// Hope there is no need to check this ...
71			// if (b->er.key.start_block != b->curr_block)
72			// HFSP_ERROR(ENOENT,
73			// "Extents record inconistent");
74			}
75			else
76			{
77			err = record_init_file(&b->er, extents_tree, b->forktype,
78			b->fileId, b->curr_block);
79			b->in_extent = -1; // true
80			}
81			b->e = b->er.extent;
82			return err;
83			}
84
85			/* find next block of the fork iterating over */
86			int blockiter_next(blockiter *b)
87			{
88			b->curr_block ++;
89			b->block ++;
90			if (b->curr_block >= b->max_block)
91			return -1; // end of Blocks, but no error
92			// in current part of extent ?
93			if (b->block >= b->e->block_count)
94			{
95			b->index++;
96			b->block = 0; // reset relative position
97			b->e++;
98			if (b -> index >= 8) // need to fetch another extent
99			{
100			if (blockiter_next_extent(b))
101			HFSP_ERROR(ENOENT, "Extends record not found.");
102			}
103			}
104			return 0;
105
106			fail:
107			return -1;
108			}
109
110			/* skip the indicated number of blocks */
111			int blockiter_skip(blockiter *b, UInt32 skip)
112			{
113			while (skip > 0)
114			{
115			// Skip to skip or end of current extent
116			UInt32 diff = b->e->block_count - b->block;
117			if (skip < diff)
118			{
119			diff = skip;
120			skip = 0;
121			}
122			else
123			skip -= diff;
124			b->curr_block += diff;
125			b->block += diff;
126			if (b->curr_block >= b->max_block)
127			return -1; // end of Blocks, but no error
128			if (b->block >= b->e->block_count)
129			{
130			b->index++;
131			b->block = 0; // reset relative position
132			b->e++;
133			if (b -> index >= 8) // need to fetch another extent
134			{
135			if (blockiter_next_extent(b))
136			HFSP_ERROR(ENOENT, "Extends record not found.");
137			}
138			}
139			} // we are here when skip was null, thats ok
140			return 0;
141			fail:
142			return -1;
143			}
144