]>
Commit | Line | Data |
---|---|---|
26ec9513 MT |
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 | }\ |