00001
00002
00003
00004
00005
00006
00007
00008 #include"giis.h"
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 int search4dir ()
00022 {
00023 int i, fp, level_count = 0;
00024 while (level_count < LEVEL_VALUE)
00025 {
00026
00027 fp = open (DIR_INFO_FILE, 0);
00028 if (fp == -1)
00029 {
00030 perror ("open");
00031 return -1;
00032 }
00033
00034 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00035 CHECK while (i > 0)
00036 {
00037 if (giis_d.info.search_flag == 1)
00038 {
00039
00040 fs.inode_number = giis_d.info.inode_number;
00041 i = find_inode_offset ();
00042 CHECK i = read_inode ();
00043 CHECK i = set_content_offset ();
00044 CHECK if (dir)
00045 {
00046
00047 i = read_dir ();
00048 CHECK i = show_dir ();
00049 CHECK}
00050
00051 }
00052 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00053 CHECK}
00054 if ((install == 1 && install_file == 0))
00055 {
00056 i = update_dir_info_file (level_count);
00057 CHECK i = avoid_dups ();
00058 CHECK}
00059
00060 if (update_dir == 1)
00061 {
00062 close (fp);
00063 update_dir = 0;
00064 i = search4dir ();
00065 if (i == 444)
00066 {
00067 close (fp);
00068 get_sample_data ();
00069 printf ("\n\n\t\t giis updated...");
00070 return 1;
00071
00072 }
00073
00074
00075 }
00076
00077 if (install_file == 1 || update_file == 1)
00078 return 444;
00079
00080 level_count++;
00081 close (fp);
00082 }
00083
00084
00085
00086
00087
00088
00089 if (install == 1 && install_file == 0)
00090 {
00091 install_file = 1;
00092 search4dir ();
00093 }
00094
00095 return 1;
00096 }
00097
00098
00099
00100
00101
00102
00103
00104
00105 int update_dir_info_file (int level_count)
00106 {
00107 int fp, i, flag, count = 0;
00108
00109
00110 fp = open (DIR_INFO_FILE, 2);
00111 if (fp == -1)
00112 {
00113 perror ("open");
00114 return -1;
00115 }
00116 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00117 CHECK
00118
00119 while (i > 0)
00120 {
00121 if ((giis_d.info.search_flag == 0) && (giis_d.info.parent_inode_number != 2))
00122 {
00123 flag = get_parent_inode_flag (giis_d.info.parent_inode_number);
00124 if (flag == -1)
00125 break;
00126 if (flag == 1)
00127 {
00128 lseek (fp, count * GIIS_DSIZE, 0);
00129 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00130 if (i != GIIS_DSIZE)
00131 {
00132 perror ("read");
00133 return -1;
00134 }
00135 giis_d.info.search_flag = 1;
00136 lseek (fp, -GIIS_DSIZE, 1);
00137 i = write (fp, giis_d.buffer, GIIS_DSIZE);
00138 if (i != GIIS_DSIZE)
00139 {
00140 perror ("write");
00141 return -1;
00142 }
00143
00144 }
00145 }
00146 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00147
00148 count++;
00149
00150 }
00151
00152 printf ("\n\t Files at Directory Level %d are updated......", level_count + 1);
00153 close (fp);
00154 return 1;
00155 }
00156
00157
00158
00159
00160
00161
00162 int get_parent_inode_flag (unsigned long parent)
00163 {
00164 int fp, i;
00165
00166 fp = open (DIR_INFO_FILE, 0);
00167 if (fp == -1)
00168 {
00169 perror ("open");
00170 return -1;
00171 }
00172
00173 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00174 CHECK while (i > 0)
00175 {
00176 if (giis_d.info.inode_number == parent)
00177 {
00178 close (fp);
00179 return 1;
00180 }
00181 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00182 CHECK}
00183
00184 close (fp);
00185 return -1;
00186 }
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209 int search4sequence12 ()
00210 {
00211 unsigned long indirect_block[1024], prev;
00212 int i, hole, fp, count;
00213 count = hole = 0;
00214 lseek64 (fd, (unsigned long long) giis_f.info.data_block[12] * fs.block_size, 0);
00215 read (fd, indirect_block, fs.block_size);
00216
00217
00218 if (indirect_block[0] - giis_f.info.data_block[12] != 1)
00219 {
00220 idata_block[count++] = giis_f.info.data_block[12];
00221 idata_block[count++] = indirect_block[0];
00222 hole++;
00223 }
00224
00225 prev = indirect_block[0];
00226
00227 for (i = 1; i < 1024 && indirect_block[i]; i++)
00228 {
00229
00230 if (indirect_block[i] - prev == 1)
00231 {
00232 prev = indirect_block[i];
00233 continue;
00234 }
00235
00236 else
00237 {
00238 idata_block[count++] = prev;
00239 idata_block[count++] = indirect_block[i];
00240 hole++;
00241 prev = indirect_block[i];
00242 }
00243
00244 }
00245
00246
00247
00248 if ((i == 1024 || indirect_block[i] == 0) && (hole == 0))
00249 {
00250 giis_f.info.is_offset = 0;
00251 giis_f.info.sfragment_flag = 1;
00252 giis_f.info.last_data_block = indirect_block[i - 1];
00253 return (hole);
00254 }
00255
00256 if ((i == 1024 || indirect_block[i] == 0) && hole)
00257 {
00258 giis_f.info.is_offset = count;
00259 giis_f.info.sfragment_flag = 2;
00260 giis_f.info.last_data_block = indirect_block[i - 1];
00261
00262
00263
00264 fp = open (SIND_INFO_FILE, 1);
00265 if (fp == -1)
00266 {
00267 perror ("Open:");
00268 printf ("Error no :%d", errno);
00269 return -1;
00270 }
00271 lseek (fp, 0, 2);
00272 i = write (fp, idata_block, count * sizeof (unsigned long));
00273 if (i != count * sizeof (unsigned long))
00274 {
00275 perror ("write");
00276 printf ("Error no :%d", errno);
00277 return -1;
00278 }
00279 close (fp);
00280 return 1;
00281 }
00282
00283 return 1;
00284 }
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301 int search4sequence13 ()
00302 {
00303 unsigned long indirect_block[1024];
00304 int i, fp, count, err, ret;
00305 static unsigned long prev;
00306 count = 0, ret = 0;
00307
00308
00309
00310
00311
00312
00313
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323 if (i_round == 0)
00324 {
00325 count = hole = 0;
00326 lseek64 (fd, (unsigned long long) giis_f.info.data_block[13] * fs.block_size, 0);
00327 read (fd, indirect_block, fs.block_size);
00328
00329 lseek64 (fd, (unsigned long long) indirect_block[0] * fs.block_size, 0);
00330 read (fd, indirect_block, fs.block_size);
00331 prev = giis_f.info.data_block[13];
00332
00333 }
00334 else
00335 {
00336 lseek64 (fd, (unsigned long long) prev * 4096, 0);
00337 read (fd, indirect_block, fs.block_size);
00338 lseek64 (fd, (unsigned long long) indirect_block[0] * 4096, 0);
00339 read (fd, indirect_block, fs.block_size);
00340 }
00341
00342 if (indirect_block[0] - prev != 2)
00343 {
00344
00345 idata_block[count++] = prev;
00346 idata_block[count++] = indirect_block[0];
00347 hole++;
00348 }
00349
00350 prev = indirect_block[0];
00351
00352 for (i = 1; i < 1024 && indirect_block[i]; i++)
00353 {
00354
00355 if (indirect_block[i] - prev == 1)
00356 {
00357 prev = indirect_block[i];
00358 continue;
00359 }
00360
00361 else
00362 {
00363 idata_block[count++] = prev;
00364 idata_block[count++] = indirect_block[i];
00365 hole++;
00366 prev = indirect_block[i];
00367 }
00368
00369
00370 }
00371
00372
00373
00374 if ((indirect_block[i] == 0) && (hole == 0))
00375 {
00376 giis_f.info.id_offset = 0;
00377 giis_f.info.dfragment_flag = 1;
00378 giis_f.info.last_data_block = indirect_block[i - 1];
00379
00380 return 444;
00381 }
00382
00383 if ((i == 1024 || indirect_block[i] == 0) && hole)
00384 {
00385 giis_f.info.id_offset += count;
00386 giis_f.info.dfragment_flag = 2;
00387 giis_f.info.last_data_block = indirect_block[i - 1];
00388
00389
00390
00391 fp = open (DIND_INFO_FILE, 1);
00392 if (fp == -1)
00393 {
00394 perror ("Open:");
00395 printf ("Error no :%d", errno);
00396 return -1;
00397 }
00398 lseek (fp, 0, 2);
00399 err = write (fp, idata_block, count * sizeof (unsigned long));
00400 if (err != count * sizeof (unsigned long))
00401 {
00402 perror ("write");
00403 printf ("Error no :%d", errno);
00404 return -1;
00405 }
00406 close (fp);
00407 }
00408
00409 if (i == 1024 && indirect_block[1023] != 0)
00410 {
00411 prev = indirect_block[1023];
00412 i_round++;
00413 ret = search4sequence13 ();
00414 if (ret == 444)
00415 return 1;
00416
00417 }
00418
00419
00420 return 444;
00421 }
00422
00423
00424
00425
00426
00427
00428
00429
00430 int avoid_dups ()
00431 {
00432 int fp1, fp2, i, record_no, bity;
00433 unsigned long temp, end;
00434
00435 fp1 = open (DIR_INFO_FILE, 0);
00436 if (fp1 == -1)
00437 {
00438 perror ("open:");
00439 printf ("\nError No:%d", errno);
00440 close (fp1);
00441 return -1;
00442 }
00443 fp2 = open (DIR_INFO_FILE, 0);
00444 if (fp2 == -1)
00445 {
00446 perror ("open:");
00447 printf ("\nError No:%d", errno);
00448 close (fp1);
00449 return -1;
00450 }
00451
00452
00453
00454
00455
00456
00457 end = lseek (fp1, 0, 2);
00458 lseek (fp1, 0, 0);
00459 temp = bity = 0;
00460
00461 while (temp < (end - GIIS_DSIZE))
00462 {
00463 i = read (fp1, giis_d.buffer, GIIS_DSIZE);
00464 if (i != GIIS_DSIZE)
00465 {
00466 perror ("read1()");
00467 printf ("\nError No:%d \t fp=%d", errno, fp1);
00468 close (fp1);
00469 return -1;
00470 }
00471 temp += GIIS_DSIZE;
00472
00473
00474
00475 lseek (fp2, lseek (fp1, 0, 1), 0);
00476
00477 while (i > 0)
00478 {
00479 i = read (fp2, giis_dt.buffer, GIIS_DSIZE);
00480
00481 if ((giis_d.info.inode_number == giis_dt.info.inode_number)
00482 && (giis_dt.info.search_flag == 1))
00483 {
00484
00485
00486
00487 record_no = lseek (fp2, 0, 1) / GIIS_DSIZE;
00488 call2remove (record_no);
00489 }
00490 }
00491 }
00492 close (fp1);
00493 close (fp2);
00494 return 1;
00495 }
00496
00497
00498
00499
00500
00501
00502
00503
00504 int call2remove (int record_no)
00505 {
00506 int fdes, i;
00507 fdes = open (DIR_INFO_FILE, 2);
00508 if (fdes == -1)
00509 {
00510 perror ("open");
00511 return -1;
00512 }
00513
00514 lseek (fdes, (record_no - 1) * GIIS_DSIZE, 0);
00515 i = read (fdes, giis_dt.buffer, GIIS_DSIZE);
00516 if (i != GIIS_DSIZE)
00517 {
00518 perror ("read1()");
00519 printf ("\nError No:%d \t fp=%d", errno, fdes);
00520 close (fdes);
00521 return -1;
00522 }
00523
00524
00525 giis_dt.info.search_flag = 0;
00526 lseek (fdes, -GIIS_DSIZE, 1);
00527 i = write (fdes, giis_dt.buffer, GIIS_DSIZE);
00528
00529 if (i != GIIS_DSIZE)
00530 {
00531 perror ("read1()");
00532 printf ("\nError No:%d \t fp=%d", errno, fdes);
00533 close (fdes);
00534 return -1;
00535 }
00536
00537
00538 close (fdes);
00539 return 1;
00540
00541 }
00542
00543
00544
00545
00546
00547 int check4file_dups (unsigned long parent)
00548 {
00549 int i, fp;
00550
00551 fp = open (FILE_INFO_FILE, 0);
00552 if (fp == -1)
00553 {
00554 perror ("open");
00555 return -1;
00556 }
00557 if (lseek (fp, 0, 0) == lseek (fp, 0, 2))
00558 {
00559 close (fp);
00560 return 1;
00561 }
00562 lseek (fp, 0, 0);
00563
00564 i = read (fp, giis_f.buffer, GIIS_FSIZE);
00565 while (i > 0)
00566 {
00567 if ((giis_f.info.inode_number == ide.de.inode)
00568 && (giis_f.info.parent_inode_number == parent)
00569 && (giis_f.info.file_size == iin.in.i_size))
00570 {
00571 close (fp);
00572 return 0;
00573 }
00574 i = read (fp, giis_f.buffer, GIIS_FSIZE);
00575 CHECK}
00576 close (fp);
00577 return 1;
00578 }
00579
00580
00581
00582
00583
00584 int check4dir_dups (unsigned long parent)
00585 {
00586 int i, fp;
00587
00588 if (ide.de.inode == ROOT_INODE)
00589 return 0;
00590 if (ide.de.name[0] == '.')
00591 return 0;
00592 fp = open (DIR_INFO_FILE, 0);
00593 if (fp == -1)
00594 {
00595 perror ("open");
00596 return -1;
00597 }
00598 if (lseek (fp, 0, 0) == lseek (fp, 0, 2))
00599 {
00600 close (fp);
00601 return 1;
00602 }
00603 lseek (fp, 0, 0);
00604
00605 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00606 while (i > 0)
00607 {
00608 if (giis_d.info.inode_number == ide.de.inode)
00609 {
00610 close (fp);
00611 return 0;
00612 }
00613 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00614 CHECK}
00615 close (fp);
00616 dir_level = 1;
00617 i = dir_depth (parent);
00618 CHECK if ((i == 444) && (dir_level < LEVEL_VALUE))
00619 return 1;
00620
00621 if ((i == 444) && (dir_level > LEVEL_VALUE))
00622 return 0;
00623
00624 return 0;
00625 }
00626
00627
00628
00629
00630
00631 int dir_depth (unsigned long inode)
00632 {
00633 int i, fp;
00634
00635 if (inode == ROOT_INODE)
00636 return 444;
00637 fp = open (DIR_INFO_FILE, 0);
00638 if (fp == -1)
00639 {
00640 perror ("open");
00641 return -1;
00642 }
00643
00644 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00645
00646 while (i > 0)
00647 {
00648 if (inode == ROOT_INODE)
00649 return 444;
00650
00651 if (giis_d.info.inode_number == inode)
00652 {
00653 close (fp);
00654 dir_level++;
00655 i = dir_depth (giis_d.info.parent_inode_number);
00656 if (i == 444)
00657 return i;
00658 else
00659 return 0;
00660 }
00661 i = read (fp, giis_d.buffer, GIIS_DSIZE);
00662 CHECK}
00663 close (fp);
00664 return 0;
00665 }
00666
00667
00668
00669
00670
00671 int get_sample_data ()
00672 {
00673 int sfp, ffp, dfp, i, ret;
00674 unsigned long device_block_number;
00675 char sample[32];
00676
00677
00678 sfp = open (SAMPLE_DATA_FILE, O_RDWR);
00679 if (sfp == -1)
00680 {
00681 printf ("\nFile Not found %s", SAMPLE_DATA_FILE);
00682 return -1;
00683 }
00684
00685 dfp = open (device_name, 0);
00686 if (dfp == -1)
00687 {
00688 perror ("open");
00689 ERROR}
00690
00691
00692 ffp = open (FILE_INFO_FILE, 0);
00693 if (ffp == -1)
00694 {
00695 perror ("open");
00696 return -1;
00697 }
00698
00699 i = read (ffp, giis_f.buffer, GIIS_FSIZE);
00700
00701 while (i > 0)
00702 {
00703
00704
00705 ret = check4samplefile_dups (giis_f.info.inode_number);
00706
00707 if (ret)
00708 {
00709 fs.block_number = giis_f.info.data_block[0];
00710 if (fs.block_number != 0)
00711 {
00712 i = eye_on_gd ();
00713 if (i == -1)
00714 {
00715 printf ("\n\tAbnormal : Group Descriptor not found ");
00716 close (ffp);
00717 close (dfp);
00718 close (sfp);
00719 return -1;
00720 }
00721 device_block_number =
00722 ((fs.block_number - 1) % fs.blocks_per_group) +
00723 fs.group_number * fs.blocks_per_group;
00724 device_block_number += fs.first_data_block;
00725 fs.content_offset =
00726 (unsigned long long) device_block_number *(unsigned long long) fs.block_size;
00727 fs.content_offset += fs.block_size;
00728
00729 lseek64 (dfp, fs.content_offset, 0);
00730
00731 for (i = 0; i < 32; i++)
00732 {
00733 giis_s.info.sdata[i] = '\0';
00734 }
00735
00736 i = read (dfp, sample, 32);
00737 if (i != 32)
00738 {
00739 perror ("read():get_sample_data()");
00740 printf ("\nError No:%d", errno);
00741 close (ffp);
00742 close (dfp);
00743 close (sfp);
00744 return -1;
00745 }
00746 sample[31] = '\0';
00747 strcpy (giis_s.info.sdata, sample);
00748 giis_s.info.inode_number = giis_f.info.inode_number;
00749
00750
00751
00752 i = write (sfp, giis_s.buffer, GIIS_SSIZE);
00753 if (i != GIIS_SSIZE)
00754 {
00755 perror (" write():");
00756 printf ("\nError No:%d", errno);
00757 close (ffp);
00758 close (dfp);
00759 close (sfp);
00760 return -1;
00761
00762 }
00763 }
00764 }
00765
00766 i = read (ffp, giis_f.buffer, GIIS_FSIZE);
00767 CHECK}
00768 close (ffp);
00769 close (dfp);
00770 close (sfp);
00771 return 0;
00772 }
00773
00774
00775
00776
00777
00778 int check4samplefile_dups (unsigned long temp_inode_number)
00779 {
00780 int i, fp;
00781 fp = open (SAMPLE_DATA_FILE, 0);
00782 if (fp == -1)
00783 {
00784 perror ("open");
00785 return -1;
00786 }
00787 if (lseek (fp, 0, 0) == lseek (fp, 0, 2))
00788 {
00789 close (fp);
00790 return 1;
00791 }
00792 lseek (fp, 0, 0);
00793
00794 i = read (fp, giis_s.buffer, GIIS_SSIZE);
00795 while (i > 0)
00796 {
00797 if (giis_s.info.inode_number == temp_inode_number)
00798 {
00799 close (fp);
00800 return 0;
00801 }
00802 i = read (fp, giis_s.buffer, GIIS_SSIZE);
00803 CHECK}
00804 close (fp);
00805 return 1;
00806 }