int main(int argc, char * argv[]){
FILE *ifp,*ofp;
if(argc > 3 || argc < 2)
report_exit("error: command inputfile");
ifp = fopen(argv[1], "r") ;
ofp = fopen(argv[2], "w") ;
if( InputFile(ifp) != 1 )
report_exit("Error reading file");
char buf[80];
int i;
FILE * pFig = fopen("cluster.fig","w");
// start to test
preprocess_block(&blockage);
preprocess_sinks(&sink);
construct_g_all(&blockage,&sink);
all_pair_shortest();
cluster_sinks(&blockage,&sink);
draw_case(pFig);
draw_link_sink(pFig);
free_clusters();
free_all();
return 0;
}
int main(int argc, char** argv) {
int LCS_threshold=0,n=0,i=0,j=0;
char clustername[10];
create_cluster();
display_clusters();
printf("NC_LCS=%d",((int)large_cluster(cnode)));
printf("\nEnter the LCS threshold:");
scanf("%d",&LCS_threshold);
printf("\nEnter the cluster name:");
scanf("%s",clustername);
n=num_of_clusters;
for(i=0;i<n;i++)
{
if((strcmp((cnode+i)->cname,clustername)==0))
{
for(j=0;j<((cnode+i)->num_of_pages);j++)
{
printf("\n%s",(((cnode+i)->pagelink)+j)->pname);
}
}
}
free_clusters();
return (EXIT_SUCCESS);
}
int main(int argc, char** argv) {
uint8_t *image_buf;
int fd;
struct bpb33* bpb;
if (argc < 2) {
usage(argv[0]);
}
image_buf = mmap_file(argv[1], &fd);
bpb = check_bootsector(image_buf);
traverse_root(image_buf, bpb);
foster_orphans(image_buf, bpb);
free_clusters();
free(bpb);
unmmap_file(image_buf, &fd);
return 0;
}
static int remove_entry(struct ghostfs *gfs, const char *path, bool is_dir)
{
struct dir_iter link, it;
int ret;
ret = dir_iter_lookup(gfs, &link, path, false);
if (ret < 0)
return ret;
if (link.entry == &gfs->root_entry)
return -EINVAL;
if (is_dir != dir_entry_is_directory(link.entry))
return is_dir ? -ENOTDIR : -EISDIR;
// no clusters, we are done
if (!link.entry->cluster)
goto unlink;
ret = dir_iter_init(gfs, &it, link.entry->cluster);
if (ret < 0)
return ret;
// make sure directory is empty
if (is_dir) {
if (dir_entry_used(it.entry))
return -ENOTEMPTY;
ret = dir_iter_next_used(&it);
if (ret != -ENOENT)
return ret == 0 ? -ENOTEMPTY : ret;
}
free_clusters(gfs, it.cluster);
unlink:
link.entry->filename[0] = '\0';
cluster_set_dirty(link.cluster, true);
return 0;
}
void check_file_length(uint16_t cluster, uint8_t *image_buf, struct bpb33* bpb)
{
struct direntry *dirent;
int d, i;
dirent = (struct direntry*) cluster_to_addr(cluster, image_buf, bpb);
int clust_size = bpb->bpbBytesPerSec * bpb->bpbSecPerClust;
while (1) {
for (d = 0; d < clust_size; d += sizeof(struct direntry)) {
char name[9];
char extension[4];
uint32_t size;
uint16_t file_cluster;
name[8] = ' ';
extension[3] = ' ';
memcpy(name, &(dirent->deName[0]), 8);
memcpy(extension, dirent->deExtension, 3);
if (name[0] == SLOT_EMPTY)
return;
/* skip over deleted entries */
if (((uint8_t)name[0]) == SLOT_DELETED)
continue;
/* names are space padded - remove the spaces */
for (i = 8; i > 0; i--) {
if (name[i] == ' ')
name[i] = '\0';
else
break;
}
/* remove the spaces from extensions */
for (i = 3; i > 0; i--) {
if (extension[i] == ' ')
extension[i] = '\0';
else
break;
}
/* don't print "." or ".." directories */
if (strcmp(name, ".") == 0) {
dirent++;
continue;
}
if (strcmp(name, "..") == 0) {
dirent++;
continue;
}
if ((dirent->deAttributes & ATTR_VOLUME) != 0) {
continue;
} else if ((dirent->deAttributes & ATTR_DIRECTORY) != 0) {
file_cluster = getushort(dirent->deStartCluster);
check_file_length(file_cluster, image_buf, bpb);
} else {
size = getulong(dirent->deFileSize);
file_cluster = getushort(dirent->deStartCluster);
uint16_t fat_size_clusters = get_file_length(file_cluster, image_buf, bpb);
uint32_t size_clusters = (size + (clust_size - 1)) / clust_size;
uint32_t fat_size = fat_size_clusters * clust_size;
if (size_clusters != fat_size_clusters) {
printf("%s.%s %u %u\n", name, extension, size, fat_size);
uint16_t begin_cluster = file_cluster + size_clusters - 1;
uint16_t end_cluster = file_cluster + fat_size_clusters;
free_clusters(begin_cluster, end_cluster, image_buf, bpb);
}
}
dirent++;
}
/* We've reached the end of the cluster for this directory. Where's the next cluster? */
if (cluster == 0) {
// root dir is special
dirent++;
} else {
cluster = get_fat_entry(cluster, image_buf, bpb);
dirent = (struct direntry*) cluster_to_addr(cluster, image_buf, bpb);
}
}
}
static int do_truncate(struct ghostfs *gfs, struct dir_iter *it, off_t new_size)
{
int ret;
int count;
int next;
struct cluster *c = NULL;
if (new_size < 0)
return -EINVAL;
if (new_size > FILESIZE_MAX)
return -EFBIG;
if (dir_entry_is_directory(it->entry))
return -EISDIR;
next = it->entry->cluster;
count = size_to_clusters(min(it->entry->size, new_size));
if (count) {
ret = cluster_at(gfs, next, count - 1, &c);
if (ret < 0)
return ret;
next = c->hdr.next;
}
if (new_size > it->entry->size) {
int alloc;
long used = it->entry->size % CLUSTER_DATA;
// zero remaining cluster space
if (used) {
memset(c->data + used, 0, CLUSTER_DATA - used);
cluster_set_dirty(c, true);
}
alloc = size_to_clusters(new_size) - count;
if (alloc) {
ret = alloc_clusters(gfs, alloc, NULL, true);
if (ret < 0)
return ret;
if (c) {
c->hdr.next = ret;
cluster_set_dirty(c, true);
} else {
it->entry->cluster = ret;
}
}
} else if (new_size < it->entry->size) {
if (next) {
if (c) {
c->hdr.next = 0;
cluster_set_dirty(c, true);
}
ret = cluster_get(gfs, next, &c);
if (ret < 0)
return ret;
free_clusters(gfs, c);
}
}
dir_entry_set_size(it->entry, new_size, false);
cluster_set_dirty(it->cluster, true);
return 0;
}
static int create_entry(struct ghostfs *gfs, const char *path, bool is_dir,
struct dir_entry **entry)
{
struct dir_iter it;
struct cluster *prev = NULL, *next = NULL;
const char *name;
int cluster_nr = 0;
int ret;
ret = dir_iter_lookup(gfs, &it, path, true);
if (ret < 0)
return ret;
if (!dir_entry_is_directory(it.entry))
return -ENOTDIR;
name = last_component(path);
if (strlen(name) > FILENAME_SIZE - 1)
return -ENAMETOOLONG;
if (!name[0])
return -EINVAL;
if (dir_contains(gfs, it.entry->cluster, name) == 0)
return -EEXIST;
ret = find_empty_entry(gfs, &it, it.entry->cluster);
if (ret < 0) {
int nr;
if (ret != -ENOENT)
return ret;
nr = alloc_clusters(gfs, 1, &next, true);
if (nr < 0)
return nr;
prev = it.cluster;
find_empty_entry(gfs, &it, nr);
prev->hdr.next = nr;
cluster_set_dirty(prev, true);
}
if (is_dir) {
cluster_nr = alloc_clusters(gfs, 1, NULL, true);
if (cluster_nr < 0) {
if (next) {
free_clusters(gfs, next);
prev->hdr.next = 0;
}
return cluster_nr;
}
}
strcpy(it.entry->filename, name);
dir_entry_set_size(it.entry, 0, is_dir);
it.entry->cluster = cluster_nr;
cluster_set_dirty(it.cluster, true);
if (entry)
*entry = it.entry;
return 0;
}
