« back to all changes in this revision
Viewing changes to xorriso/check_media.c
- browse files at revision 12
- compare with another revision
- download diff
- download tarball
- view history from revision 12
- Committer: Bazaar Package Importer
- Author(s): George Danchev
- Date: 2011-05-26 16:21:32 UTC
- mfrom: (9.1.12 sid)
- Revision ID: james.westby@ubuntu.com-20110526162132-9lzoagfaggnera53
Tags: 1.0.8.pl00-4
* [MA] Improve package descriptions and README.Debian.
* [MA] Migrate to format "3.0 (quilt)" and compatibility 8.
+ debian/control: Drop build-dep on 'cdbs'. Require debhelper (>= 8).
+ debian/rules: Reformulate using 'dh'.
+ debian/libisoburn{1,-dev,-doc}.docs: New files.
+ debian/xorriso.docs: Addition of upstream documents.
* [GD] Make sure doxygen documentaton (doc package) is not built
when dpkg-buildpackage -B is called (i.e. autobuilders).
* [GD] Move doxygen, graphviz to Build-Depends-Indep.
* [GD] Add missing copyrights for debian packaging.
* [GD] Standards-Version: 3.9.2 (no changes needed).
* [GD] More package description and README.Debian improvements;
thanks to Tony Mancill <tmancill@debian.org>.
* [MA] Migrate to format "3.0 (quilt)" and compatibility 8.
+ debian/control: Drop build-dep on 'cdbs'. Require debhelper (>= 8).
+ debian/rules: Reformulate using 'dh'.
+ debian/libisoburn{1,-dev,-doc}.docs: New files.
+ debian/xorriso.docs: Addition of upstream documents.
* [GD] Make sure doxygen documentaton (doc package) is not built
when dpkg-buildpackage -B is called (i.e. autobuilders).
* [GD] Move doxygen, graphviz to Build-Depends-Indep.
* [GD] Add missing copyrights for debian packaging.
* [GD] Standards-Version: 3.9.2 (no changes needed).
* [GD] More package description and README.Debian improvements;
thanks to Tony Mancill <tmancill@debian.org>.
- files added:
- ChangeLog
- debian/local
- files removed:
- debian/libisoburn1.symbols
- files modified:
- COPYRIGHT
added
removed
xorriso/check_media.c
1
2
/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
3
4
Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
5
6
Provided under GPL version 2 or later.
7
8
This file contains the implementation of classes SpotlistiteM, SectorbitmaP,
9
CheckmediajoB which perform verifying runs on media resp. images.
10
*/
11
12
#ifdef HAVE_CONFIG_H
13
#include "../config.h"
14
#endif
15
16
#include <ctype.h>
17
#include <sys/types.h>
18
#include <unistd.h>
19
#include <stdlib.h>
20
#include <stdio.h>
21
#include <string.h>
22
#include <sys/stat.h>
23
#include <sys/time.h>
24
#include <time.h>
25
#include <fcntl.h>
26
#include <errno.h>
27
28
#include "xorriso.h"
29
#include "xorriso_private.h"
30
#include "xorrisoburn.h"
31
32
33
/* ------------------------------ SpotlisT -------------------------------- */
34
35
36
struct SpotlistiteM {
37
int start_lba;
38
int blocks;
39
int quality;
40
struct SpotlistiteM *next;
41
};
42
43
44
int Spotlistitem_new(struct SpotlistiteM **o, int start_lba, int blocks,
45
int quality, int flag)
46
{
47
struct SpotlistiteM *m;
48
49
m= TSOB_FELD(struct SpotlistiteM,1);
50
if(m==NULL)
51
return(-1);
52
*o= m;
53
m->start_lba= start_lba;
54
m->blocks= blocks;
55
m->quality= quality;
56
m->next= NULL;
57
return(1);
58
}
59
60
61
int Spotlistitem_destroy(struct SpotlistiteM **o, int flag)
62
{
63
if((*o) == NULL)
64
return(0);
65
free((char *) *o);
66
*o= NULL;
67
return(1);
68
}
69
70
71
struct SpotlisT {
72
struct SpotlistiteM *list_start;
73
struct SpotlistiteM *list_end;
74
int list_count;
75
struct SpotlistiteM *current_item;
76
int current_idx;
77
};
78
79
80
int Spotlist_new(struct SpotlisT **o, int flag)
81
{
82
struct SpotlisT *m;
83
84
m= TSOB_FELD(struct SpotlisT,1);
85
if(m==NULL)
86
return(-1);
87
*o= m;
88
m->list_start= NULL;
89
m->list_end= NULL;
90
m->list_count= 0;
91
m->current_item= NULL;
92
m->current_idx= -1;
93
return(1);
94
}
95
96
97
int Spotlist_destroy(struct SpotlisT **o, int flag)
98
{
99
struct SpotlisT *m;
100
struct SpotlistiteM *li, *next_li;
101
102
if((*o) == NULL)
103
return(0);
104
m= *o;
105
for(li= m->list_start; li != NULL; li= next_li) {
106
next_li= li->next;
107
Spotlistitem_destroy(&li, 0);
108
}
109
free((char *) *o);
110
*o= NULL;
111
return(1);
112
}
113
114
115
int Spotlist_add_item(struct SpotlisT *o, int start_lba, int blocks,
116
int quality, int flag)
117
{
118
int ret;
119
struct SpotlistiteM *li;
120
static int debug_verbous= 0;
121
122
ret= Spotlistitem_new(&li, start_lba, blocks, quality, 0);
123
if(ret <= 0)
124
return(ret);
125
if(o->list_end != NULL)
126
o->list_end->next= li;
127
o->list_end= li;
128
if(o->list_start == NULL)
129
o->list_start= li;
130
(o->list_count)++;
131
132
if(debug_verbous) {char quality_name[80];
133
fprintf(stderr, "debug: lba %10d , size %10d , quality '%s'\n",
134
start_lba, blocks, Spotlist__quality_name(quality, quality_name,
135
Xorriso_read_quality_invaliD, 0) + 2);
136
}
137
138
return(1);
139
}
140
141
142
int Spotlist_count(struct SpotlisT *o, int flag)
143
{
144
return o->list_count;
145
}
146
147
148
int Spotlist_block_count(struct SpotlisT *o, int flag)
149
{
150
int list_blocks= 0;
151
struct SpotlistiteM *li;
152
153
for(li= o->list_start; li != NULL; li= li->next) {
154
if(li->start_lba + li->blocks > list_blocks)
155
list_blocks= li->start_lba + li->blocks;
156
}
157
return(list_blocks);
158
}
159
160
161
int Spotlist_sector_size(struct SpotlisT *o, int read_chunk, int flag)
162
{
163
int sector_size;
164
struct SpotlistiteM *li;
165
166
sector_size= read_chunk * 2048;
167
for(li= o->list_start; li != NULL; li= li->next) {
168
if((li->start_lba % read_chunk) || (li->blocks % read_chunk)) {
169
sector_size= 2048;
170
break;
171
}
172
}
173
return(sector_size);
174
}
175
176
177
int Spotlist_get_item(struct SpotlisT *o, int idx,
178
int *start_lba, int *blocks, int *quality, int flag)
179
{
180
int i;
181
struct SpotlistiteM *li;
182
183
if(idx < 0 || idx > o->list_count)
184
return(0);
185
if(idx == o->current_idx && o->current_item != NULL)
186
li= o->current_item;
187
else if(idx == o->current_idx + 1 && o->current_item != NULL) {
188
li= o->current_item->next;
189
} else {
190
li= o->list_start;
191
for(i= 0; i < idx; i++)
192
li= li->next;
193
}
194
o->current_item= li;
195
o->current_idx= idx;
196
*start_lba= li->start_lba;
197
*blocks= li->blocks;
198
*quality= li->quality;
199
return(1);
200
}
201
202
203
char *Spotlist__quality_name(int quality, char name[80], int bad_limit,
204
int flag)
205
{
206
if(quality == Xorriso_read_quality_untesteD ||
207
quality == Xorriso_read_quality_tao_enD ||
208
quality == Xorriso_read_quality_off_tracK)
209
strcpy(name, "0 ");
210
else if(quality <= bad_limit)
211
strcpy(name, "- ");
212
else
213
strcpy(name, "+ ");
214
if(quality == Xorriso_read_quality_gooD)
215
strcat(name, "good");
216
else if(quality == Xorriso_read_quality_md5_matcH)
217
strcat(name, "md5_match");
218
else if(quality == Xorriso_read_quality_sloW)
219
strcat(name, "slow");
220
else if(quality == Xorriso_read_quality_partiaL)
221
strcat(name, "partial");
222
else if(quality == Xorriso_read_quality_valiD)
223
strcat(name, "valid");
224
else if(quality == Xorriso_read_quality_untesteD)
225
strcat(name, "untested");
226
else if(quality == Xorriso_read_quality_invaliD)
227
strcat(name, "invalid");
228
else if(quality == Xorriso_read_quality_tao_enD)
229
strcat(name, "tao_end");
230
else if(quality == Xorriso_read_quality_off_tracK)
231
strcat(name, "off_track");
232
else if(quality == Xorriso_read_quality_md5_mismatcH)
233
strcat(name, "md5_mismatch");
234
else if(quality == Xorriso_read_quality_unreadablE)
235
strcat(name, "unreadable");
236
else
237
sprintf(name, "0 0x%8.8X", (unsigned int) quality);
238
return(name);
239
}
240
241
242
/* ---------------------------- End SpotlisT ------------------------------ */
243
244
/* ---------------------------- SectorbitmaP ------------------------------ */
245
246
int Sectorbitmap_new(struct SectorbitmaP **o, int sectors, int sector_size,
247
int flag)
248
{
249
struct SectorbitmaP *m;
250
251
m= TSOB_FELD(struct SectorbitmaP,1);
252
if(m==NULL)
253
return(-1);
254
*o= m;
255
m->sectors= sectors;
256
m->sector_size= sector_size;
257
m->map= NULL;
258
m->map_size= sectors / 8 + 1;
259
260
m->map= calloc(m->map_size, 1);
261
if(m->map == NULL)
262
goto failure;
263
return(1);
264
failure:;
265
Sectorbitmap_destroy(o, 0);
266
return(-1);
267
}
268
269
270
int Sectorbitmap_destroy(struct SectorbitmaP **o, int flag)
271
{
272
if((*o) == NULL)
273
return(0);
274
if((*o)->map != NULL)
275
free((char *) (*o)->map);
276
free((char *) *o);
277
*o= NULL;
278
return(1);
279
}
280
281
282
int Sectorbitmap_from_file(struct SectorbitmaP **o, char *path, char *msg,
283
int *os_errno, int flag)
284
{
285
int ret, fd= -1, sectors, sector_size, i, todo, map_size, skip;
286
unsigned char *map;
287
unsigned char buf[1024];
288
289
*os_errno= 0;
290
if(msg != NULL)
291
msg[0]= 0;
292
fd= open(path, O_RDONLY);
293
if(fd == -1) {
294
*os_errno= errno;
295
if(msg != NULL) {
296
strcpy(msg, "Cannot open path ");
297
Text_shellsafe(path, msg+strlen(msg), 0);
298
}
299
return(0);
300
}
301
ret= read(fd, buf, 32);
302
if(ret < 32) {
303
wrong_filetype:;
304
if(ret == -1)
305
*os_errno= errno;
306
if(msg != NULL) {
307
strcpy(msg, "Not a sector bitmap file: ");
308
Text_shellsafe(path, msg+strlen(msg), 0);
309
}
310
ret= 0; goto ex;
311
}
312
if(strncmp((char *) buf, "xorriso sector bitmap v1 ", 32) == 0)
313
/* ok */;
314
else if(strncmp((char *) buf, "xorriso sector bitmap v2 ", 25) == 0) {
315
skip= -1;
316
sscanf(((char *) buf) + 25, "%d", &skip);
317
if(skip < 0)
318
{ret= 0; goto wrong_filetype;}
319
for(i= 0; i < skip; i+= sizeof(buf)) {
320
todo= sizeof(buf);
321
if(i + todo > skip)
322
todo= skip - i;
323
ret= read(fd, buf, todo);
324
if(ret < todo)
325
goto wrong_filetype;
326
}
327
} else
328
{ret= 0; goto wrong_filetype;}
329
ret= read(fd, buf, 8);
330
if(ret < 4)
331
goto wrong_filetype;
332
sectors= (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
333
sector_size= (buf[4] << 24) | (buf[5] << 16) | (buf[6] << 8) | buf[7];
334
if(sectors <= 0 || sector_size <= 0)
335
goto wrong_filetype;
336
ret= Sectorbitmap_new(o, sectors, sector_size, 0);
337
if(ret <= 0) {
338
if(msg != NULL)
339
sprintf(msg, "Cannot allocate bitmap memory for %d sectors", sectors);
340
ret= -1; goto ex;
341
}
342
map= (*o)->map;
343
map_size= (*o)->map_size;
344
for(i= 0; i < map_size; i+= sizeof(buf)) {
345
todo= sizeof(buf);
346
if(i + todo > map_size)
347
todo= map_size - i;
348
ret= read(fd, buf, todo);
349
if(ret != todo)
350
goto wrong_filetype;
351
memcpy(map + i, buf, todo);
352
}
353
ret= 1;
354
ex:;
355
if(fd != -1)
356
close(fd);
357
if(ret <= 0)
358
Sectorbitmap_destroy(o, 0);
359
return(ret);
360
}
361
362
363
int Sectorbitmap_to_file(struct SectorbitmaP *o, char *path, char *info,
364
char *msg, int *os_errno, int flag)
365
{
366
int ret, fd= -1, j, l;
367
unsigned char buf[40];
368
369
*os_errno= 0;
370
fd= open(path, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
371
if(fd == -1) {
372
*os_errno= errno;
373
if(msg != NULL) {
374
strcpy(msg, "Cannot open path ");
375
Text_shellsafe(path, msg+strlen(msg), 0);
376
}
377
return(0);
378
}
379
380
l= 0;
381
if(info != NULL)
382
l= strlen(info);
383
if(l > 999999) {
384
strcpy(msg, "Info string is longer than 999999 bytes");
385
return(0);
386
}
387
sprintf((char *) buf, "xorriso sector bitmap v2 %-6d\n", l);
388
389
ret= write(fd, buf, 32);
390
if(ret != 32) {
391
cannot_write:;
392
*os_errno= errno;
393
if(msg != NULL) {
394
strcpy(msg, "Cannot write to ");
395
Text_shellsafe(path, msg+strlen(msg), 0);
396
}
397
ret= 0; goto ex;
398
}
399
if(l > 0) {
400
ret= write(fd, info, l);
401
if(ret != l)
402
goto cannot_write;
403
}
404
405
for(j= 0; j < 4; j++) {
406
buf[j]= o->sectors >> (24 - j * 8);
407
buf[j+4]= o->sector_size >> (24 - j * 8);
408
}
409
ret= write(fd, buf, 8);
410
if(ret != 8)
411
goto cannot_write;
412
ret= write(fd, o->map, o->map_size);
413
if(ret != o->map_size)
414
goto cannot_write;
415
416
ret= 1;
417
ex:;
418
if(fd != -1)
419
close(fd);
420
return(ret);
421
}
422
423
424
/* @param flag bit0= sector bit value
425
*/
426
int Sectorbitmap_set(struct SectorbitmaP *o, int sector, int flag)
427
{
428
if(sector < 0 || sector >= o->sectors)
429
return(0);
430
if(flag & 1)
431
o->map[sector / 8]|= 1 << (sector % 8);
432
else
433
o->map[sector / 8]&= ~(1 << (sector % 8));
434
return(1);
435
}
436
437
438
/* @param flag bit0= sector bit value
439
*/
440
int Sectorbitmap_set_range(struct SectorbitmaP *o,
441
int start_sector, int sectors, int flag)
442
{
443
int start_i, end_i, i;
444
unsigned char value;
445
446
if(start_sector < 0 || start_sector + sectors > o->sectors || sectors < 1)
447
return(0);
448
if(flag & 1)
449
value= ~0;
450
else
451
value= 0;
452
start_i= start_sector / 8;
453
end_i= (start_sector + sectors - 1) / 8;
454
for(i= start_sector; i / 8 == start_i && i < start_sector + sectors; i++)
455
Sectorbitmap_set(o, i, flag & 1);
456
for(i= start_i + 1; i < end_i; i++)
457
o->map[i]= value;
458
if(end_i > start_i)
459
for(i= end_i * 8; i < start_sector + sectors; i++)
460
Sectorbitmap_set(o, i, flag & 1);
461
return(1);
462
}
463
464
465
int Sectorbitmap_is_set(struct SectorbitmaP *o, int sector, int flag)
466
{
467
if(sector < 0 || sector >= o->sectors)
468
return(0);
469
return(!! (o->map[sector / 8] & (1 << (sector % 8))));
470
}
471
472
473
int Sectorbitmap_bytes_are_set(struct SectorbitmaP *o,
474
off_t start_byte, off_t end_byte, int flag)
475
{
476
int end_sector, i;
477
478
end_sector= end_byte / o->sector_size;
479
for(i= start_byte / o->sector_size; i <= end_sector; i++)
480
if(!Sectorbitmap_is_set(o, i, 0))
481
return(0);
482
return(1);
483
}
484
485
486
int Sectorbitmap_get_layout(struct SectorbitmaP *o,
487
int *sectors, int *sector_size, int flag)
488
{
489
*sectors= o->sectors;
490
*sector_size= o->sector_size;
491
return(1);
492
}
493
494
495
int Sectorbitmap_copy(struct SectorbitmaP *from, struct SectorbitmaP *to,
496
int flag)
497
{
498
int i, run_start, run_value, start_sec, limit_sec, start_aligned;
499
int end_complete;
500
501
if(((off_t) from->sectors) * ((off_t) from->sector_size) >
502
((off_t) to->sectors) * ((off_t) to->sector_size))
503
return(-1);
504
if(from->sector_size == to->sector_size) {
505
for(i= 0; i < from->map_size; i++)
506
to->map[i]= from->map[i];
507
return(1);
508
}
509
run_start= 0;
510
run_value= Sectorbitmap_is_set(from, 0, 0);
511
for(i= 1; i <= from->sectors; i++) {
512
if(i < from->sectors)
513
if(Sectorbitmap_is_set(from, i, 0) == run_value)
514
continue;
515
start_sec= run_start * from->sector_size / to->sector_size;
516
start_aligned=
517
(start_sec * to->sector_size == run_start * from->sector_size);
518
limit_sec= i * from->sector_size / to->sector_size;
519
end_complete= (limit_sec * to->sector_size == i * from->sector_size);
520
if(run_value) {
521
if(!start_aligned)
522
start_sec++;
523
} else {
524
if(!end_complete)
525
limit_sec++;
526
}
527
if(start_sec < limit_sec)
528
Sectorbitmap_set_range(to, start_sec, limit_sec - 1 - start_sec,
529
!!run_value);
530
run_value= !run_value;
531
run_start= i;
532
}
533
return(1);
534
}
535
536
537
int Sectorbitmap_clone(struct SectorbitmaP *from, struct SectorbitmaP **clone,
538
int flag)
539
{
540
int ret;
541
542
ret= Sectorbitmap_new(clone, from->sectors, from->sector_size, 0);
543
if(ret <= 0)
544
return(ret);
545
ret= Sectorbitmap_copy(from, *clone, 0);
546
if(ret <= 0)
547
Sectorbitmap_destroy(clone, 0);
548
return(ret);
549
}
550
551
552
/* -------------------------- End SectorbitmaP ---------------------------- */
553
554
/* ---------------------------- CheckmediajoB ----------------------------- */
555
556
int Checkmediajob_new(struct CheckmediajoB **o, int flag)
557
{
558
struct CheckmediajoB *m;
559
560
m= TSOB_FELD(struct CheckmediajoB,1);
561
if(m==NULL)
562
return(-1);
563
*o= m;
564
m->use_dev= 0;
565
m->min_lba= -1;
566
m->max_lba= -1;
567
m->min_block_size= 0;
568
m->mode= 0;
569
m->start_time= time(NULL);
570
m->time_limit= 28800;
571
m->item_limit= 100000;
572
strcpy(m->abort_file_path, "/var/opt/xorriso/do_abort_check_media");
573
m->data_to_path[0]= 0;
574
m->data_to_fd= -1;
575
m->data_to_offset= 0;
576
m->data_to_limit= -1;
577
m->patch_lba0= 0;
578
m->patch_lba0_msc1= -1;
579
m->sector_map_path[0]= 0;
580
m->sector_map= NULL;
581
m->map_with_volid= 0;
582
m->retry= 0;
583
m->report_mode= 0;
584
strcpy(m->event_severity, "ALL");
585
m->slow_threshold_seq= 1.0;
586
m->untested_valid= 0;
587
return(1);
588
}
589
590
591
int Checkmediajob_destroy(struct CheckmediajoB **o, int flag)
592
{
593
if((*o) == NULL)
594
return(0);
595
if((*o)->data_to_fd != -1)
596
close((*o)->data_to_fd);
597
Sectorbitmap_destroy(&((*o)->sector_map), 0);
598
free((char *) *o);
599
*o= NULL;
600
return(1);
601
}
602
603
604
int Checkmediajob_copy(struct CheckmediajoB *from, struct CheckmediajoB *to,
605
int flag)
606
{
607
to->use_dev= from->use_dev;
608
to->min_lba= from->min_lba;
609
to->max_lba= from->max_lba;
610
to->min_block_size= from->min_block_size;
611
to->mode= from->mode;
612
to->time_limit= from->time_limit;
613
to->item_limit= from->item_limit;
614
strcpy(to->abort_file_path, from->abort_file_path);
615
strcpy(to->data_to_path, from->data_to_path);
616
/* not copied: data_to_fd */
617
to->data_to_offset= from->data_to_offset;
618
to->data_to_limit= from->data_to_limit;
619
to->patch_lba0= from->patch_lba0;
620
to->patch_lba0_msc1= from->patch_lba0_msc1;
621
strcpy(to->sector_map_path, from->sector_map_path);
622
/* not copied: sector_map */
623
to->map_with_volid= from->map_with_volid;
624
to->retry= from->retry;
625
to->report_mode= from->report_mode;
626
strcpy(to->event_severity, from->event_severity);
627
to->slow_threshold_seq= from->slow_threshold_seq;
628
to->untested_valid= from->untested_valid;
629
return(1);
630
}
631
632
633
/* -------------------------- End CheckmediajoB --------------------------- */
634
635
636
int Xorriso_check_media_setup_job(struct XorrisO *xorriso,
637
struct CheckmediajoB *job,
638
char **argv, int old_idx, int end_idx, int flag)
639
{
640
int ret, i, sev;
641
double num;
642
struct CheckmediajoB *default_job;
643
char sev_text[20];
644
645
if(xorriso->check_media_default != NULL)
646
Checkmediajob_copy(xorriso->check_media_default, job, 0);
647
for(i= old_idx; i < end_idx; i++) {
648
if(strncmp(argv[i], "abort_file=", 11) == 0) {
649
ret= Sfile_str(job->abort_file_path, argv[i] + 11, 0);
650
if(ret <= 0)
651
goto ex;
652
} else if(strncmp(argv[i], "bad_limit=", 10) == 0) {
653
if(strcmp(argv[i] + 10, "good") == 0)
654
xorriso->check_media_bad_limit= Xorriso_read_quality_gooD;
655
else if(strcmp(argv[i] + 10, "md5_match") == 0)
656
xorriso->check_media_bad_limit= Xorriso_read_quality_md5_matcH;
657
else if(strcmp(argv[i] + 10, "slow") == 0)
658
xorriso->check_media_bad_limit= Xorriso_read_quality_sloW;
659
else if(strcmp(argv[i] + 10, "partial") == 0)
660
xorriso->check_media_bad_limit= Xorriso_read_quality_partiaL;
661
else if(strcmp(argv[i] + 10, "valid") == 0)
662
xorriso->check_media_bad_limit= Xorriso_read_quality_valiD;
663
else if(strcmp(argv[i] + 10, "untested") == 0)
664
xorriso->check_media_bad_limit= Xorriso_read_quality_untesteD;
665
else if(strcmp(argv[i] + 10, "invalid") == 0)
666
xorriso->check_media_bad_limit= Xorriso_read_quality_invaliD;
667
else if(strcmp(argv[i] + 10, "tao_end") == 0)
668
xorriso->check_media_bad_limit= Xorriso_read_quality_tao_enD;
669
else if(strcmp(argv[i] + 10, "off_track") == 0)
670
xorriso->check_media_bad_limit= Xorriso_read_quality_off_tracK;
671
else if(strcmp(argv[i] + 10, "md5_mismatch") == 0)
672
xorriso->check_media_bad_limit= Xorriso_read_quality_md5_mismatcH;
673
else if(strcmp(argv[i] + 10, "unreadable") == 0)
674
xorriso->check_media_bad_limit= Xorriso_read_quality_unreadablE;
675
else
676
goto unknown_value;
677
} else if(strncmp(argv[i], "data_to=", 8) == 0) {
678
ret= Sfile_str(job->data_to_path, argv[i] + 8, 0);
679
if(ret <= 0)
680
goto ex;
681
} else if(strncmp(argv[i], "chunk_size=", 11) == 0) {
682
num= Scanf_io_size(argv[i] + 11, 1);
683
if(num >= 2048 || num == 0)
684
job->min_block_size= num / 2048;
685
else
686
goto unknown_value;
687
} else if(strncmp(argv[i], "event=", 6) == 0) {
688
strncpy(sev_text, argv[i] + 6, 19);
689
sev_text[19]= 0;
690
ret= Xorriso__text_to_sev(sev_text, &sev, 0);
691
if(ret <= 0) {
692
strcpy(xorriso->info_text, "-check_media event=");
693
Text_shellsafe(sev_text, xorriso->info_text, 1);
694
strcat(xorriso->info_text, " : Not a known severity name");
695
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
696
goto ex;
697
}
698
strcpy(job->event_severity, sev_text);
699
} else if(strncmp(argv[i], "map_with_volid=", 15) == 0) {
700
if(strcmp(argv[i] + 15, "on") == 0)
701
job->map_with_volid= 1;
702
else if(strcmp(argv[i] + 15, "off") == 0)
703
job->map_with_volid= 0;
704
else
705
goto unknown_value;
706
} else if(strncmp(argv[i], "max_lba=", 8) == 0 ||
707
strncmp(argv[i], "min_lba=", 8) == 0) {
708
num= -1;
709
sscanf(argv[i] + 8, "%lf", &num);
710
if(num > 0x7fffffff || num < 0)
711
num= -1;
712
if(strncmp(argv[i], "max_lba=", 8) == 0)
713
job->max_lba= num;
714
else
715
job->min_lba= num;
716
} else if(strncmp(argv[i], "patch_lba0=", 11) == 0) {
717
job->patch_lba0_msc1= -1;
718
if(strcmp(argv[i] + 11, "on") == 0)
719
job->patch_lba0= 1;
720
else if(strcmp(argv[i] + 11, "off") == 0)
721
job->patch_lba0= 0;
722
else if(strcmp(argv[i] + 11, "force") == 0)
723
job->patch_lba0= 2;
724
else if(argv[i][11] >= '1' && argv[i][11] <= '9') {
725
num= -1;
726
sscanf(argv[i] + 11, "%lf", &num);
727
if(num > 0x7fffffff || num < 0)
728
goto unknown_value;
729
job->patch_lba0_msc1= num;
730
job->patch_lba0= (num >= 32) + (strstr(argv[i] + 11, ":force") != NULL);
731
} else
732
goto unknown_value;
733
} else if(strncmp(argv[i], "report=", 7) == 0) {
734
if(strcmp(argv[i] + 7, "blocks") == 0)
735
job->report_mode= 0;
736
else if(strcmp(argv[i] + 7, "files") == 0)
737
job->report_mode= 1;
738
else if(strcmp(argv[i] + 7, "blocks_files") == 0)
739
job->report_mode= 2;
740
else
741
goto unknown_value;
742
} else if(strcmp(argv[i], "reset=now") == 0) {
743
ret= Checkmediajob_new(&default_job, 0);
744
if(ret <= 0) {
745
sprintf(xorriso->info_text,
746
"-check_media: Cannot reset options due to lack of resources");
747
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
748
ret= -1; goto ex;
749
}
750
Checkmediajob_copy(default_job, job, 0);
751
Checkmediajob_destroy(&default_job, 0);
752
xorriso->check_media_bad_limit= Xorriso_read_quality_invaliD;
753
} else if(strncmp(argv[i], "retry=", 6) == 0) {
754
if(strcmp(argv[i] + 6, "on") == 0)
755
job->retry= 1;
756
else if(strcmp(argv[i] + 6, "off") == 0)
757
job->retry= -1;
758
else if(strcmp(argv[i] + 6, "default") == 0)
759
job->retry= 0;
760
else
761
goto unknown_value;
762
} else if(strncmp(argv[i], "sector_map=", 11) == 0) {
763
ret= Sfile_str(job->sector_map_path, argv[i] + 11, 0);
764
if(ret <= 0)
765
goto ex;
766
} else if(strncmp(argv[i], "slow_limit=", 11) == 0) {
767
sscanf(argv[i] + 11, "%lf", &(job->slow_threshold_seq));
768
} else if(strncmp(argv[i], "time_limit=", 11) == 0 ||
769
strncmp(argv[i], "item_limit=", 11) == 0 ) {
770
num= -1;
771
sscanf(argv[i] + 11, "%lf", &num);
772
if(num > 0x7fffffff || num < 0)
773
num= -1;
774
if(strncmp(argv[i], "time_limit=", 11) == 0)
775
job->time_limit= num;
776
else
777
job->item_limit= num;
778
779
#ifdef NIX
780
} else if(strncmp(argv[i], "untested=", 9) == 0) {
781
if(strcmp(argv[i] + 9, "damaged") == 0)
782
job->untested_valid= 0;
783
if(strcmp(argv[i] + 9, "undamaged") == 0 ||
784
strcmp(argv[i] + 9, "ok") == 0)
785
job->untested_valid= 1;
786
else
787
goto unknown_value;
788
#endif
789
790
} else if(strncmp(argv[i], "use=", 4) == 0) {
791
if(strcmp(argv[i] + 4, "outdev") == 0)
792
job->use_dev= 1;
793
else if(strcmp(argv[i] + 4, "indev") == 0)
794
job->use_dev= 0;
795
else if(strcmp(argv[i] + 4, "sector_map") == 0)
796
job->use_dev= 2;
797
else
798
goto unknown_value;
799
} else if(strncmp(argv[i], "what=", 5) == 0) {
800
if(strcmp(argv[i]+5, "tracks") == 0)
801
job->mode= 0;
802
else if(strcmp(argv[i]+5, "disc")== 0)
803
job->mode= 1;
804
else {
805
unknown_value:;
806
sprintf(xorriso->info_text,
807
"-check_media: Unknown value with option %s", argv[i]);
808
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
809
ret= 0; goto ex;
810
}
811
} else {
812
sprintf(xorriso->info_text, "-check_media: Unknown option '%s'", argv[i]);
813
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
814
ret= 0; goto ex;
815
}
816
}
817
ret= 1;
818
ex:;
819
return(ret);
820
}
821
822
823
/* @param report Buffer of at least 10*SfileadrL
824
@param flag bit0= only report non-default settings
825
@return <=0 error , 1 ok , 2 with bit0: every option is on default setting
826
*/
827
int Xorriso_check_media_list_job(struct XorrisO *xorriso,
828
struct CheckmediajoB *job,
829
char *report, int flag)
830
{
831
int all, ret;
832
char default_report[161], quality_name[80];
833
struct CheckmediajoB *dflt= NULL;
834
835
all= !(flag&1);
836
report[0]= 0;
837
ret= Checkmediajob_new(&dflt, 0);
838
if(ret <= 0)
839
return(-1);
840
sprintf(report, "-check_media_defaults");
841
if(!all)
842
strcat(report, " reset=now");
843
if(all || job->use_dev != dflt->use_dev)
844
sprintf(report + strlen(report), " use=%s",
845
job->use_dev == 1 ? "outdev" :
846
job->use_dev == 2 ? "sector_map" : "indev");
847
if(all || job->mode != dflt->mode)
848
sprintf(report + strlen(report), " what=%s",
849
job->mode == 1 ? "disc" : "tracks");
850
if(all || job->min_lba != dflt->min_lba)
851
sprintf(report + strlen(report), " min_lba=%d", job->min_lba);
852
if(all || job->max_lba != dflt->max_lba)
853
sprintf(report + strlen(report), " max_lba=%d", job->max_lba);
854
if(all || job->retry != dflt->retry)
855
sprintf(report + strlen(report), " retry=%s",
856
job->retry == 1 ? "on" : job->retry == -1 ? "off" : "default");
857
if(all || job->time_limit != dflt->time_limit)
858
sprintf(report + strlen(report), " time_limit=%d", job->time_limit);
859
if(all || job->item_limit != dflt->item_limit)
860
sprintf(report + strlen(report), " item_limit=%d", job->item_limit);
861
if(all || strcmp(job->abort_file_path, dflt->abort_file_path)) {
862
strcat(report, " abort_file=");
863
Text_shellsafe(job->abort_file_path, report + strlen(report), 0);
864
}
865
if(strlen(report) > 4 * SfileadrL)
866
{ret= 0; goto ex;}
867
if(all || strcmp(job->data_to_path, dflt->data_to_path)) {
868
strcat(report, " data_to=");
869
Text_shellsafe(job->data_to_path, report + strlen(report), 0);
870
}
871
if(strlen(report) > 4 * SfileadrL)
872
{ret= 0; goto ex;}
873
if(all || strcmp(job->sector_map_path, dflt->sector_map_path)) {
874
strcat(report, " sector_map=");
875
Text_shellsafe(job->sector_map_path, report + strlen(report), 0);
876
}
877
if(all || job->map_with_volid != dflt->map_with_volid)
878
sprintf(report + strlen(report), " map_with_volid=%s",
879
job->map_with_volid == 1 ? "on" : "off");
880
if(all || job->patch_lba0 != dflt->patch_lba0) {
881
sprintf(report + strlen(report), " patch_lba0=");
882
if(job->patch_lba0 == 0)
883
sprintf(report + strlen(report), "off");
884
else if(job->patch_lba0_msc1 >= 0)
885
sprintf(report + strlen(report), "%d%s",
886
job->patch_lba0_msc1, job->patch_lba0 == 2 ? ":force" : "");
887
else
888
sprintf(report + strlen(report), "%s",
889
job->patch_lba0 == 2 ? "force" : "on");
890
}
891
if(all || job->report_mode != dflt->report_mode)
892
sprintf(report + strlen(report), " report=%s",
893
job->report_mode == 0 ? "blocks" :
894
job->report_mode == 1 ? "files" : "blocks_files");
895
if(all || job->slow_threshold_seq != dflt->slow_threshold_seq)
896
sprintf(report + strlen(report), " slow_limit=%f", job->slow_threshold_seq);
897
if(all || xorriso->check_media_bad_limit != Xorriso_read_quality_invaliD)
898
sprintf(report + strlen(report), " bad_limit=%s",
899
Spotlist__quality_name(xorriso->check_media_bad_limit, quality_name,
900
Xorriso_read_quality_invaliD, 0) + 2);
901
if(all || job->min_block_size != dflt->min_block_size)
902
sprintf(report + strlen(report), " chunk_size=%ds", job->min_block_size);
903
if(all || strcmp(job->event_severity, "ALL") != 0)
904
sprintf(report + strlen(report), " event=%s", job->event_severity);
905
if(strlen(report) > 4 * SfileadrL)
906
{ret= 0; goto ex;}
907
ret= 1;
908
ex:;
909
strcat(report, " ");
910
strcat(report, xorriso->list_delimiter);
911
Checkmediajob_destroy(&dflt, 0);
912
sprintf(default_report, "-check_media_defaults reset=now %s",
913
xorriso->list_delimiter);
914
if(ret > 0 && strcmp(report, default_report) == 0)
915
return(2);
916
return(ret);
917
}
918
919
920
int Xorriso_sectormap_to_spotlist(struct XorrisO *xorriso,
921
struct CheckmediajoB *job,
922
struct SpotlisT **spotlist,
923
int flag)
924
{
925
struct SectorbitmaP *map;
926
int ret, i, sectors, sector_size, value, old_value= -1, old_start= -1;
927
928
map= job->sector_map;
929
if(map == NULL)
930
return(-1);
931
ret= Spotlist_new(spotlist, 0);
932
if(ret <= 0)
933
{ret= -1; goto ex;}
934
Sectorbitmap_get_layout(map, §ors, §or_size, 0);
935
sector_size/= 2048;
936
if(job->max_lba >= 0)
937
sectors= (job->max_lba + 1) / sector_size;
938
i= 0;
939
if(job->min_lba >= 0)
940
i= job->min_lba / sector_size;
941
for(; i < sectors; i++) {
942
value= Sectorbitmap_is_set(map, i, 0);
943
if(value == old_value)
944
continue;
945
if(old_value >= 0) {
946
ret= Spotlist_add_item(*spotlist, old_start, i * sector_size - old_start,
947
(old_value ? Xorriso_read_quality_valiD :
948
Xorriso_read_quality_invaliD), 0);
949
if(ret <= 0)
950
goto ex;
951
if(job->item_limit > 0 &&
952
Spotlist_count(*spotlist, 0) + 1 >= job->item_limit) {
953
sprintf(xorriso->info_text, "-check_media: Reached item_limit=%d",
954
job->item_limit);
955
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
956
if(sectors - i > 1) {
957
ret= Spotlist_add_item(*spotlist, i * sector_size,
958
(sectors - i - 1) * sector_size,
959
Xorriso_read_quality_untesteD, 0);
960
if(ret <= 0)
961
goto ex;
962
}
963
ret= 2; goto ex;
964
}
965
}
966
old_value= value;
967
old_start= i * sector_size;
968
}
969
if(old_value >= 0) {
970
ret= Spotlist_add_item(*spotlist, old_start, i * sector_size - old_start,
971
(old_value ? Xorriso_read_quality_valiD :
972
Xorriso_read_quality_invaliD), 0);
973
if(ret <= 0)
974
goto ex;
975
}
976
ret= 1;
977
ex:;
978
if(ret <= 0)
979
Spotlist_destroy(spotlist, 0);
980
return(ret);
981
}
982
983
984
/* @param flag bit0= mark untested areas as valid
985
*/
986
int Xorriso_spotlist_to_sectormap(struct XorrisO *xorriso,
987
struct SpotlisT *spotlist,
988
int read_chunk,
989
struct SectorbitmaP **map,
990
int flag)
991
{
992
struct SectorbitmaP *m;
993
int map_sectors= -1, map_sector_size= -1, valid;
994
int list_sectors, list_blocks, sector_size, sector_blocks;
995
int replace_map= 0, count, i, lba, blocks, quality, ret, pass;
996
997
sector_size= Spotlist_sector_size(spotlist, read_chunk, 0);
998
sector_blocks= sector_size / 2048;
999
if(*map != NULL)
1000
Sectorbitmap_get_layout(*map, &map_sectors, &map_sector_size, 0);
1001
1002
count= Spotlist_count(spotlist, 0);
1003
list_blocks= Spotlist_block_count(spotlist, 0);
1004
1005
/* >>> ??? insist in list_blocks % sector_blocks == 0 */
1006
1007
list_sectors= list_blocks / sector_blocks;
1008
if(list_sectors * sector_blocks < list_blocks)
1009
list_sectors++;
1010
if(*map != NULL && map_sectors * (map_sector_size / 2048) >= list_blocks &&
1011
map_sector_size == sector_size)
1012
m= *map;
1013
else {
1014
if(*map != NULL) {
1015
if(((off_t) (*map)->sectors) * ((off_t) (*map)->sector_size) >
1016
((off_t) list_sectors) * ((off_t) sector_size))
1017
list_sectors= (((off_t) (*map)->sectors) *
1018
((off_t) (*map)->sector_size)) / ((off_t) sector_size)
1019
+ 1;
1020
}
1021
ret= Sectorbitmap_new(&m, list_sectors, sector_size, 0);
1022
if(ret <= 0)
1023
return(-1);
1024
replace_map= 1;
1025
if(*map != NULL) {
1026
ret= Sectorbitmap_copy(*map, m, 0);
1027
if(ret <= 0) {
1028
Sectorbitmap_destroy(&m, 0);
1029
return(0);
1030
}
1031
}
1032
}
1033
1034
count= Spotlist_count(spotlist, 0);
1035
/* first set good bits, then eventually override by bad bits */
1036
for(pass= 0; pass < 2; pass++) {
1037
for(i= 0; i < count; i++) {
1038
ret= Spotlist_get_item(spotlist, i, &lba, &blocks, &quality, 0);
1039
if(ret <= 0)
1040
continue;
1041
valid= quality > xorriso->check_media_bad_limit;
1042
if(quality == Xorriso_read_quality_untesteD && (flag & 1))
1043
valid= 1;
1044
else if(pass == 0 && !valid)
1045
continue;
1046
else if(pass == 1 && valid)
1047
continue;
1048
Sectorbitmap_set_range(m, lba / sector_blocks, blocks / sector_blocks,
1049
valid);
1050
}
1051
}
1052
if(replace_map) {
1053
Sectorbitmap_destroy(map, 0);
1054
*map= m;
1055
}
1056
return(1);
1057
}
1058
1059
1060
int Xorriso_open_job_data_to(struct XorrisO *xorriso,
1061
struct CheckmediajoB *job, int flag)
1062
{
1063
char sfe[5*SfileadrL];
1064
1065
if(job->data_to_path[0] == 0)
1066
return(2);
1067
job->data_to_fd= open(job->data_to_path, O_RDWR | O_CREAT,
1068
S_IRUSR | S_IWUSR);
1069
if(job->data_to_fd == -1) {
1070
sprintf(xorriso->info_text, "Cannot open path %s",
1071
Text_shellsafe(job->data_to_path, sfe, 0));
1072
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
1073
return(0);
1074
}
1075
return(1);
1076
}
1077
1078
1079
int Xorriso_update_in_sector_map(struct XorrisO *xorriso,
1080
struct SpotlisT *spotlist, int read_chunk,
1081
struct CheckmediajoB *job, int flag)
1082
{
1083
int sectors, sector_size, sector_blocks, ret;
1084
struct SectorbitmaP *map;
1085
1086
Sectorbitmap_destroy(&(xorriso->in_sector_map), 0);
1087
if(job->use_dev == 1)
1088
return(1);
1089
map= job->sector_map;
1090
sectors= Spotlist_block_count(spotlist, 0);
1091
if(sectors <= 0)
1092
return(0);
1093
sector_size= Spotlist_sector_size(spotlist, read_chunk, 0);
1094
sector_blocks= sector_size / 2048;
1095
if(sector_blocks > 1)
1096
sectors= sectors / sector_blocks + !!(sectors % sector_blocks);
1097
ret= Sectorbitmap_new(&(xorriso->in_sector_map), sectors, sector_size, 0);
1098
if(ret <= 0)
1099
return(ret);
1100
if(map != NULL)
1101
Sectorbitmap_copy(map, xorriso->in_sector_map, 0);
1102
ret= Xorriso_spotlist_to_sectormap(xorriso, spotlist, read_chunk,
1103
&(xorriso->in_sector_map), 1);
1104
return(ret);
1105
}
1106
Loggerhead is a web-based interface for Breezy
Version: 2.0.1