Changeset 128 in MondoRescue for branches/2.05/mondo/mondo/common/libmondo-string.c
- Timestamp:
- Nov 19, 2005, 2:27:41 AM (18 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/2.05/mondo/mondo/common/libmondo-string.c
r30 r128 1 1 /* libmondo-string.c 2 $Id : libmondo-string.c,v 1.3 2004/06/21 20:20:36 hugo Exp$2 $Id$ 3 3 4 4 - string manipulation … … 71 71 72 72 /*@unused@*/ 73 //static char cvsid[] = "$Id : libmondo-string.c,v 1.3 2004/06/21 20:20:36 hugo Exp$";73 //static char cvsid[] = "$Id$"; 74 74 75 75 extern int g_current_media_number; … … 89 89 * @note If @p drive ends in a digit, then 'p' (on Linux) or 's' (on *BSD) is added before @p partno. 90 90 */ 91 char * 92 build_partition_name (char *partition, const char *drive, int partno) 93 { 94 char *p, *c; 95 96 assert(partition!=NULL); 97 assert_string_is_neither_NULL_nor_zerolength(drive); 98 assert(partno>=0); 99 100 p = strcpy(partition, drive); 101 /* is this a devfs device path? */ 102 c = strrchr (partition, '/'); 103 if (c && strncmp (c, "/disc", 5) == 0) { 104 /* yup it's devfs, return the "part" path */ 105 strcpy (c + 1, "part"); 106 p = c + 5; 107 } else { 108 p += strlen (p); 109 if (isdigit (p[-1])) { 110 *p++ = 91 char *build_partition_name(char *partition, const char *drive, int partno) 92 { 93 char *p, *c; 94 95 assert(partition != NULL); 96 assert_string_is_neither_NULL_nor_zerolength(drive); 97 assert(partno >= 0); 98 99 p = strcpy(partition, drive); 100 /* is this a devfs device path? */ 101 c = strrchr(partition, '/'); 102 if (c && strncmp(c, "/disc", 5) == 0) { 103 /* yup it's devfs, return the "part" path */ 104 strcpy(c + 1, "part"); 105 p = c + 5; 106 } else { 107 p += strlen(p); 108 if (isdigit(p[-1])) { 109 *p++ = 111 110 #ifdef BSD 112 111 's'; 113 112 #else 114 113 'p'; 115 114 #endif 116 117 118 sprintf(p, "%d", partno);119 115 } 116 } 117 sprintf(p, "%d", partno); 118 return (partition); 120 119 } 121 120 … … 137 136 * @param width The width of the final result. 138 137 */ 139 void center_string (char *in_out, int width) 140 { 141 char scratch[MAX_STR_LEN]; 142 char *p; 143 int i; /* purpose */ 144 int len; /* purpose */ 145 int mid; /* purpose */ 146 int x; /* purpose */ 147 148 assert(in_out!=NULL); 149 assert(width>2); 150 151 if (strlen (in_out) == 0) 152 { 153 return; 154 } 155 for (p = in_out; *p == ' '; p++); 156 strcpy (scratch, p); 157 len = (int) strlen (scratch); 158 mid = width / 2; 159 x = mid - len / 2; 160 for (i = 0; i < x; i++) 161 { 162 in_out[i] = ' '; 163 } 164 in_out[i] = '\0'; 165 strcat (in_out, scratch); 166 } 167 168 169 170 171 inline void turn_wildcard_chars_into_literal_chars(char*sout, char*sin) 138 void center_string(char *in_out, int width) 139 { 140 char scratch[MAX_STR_LEN]; 141 char *p; 142 int i; /* purpose */ 143 int len; /* purpose */ 144 int mid; /* purpose */ 145 int x; /* purpose */ 146 147 assert(in_out != NULL); 148 assert(width > 2); 149 150 if (strlen(in_out) == 0) { 151 return; 152 } 153 for (p = in_out; *p == ' '; p++); 154 strcpy(scratch, p); 155 len = (int) strlen(scratch); 156 mid = width / 2; 157 x = mid - len / 2; 158 for (i = 0; i < x; i++) { 159 in_out[i] = ' '; 160 } 161 in_out[i] = '\0'; 162 strcat(in_out, scratch); 163 } 164 165 166 167 168 inline void turn_wildcard_chars_into_literal_chars(char *sout, char *sin) 172 169 { 173 170 char *p, *q; 174 175 for(p=sin, q=sout; *p!='\0'; *(q++) = *(p++) ) 176 { 177 if (strchr("[]*?", *p)) { *(q++) = '\\'; } 178 } 179 *q = *p; // for the final '\0' 171 172 for (p = sin, q = sout; *p != '\0'; *(q++) = *(p++)) { 173 if (strchr("[]*?", *p)) { 174 *(q++) = '\\'; 175 } 176 } 177 *q = *p; // for the final '\0' 180 178 } 181 179 … … 188 186 * @note The returned string points to static storage that will be overwritten with each call. 189 187 */ 190 char* commarize(char*input) 191 { 192 char pos_w_commas[MAX_STR_LEN]; 193 static char output[MAX_STR_LEN]; 194 char tmp[MAX_STR_LEN]; 195 int j; 196 197 assert(input!=NULL); 198 199 strcpy(tmp, input); 200 if (strlen(tmp) > 6) 201 { 202 strcpy(pos_w_commas, tmp); 203 j = (int) strlen(pos_w_commas); 204 tmp[j-6] = ','; 205 strcpy(tmp+j-5, pos_w_commas+j-6); 188 char *commarize(char *input) 189 { 190 char pos_w_commas[MAX_STR_LEN]; 191 static char output[MAX_STR_LEN]; 192 char tmp[MAX_STR_LEN]; 193 int j; 194 195 assert(input != NULL); 196 197 strcpy(tmp, input); 198 if (strlen(tmp) > 6) { 199 strcpy(pos_w_commas, tmp); 200 j = (int) strlen(pos_w_commas); 201 tmp[j - 6] = ','; 202 strcpy(tmp + j - 5, pos_w_commas + j - 6); 206 203 // tmp[j-2] = ','; 207 204 // strcpy(tmp+j-1, pos_w_commas+j-3); 208 strcpy(pos_w_commas, tmp); 209 } 210 if (strlen(tmp) > 3) 211 { 212 j = (int) strlen(tmp); 213 strcpy(pos_w_commas, tmp); 214 pos_w_commas[j-3] = ','; 215 strcpy(pos_w_commas+j-2, tmp+j-3); 216 } 217 else 218 { 219 strcpy(pos_w_commas, tmp); 220 } 221 strcpy(output, pos_w_commas); 222 return(output); 205 strcpy(pos_w_commas, tmp); 206 } 207 if (strlen(tmp) > 3) { 208 j = (int) strlen(tmp); 209 strcpy(pos_w_commas, tmp); 210 pos_w_commas[j - 3] = ','; 211 strcpy(pos_w_commas + j - 2, tmp + j - 3); 212 } else { 213 strcpy(pos_w_commas, tmp); 214 } 215 strcpy(output, pos_w_commas); 216 return (output); 223 217 } 224 218 … … 241 235 * @note The returned string points to static storage and will be overwritten with each call. 242 236 */ 243 char * 244 disklist_entry_to_string (struct list_of_disks *disklist, int lino) 245 { 246 247 /*@ buffers ***********************************************************/ 248 static char output[MAX_STR_LEN]; 249 250 assert(disklist!=NULL); 251 252 sprintf (output, "%-24s %8d", disklist->el[lino].device, 253 disklist->el[lino].index); 254 return (output); 237 char *disklist_entry_to_string(struct list_of_disks *disklist, int lino) 238 { 239 240 /*@ buffers ********************************************************** */ 241 static char output[MAX_STR_LEN]; 242 243 assert(disklist != NULL); 244 245 sprintf(output, "%-24s %8d", disklist->el[lino].device, 246 disklist->el[lino].index); 247 return (output); 255 248 } 256 249 … … 266 259 * @return The size in megabytes. 267 260 */ 268 long 269 friendly_sizestr_to_sizelong (char *incoming) 270 { 271 long outval; 272 int i; 273 char *tmp; 274 char ch; 275 276 assert_string_is_neither_NULL_nor_zerolength(incoming); 277 278 malloc_string(tmp); 279 if (!incoming[0]) { free(tmp); return(0); } 280 if (strchr(incoming, '.')) 281 { fatal_error("Please use integers only. No decimal points."); } 282 strcpy (tmp, incoming); 283 i = (int) strlen(tmp); 284 if (tmp[i-1]=='B' || tmp[i-1]=='b') { tmp[i-1]='\0'; } 285 for (i = 0; i < (int) strlen (tmp) && isdigit (tmp[i]); i++); 286 ch = tmp[i]; 287 tmp[i] = '\0'; 288 outval = atol (tmp); 289 if (ch == 'g' || ch == 'G') 290 { 291 outval = outval * 1024; 292 } 293 else if (ch == 'k' || ch == 'K') 294 { 295 outval = outval / 1024; 296 } 297 else if (ch == 't' || ch == 'T') // terabyte 298 { 299 outval *= 1048576; 300 } 301 else if (ch == 'Y' || ch == 'y') // yottabyte - the biggest measure in the info file 302 { 303 log_it ("Oh my gosh. You actually think a YOTTABYTE will get you anywhere? What're you going to do with 1,208,925,819,614,629,174,706,176 bytes of data?!?!"); 304 popup_and_OK ("That sizespec is more than 1,208,925,819,614,629,174,706,176 bytes. You have a shocking amount of data. Please send a screenshot to the list :-)"); 305 fatal_error ("Integer overflow."); 306 } 307 else if (ch != 'm' && ch != 'M') 308 { 309 sprintf(tmp, "Re: parameter '%s' - bad multiplier ('%c')", incoming, ch); 310 fatal_error(tmp); 311 } 312 paranoid_free(tmp); 313 return (outval); 261 long friendly_sizestr_to_sizelong(char *incoming) 262 { 263 long outval; 264 int i; 265 char *tmp; 266 char ch; 267 268 assert_string_is_neither_NULL_nor_zerolength(incoming); 269 270 malloc_string(tmp); 271 if (!incoming[0]) { 272 free(tmp); 273 return (0); 274 } 275 if (strchr(incoming, '.')) { 276 fatal_error("Please use integers only. No decimal points."); 277 } 278 strcpy(tmp, incoming); 279 i = (int) strlen(tmp); 280 if (tmp[i - 1] == 'B' || tmp[i - 1] == 'b') { 281 tmp[i - 1] = '\0'; 282 } 283 for (i = 0; i < (int) strlen(tmp) && isdigit(tmp[i]); i++); 284 ch = tmp[i]; 285 tmp[i] = '\0'; 286 outval = atol(tmp); 287 if (ch == 'g' || ch == 'G') { 288 outval = outval * 1024; 289 } else if (ch == 'k' || ch == 'K') { 290 outval = outval / 1024; 291 } else if (ch == 't' || ch == 'T') // terabyte 292 { 293 outval *= 1048576; 294 } else if (ch == 'Y' || ch == 'y') // yottabyte - the biggest measure in the info file 295 { 296 log_it 297 ("Oh my gosh. You actually think a YOTTABYTE will get you anywhere? What're you going to do with 1,208,925,819,614,629,174,706,176 bytes of data?!?!"); 298 popup_and_OK 299 ("That sizespec is more than 1,208,925,819,614,629,174,706,176 bytes. You have a shocking amount of data. Please send a screenshot to the list :-)"); 300 fatal_error("Integer overflow."); 301 } else if (ch != 'm' && ch != 'M') { 302 sprintf(tmp, "Re: parameter '%s' - bad multiplier ('%c')", 303 incoming, ch); 304 fatal_error(tmp); 305 } 306 paranoid_free(tmp); 307 return (outval); 314 308 } 315 309 … … 324 318 * @bug Why does center_string() modify its argument but leftpad_string() returns a modified copy? 325 319 */ 326 char * 327 leftpad_string (char *incoming, int width) 328 { 329 /*@ buffers ******************************************************/ 330 static char output[MAX_STR_LEN]; 331 332 /*@ ints *********************************************************/ 333 int i; 334 335 /*@ end vars *****************************************************/ 336 assert(incoming!=NULL); 337 assert(width>2); 338 339 strcpy (output, incoming); 340 for (i = (int) strlen (output); i < width; i++) 341 { 342 output[i] = ' '; 343 } 344 output[i] = '\0'; 345 return (output); 320 char *leftpad_string(char *incoming, int width) 321 { 322 /*@ buffers ***************************************************** */ 323 static char output[MAX_STR_LEN]; 324 325 /*@ ints ******************************************************** */ 326 int i; 327 328 /*@ end vars **************************************************** */ 329 assert(incoming != NULL); 330 assert(width > 2); 331 332 strcpy(output, incoming); 333 for (i = (int) strlen(output); i < width; i++) { 334 output[i] = ' '; 335 } 336 output[i] = '\0'; 337 return (output); 346 338 } 347 339 … … 355 347 * @note The returned string points to static storage that will be overwritten with each call. 356 348 */ 357 char * 358 marker_to_string (int marker) 359 { 360 /*@ buffer *******************************************************/ 361 static char outstr[MAX_STR_LEN]; 362 363 364 /*@ end vars ****************************************************/ 365 366 switch (marker) 367 { 368 case BLK_START_OF_BACKUP: 369 strcpy (outstr, "BLK_START_OF_BACKUP"); 370 break; 371 case BLK_START_OF_TAPE: 372 strcpy (outstr, "BLK_START_OF_TAPE"); 373 break; 374 case BLK_START_AN_AFIO_OR_SLICE: 375 strcpy (outstr, "BLK_START_AN_AFIO_OR_SLICE"); 376 break; 377 case BLK_STOP_AN_AFIO_OR_SLICE: 378 strcpy (outstr, "BLK_STOP_AN_AFIO_OR_SLICE"); 379 break; 380 case BLK_START_AFIOBALLS: 381 strcpy (outstr, "BLK_START_AFIOBALLS"); 382 break; 383 case BLK_STOP_AFIOBALLS: 384 strcpy (outstr, "BLK_STOP_AFIOBALLS"); 385 break; 386 case BLK_STOP_BIGGIEFILES: 387 strcpy (outstr, "BLK_STOP_BIGGIEFILES"); 388 break; 389 case BLK_START_A_NORMBIGGIE: 390 strcpy (outstr, "BLK_START_A_NORMBIGGIE"); 391 break; 392 case BLK_START_A_PIHBIGGIE: 393 strcpy (outstr, "BLK_START_A_PIHBIGGIE"); 394 break; 395 case BLK_START_EXTENDED_ATTRIBUTES: 396 strcpy (outstr, "BLK_START_EXTENDED_ATTRIBUTES"); 397 break; 398 case BLK_STOP_EXTENDED_ATTRIBUTES: 399 strcpy (outstr, "BLK_STOP_EXTENDED_ATTRIBUTES"); 400 break; 401 case BLK_START_EXAT_FILE: 402 strcpy (outstr, "BLK_START_EXAT_FILE"); 403 break; 404 case BLK_STOP_EXAT_FILE: 405 strcpy (outstr, "BLK_STOP_EXAT_FILE"); 406 break; 407 case BLK_START_BIGGIEFILES: 408 strcpy (outstr, "BLK_START_BIGGIEFILES"); 409 break; 410 case BLK_STOP_A_BIGGIE: 411 strcpy (outstr, "BLK_STOP_A_BIGGIE"); 412 break; 413 case BLK_END_OF_TAPE: 414 strcpy (outstr, "BLK_END_OF_TAPE"); 415 break; 416 case BLK_END_OF_BACKUP: 417 strcpy (outstr, "BLK_END_OF_BACKUP"); 418 break; 419 case BLK_ABORTED_BACKUP: 420 strcpy (outstr, "BLK_ABORTED_BACKUP"); 421 break; 422 case BLK_START_FILE: 423 strcpy (outstr, "BLK_START_FILE"); 424 break; 425 case BLK_STOP_FILE: 426 strcpy (outstr, "BLK_STOP_FILE"); 427 break; 428 default: 429 sprintf (outstr, "BLK_UNKNOWN (%d)", marker); 430 break; 431 } 432 return (outstr); 349 char *marker_to_string(int marker) 350 { 351 /*@ buffer ****************************************************** */ 352 static char outstr[MAX_STR_LEN]; 353 354 355 /*@ end vars *************************************************** */ 356 357 switch (marker) { 358 case BLK_START_OF_BACKUP: 359 strcpy(outstr, "BLK_START_OF_BACKUP"); 360 break; 361 case BLK_START_OF_TAPE: 362 strcpy(outstr, "BLK_START_OF_TAPE"); 363 break; 364 case BLK_START_AN_AFIO_OR_SLICE: 365 strcpy(outstr, "BLK_START_AN_AFIO_OR_SLICE"); 366 break; 367 case BLK_STOP_AN_AFIO_OR_SLICE: 368 strcpy(outstr, "BLK_STOP_AN_AFIO_OR_SLICE"); 369 break; 370 case BLK_START_AFIOBALLS: 371 strcpy(outstr, "BLK_START_AFIOBALLS"); 372 break; 373 case BLK_STOP_AFIOBALLS: 374 strcpy(outstr, "BLK_STOP_AFIOBALLS"); 375 break; 376 case BLK_STOP_BIGGIEFILES: 377 strcpy(outstr, "BLK_STOP_BIGGIEFILES"); 378 break; 379 case BLK_START_A_NORMBIGGIE: 380 strcpy(outstr, "BLK_START_A_NORMBIGGIE"); 381 break; 382 case BLK_START_A_PIHBIGGIE: 383 strcpy(outstr, "BLK_START_A_PIHBIGGIE"); 384 break; 385 case BLK_START_EXTENDED_ATTRIBUTES: 386 strcpy(outstr, "BLK_START_EXTENDED_ATTRIBUTES"); 387 break; 388 case BLK_STOP_EXTENDED_ATTRIBUTES: 389 strcpy(outstr, "BLK_STOP_EXTENDED_ATTRIBUTES"); 390 break; 391 case BLK_START_EXAT_FILE: 392 strcpy(outstr, "BLK_START_EXAT_FILE"); 393 break; 394 case BLK_STOP_EXAT_FILE: 395 strcpy(outstr, "BLK_STOP_EXAT_FILE"); 396 break; 397 case BLK_START_BIGGIEFILES: 398 strcpy(outstr, "BLK_START_BIGGIEFILES"); 399 break; 400 case BLK_STOP_A_BIGGIE: 401 strcpy(outstr, "BLK_STOP_A_BIGGIE"); 402 break; 403 case BLK_END_OF_TAPE: 404 strcpy(outstr, "BLK_END_OF_TAPE"); 405 break; 406 case BLK_END_OF_BACKUP: 407 strcpy(outstr, "BLK_END_OF_BACKUP"); 408 break; 409 case BLK_ABORTED_BACKUP: 410 strcpy(outstr, "BLK_ABORTED_BACKUP"); 411 break; 412 case BLK_START_FILE: 413 strcpy(outstr, "BLK_START_FILE"); 414 break; 415 case BLK_STOP_FILE: 416 strcpy(outstr, "BLK_STOP_FILE"); 417 break; 418 default: 419 sprintf(outstr, "BLK_UNKNOWN (%d)", marker); 420 break; 421 } 422 return (outstr); 433 423 } 434 424 … … 447 437 * @note The returned string points to static storage and will be overwritten with each call. 448 438 */ 449 char * 450 mountlist_entry_to_string (struct mountlist_itself *mountlist,int lino)451 { 452 453 /*@ buffer *********************************************************** */454 455 456 assert(mountlist!=NULL);457 458 sprintf(output, "%-24s %-24s %-10s %8lld", mountlist->el[lino].device,459 460 461 439 char *mountlist_entry_to_string(struct mountlist_itself *mountlist, 440 int lino) 441 { 442 443 /*@ buffer *********************************************************** */ 444 static char output[MAX_STR_LEN]; 445 446 assert(mountlist != NULL); 447 448 sprintf(output, "%-24s %-24s %-10s %8lld", mountlist->el[lino].device, 449 mountlist->el[lino].mountpoint, mountlist->el[lino].format, 450 mountlist->el[lino].size / 1024); 451 return (output); 462 452 } 463 453 … … 475 465 * @note The returned string points to static storage and will be overwritten with each call. 476 466 */ 477 char * 478 number_of_disks_as_string (int noof_disks, char *label) 479 { 480 481 /*@ buffers **********************************************************/ 482 static char output[MAX_STR_LEN]; 483 484 /*@ char *********************************************************/ 485 char p; 486 487 assert(label!=NULL); 488 489 if (noof_disks > 1) 490 { 491 p = 's'; 492 } 493 else 494 { 495 p = ' '; 496 } 497 sprintf (output, "%d %s disk%c", noof_disks, label, p); 498 while (strlen (output) < 14) 499 { 500 strcat (output, " "); 501 } 502 return (output); 467 char *number_of_disks_as_string(int noof_disks, char *label) 468 { 469 470 /*@ buffers ********************************************************* */ 471 static char output[MAX_STR_LEN]; 472 473 /*@ char ******************************************************** */ 474 char p; 475 476 assert(label != NULL); 477 478 if (noof_disks > 1) { 479 p = 's'; 480 } else { 481 p = ' '; 482 } 483 sprintf(output, "%d %s disk%c", noof_disks, label, p); 484 while (strlen(output) < 14) { 485 strcat(output, " "); 486 } 487 return (output); 503 488 } 504 489 … … 512 497 * @note The returned value points to static strorage that will be overwritten with each call. 513 498 */ 514 char * 515 number_to_text (int i) 516 { 517 518 /*@ buffers ******************************************************/ 519 static char output[MAX_STR_LEN]; 520 521 522 /*@ end vars ****************************************************/ 523 524 switch (i) 525 { 526 case 0: 527 strcpy (output, "zero"); 528 break; 529 case 1: 530 strcpy (output, "one"); 531 break; 532 case 2: 533 strcpy (output, "two"); 534 break; 535 case 3: 536 strcpy (output, "three"); 537 break; 538 case 4: 539 strcpy (output, "four"); 540 break; 541 case 5: 542 strcpy (output, "five"); 543 break; 544 case 6: 545 strcpy (output, "six"); 546 break; 547 case 7: 548 strcpy (output, "seven"); 549 break; 550 case 8: 551 strcpy (output, "eight"); 552 break; 553 case 9: 554 strcpy (output, "nine"); 555 case 10: 556 strcpy (output, "ten"); 557 default: 558 sprintf (output, "%d", i); 559 } 560 return (output); 499 char *number_to_text(int i) 500 { 501 502 /*@ buffers ***************************************************** */ 503 static char output[MAX_STR_LEN]; 504 505 506 /*@ end vars *************************************************** */ 507 508 switch (i) { 509 case 0: 510 strcpy(output, "zero"); 511 break; 512 case 1: 513 strcpy(output, "one"); 514 break; 515 case 2: 516 strcpy(output, "two"); 517 break; 518 case 3: 519 strcpy(output, "three"); 520 break; 521 case 4: 522 strcpy(output, "four"); 523 break; 524 case 5: 525 strcpy(output, "five"); 526 break; 527 case 6: 528 strcpy(output, "six"); 529 break; 530 case 7: 531 strcpy(output, "seven"); 532 break; 533 case 8: 534 strcpy(output, "eight"); 535 break; 536 case 9: 537 strcpy(output, "nine"); 538 case 10: 539 strcpy(output, "ten"); 540 default: 541 sprintf(output, "%d", i); 542 } 543 return (output); 561 544 } 562 545 … … 571 554 * @param value The value to replace @p token. 572 555 */ 573 void 574 resolve_naff_tokens (char *output, char *ip, char *value, char *token) 575 { 576 /*@ buffers ****/ 577 char *input; 578 579 /*@ pointers **/ 580 char *p; 581 582 input = malloc(2000); 583 assert_string_is_neither_NULL_nor_zerolength(ip); 584 assert_string_is_neither_NULL_nor_zerolength(token); 585 assert(value!=NULL); 586 587 strcpy (output, ip); /* just in case the token doesn't appear in string at all */ 588 for (strcpy (input, ip); strstr (input, token); strcpy (input, output)) 589 { 590 strcpy (output, input); 591 p = strstr (output, token); 592 *p = '\0'; 593 strcat (output, value); 594 p = strstr (input, token) + strlen (token); 595 strcat (output, p); 596 } 597 paranoid_free(input); 556 void resolve_naff_tokens(char *output, char *ip, char *value, char *token) 557 { 558 /*@ buffers *** */ 559 char *input; 560 561 /*@ pointers * */ 562 char *p; 563 564 input = malloc(2000); 565 assert_string_is_neither_NULL_nor_zerolength(ip); 566 assert_string_is_neither_NULL_nor_zerolength(token); 567 assert(value != NULL); 568 569 strcpy(output, ip); /* just in case the token doesn't appear in string at all */ 570 for (strcpy(input, ip); strstr(input, token); strcpy(input, output)) { 571 strcpy(output, input); 572 p = strstr(output, token); 573 *p = '\0'; 574 strcat(output, value); 575 p = strstr(input, token) + strlen(token); 576 strcat(output, p); 577 } 578 paranoid_free(input); 598 579 } 599 580 … … 617 598 * @note The returned value points to static storage and will be overwritten with each call. 618 599 */ 619 char * 620 slice_fname (long bigfileno, long sliceno, char *path, char *s) 621 { 622 623 /*@ buffers *****************************************************/ 624 static char output[MAX_STR_LEN]; 625 static char suffix[MAX_STR_LEN]; 626 627 /*@ end vars ****************************************************/ 628 629 assert_string_is_neither_NULL_nor_zerolength(path); 630 if (s[0] != '\0') 631 { 632 sprintf (suffix, ".%s", s); 633 } 634 else 635 { 636 suffix[0] = '\0'; 637 } 638 sprintf (output, "%s/slice-%07ld.%05ld.dat%s", path, bigfileno, sliceno, 639 suffix); 640 return (output); 600 char *slice_fname(long bigfileno, long sliceno, char *path, char *s) 601 { 602 603 /*@ buffers **************************************************** */ 604 static char output[MAX_STR_LEN]; 605 static char suffix[MAX_STR_LEN]; 606 607 /*@ end vars *************************************************** */ 608 609 assert_string_is_neither_NULL_nor_zerolength(path); 610 if (s[0] != '\0') { 611 sprintf(suffix, ".%s", s); 612 } else { 613 suffix[0] = '\0'; 614 } 615 sprintf(output, "%s/slice-%07ld.%05ld.dat%s", path, bigfileno, sliceno, 616 suffix); 617 return (output); 641 618 } 642 619 … … 650 627 * @return The character for this iteration. 651 628 */ 652 int 653 special_dot_char (int i) 654 { 655 switch (i % 4) 656 { 657 case 0: 658 return ('/'); 659 case 1: 660 return ('-'); 661 case 2: 662 return ('\\'); 663 case 3: 664 return ('|'); 665 default: 666 return ('.'); 667 } 668 return ('.'); 629 int special_dot_char(int i) 630 { 631 switch (i % 4) { 632 case 0: 633 return ('/'); 634 case 1: 635 return ('-'); 636 case 2: 637 return ('\\'); 638 case 3: 639 return ('|'); 640 default: 641 return ('.'); 642 } 643 return ('.'); 669 644 } 670 645 … … 682 657 */ 683 658 bool 684 spread_flaws_across_three_lines (char *flaws_str, char *flaws_str_A, 685 char *flaws_str_B, char *flaws_str_C, 686 int res) 687 { 688 689 /*@ int **************************************************************/ 690 int i = 0; 691 692 /*@ initialize *******************************************************/ 693 assert(flaws_str_A!=NULL); 694 assert(flaws_str_B!=NULL); 695 assert(flaws_str_C!=NULL); 696 assert(flaws_str!=NULL); 697 698 flaws_str_A[0] = flaws_str_B[0] = flaws_str_C[0] = '\0'; 699 700 701 if (!res && !strlen (flaws_str)) 702 { 703 return (TRUE); 704 } 705 if (strlen (flaws_str) > 0) 706 { 707 sprintf (flaws_str_A, "%s", flaws_str + 1); 708 } 709 if (strlen (flaws_str_A) >= 74) 710 { 711 for (i = 74; flaws_str_A[i] != ' '; i--); 712 strcpy (flaws_str_B, flaws_str_A + i + 1); 713 flaws_str_A[i] = '\0'; 714 } 715 if (strlen (flaws_str_B) >= 74) 716 { 717 for (i = 74; flaws_str_B[i] != ' '; i--); 718 strcpy (flaws_str_C, flaws_str_B + i + 1); 719 flaws_str_B[i] = '\0'; 720 } 721 if (res) 722 { 723 return (FALSE); 724 } 725 else 726 { 727 return (TRUE); 728 } 659 spread_flaws_across_three_lines(char *flaws_str, char *flaws_str_A, 660 char *flaws_str_B, char *flaws_str_C, 661 int res) 662 { 663 664 /*@ int ************************************************************* */ 665 int i = 0; 666 667 /*@ initialize ****************************************************** */ 668 assert(flaws_str_A != NULL); 669 assert(flaws_str_B != NULL); 670 assert(flaws_str_C != NULL); 671 assert(flaws_str != NULL); 672 673 flaws_str_A[0] = flaws_str_B[0] = flaws_str_C[0] = '\0'; 674 675 676 if (!res && !strlen(flaws_str)) { 677 return (TRUE); 678 } 679 if (strlen(flaws_str) > 0) { 680 sprintf(flaws_str_A, "%s", flaws_str + 1); 681 } 682 if (strlen(flaws_str_A) >= 74) { 683 for (i = 74; flaws_str_A[i] != ' '; i--); 684 strcpy(flaws_str_B, flaws_str_A + i + 1); 685 flaws_str_A[i] = '\0'; 686 } 687 if (strlen(flaws_str_B) >= 74) { 688 for (i = 74; flaws_str_B[i] != ' '; i--); 689 strcpy(flaws_str_C, flaws_str_B + i + 1); 690 flaws_str_B[i] = '\0'; 691 } 692 if (res) { 693 return (FALSE); 694 } else { 695 return (TRUE); 696 } 729 697 } 730 698 … … 740 708 * there are any in the middle those will be sorted ASCIIbetically. 741 709 */ 742 int 743 strcmp_inc_numbers (char *stringA, char *stringB) 744 { 745 /*@ int **********************************************************/ 746 int i; 747 int start_of_numbers_in_A; 748 int start_of_numbers_in_B; 749 int res; 750 751 /*@ long ********************************************************/ 752 long numA; 753 long numB; 754 755 /*@ end vars ****************************************************/ 756 assert(stringA!=NULL); 757 assert(stringB!=NULL); 758 759 if (strlen (stringA) == strlen (stringB)) 760 { 761 return (strcmp (stringA, stringB)); 762 } 763 for (i = (int) strlen (stringA); i > 0 && isdigit (stringA[i - 1]); i--); 764 if (i == (int) strlen (stringA)) 765 { 766 return (strcmp (stringA, stringB)); 767 } 768 start_of_numbers_in_A = i; 769 for (i = (int) strlen (stringB); i > 0 && isdigit (stringB[i - 1]); i--); 770 if (i == (int) strlen (stringB)) 771 { 772 return (strcmp (stringA, stringB)); 773 } 774 start_of_numbers_in_B = i; 775 if (start_of_numbers_in_A != start_of_numbers_in_B) 776 { 777 return (strcmp (stringA, stringB)); 778 } 779 res = strncmp (stringA, stringB, (size_t) i); 780 if (res) 781 { 782 return (res); 783 } 784 numA = atol (stringA + start_of_numbers_in_A); 785 numB = atol (stringB + start_of_numbers_in_B); 786 /* 787 sprintf(tmp,"Comparing %s and %s --> %ld,%ld\n",stringA,stringB,numA,numB); 788 log_to_screen(tmp); 789 */ 790 return ((int) (numA - numB)); 710 int strcmp_inc_numbers(char *stringA, char *stringB) 711 { 712 /*@ int ********************************************************* */ 713 int i; 714 int start_of_numbers_in_A; 715 int start_of_numbers_in_B; 716 int res; 717 718 /*@ long ******************************************************* */ 719 long numA; 720 long numB; 721 722 /*@ end vars *************************************************** */ 723 assert(stringA != NULL); 724 assert(stringB != NULL); 725 726 if (strlen(stringA) == strlen(stringB)) { 727 return (strcmp(stringA, stringB)); 728 } 729 for (i = (int) strlen(stringA); i > 0 && isdigit(stringA[i - 1]); i--); 730 if (i == (int) strlen(stringA)) { 731 return (strcmp(stringA, stringB)); 732 } 733 start_of_numbers_in_A = i; 734 for (i = (int) strlen(stringB); i > 0 && isdigit(stringB[i - 1]); i--); 735 if (i == (int) strlen(stringB)) { 736 return (strcmp(stringA, stringB)); 737 } 738 start_of_numbers_in_B = i; 739 if (start_of_numbers_in_A != start_of_numbers_in_B) { 740 return (strcmp(stringA, stringB)); 741 } 742 res = strncmp(stringA, stringB, (size_t) i); 743 if (res) { 744 return (res); 745 } 746 numA = atol(stringA + start_of_numbers_in_A); 747 numB = atol(stringB + start_of_numbers_in_B); 748 /* 749 sprintf(tmp,"Comparing %s and %s --> %ld,%ld\n",stringA,stringB,numA,numB); 750 log_to_screen(tmp); 751 */ 752 return ((int) (numA - numB)); 791 753 } 792 754 … … 801 763 * @note The returned string points to static storage that will be overwritten with each call. 802 764 */ 803 char * 804 strip_afio_output_line (char *input) 805 { 806 /*@ buffer *******************************************************/ 807 static char output[MAX_STR_LEN]; 808 809 /*@ pointers *****************************************************/ 810 char *p; 811 char *q; 812 /*@ end vars ****************************************************/ 813 814 assert(input!=NULL); 815 strcpy (output, input); 816 p = strchr (input, '\"'); 817 if (p) 818 { 819 q = strchr (++p, '\"'); 820 if (q) 821 { 822 strcpy (output, p); 823 *(strchr (output, '\"')) = '\0'; 824 } 825 } 826 return (output); 765 char *strip_afio_output_line(char *input) 766 { 767 /*@ buffer ****************************************************** */ 768 static char output[MAX_STR_LEN]; 769 770 /*@ pointers **************************************************** */ 771 char *p; 772 char *q; 773 /*@ end vars *************************************************** */ 774 775 assert(input != NULL); 776 strcpy(output, input); 777 p = strchr(input, '\"'); 778 if (p) { 779 q = strchr(++p, '\"'); 780 if (q) { 781 strcpy(output, p); 782 *(strchr(output, '\"')) = '\0'; 783 } 784 } 785 return (output); 827 786 } 828 787 … … 834 793 * @param in_out The string to strip spaces/control characters from (modified). 835 794 */ 836 void 837 strip_spaces (char *in_out) 838 { 839 /*@ buffers ******************************************************/ 840 char *tmp; 841 842 /*@ pointers *****************************************************/ 843 char *p; 844 845 /*@ int *********************************************************/ 846 int i; 847 int original_incoming_length; 848 849 /*@ end vars ****************************************************/ 850 851 assert(in_out!=NULL); 852 malloc_string(tmp); 853 original_incoming_length = (int) strlen(in_out); 854 for (i = 0; in_out[i] <= ' ' && i < (int) strlen (in_out); i++); 855 strcpy (tmp, in_out + i); 856 for (i = (int) strlen (tmp); i>0 && tmp[i - 1] <= 32; i--); 857 tmp[i] = '\0'; 858 for (i = 0; i < original_incoming_length && MAX_STR_LEN; i++) 859 { 860 in_out[i] = ' '; 861 } 862 in_out[i] = '\0'; 863 i = 0; 864 p = tmp; 865 while (*p != '\0') 866 { 867 in_out[i] = *(p++); 868 in_out[i + 1] = '\0'; 869 if (in_out[i] < 32 && i > 0) 870 { 871 if (in_out[i] == 8) 872 { 873 i--; 874 } 875 else if (in_out[i] == 9) 876 { 877 in_out[i++] = ' '; 878 } 879 else if (in_out[i] == '\r') // added 1st October 2003 -- FIXME 880 { 881 strcpy(tmp, in_out+i); 882 strcpy(in_out,tmp); 883 i=-1; 884 continue; 885 } 886 else if (in_out[i] == '\t') 887 { 888 for (i++; i % 5; i++); 889 } 890 else if (in_out[i] >= 10 && in_out[i] <= 13) 891 { 892 break; 893 } 894 else 895 { 896 i--; 897 } 898 } 899 else 900 { 901 i++; 902 } 903 } 904 in_out[i] = '\0'; 905 paranoid_free(tmp); 795 void strip_spaces(char *in_out) 796 { 797 /*@ buffers ***************************************************** */ 798 char *tmp; 799 800 /*@ pointers **************************************************** */ 801 char *p; 802 803 /*@ int ******************************************************** */ 804 int i; 805 int original_incoming_length; 806 807 /*@ end vars *************************************************** */ 808 809 assert(in_out != NULL); 810 malloc_string(tmp); 811 original_incoming_length = (int) strlen(in_out); 812 for (i = 0; in_out[i] <= ' ' && i < (int) strlen(in_out); i++); 813 strcpy(tmp, in_out + i); 814 for (i = (int) strlen(tmp); i > 0 && tmp[i - 1] <= 32; i--); 815 tmp[i] = '\0'; 816 for (i = 0; i < original_incoming_length && MAX_STR_LEN; i++) { 817 in_out[i] = ' '; 818 } 819 in_out[i] = '\0'; 820 i = 0; 821 p = tmp; 822 while (*p != '\0') { 823 in_out[i] = *(p++); 824 in_out[i + 1] = '\0'; 825 if (in_out[i] < 32 && i > 0) { 826 if (in_out[i] == 8) { 827 i--; 828 } else if (in_out[i] == 9) { 829 in_out[i++] = ' '; 830 } else if (in_out[i] == '\r') // added 1st October 2003 -- FIXME 831 { 832 strcpy(tmp, in_out + i); 833 strcpy(in_out, tmp); 834 i = -1; 835 continue; 836 } else if (in_out[i] == '\t') { 837 for (i++; i % 5; i++); 838 } else if (in_out[i] >= 10 && in_out[i] <= 13) { 839 break; 840 } else { 841 i--; 842 } 843 } else { 844 i++; 845 } 846 } 847 in_out[i] = '\0'; 848 paranoid_free(tmp); 906 849 /* for(i=strlen(in_out); i>0 && in_out[i-1]<=32; i--) {in_out[i-1]='\0';} */ 907 850 } … … 914 857 * @return @p incoming. 915 858 */ 916 char * 917 trim_empty_quotes (char *incoming) 918 { 919 /*@ buffer *******************************************************/ 920 static char outgoing[MAX_STR_LEN]; 921 922 /*@ end vars ****************************************************/ 923 assert(incoming!=NULL); 924 925 if (incoming[0] == '\"' && incoming[strlen (incoming) - 1] == '\"') 926 { 927 strcpy (outgoing, incoming + 1); 928 outgoing[strlen (outgoing) - 1] = '\0'; 929 } 930 else 931 { 932 strcpy (outgoing, incoming); 933 } 934 return (outgoing); 859 char *trim_empty_quotes(char *incoming) 860 { 861 /*@ buffer ****************************************************** */ 862 static char outgoing[MAX_STR_LEN]; 863 864 /*@ end vars *************************************************** */ 865 assert(incoming != NULL); 866 867 if (incoming[0] == '\"' && incoming[strlen(incoming) - 1] == '\"') { 868 strcpy(outgoing, incoming + 1); 869 outgoing[strlen(outgoing) - 1] = '\0'; 870 } else { 871 strcpy(outgoing, incoming); 872 } 873 return (outgoing); 935 874 } 936 875 … … 943 882 * @return @p partition. 944 883 */ 945 char * 946 truncate_to_drive_name (char *partition) 947 { 948 int i = strlen (partition) - 1; 949 char *c; 884 char *truncate_to_drive_name(char *partition) 885 { 886 int i = strlen(partition) - 1; 887 char *c; 950 888 951 889 #ifdef __FreeBSD__ 952 890 953 if (islower (partition[i]))// BSD subpartition954 955 956 while (isdigit(partition[i]))957 958 959 960 891 if (islower(partition[i])) // BSD subpartition 892 i--; 893 if (partition[i - 1] == 's') { 894 while (isdigit(partition[i])) 895 i--; 896 i--; 897 } 898 partition[i + 1] = '\0'; 961 899 962 900 #else 963 901 964 assert_string_is_neither_NULL_nor_zerolength(partition); 965 /* first see if it's a devfs style device */ 966 c = strrchr(partition, '/'); 967 if (c && strncmp(c, "/part", 5) == 0) { 968 /* yup it's devfs, return the "disc" path */ 969 strcpy(c + 1, "disc"); 970 return partition; 971 } 972 973 for (i = strlen (partition); isdigit (partition[i - 1]); i--) 974 continue; 975 if (partition[i - 1] == 'p' && isdigit (partition[i - 2])) 976 { 977 i--; 978 } 979 partition[i] = '\0'; 902 assert_string_is_neither_NULL_nor_zerolength(partition); 903 /* first see if it's a devfs style device */ 904 c = strrchr(partition, '/'); 905 if (c && strncmp(c, "/part", 5) == 0) { 906 /* yup it's devfs, return the "disc" path */ 907 strcpy(c + 1, "disc"); 908 return partition; 909 } 910 911 for (i = strlen(partition); isdigit(partition[i - 1]); i--) 912 continue; 913 if (partition[i - 1] == 'p' && isdigit(partition[i - 2])) { 914 i--; 915 } 916 partition[i] = '\0'; 980 917 981 918 #endif 982 919 983 920 return partition; 984 921 } 985 922 … … 996 933 * @note The returned value points to static storage that will be overwritten with each call. 997 934 */ 998 char * 999 turn_raid_level_number_to_string (int raid_level) 1000 { 1001 1002 /*@ buffer ***********************************************************/ 1003 static char output[MAX_STR_LEN]; 1004 1005 1006 1007 if (raid_level >= 0) 1008 { 1009 sprintf (output, " RAID %-2d ", raid_level); 1010 } 1011 else 1012 { 1013 sprintf (output, "Linear RAID"); 1014 } 1015 return (output); 935 char *turn_raid_level_number_to_string(int raid_level) 936 { 937 938 /*@ buffer ********************************************************** */ 939 static char output[MAX_STR_LEN]; 940 941 942 943 if (raid_level >= 0) { 944 sprintf(output, " RAID %-2d ", raid_level); 945 } else { 946 sprintf(output, "Linear RAID"); 947 } 948 return (output); 1016 949 } 1017 950 … … 1033 966 int severity_of_difference(char *fn, char *out_reason) 1034 967 { 1035 1036 1037 1038 1039 1040 968 int sev; 969 char *reason; 970 char *filename; 971 972 malloc_string(reason); 973 malloc_string(filename); 1041 974 // out_reason might be null on purpose, so don't bomb if it is :) OK? 1042 assert_string_is_neither_NULL_nor_zerolength(fn); 1043 if (!strncmp(fn, MNT_RESTORING, strlen(MNT_RESTORING))) 1044 { strcpy(filename, fn+strlen(MNT_RESTORING)); } 1045 else if (fn[0]!='/') 1046 { sprintf(filename, "/%s", fn); } 1047 else 1048 { strcpy(filename, fn); } 1049 1050 sev = 3; 1051 sprintf(reason, "Changed since backup. Consider running a differential backup in a day or two."); 1052 if (!strncmp(filename, "/var/", 5)) { sev = 2; sprintf(reason, "/var's contents will change regularly, inevitably."); } 1053 if (!strncmp(filename, "/home", 5)) { sev = 2; sprintf(reason, "It's in your /home partiton. Therefore, it is important."); } 1054 if (!strncmp(filename, "/usr/", 5)) { sev = 3; sprintf(reason, "You may have installed/removed software during the backup."); } 1055 if (!strncmp(filename, "/etc/", 5)) { sev = 3; sprintf(reason, "Do not edit config files while backing up your PC."); } 1056 if (!strcmp(filename, "/etc/adjtime") || !strcmp(filename, "/etc/mtab")) { sev = 1; sprintf(reason, "This file changes all the time. It's OK."); } 1057 if (!strncmp(filename, "/root/", 6)) { sev = 3; sprintf(reason, "Were you compiling/editing something in /root?"); } 1058 if (!strncmp(filename, "/root/.", 7)) { sev = 2; sprintf(reason, "Temp or 'dot' files changed in /root."); } 1059 if (!strncmp(filename, "/var/lib/", 9)) { sev = 2; sprintf(reason, "Did you add/remove software during backing?"); } 1060 if (!strncmp(filename, "/var/lib/rpm", 12)) { sev = 3; sprintf(reason, "Did you add/remove software during backing?"); } 1061 if (!strncmp(filename, "/var/lib/slocate", 16)) { sev = 1; sprintf(reason, "The 'update' daemon ran during backup. This does not affect the integrity of your backup."); } 1062 if (!strncmp(filename, "/var/log/", 9) || strstr(filename,"/.xsession") || !strcmp(filename+strlen(filename)-4, ".log")) { sev = 1; sprintf(reason, "Log files change frequently as the computer runs. Fret not."); } 1063 if (!strncmp(filename, "/var/spool", 10)) { sev = 1; sprintf(reason, "Background processes or printers were active. This does not affect the integrity of your backup."); } 1064 if (!strncmp(filename, "/var/spool/mail", 10)) { sev = 2; sprintf(reason, "Mail was sent/received during backup."); } 1065 if (filename[strlen(filename)-1]== '~') 1066 { sev = 1; sprintf(reason, "Backup copy of another file which was modified recently."); } 1067 if (strstr(filename, "cache")) 1068 { sev = 1; sprintf(reason, "Part of a cache of data. Caches change from time to time. Don't worry."); } 1069 if (!strncmp(filename, "/var/run/", 9) || !strncmp(filename, "/var/lock", 8) || strstr(filename, "/.DCOPserver") || strstr(filename, "/.MCOP") || strstr(filename, "/.Xauthority")) 1070 { sev = 1; sprintf(reason, "Temporary file (a lockfile, perhaps) used by software such as X or KDE to register its presence."); } 1071 if (out_reason) { strcpy(out_reason,reason); } 1072 paranoid_free(filename); 1073 paranoid_free(reason); 1074 return(sev); 975 assert_string_is_neither_NULL_nor_zerolength(fn); 976 if (!strncmp(fn, MNT_RESTORING, strlen(MNT_RESTORING))) { 977 strcpy(filename, fn + strlen(MNT_RESTORING)); 978 } else if (fn[0] != '/') { 979 sprintf(filename, "/%s", fn); 980 } else { 981 strcpy(filename, fn); 982 } 983 984 sev = 3; 985 sprintf(reason, 986 "Changed since backup. Consider running a differential backup in a day or two."); 987 if (!strncmp(filename, "/var/", 5)) { 988 sev = 2; 989 sprintf(reason, 990 "/var's contents will change regularly, inevitably."); 991 } 992 if (!strncmp(filename, "/home", 5)) { 993 sev = 2; 994 sprintf(reason, 995 "It's in your /home partiton. Therefore, it is important."); 996 } 997 if (!strncmp(filename, "/usr/", 5)) { 998 sev = 3; 999 sprintf(reason, 1000 "You may have installed/removed software during the backup."); 1001 } 1002 if (!strncmp(filename, "/etc/", 5)) { 1003 sev = 3; 1004 sprintf(reason, 1005 "Do not edit config files while backing up your PC."); 1006 } 1007 if (!strcmp(filename, "/etc/adjtime") 1008 || !strcmp(filename, "/etc/mtab")) { 1009 sev = 1; 1010 sprintf(reason, "This file changes all the time. It's OK."); 1011 } 1012 if (!strncmp(filename, "/root/", 6)) { 1013 sev = 3; 1014 sprintf(reason, "Were you compiling/editing something in /root?"); 1015 } 1016 if (!strncmp(filename, "/root/.", 7)) { 1017 sev = 2; 1018 sprintf(reason, "Temp or 'dot' files changed in /root."); 1019 } 1020 if (!strncmp(filename, "/var/lib/", 9)) { 1021 sev = 2; 1022 sprintf(reason, "Did you add/remove software during backing?"); 1023 } 1024 if (!strncmp(filename, "/var/lib/rpm", 12)) { 1025 sev = 3; 1026 sprintf(reason, "Did you add/remove software during backing?"); 1027 } 1028 if (!strncmp(filename, "/var/lib/slocate", 16)) { 1029 sev = 1; 1030 sprintf(reason, 1031 "The 'update' daemon ran during backup. This does not affect the integrity of your backup."); 1032 } 1033 if (!strncmp(filename, "/var/log/", 9) 1034 || strstr(filename, "/.xsession") 1035 || !strcmp(filename + strlen(filename) - 4, ".log")) { 1036 sev = 1; 1037 sprintf(reason, 1038 "Log files change frequently as the computer runs. Fret not."); 1039 } 1040 if (!strncmp(filename, "/var/spool", 10)) { 1041 sev = 1; 1042 sprintf(reason, 1043 "Background processes or printers were active. This does not affect the integrity of your backup."); 1044 } 1045 if (!strncmp(filename, "/var/spool/mail", 10)) { 1046 sev = 2; 1047 sprintf(reason, "Mail was sent/received during backup."); 1048 } 1049 if (filename[strlen(filename) - 1] == '~') { 1050 sev = 1; 1051 sprintf(reason, 1052 "Backup copy of another file which was modified recently."); 1053 } 1054 if (strstr(filename, "cache")) { 1055 sev = 1; 1056 sprintf(reason, 1057 "Part of a cache of data. Caches change from time to time. Don't worry."); 1058 } 1059 if (!strncmp(filename, "/var/run/", 9) 1060 || !strncmp(filename, "/var/lock", 8) 1061 || strstr(filename, "/.DCOPserver") || strstr(filename, "/.MCOP") 1062 || strstr(filename, "/.Xauthority")) { 1063 sev = 1; 1064 sprintf(reason, 1065 "Temporary file (a lockfile, perhaps) used by software such as X or KDE to register its presence."); 1066 } 1067 if (out_reason) { 1068 strcpy(out_reason, reason); 1069 } 1070 paranoid_free(filename); 1071 paranoid_free(reason); 1072 return (sev); 1075 1073 } 1076 1074 … … 1084 1082 * @return The return value of strcmp(). 1085 1083 */ 1086 int compare_two_filelist_entries(void *va,void*vb)1087 { 1088 1089 1090 1091 assert(va!=NULL);1092 assert(vb!=NULL);1093 fa = (struct s_filelist_entry*)va;1094 fb = (struct s_filelist_entry*)vb;1095 1096 return(res);1084 int compare_two_filelist_entries(void *va, void *vb) 1085 { 1086 static int res; 1087 struct s_filelist_entry *fa, *fb; 1088 1089 assert(va != NULL); 1090 assert(vb != NULL); 1091 fa = (struct s_filelist_entry *) va; 1092 fb = (struct s_filelist_entry *) vb; 1093 res = strcmp(fa->filename, fb->filename); 1094 return (res); 1097 1095 } 1098 1096 … … 1113 1111 * @note The returned string points to static storage that will be overwritten with each call. 1114 1112 */ 1115 char * 1116 percent_media_full_comment (struct s_bkpinfo *bkpinfo) 1117 { 1118 /*@ int ************************************************/ 1119 int percentage; 1120 int j; 1121 1122 /*@ buffers ********************************************/ 1123 static char outstr[MAX_STR_LEN]; 1124 char *pos_w_commas, *tmp; 1125 1126 assert(bkpinfo!=NULL); 1127 malloc_string(pos_w_commas); 1128 malloc_string(tmp); 1129 sprintf(tmp, "%lld", g_tape_posK); 1130 strcpy(pos_w_commas, commarize(tmp)); 1131 1132 1133 1134 if (bkpinfo->media_size[g_current_media_number]<=0) 1113 char *percent_media_full_comment(struct s_bkpinfo *bkpinfo) 1114 { 1115 /*@ int *********************************************** */ 1116 int percentage; 1117 int j; 1118 1119 /*@ buffers ******************************************* */ 1120 static char outstr[MAX_STR_LEN]; 1121 char *pos_w_commas, *tmp; 1122 1123 assert(bkpinfo != NULL); 1124 malloc_string(pos_w_commas); 1125 malloc_string(tmp); 1126 sprintf(tmp, "%lld", g_tape_posK); 1127 strcpy(pos_w_commas, commarize(tmp)); 1128 1129 1130 1131 if (bkpinfo->media_size[g_current_media_number] <= 0) 1135 1132 // { fatal_error( "percentage_media_full_comment() - unknown media size"); } 1136 { 1137 sprintf( outstr, "Volume %d: %s kilobytes archived so far", g_current_media_number, pos_w_commas); 1138 return( outstr ); 1139 } 1133 { 1134 sprintf(outstr, "Volume %d: %s kilobytes archived so far", 1135 g_current_media_number, pos_w_commas); 1136 return (outstr); 1137 } 1140 1138 1141 1139 /* update screen */ 1142 if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) 1143 { 1144 percentage = (int) (g_tape_posK / 10 / bkpinfo->media_size[g_current_media_number]); 1145 if (percentage > 100) 1146 { 1147 percentage = 100; 1148 } 1149 sprintf (outstr, "Volume %d: [", g_current_media_number); 1150 } 1151 else 1152 { 1153 percentage = 1154 (int) (space_occupied_by_cd (bkpinfo->scratchdir) * 100 / 1024 / 1155 bkpinfo->media_size[g_current_media_number]); 1156 sprintf (outstr, "%s %d: [", media_descriptor_string(bkpinfo->backup_media_type), g_current_media_number); 1157 } 1158 for (j = 0; j < percentage; j += 5) 1159 { 1160 strcat (outstr, "*"); 1161 } 1162 for (; j < 100; j += 5) 1163 { 1164 strcat (outstr, "."); 1165 } 1166 j = (int) strlen (outstr); 1167 sprintf (outstr + j, "] %d%% used", percentage); 1168 paranoid_free(pos_w_commas); 1169 paranoid_free(tmp); 1170 return (outstr); 1140 if (IS_THIS_A_STREAMING_BACKUP(bkpinfo->backup_media_type)) { 1141 percentage = 1142 (int) (g_tape_posK / 10 / 1143 bkpinfo->media_size[g_current_media_number]); 1144 if (percentage > 100) { 1145 percentage = 100; 1146 } 1147 sprintf(outstr, "Volume %d: [", g_current_media_number); 1148 } else { 1149 percentage = 1150 (int) (space_occupied_by_cd(bkpinfo->scratchdir) * 100 / 1024 / 1151 bkpinfo->media_size[g_current_media_number]); 1152 sprintf(outstr, "%s %d: [", 1153 media_descriptor_string(bkpinfo->backup_media_type), 1154 g_current_media_number); 1155 } 1156 for (j = 0; j < percentage; j += 5) { 1157 strcat(outstr, "*"); 1158 } 1159 for (; j < 100; j += 5) { 1160 strcat(outstr, "."); 1161 } 1162 j = (int) strlen(outstr); 1163 sprintf(outstr + j, "] %d%% used", percentage); 1164 paranoid_free(pos_w_commas); 1165 paranoid_free(tmp); 1166 return (outstr); 1171 1167 } 1172 1168 … … 1179 1175 char *media_descriptor_string(t_bkptype type_of_bkp) 1180 1176 { 1181 static char *type_of_backup=NULL;1182 1183 if (!type_of_backup) 1184 { malloc_string(type_of_backup); } 1185 1186 switch(type_of_bkp) 1187 1177 static char *type_of_backup = NULL; 1178 1179 if (!type_of_backup) { 1180 malloc_string(type_of_backup); 1181 } 1182 1183 switch (type_of_bkp) { 1188 1184 case dvd: 1189 1185 strcpy(type_of_backup, "DVD"); … … 1213 1209 strcpy(type_of_backup, "ISO"); 1214 1210 } 1215 return(type_of_backup);1211 return (type_of_backup); 1216 1212 } 1217 1213
Note:
See TracChangeset
for help on using the changeset viewer.