SquashFS hinzugefuegt damit wir auf OpenVZ-Maschinen bauen koennen.
[people/pmueller/ipfire-2.x.git] / src / patches / squashfstools-3.0.patch
1 diff -u squashfs3.0old/squashfs-tools/mksquashfs.c squashfs3.0/squashfs-tools/mksquashfs.c
2 --- squashfs3.0old/squashfs-tools/mksquashfs.c 2006-03-15 21:36:20.000000000 +0000
3 +++ squashfs3.0/squashfs-tools/mksquashfs.c 2006-04-17 10:58:49.000000000 +0100
4 @@ -72,7 +72,7 @@
5 #define EXIT_MKSQUASHFS() do {\
6 if(restore)\
7 restorefs();\
8 - if(delete && destination_file && !block_device)\
9 + if(deletesquash && destination_file && !block_device)\
10 unlink(destination_file);\
11 exit(1);\
12 } while(0)
13 @@ -81,7 +81,7 @@
14 EXIT_MKSQUASHFS();\
15 } while(0)
16
17 -int delete = FALSE;
18 +int deletesquash = FALSE;
19 long long total_compressed = 0, total_uncompressed = 0;
20 int fd;
21
22 @@ -251,6 +251,7 @@
23 squashfs_fragment_entry **fragment_table);
24 int get_sorted_inode(squashfs_inode *inode, struct stat *buf);
25 int read_sort_file(char *filename, int source, char *source_path[]);
26 +int dir_scan2(squashfs_inode *inode, struct dir_info *dir_info);
27 void sort_files_and_write(struct dir_info *dir);
28 struct file_info *duplicate(char *(get_next_file_block)(struct duplicate_buffer_handle *, unsigned int), struct duplicate_buffer_handle *file_start, long long bytes, unsigned int **block_list, long long *start, int blocks, struct fragment **fragment, char *frag_data, int frag_bytes);
29 struct dir_info *dir_scan1(char *, int (_readdir)(char *, char *, struct dir_info *));
30 @@ -285,7 +286,7 @@
31 }
32
33
34 -void sighandler()
35 +void sighandler(int signal)
36 {
37 if(interrupted == 1)
38 restorefs();
39 @@ -297,7 +298,7 @@
40 }
41
42
43 -void sighandler2()
44 +void sighandler2(int signal)
45 {
46 EXIT_MKSQUASHFS();
47 }
48 @@ -693,7 +694,7 @@
49
50 void scan2_init_dir(struct directory *dir)
51 {
52 - if((dir->buff = malloc(SQUASHFS_METADATA_SIZE)) == NULL) {
53 + if((dir->buff = (unsigned char *)malloc(SQUASHFS_METADATA_SIZE)) == NULL) {
54 BAD_ERROR("Out of memory allocating directory buffer\n");
55 }
56
57 @@ -720,7 +721,7 @@
58 }
59
60 if(dir->p + sizeof(squashfs_dir_entry) + size + sizeof(squashfs_dir_header) >= dir->buff + dir->size) {
61 - if((buff = realloc(dir->buff, dir->size += SQUASHFS_METADATA_SIZE)) == NULL) {
62 + if((buff = (unsigned char *)realloc(dir->buff, dir->size += SQUASHFS_METADATA_SIZE)) == NULL) {
63 BAD_ERROR("Out of memory reallocating directory buffer\n");
64 }
65
66 @@ -737,7 +738,7 @@
67
68 if((dir->p + sizeof(squashfs_dir_entry) + size - dir->index_count_p) > SQUASHFS_METADATA_SIZE) {
69 if(dir->i_count % I_COUNT_SIZE == 0)
70 - if((dir->index = realloc(dir->index, (dir->i_count + I_COUNT_SIZE) * sizeof(struct cached_dir_index))) == NULL)
71 + if((dir->index = (struct cached_dir_index *)realloc(dir->index, (dir->i_count + I_COUNT_SIZE) * sizeof(struct cached_dir_index))) == NULL)
72 BAD_ERROR("Out of memory in directory index table reallocation!\n");
73 dir->index[dir->i_count].index.index = dir->p - dir->buff;
74 dir->index[dir->i_count].index.size = size - 1;
75 @@ -1175,7 +1176,7 @@
76 int blocks = (read_size + block_size - 1) >> block_log, allocated_blocks = blocks;
77 unsigned int *block_list, *block_listp;
78
79 - if((block_list = malloc(blocks * sizeof(unsigned int))) == NULL)
80 + if((block_list = (unsigned int *)malloc(blocks * sizeof(unsigned int))) == NULL)
81 BAD_ERROR("Out of memory allocating block_list\n");
82 block_listp = block_list;
83
84 @@ -1329,7 +1330,7 @@
85 inode = inode->next;
86 }
87
88 - if((inode = malloc(sizeof(struct inode_info))) == NULL)
89 + if((inode = (struct inode_info *)malloc(sizeof(struct inode_info))) == NULL)
90 BAD_ERROR("Out of memory in inode hash table entry allocation\n");
91
92 memcpy(&inode->buf, buf, sizeof(struct stat));
93 @@ -1350,10 +1351,10 @@
94 inline void add_dir_entry(char *name, char *pathname, struct dir_info *sub_dir, struct inode_info *inode_info, void *data, struct dir_info *dir)
95 {
96 if((dir->count % DIR_ENTRIES) == 0)
97 - if((dir->list = realloc(dir->list, (dir->count + DIR_ENTRIES) * sizeof(struct dir_ent *))) == NULL)
98 + if((dir->list = (struct dir_ent **)realloc(dir->list, (dir->count + DIR_ENTRIES) * sizeof(struct dir_ent *))) == NULL)
99 BAD_ERROR("Out of memory in add_dir_entry\n");
100
101 - if((dir->list[dir->count] = malloc(sizeof(struct dir_ent))) == NULL)
102 + if((dir->list[dir->count] = (struct dir_ent *)malloc(sizeof(struct dir_ent))) == NULL)
103 BAD_ERROR("Out of memory in linux_opendir\n");
104
105 if(sub_dir)
106 @@ -1363,7 +1364,7 @@
107 dir->list[dir->count]->inode = inode_info;
108 dir->list[dir->count]->dir = sub_dir;
109 dir->list[dir->count]->our_dir = dir;
110 - dir->list[dir->count++]->data = data;
111 + dir->list[dir->count++]->data = (struct old_root_entry_info *)data;
112 dir->byte_count += strlen(name) + sizeof(squashfs_dir_entry);
113 }
114
115 @@ -1392,7 +1393,7 @@
116 struct dirent *d_name;
117 struct dir_info *dir;
118
119 - if((dir = malloc(sizeof(struct dir_info))) == NULL)
120 + if((dir = (struct dir_info *)malloc(sizeof(struct dir_info))) == NULL)
121 return NULL;
122
123 if(pathname[0] != '\0' && (dir->linuxdir = opendir(pathname)) == NULL) {
124 @@ -1527,10 +1528,10 @@
125 if(dir_info == NULL)
126 return;
127
128 - if((dir_ent = malloc(sizeof(struct dir_ent))) == NULL)
129 + if((dir_ent = (struct dir_ent *)malloc(sizeof(struct dir_ent))) == NULL)
130 BAD_ERROR("Out of memory in dir_scan\n");
131
132 - if((inode_info = malloc(sizeof(struct inode_info))) == NULL)
133 + if((inode_info = (struct inode_info *)malloc(sizeof(struct inode_info))) == NULL)
134 BAD_ERROR("Out of memory in dir_scan\n");
135
136 dir_ent->name = dir_ent->pathname = strdup(pathname);
137 @@ -1929,7 +1930,7 @@
138 break;
139
140 else if(strcmp(argv[i], "-noappend") == 0)
141 - delete = TRUE;
142 + deletesquash = TRUE;
143
144 else if(strcmp(argv[i], "-keep-as-directory") == 0)
145 keep_as_directory = TRUE;
146 @@ -1996,7 +1997,7 @@
147 perror("Could not create destination file");
148 exit(1);
149 }
150 - delete = TRUE;
151 + deletesquash = TRUE;
152 } else {
153 perror("Could not stat destination file");
154 exit(1);
155 @@ -2011,7 +2012,7 @@
156 block_device = 1;
157
158 } else if(S_ISREG(buf.st_mode)) {
159 - if((fd = open(argv[source + 1], (delete ? O_TRUNC : 0) | O_RDWR)) == -1) {
160 + if((fd = open(argv[source + 1], (deletesquash ? O_TRUNC : 0) | O_RDWR)) == -1) {
161 perror("Could not open regular file for writing as destination");
162 exit(1);
163 }
164 @@ -2023,7 +2024,7 @@
165
166 }
167
168 - if(!delete) {
169 + if(!deletesquash) {
170 if(read_super(fd, &sBlk, &orig_be, argv[source + 1]) == 0) {
171 ERROR("Failed to read existing filesystem - will not overwrite - ABORTING!\n");
172 EXIT_MKSQUASHFS();
173 @@ -2068,7 +2069,7 @@
174 else if(strcmp(argv[i], "-b") == 0 || strcmp(argv[i], "-root-becomes") == 0 || strcmp(argv[i], "-ef") == 0)
175 i++;
176
177 - if(delete) {
178 + if(deletesquash) {
179 printf("Creating %s %d.%d filesystem on %s, block size %d.\n",
180 be ? "big endian" : "little endian", SQUASHFS_MAJOR, SQUASHFS_MINOR, argv[source + 1], block_size);
181 bytes = sizeof(squashfs_super_block);
182 @@ -2176,7 +2177,7 @@
183
184 block_offset = check_data ? 3 : 2;
185
186 - if(delete && !keep_as_directory && source == 1 && S_ISDIR(source_buf.st_mode))
187 + if(deletesquash && !keep_as_directory && source == 1 && S_ISDIR(source_buf.st_mode))
188 dir_scan(&inode, source_path[0], scan1_readdir);
189 else if(!keep_as_directory && source == 1 && S_ISDIR(source_buf.st_mode))
190 dir_scan(&inode, source_path[0], scan1_single_readdir);
191 diff -u squashfs3.0old/squashfs-tools/read_fs.c squashfs3.0/squashfs-tools/read_fs.c
192 --- squashfs3.0old/squashfs-tools/read_fs.c 2006-03-15 21:36:21.000000000 +0000
193 +++ squashfs3.0/squashfs-tools/read_fs.c 2006-04-17 11:01:56.000000000 +0100
194 @@ -61,14 +61,14 @@
195 fprintf(stderr, s, ## args); \
196 } while(0)
197
198 -int swap;
199 +int swapsquash;
200
201 int read_block(int fd, long long start, long long *next, unsigned char *block, squashfs_super_block *sBlk)
202 {
203 unsigned short c_byte;
204 int offset = 2;
205
206 - if(swap) {
207 + if(swapsquash) {
208 read_bytes(fd, start, 2, (char *) block);
209 ((unsigned char *) &c_byte)[1] = block[0];
210 ((unsigned char *) &c_byte)[0] = block[1];
211 @@ -125,7 +125,7 @@
212 *root_inode_block = bytes;
213 }
214 if((size - bytes < SQUASHFS_METADATA_SIZE) &&
215 - ((*inode_table = realloc(*inode_table, size += SQUASHFS_METADATA_SIZE)) == NULL))
216 + ((*inode_table = (unsigned char *)realloc(*inode_table, size += SQUASHFS_METADATA_SIZE)) == NULL))
217 return FALSE;
218 TRACE("scan_inode_table: reading block 0x%llx\n", start);
219 if((byte = read_block(fd, start, &start, *inode_table + bytes, sBlk)) == 0) {
220 @@ -145,14 +145,14 @@
221 */
222 *root_inode_size = bytes - (*root_inode_block + root_inode_offset);
223 bytes = *root_inode_block + root_inode_offset;
224 - if(swap) {
225 + if(swapsquash) {
226 squashfs_base_inode_header sinode;
227 memcpy(&sinode, *inode_table + bytes, sizeof(dir_inode->base));
228 SQUASHFS_SWAP_BASE_INODE_HEADER(&dir_inode->base, &sinode, sizeof(squashfs_base_inode_header));
229 } else
230 memcpy(&dir_inode->base, *inode_table + bytes, sizeof(dir_inode->base));
231 if(dir_inode->base.inode_type == SQUASHFS_DIR_TYPE) {
232 - if(swap) {
233 + if(swapsquash) {
234 squashfs_dir_inode_header sinode;
235 memcpy(&sinode, *inode_table + bytes, sizeof(dir_inode->dir));
236 SQUASHFS_SWAP_DIR_INODE_HEADER(&dir_inode->dir, &sinode);
237 @@ -160,7 +160,7 @@
238 memcpy(&dir_inode->dir, *inode_table + bytes, sizeof(dir_inode->dir));
239 directory_start_block = dir_inode->dir.start_block;
240 } else {
241 - if(swap) {
242 + if(swapsquash) {
243 squashfs_ldir_inode_header sinode;
244 memcpy(&sinode, *inode_table + bytes, sizeof(dir_inode->ldir));
245 SQUASHFS_SWAP_LDIR_INODE_HEADER(&dir_inode->ldir, &sinode);
246 @@ -170,7 +170,7 @@
247 }
248
249 for(cur_ptr = *inode_table; cur_ptr < *inode_table + bytes; files ++) {
250 - if(swap) {
251 + if(swapsquash) {
252 squashfs_reg_inode_header sinode;
253 memcpy(&sinode, cur_ptr, sizeof(inode));
254 SQUASHFS_SWAP_REG_INODE_HEADER(&inode, &sinode);
255 @@ -191,13 +191,13 @@
256
257 TRACE("scan_inode_table: regular file, file_size %lld, blocks %d\n", inode.file_size, blocks);
258
259 - if((block_list = malloc(blocks * sizeof(unsigned int))) == NULL) {
260 + if((block_list = (unsigned int *)malloc(blocks * sizeof(unsigned int))) == NULL) {
261 ERROR("Out of memory in block list malloc\n");
262 goto failed;
263 }
264
265 cur_ptr += sizeof(inode);
266 - if(swap) {
267 + if(swapsquash) {
268 unsigned int sblock_list[blocks];
269 memcpy(sblock_list, cur_ptr, blocks * sizeof(unsigned int));
270 SQUASHFS_SWAP_INTS(block_list, sblock_list, blocks);
271 @@ -222,7 +222,7 @@
272 int i, start;
273 unsigned int *block_list;
274
275 - if(swap) {
276 + if(swapsquash) {
277 squashfs_lreg_inode_header sinodep;
278 memcpy(&sinodep, cur_ptr, sizeof(sinodep));
279 SQUASHFS_SWAP_LREG_INODE_HEADER(&inode, &sinodep);
280 @@ -238,12 +238,12 @@
281 sBlk->block_log;
282 start = inode.start_block;
283
284 - if((block_list = malloc(blocks * sizeof(unsigned int))) == NULL) {
285 + if((block_list = (unsigned int *)malloc(blocks * sizeof(unsigned int))) == NULL) {
286 ERROR("Out of memory in block list malloc\n");
287 goto failed;
288 }
289
290 - if(swap) {
291 + if(swapsquash) {
292 unsigned int sblock_list[blocks];
293 memcpy(sblock_list, cur_ptr, blocks * sizeof(unsigned int));
294 SQUASHFS_SWAP_INTS(block_list, sblock_list, blocks);
295 @@ -263,7 +263,7 @@
296 case SQUASHFS_SYMLINK_TYPE: {
297 squashfs_symlink_inode_header inodep;
298
299 - if(swap) {
300 + if(swapsquash) {
301 squashfs_symlink_inode_header sinodep;
302 memcpy(&sinodep, cur_ptr, sizeof(sinodep));
303 SQUASHFS_SWAP_SYMLINK_INODE_HEADER(&inodep, &sinodep);
304 @@ -276,7 +276,7 @@
305 case SQUASHFS_DIR_TYPE: {
306 squashfs_dir_inode_header dir_inode;
307
308 - if(swap) {
309 + if(swapsquash) {
310 squashfs_dir_inode_header sinode;
311 memcpy(&sinode, cur_ptr, sizeof(dir_inode));
312 SQUASHFS_SWAP_DIR_INODE_HEADER(&dir_inode, &sinode);
313 @@ -292,7 +292,7 @@
314 squashfs_ldir_inode_header dir_inode;
315 int i;
316
317 - if(swap) {
318 + if(swapsquash) {
319 squashfs_ldir_inode_header sinode;
320 memcpy(&sinode, cur_ptr, sizeof(dir_inode));
321 SQUASHFS_SWAP_LDIR_INODE_HEADER(&dir_inode, &sinode);
322 @@ -304,7 +304,7 @@
323 cur_ptr += sizeof(squashfs_ldir_inode_header);
324 for(i = 0; i < dir_inode.i_count; i++) {
325 squashfs_dir_index index;
326 - if(swap) {
327 + if(swapsquash) {
328 squashfs_dir_index sindex;
329 memcpy(&sindex, cur_ptr, sizeof(squashfs_dir_index));
330 SQUASHFS_SWAP_DIR_INDEX(&index, &sindex);
331 @@ -348,14 +348,14 @@
332 read_bytes(fd, SQUASHFS_START, sizeof(squashfs_super_block), (char *) sBlk);
333
334 /* Check it is a SQUASHFS superblock */
335 - swap = 0;
336 + swapsquash = 0;
337 if(sBlk->s_magic != SQUASHFS_MAGIC) {
338 if(sBlk->s_magic == SQUASHFS_MAGIC_SWAP) {
339 squashfs_super_block sblk;
340 ERROR("Reading a different endian SQUASHFS filesystem on %s - ignoring -le/-be options\n", source);
341 SQUASHFS_SWAP_SUPER_BLOCK(&sblk, sBlk);
342 memcpy(sBlk, &sblk, sizeof(squashfs_super_block));
343 - swap = 1;
344 + swapsquash = 1;
345 } else {
346 ERROR("Can't find a SQUASHFS superblock on %s\n", source);
347 goto failed_mount;
348 @@ -373,9 +373,9 @@
349 }
350
351 #if __BYTE_ORDER == __BIG_ENDIAN
352 - *be = !swap;
353 + *be = !swapsquash;
354 #else
355 - *be = swap;
356 + *be = swapsquash;
357 #endif
358
359 printf("Found a valid SQUASHFS superblock on %s.\n", source);
360 @@ -416,7 +416,7 @@
361 long long start = sBlk->directory_table_start + directory_start_block, last_start_block;
362
363 size += offset;
364 - if((directory_table = malloc((size + SQUASHFS_METADATA_SIZE * 2 - 1) & ~(SQUASHFS_METADATA_SIZE - 1))) == NULL)
365 + if((directory_table = (unsigned char *)malloc((size + SQUASHFS_METADATA_SIZE * 2 - 1) & ~(SQUASHFS_METADATA_SIZE - 1))) == NULL)
366 return NULL;
367 while(bytes < size) {
368 TRACE("squashfs_readdir: reading block 0x%llx, bytes read so far %d\n", start, bytes);
369 @@ -433,7 +433,7 @@
370
371 bytes = offset;
372 while(bytes < size) {
373 - if(swap) {
374 + if(swapsquash) {
375 squashfs_dir_header sdirh;
376 memcpy(&sdirh, directory_table + bytes, sizeof(sdirh));
377 SQUASHFS_SWAP_DIR_HEADER(&dirh, &sdirh);
378 @@ -445,7 +445,7 @@
379 bytes += sizeof(dirh);
380
381 while(dir_count--) {
382 - if(swap) {
383 + if(swapsquash) {
384 squashfs_dir_entry sdire;
385 memcpy(&sdire, directory_table + bytes, sizeof(sdire));
386 SQUASHFS_SWAP_DIR_ENTRY(dire, &sdire);
387 @@ -481,7 +481,7 @@
388 return 0;
389 }
390
391 - if(swap) {
392 + if(swapsquash) {
393 squashfs_fragment_index sfragment_table_index[indexes];
394
395 read_bytes(fd, sBlk->fragment_table_start, SQUASHFS_FRAGMENT_INDEX_BYTES(sBlk->fragments), (char *) sfragment_table_index);
396 @@ -494,7 +494,7 @@
397 TRACE("Read fragment table block %d, from 0x%llx, length %d\n", i, fragment_table_index[i], length);
398 }
399
400 - if(swap) {
401 + if(swapsquash) {
402 squashfs_fragment_entry sfragment;
403 for(i = 0; i < sBlk->fragments; i++) {
404 SQUASHFS_SWAP_FRAGMENT_ENTRY((&sfragment), (&(*fragment_table)[i]));
405 @@ -584,7 +584,7 @@
406 }
407 memcpy(*directory_data_cache, directory_table, *inode_dir_offset + *inode_dir_file_size);
408
409 - if(!swap)
410 + if(!swapsquash)
411 read_bytes(fd, sBlk->uid_start, sBlk->no_uids * sizeof(squashfs_uid), (char *) uids);
412 else {
413 squashfs_uid uids_copy[sBlk->no_uids];
414 @@ -593,7 +593,7 @@
415 SQUASHFS_SWAP_DATA(uids, uids_copy, sBlk->no_uids, sizeof(squashfs_uid) * 8);
416 }
417
418 - if(!swap)
419 + if(!swapsquash)
420 read_bytes(fd, sBlk->guid_start, sBlk->no_guids * sizeof(squashfs_uid), (char *) guids);
421 else {
422 squashfs_uid guids_copy[sBlk->no_guids];
423 diff -u squashfs3.0old/squashfs-tools/sort.c squashfs3.0/squashfs-tools/sort.c
424 --- squashfs3.0old/squashfs-tools/sort.c 2006-03-15 21:36:21.000000000 +0000
425 +++ squashfs3.0/squashfs-tools/sort.c 2006-04-17 11:01:33.000000000 +0100
426 @@ -87,7 +87,7 @@
427 struct priority_entry *new_priority_entry;
428
429 priority += 32768;
430 - if((new_priority_entry = malloc(sizeof(struct priority_entry))) == NULL) {
431 + if((new_priority_entry = (struct priority_entry *)malloc(sizeof(struct priority_entry))) == NULL) {
432 ERROR("Out of memory allocating priority entry\n");
433 return FALSE;
434 }
435 @@ -117,7 +117,7 @@
436 #define ADD_ENTRY(buf, priority) {\
437 int hash = buf.st_ino & 0xffff;\
438 struct sort_info *s;\
439 - if((s = malloc(sizeof(struct sort_info))) == NULL) {\
440 + if((s = (struct sort_info *)malloc(sizeof(struct sort_info))) == NULL) {\
441 ERROR("Out of memory allocating sort list entry\n");\
442 return FALSE;\
443 }\