/**
* Free a HttpRequest object
*/
static void destroy_HttpRequest(HttpRequest req) {
if(req) {
FREE(req->method);
FREE(req->url);
FREE(req->pathinfo);
FREE(req->protocol);
FREE(req->remote_user);
if(req->headers)
destroy_entry(req->headers);
if(req->params)
destroy_entry(req->params);
FREE(req);
}
}
/**
* Parse request parameters from the given query string and return a
* linked list of HttpParameters
*/
static HttpParameter parse_parameters(char *query_string) {
#define KEY 1
#define VALUE 2
int token;
int cursor= 0;
char *key= NULL;
char *value= NULL;
HttpParameter head= NULL;
while((token= get_next_token(query_string, &cursor, &value))) {
if(token==KEY)
key= value;
else if(token==VALUE) {
HttpParameter p= NULL;
if(!key) goto error;
NEW(p);
p->name= key;
p->value= value;
p->next= head;
head= p;
key= NULL;
}
}
return head;
error:
FREE(key);
FREE(value);
if ( head != NULL ) {
destroy_entry(head);
}
return NULL;
}
/*
* Function: void destroy_root( Bt_Entry* root, destroy_item del_item )
* Description: destroy binary tree
* Input: root: binary tree root entry
* del_item: item deleting function
* Output: none
* Return: void
* Others: none
*/
void destroy_root( Bt_Entry* root, destroy_item del_item )
{
if( !root )
{
return;
}
if( root->right )
{
destroy_root( root->right, del_item );
}
if( root->left )
{
destroy_root( root->left, del_item );
}
if( root )
{
if( del_item )
{
( *del_item )( root->item );
}
_( printf( "destroy entry with item[%s]\n", ( char * )root->item ) );
destroy_entry( root );
}
}
void* stack_pop(stack* stk)
{
list_entry* tmp = stk->top;
stk->top = tmp->next;
stk->entries--;
return destroy_entry(tmp);
}
/**
* Clear the response output buffer and headers
*/
static void reset_response(HttpResponse res) {
if(res->headers) {
destroy_entry(res->headers);
res->headers= NULL; /* Release Pragma */
}
StringBuffer_clear(res->outputbuffer);
}
/**
* Destroy a search table.
*/
static void
st_destroy(search_table_t *table)
{
int i;
search_table_check(table);
if (table->bins) {
for (i = 0; i < table->nbins; i++) {
struct st_bin *bin = table->bins[i];
if (bin) {
bin_destroy(bin);
WFREE(bin);
}
}
HFREE_NULL(table->bins);
}
if (table->all_entries.vals) {
for (i = 0; i < table->all_entries.nvals; i++) {
destroy_entry(table->all_entries.vals[i]);
table->all_entries.vals[i] = NULL;
}
bin_destroy(&table->all_entries);
}
}
/*
*void* destroy_list( List* l, destroy_item del_item )
* Description: release one List object
* Input: l: the List object
* del_item: the function that is used to release item field of List_Entry
* Output: none
* Return: void
* Others: none
*/
void* destroy_list( List* l, destroy_item del_item )
{
List_Entry* next, *cur;
if( !l )
{
printf("none for list\n");
return;
}
if( !l->head )
{
printf("none for list entry head\n");
free( l );
return;
}
cur = l->head;
while( cur )
{
next = cur->next;
if( del_item )
{
( *del_item )( cur->item );
}
destroy_entry( cur );
cur = next;
}
free( l );
}
/**
* Free a HttpResponse object
*/
static void destroy_HttpResponse(HttpResponse res) {
if(res) {
StringBuffer_free(&(res->outputbuffer));
if(res->headers)
destroy_entry(res->headers);
FREE(res);
}
}
/**
* Free a (linked list of) http entry object(s). Both HttpHeader and
* HttpParameter are of this type.
*/
static void destroy_entry(void *p) {
struct entry *h= p;
if(h->next) {
destroy_entry(h->next);
}
FREE(h->name);
FREE(h->value);
FREE(h);
}
void *
list_shift_value(linked_list_t *list)
{
void *val = NULL;
list_entry_t *entry = shift_entry(list);
if(entry)
{
val = entry->value;
destroy_entry(entry);
}
return val;
}
void *
list_fetch_value(linked_list_t *list, size_t pos)
{
void *val = NULL;
list_entry_t *entry = fetch_entry(list, pos);
if(entry)
{
val = entry->value;
destroy_entry(entry);
}
return val;
}
int
list_insert_value(linked_list_t *list, void *val, size_t pos)
{
int res;
list_entry_t *new_entry = create_entry();
if(!new_entry)
return -1;
new_entry->value = val;
res=insert_entry(list, new_entry, pos);
if(res != 0)
destroy_entry(new_entry);
return res;
}
int
list_unshift_value(linked_list_t *list, void *val)
{
int res;
list_entry_t *new_entry = create_entry();
if(!new_entry)
return -1;
new_entry->value = val;
res = unshift_entry(list, new_entry);
if(res != 0)
destroy_entry(new_entry);
return res;
}
/*
* Clear a linked_list_t. Removes all entries in list
* if values are associated to entries, resources for those will not be freed.
* list_clear() can be used safely with entry-based and tagged-based api,
* otherwise you must really know what you are doing
*/
void
list_clear(linked_list_t *list)
{
list_entry_t *e;
/* Destroy all entries still in list */
while((e = shift_entry(list)) != NULL)
{
/* if there is a tagged_value_t associated to the entry,
* let's free memory also for it */
if(e->tagged && e->value)
list_destroy_tagged_value_internal((tagged_value_t *)e->value, list->free_value_cb);
else if (list->free_value_cb)
list->free_value_cb(e->value);
destroy_entry(e);
}
}
/*
* Instert an entry at a specified position in a linked_list_t
*/
static inline int
insert_entry(linked_list_t *list, list_entry_t *entry, size_t pos)
{
list_entry_t *prev, *next;
int ret = -1;
MUTEX_LOCK(list->lock);
if(pos == 0) {
ret = unshift_entry(list, entry);
} else if(pos == list->length) {
ret = push_entry(list, entry);
} else if (pos > list->length) {
unsigned int i;
for (i = list->length; i < pos; i++) {
list_entry_t *emptyEntry = create_entry();
if (!emptyEntry || push_entry(list, emptyEntry) != 0)
{
if (emptyEntry)
destroy_entry(emptyEntry);
MUTEX_UNLOCK(list->lock);
return -1;
}
}
ret = push_entry(list, entry);
}
if (ret == 0) {
MUTEX_UNLOCK(list->lock);
return ret;
}
prev = pick_entry(list, pos-1);
if(prev)
{
next = prev->next;
prev->next = entry;
entry->prev = prev;
entry->next = next;
if (next)
next->prev = entry;
list->length++;
ret = 0;
}
MUTEX_UNLOCK(list->lock);
return ret;
}
int
slice_foreach_value(slice_t *slice, int (*item_handler)(void *item, size_t idx, void *user), void *user)
{
linked_list_t *list = slice->list;
MUTEX_LOCK(list->lock);
size_t idx = 0;
list_entry_t *e = pick_entry(list, slice->offset);
while(e && idx < slice->length) {
int rc = item_handler(e->value, idx++, user);
if (rc == 0) {
break;
} else if (rc == -1 || rc == -2) {
list_entry_t *d = e;
e = e->next;
if (list->head == list->tail && list->tail == d) {
list->head = list->tail = NULL;
} else if (d == list->head) {
list->head = d->next;
list->head->prev = NULL;
} else if (d == list->tail) {
list->tail = d->prev;
list->tail->next = NULL;
} else {
e->prev = d->prev;
e->prev->next = e;
}
d->list = NULL;
if (list->cur == d)
list->cur = NULL;
list->length--;
slice->length--;
// the callback got the value and will take care of releasing it
destroy_entry(d);
if (rc == -2) // -2 means : remove and stop the iteration
break;
// -1 instead means that we still want to remove the item
// but we also want to go ahead with the iteration
} else {
e = e->next;
}
}
MUTEX_UNLOCK(list->lock);
return idx;
}
int
list_insert_tagged_value(linked_list_t *list, tagged_value_t *tval, size_t pos)
{
int res = 0;
list_entry_t *new_entry;
if(tval)
{
new_entry = create_entry();
if(new_entry)
{
new_entry->tagged = 1;
new_entry->value = tval;
res = insert_entry(list, new_entry, pos);
if(res != 0)
destroy_entry(new_entry);
}
}
return res;
}
int
list_unshift_tagged_value(linked_list_t *list, tagged_value_t *tval)
{
int res = 0;
list_entry_t *new_entry;
if(tval)
{
new_entry = create_entry();
if(new_entry)
{
new_entry->tagged = 1;
new_entry->value = tval;
res = unshift_entry(list, new_entry);
if(res != 0)
destroy_entry(new_entry);
}
}
return res;
}
void
slice_destroy(slice_t *slice)
{
linked_list_t *list = slice->list;
list_entry_t *cur = list->slices;
list_entry_t *prev = NULL;
while (cur) {
if (cur->value == slice) {
if (prev) {
prev->next = cur->next;
cur->next->prev = prev;
} else {
list->slices = cur->next;
}
destroy_entry(cur);
break;
}
prev = cur;
cur = cur->next;
}
free(slice);
}
/**
* Adds a response header with the given name and value. If the header
* had already been set the new value overwrites the previous one.
* @param res HttpResponse object
* @param name Header key name
* @param value Header key value
*/
void set_header(HttpResponse res, const char *name, const char *value) {
HttpHeader h= NULL;
ASSERT(res);
ASSERT(name);
NEW(h);
h->name= Str_dup(name);
h->value= Str_dup(value);
if(res->headers) {
HttpHeader n, p;
for( n= p= res->headers; p; n= p, p= p->next) {
if(!strcasecmp(p->name, name)) {
FREE(p->value);
p->value= Str_dup(value);
destroy_entry(h);
return;
}
}
n->next= h;
} else {
res->headers= h;
}
}
static void workspace_nfs_readdirplus_simple(fuse_req_t req, size_t size, off_t offset, struct workspace_dh_struct *dh)
{
struct resource_struct *resource=dh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
unsigned int error=0;
char *buff=NULL;
size_t pos=0;
size_t dirent_size;
struct fuse_entry_param e;
char *name=NULL;
struct directory_struct *directory=dh->directory;
struct nfsdir *dir=(struct nfsdir *) dh->handle.data;
struct entry_struct *entry, *result;
struct inode_struct *inode;
struct name_struct xname={NULL, 0, 0};
memset(&e, 0, sizeof(struct fuse_entry_param));
e.generation = 1;
e.attr_timeout = fs_options.attr_timeout;
e.entry_timeout = fs_options.entry_timeout;
e.attr.st_blksize=_DEFAULT_BLOCKSIZE;
buff=malloc(size);
if (! buff) {
error=ENOMEM;
goto error;
}
if (lock_directory(directory, _DIRECTORY_LOCK_EXCL)==-1) {
free(buff);
buff=NULL;
error=EAGAIN;
goto error;
}
while (pos<size) {
if (offset==0) {
inode=dh->parent->inode;
/* the . entry */
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = inode->size;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
name = (char *) dotname;
inode->nlookup++;
} else if (offset==1) {
/* the .. entry */
if ( ! dh->parent->parent ) {
inode=dh->parent->inode;
} else {
inode=dh->parent->parent->inode;
}
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = inode->size;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
name = (char *) dotdotname;
inode->nlookup++;
} else {
if (! dh->entry) {
struct nfsdirent *de;
readdir:
pthread_mutex_lock(&nfs_export->mutex);
de=nfs_readdir(nfs_ctx, dir);
pthread_mutex_unlock(&nfs_export->mutex);
if (de) {
if (strcmp(de->name, ".")==0 || strcmp(de->name, "..")==0) continue;
xname.name=de->name;
xname.len=strlen(xname.name);
calculate_nameindex(&xname);
} else {
dh->mode |= _WORKSPACE_READDIR_MODE_FINISH;
break;
}
error=0;
entry=create_entry(dh->parent, &xname);
inode=create_inode();
if (entry && inode) {
result=insert_entry_batch(directory, entry, &error, 0);
if (result==entry) {
struct workspace_object_struct *export_object=NULL;
inode->mode = translate_libnfs_type(de->type);
inode->mode |= de->mode;
add_inode_hashtable(inode, increase_inodes_workspace, (void *) dh->object->workspace_mount);
inode->alias=entry;
entry->inode=inode;
memcpy(&entry->synctime, &dh->synctime, sizeof(struct timespec));
inode->nlookup++;
inode->nlink=2;
inode->uid=0; /* ?? */
inode->gid=0; /* ?? */
inode->size=de->size;
/* struct timeval convert to timespec */
inode->mtim.tv_sec=de->mtime.tv_sec;
inode->mtim.tv_nsec=1000 * de->mtime.tv_usec;
inode->ctim.tv_sec=de->ctime.tv_sec;
inode->ctim.tv_nsec=1000 * de->ctime.tv_usec;
adjust_pathmax(dh->pathinfo.len + 1 + xname.len);
} else {
if (error==EEXIST) {
destroy_entry(entry);
entry=result;
memcpy(&entry->synctime, &dh->synctime, sizeof(struct timespec));
free(inode);
inode=entry->inode;
} else {
free(buff);
destroy_entry(entry);
free(inode);
goto error;
}
}
} else {
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
error=ENOMEM;
free(buff);
goto error;
}
name=entry->name.name;
dh->entry=entry;
} else {
entry=dh->entry;
inode=entry->inode;
name=entry->name.name;
}
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = inode->size;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
if (inode->size % e.attr.st_blksize == 0) {
e.attr.st_blocks=inode->size / e.attr.st_blksize;
} else {
e.attr.st_blocks=1 + inode->size / e.attr.st_blksize;
}
}
dirent_size=fuse_add_direntry_plus(req, buff+pos, size-pos, name, &e, offset+1);
if (pos + dirent_size > size) {
dh->offset=offset;
break;
}
/* increase counter and clear the various fields */
dh->entry=NULL; /* forget current entry to force readdir */
offset++;
pos += dirent_size;
}
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
fuse_reply_buf(req, buff, pos);
free(buff);
buff=NULL;
return;
error:
fuse_reply_err(req, error);
}
int
main(int argc, char *argv[])
{
size_t path_len, total_files;
off_t bytes_wasted, total_wasted;
char path_buffer[PATH_MAX_LEN], *hash_value;
struct file_entry_t *file_entry, *trie_entry;
SListIterator slist_iterator;
SetIterator set_iterator;
/* Step 0: Session data */
struct file_info_t file_info;
clear_info(&file_info);
/* Step 1: Parse arguments */
while (--argc) {
/* Being unable to record implies insufficient resources */
if (!record(argv[argc], &file_info)){
fprintf(stderr, "[FATAL] out of memory\n");
destroy_info(&file_info);
return (EXIT_FAILURE);
}
}
/* Step 2: Fully explore any directories specified */
#ifndef NDEBUG
printf("[DEBUG] Creating file list...\n");
#endif
while (slist_length(file_info.file_stack) > 0) {
/* Pick off the top of the file stack */
file_entry = (struct file_entry_t *)(slist_data(file_info.file_stack));
slist_remove_entry(&file_info.file_stack, file_info.file_stack);
assert(file_entry->type == DIRECTORY);
/* Copy the basename to a buffer */
memset(path_buffer, '\0', PATH_MAX_LEN);
path_len = strnlen(file_entry->path, PATH_MAX_LEN);
memcpy(path_buffer, file_entry->path, path_len);
/* Ignore cases that would cause overflow */
if (path_len < PATH_MAX_LEN) {
/* Append a trailing slash */
path_buffer[path_len] = '/';
/* Record all contents (may push onto file stack or one of the lists) */
DIR *directory = opendir(file_entry->path);
if (traverse(&file_info, directory, path_buffer, ++path_len)) {
fprintf(stderr, "[FATAL] out of memory\n");
destroy_info(&file_info);
return (EXIT_FAILURE);
} else if (closedir(directory)) {
fprintf(stderr, "[WARNING] '%s' (close failed)\n", file_entry->path);
}
}
/* Discard this entry */
destroy_entry(file_entry);
}
/* Step 3: Warn about any ignored files */
if (slist_length(file_info.bad_files) > 0) {
slist_iterate(&file_info.bad_files, &slist_iterator);
while (slist_iter_has_more(&slist_iterator)) {
file_entry = slist_iter_next(&slist_iterator);
fprintf(stderr, "[WARNING] '%s' ", file_entry->path);
switch (file_entry->type) {
case INVALID:
++file_info.invalid_files;
fprintf(stderr, "(invalid file)\n");
break;
case INACCESSIBLE:
++file_info.protected_files;
fprintf(stderr, "(protected file)\n");
break;
default:
++file_info.irregular_files;
fprintf(stderr, "(irregular file)\n");
break;
}
}
fprintf(stderr, "[WARNING] %lu file(s) ignored\n",
(long unsigned)(num_errors(&file_info)));
}
#ifndef NDEBUG
if (num_errors(&file_info) > 0) {
fprintf(stderr, "[FATAL] cannot parse entire file tree\n");
destroy_info(&file_info);
return (EXIT_FAILURE);
}
printf("[DEBUG] Found %lu / %lu valid files\n",
(unsigned long)(num_files(&file_info)),
(unsigned long)(file_info.total_files));
#endif
/* Step 4: Begin the filtering process */
#ifndef NDEBUG
printf("[DEBUG] Creating file table...\n");
#endif
if (slist_length(file_info.good_files) > 0) {
file_info.hash_trie = trie_new();
file_info.shash_trie = trie_new();
optimize_filter(&file_info);
/* Extract each file from the list (they should all be regular) */
slist_iterate(&file_info.good_files, &slist_iterator);
while (slist_iter_has_more(&slist_iterator)) {
file_entry = slist_iter_next(&slist_iterator);
assert(file_entry->type == REGULAR);
/* Perform a "shallow" hash of the file */
hash_value = hash_entry(file_entry, SHALLOW);
#ifndef NDEBUG
printf("[SHASH] %s\t*%s\n", file_entry->path, hash_value);
#endif
/* Check to see if we might have seen this file before */
if (bloom_filter_query(file_info.shash_filter, hash_value)) {
/* Get the full hash of the new file */
hash_value = hash_entry(file_entry, FULL);
#ifndef NDEBUG
printf("[+HASH] %s\t*%s\n", file_entry->path, hash_value);
#endif
archive(&file_info, file_entry);
/* Check to see if bloom failed us */
trie_entry = trie_lookup(file_info.shash_trie, file_entry->shash);
if (trie_entry == TRIE_NULL) {
#ifndef NDEBUG
printf("[DEBUG] '%s' (false positive)\n", file_entry->path);
#endif
trie_insert(file_info.shash_trie, file_entry->shash, file_entry);
} else {
/* Get the full hash of the old file */
hash_value = hash_entry(trie_entry, FULL);
#ifndef NDEBUG
if (hash_value) {
printf("[-HASH] %s\t*%s\n", trie_entry->path, hash_value);
}
#endif
archive(&file_info, trie_entry);
}
} else {
/* Add a record of this shash to the filter */
bloom_filter_insert(file_info.shash_filter, hash_value);
trie_insert(file_info.shash_trie, hash_value, file_entry);
}
}
persist("bloom_store", &file_info);
}
/* Step 5: Output results and cleanup before exit */
printf("[EXTRA] Found %lu sets of duplicates...\n",
(unsigned long)(slist_length(file_info.duplicates)));
slist_iterate(&file_info.duplicates, &slist_iterator);
for (total_files = total_wasted = bytes_wasted = 0;
slist_iter_has_more(&slist_iterator);
total_wasted += bytes_wasted)
{
Set *set = slist_iter_next(&slist_iterator);
int size = set_num_entries(set);
if (size < 2) { continue; }
printf("[EXTRA] %lu files (w/ same hash):\n", (unsigned long)(size));
set_iterate(set, &set_iterator);
for (bytes_wasted = 0;
set_iter_has_more(&set_iterator);
bytes_wasted += file_entry->size,
++total_files)
{
file_entry = set_iter_next(&set_iterator);
printf("\t%s (%lu bytes)\n",
file_entry->path,
(unsigned long)(file_entry->size));
}
}
printf("[EXTRA] %lu bytes in %lu files (wasted)\n",
(unsigned long)(total_wasted),
(unsigned long)(total_files));
destroy_info(&file_info);
return (EXIT_SUCCESS);
}
static void workspace_nfs_readdir_simple(fuse_req_t req, size_t size, off_t offset, struct workspace_dh_struct *dh)
{
struct resource_struct *resource=dh->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
unsigned int error=0;
char *buff=NULL;
size_t pos=0;
size_t dirent_size;
char *name=NULL;
struct directory_struct *directory=dh->directory;
struct nfsdir *dir=(struct nfsdir *) dh->handle.data;
struct entry_struct *entry, *result;
struct inode_struct *inode;
struct name_struct xname={NULL, 0, 0};
struct stat st;
memset(&st, 0, sizeof(struct stat));
buff=malloc(size);
if (! buff) {
error=ENOMEM;
goto error;
}
if (lock_directory(directory, _DIRECTORY_LOCK_EXCL)==-1) {
free(buff);
buff=NULL;
error=EAGAIN;
goto error;
}
while (pos<size) {
if (offset==0) {
inode=dh->parent->inode;
/* the . entry */
st.st_ino = inode->ino;
st.st_mode = S_IFDIR;
name = (char *) dotname;
} else if (offset==1) {
/* the .. entry */
if (! dh->parent->parent ) {
inode=dh->parent->inode;
st.st_ino = inode->ino;
} else {
struct entry_struct *parent=dh->parent->parent;
inode=parent->inode;
st.st_ino=inode->ino;
}
st.st_mode = S_IFDIR;
name = (char *) dotdotname;
} else {
if (! dh->entry) {
struct nfsdirent *de;
readdir:
pthread_mutex_lock(&nfs_export->mutex);
de=nfs_readdir(nfs_ctx, dir);
pthread_mutex_unlock(&nfs_export->mutex);
if (de) {
if (strcmp(de->name, ".")==0 || strcmp(de->name, "..")==0) continue;
xname.name=de->name;
xname.len=strlen(xname.name);
calculate_nameindex(&xname);
} else {
dh->mode |= _WORKSPACE_READDIR_MODE_FINISH;
break;
}
error=0;
entry=create_entry(dh->parent, &xname);
inode=create_inode();
if (entry && inode) {
result=insert_entry_batch(directory, entry, &error, 0);
if (result==entry) {
struct workspace_object_struct *export_object=NULL;
inode->mode = translate_libnfs_type(de->type);
inode->mode |= de->mode;
add_inode_hashtable(inode, increase_inodes_workspace, (void *) dh->object->workspace_mount);
inode->alias=entry;
entry->inode=inode;
adjust_pathmax(dh->pathinfo.len + 1 + xname.len);
} else {
if (error==EEXIST) {
destroy_entry(entry);
entry=result;
free(inode);
inode=entry->inode;
} else {
free(buff);
destroy_entry(entry);
free(inode);
goto error;
}
}
st.st_mode=entry->inode->mode;
st.st_ino=entry->inode->ino;
name=entry->name.name;
} else {
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
error=ENOMEM;
free(buff);
goto error;
}
dh->entry=entry;
} else {
st.st_ino=dh->entry->inode->ino;
st.st_mode=dh->entry->inode->mode;
name=dh->entry->name.name;
}
}
dirent_size=fuse_add_direntry(req, buff+pos, size-pos, name, &st, offset+1);
if (pos + dirent_size > size) {
dh->offset = offset + 1;
break;
}
/* increase counter and clear the various fields */
dh->entry=NULL; /* forget current entry to force readdir */
offset++;
pos += dirent_size;
}
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
fuse_reply_buf(req, buff, pos);
free(buff);
buff=NULL;
return;
error:
fuse_reply_err(req, error);
}
static void workspace_nfs_mknod(fuse_req_t req, struct inode_struct *pinode, struct name_struct *xname, struct call_info_struct *call_info, mode_t mode, dev_t rdev)
{
struct resource_struct *resource=call_info->object->resource;
struct net_nfs_export_struct *nfs_export=(struct net_nfs_export_struct *) resource->data;
struct nfs_context *nfs_ctx=(struct nfs_context *) nfs_export->data;
char *path=call_info->pathinfo.path + call_info->relpath;
struct entry_struct *entry=NULL, *parent=pinode->alias;
struct inode_struct *inode;
logoutput("workspace_nfs_mknod, path %s", path);
entry=create_entry(parent, xname);
inode=create_inode();
if (entry && inode) {
int result=0;
inode->alias=entry;
entry->inode=inode;
pthread_mutex_lock(&nfs_export->mutex);
result=nfs_mknod(nfs_ctx, path, mode, rdev);
pthread_mutex_unlock(&nfs_export->mutex);
if (result==0) {
struct fuse_entry_param e;
unsigned int error=0;
struct stat st;
memset(&st, 0, sizeof(struct stat));
add_inode_hashtable(inode, increase_inodes_workspace, (void *) call_info->object->workspace_mount);
insert_entry(entry, &error, 0);
adjust_pathmax(call_info->pathinfo.len);
pthread_mutex_lock(&nfs_export->mutex);
nfs_chmod(nfs_ctx, path, mode);
nfs_stat(nfs_ctx, path, &st);
pthread_mutex_unlock(&nfs_export->mutex);
inode->nlookup=1;
inode->mode=st.st_mode;
inode->nlink=st.st_nlink;
inode->uid=st.st_uid;
inode->gid=st.st_gid;
inode->rdev=st.st_rdev;
inode->size=st.st_size;
inode->mtim.tv_sec=st.st_mtim.tv_sec;
inode->mtim.tv_nsec=st.st_mtim.tv_nsec;
inode->ctim.tv_sec=st.st_ctim.tv_sec;
inode->ctim.tv_nsec=st.st_ctim.tv_nsec;
e.ino = inode->ino;
e.generation = 1;
e.attr_timeout = fs_options.attr_timeout;
e.entry_timeout = fs_options.entry_timeout;
e.attr.st_ino = e.ino;
e.attr.st_mode = st.st_mode;
e.attr.st_nlink = st.st_nlink;
e.attr.st_uid = st.st_uid;
e.attr.st_gid = st.st_gid;
e.attr.st_rdev = st.st_rdev;
e.attr.st_atim.tv_sec = st.st_atim.tv_sec;
e.attr.st_atim.tv_nsec = st.st_atim.tv_nsec;
e.attr.st_mtim.tv_sec = st.st_mtim.tv_sec;
e.attr.st_mtim.tv_nsec = st.st_mtim.tv_nsec;
e.attr.st_ctim.tv_sec = st.st_ctim.tv_sec;
e.attr.st_ctim.tv_nsec = st.st_ctim.tv_nsec;
e.attr.st_blksize=_DEFAULT_BLOCKSIZE;
if (inode->size % e.attr.st_blksize == 0) {
e.attr.st_blocks=inode->size / e.attr.st_blksize;
} else {
e.attr.st_blocks=1 + inode->size / e.attr.st_blksize;
}
fuse_reply_entry(req, &e);
} else {
/* error nfs create */
destroy_entry(entry);
free(inode);
fuse_reply_err(req, abs(result));
}
} else {
/* not enough memory to allocate entry and/or inode */
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
fuse_reply_err(req, ENOMEM);
}
free_path_pathinfo(&call_info->pathinfo);
}
static void overlay_readdir_full(fuse_req_t req, size_t size, off_t offset, struct workspace_dh_struct *dh)
{
unsigned int error=0;
char *buff=NULL;
size_t pos=0;
size_t dirent_size;
struct stat st;
char *name=NULL;
struct directory_struct *directory=dh->directory;
struct overlay_readdir_struct *overlay_readdir=(struct overlay_readdir_struct *)dh->handle.data;
struct entry_struct *entry, *result;
struct inode_struct *inode;
struct name_struct xname={NULL, 0, 0};
unsigned char dtype=0;
int res;
memset(&st, 0, sizeof(struct stat));
buff=malloc(size);
if (! buff) {
error=ENOMEM;
goto error;
}
if (lock_directory(directory, _DIRECTORY_LOCK_EXCL)==-1) {
free(buff);
buff=NULL;
error=EAGAIN;
goto error;
}
while (pos<size) {
if (offset==0) {
inode=dh->parent->inode;
/* the . entry */
st.st_ino = inode->ino;
st.st_mode = S_IFDIR;
name = (char *) dotname;
} else if (offset==1) {
/* the .. entry */
if ( ! dh->parent->parent ) {
inode=dh->parent->inode;
st.st_ino = inode->ino;
} else {
struct entry_struct *parent=dh->parent->parent;
inode=parent->inode;
st.st_ino=inode->ino;
}
st.st_mode = S_IFDIR;
name = (char *) dotdotname;
} else {
if (! dh->entry) {
readdir:
res=get_direntry(overlay_readdir, &xname, &dtype, &error);
if (res<=0) {
if (res==-1) {
free(buff);
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
goto error;
}
dh->mode |= _WORKSPACE_READDIR_MODE_FINISH;
break;
}
xname.len=strlen(xname.name);
calculate_nameindex(&xname);
error=0;
entry=create_entry(dh->parent, &xname);
inode=create_inode();
if (entry && inode) {
result=insert_entry_batch(directory, entry, &error, 0);
if (result==entry) {
entry->inode->mode=DTTOIF(dtype);
add_inode_hashtable(inode, increase_inodes_workspace, (void *) dh->object->workspace_mount);
inode->alias=entry;
entry->inode=inode;
adjust_pathmax(dh->pathinfo.len + 1 + xname.len);
} else {
if (error==EEXIST) {
destroy_entry(entry);
entry=result;
free(inode);
inode=entry->inode;
} else {
free(buff);
destroy_entry(entry);
free(inode);
goto error;
}
}
st.st_mode=entry->inode->mode;
st.st_ino=entry->inode->ino;
name=entry->name.name;
} else {
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
error=ENOMEM;
free(buff);
goto error;
}
dh->entry=entry;
} else {
entry=dh->entry;
st.st_ino=entry->inode->ino;
st.st_mode=entry->inode->mode;
name=entry->name.name;
}
}
dirent_size=fuse_add_direntry(req, buff+pos, size-pos, name, &st, offset+1);
if (pos + dirent_size > size) {
dh->offset = offset + 1;
break;
}
/* increase counter and clear the various fields */
dh->entry=NULL; /* forget current entry to force readdir */
offset++;
pos += dirent_size;
}
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
fuse_reply_buf(req, buff, pos);
free(buff);
buff=NULL;
return;
error:
fuse_reply_err(req, error);
}
static void overlay_mknod(fuse_req_t req, struct inode_struct *pinode, struct name_struct *xname, struct call_info_struct *call_info, mode_t mode, dev_t rdev)
{
struct resource_struct *resource=call_info->object->resource;
struct localfile_struct *localfile=(struct localfile_struct *) resource->data;
struct pathinfo_struct *pathinfo=&call_info->pathinfo;
unsigned int len0=pathinfo->len - call_info->relpath, len1=localfile->pathinfo.len;
char path[len0 + len1 + 1];
struct entry_struct *entry=NULL, *parent=pinode->alias;
struct inode_struct *inode;
memcpy(path, localfile->pathinfo.path, len1);
if (len0>0) {
memcpy(path+len1, pathinfo->path + call_info->relpath, len0);
len1+=len0;
}
path[len1]='\0';
entry=create_entry(parent, xname);
inode=create_inode();
if (entry && inode) {
struct entry_struct *result=NULL;
unsigned int error=0;
entry->inode=inode;
inode->alias=entry;
result=insert_entry(entry, &error, _ENTRY_FLAG_TEMP);
if (result==entry) {
uid_t uid_keep=setfsuid(call_info->uid);
gid_t gid_keep=setfsgid(call_info->gid);
mode_t umask_keep=umask(call_info->umask);
mode = (mode & ~call_info->umask);
if (mknod(path, mode, rdev)==0) {
struct fuse_entry_param e;
adjust_pathmax(call_info->pathinfo.len);
add_inode_hashtable(inode, increase_inodes_workspace, (void *) call_info->workspace_mount);
/* here complete the insert ?? */
inode->mode=mode;
inode->nlink=1;
inode->uid=call_info->uid;
inode->gid=call_info->gid;
inode->nlookup=1;
inode->rdev=rdev;
inode->size=0;
get_current_time(&inode->mtim);
memcpy(&inode->ctim, &inode->mtim, sizeof(struct timespec));
memset(&e, 0, sizeof(e));
e.ino = inode->ino;
e.generation = 1;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_dev = 0;
e.attr.st_uid=inode->uid;
e.attr.st_gid=inode->gid;
e.attr.st_size=inode->size;
e.attr.st_rdev=inode->rdev;
memcpy(&e.attr.st_mtim, &inode->mtim, sizeof(struct timespec));
memcpy(&e.attr.st_ctim, &inode->mtim, sizeof(struct timespec));
memcpy(&e.attr.st_atim, &inode->mtim, sizeof(struct timespec));
e.attr_timeout = fs_options.attr_timeout;
e.entry_timeout = fs_options.entry_timeout;
e.attr.st_blksize=4096;
e.attr.st_blocks=0;
fuse_reply_entry(req, &e);
} else {
unsigned int error_delete=0;
error=errno;
remove_entry(entry, &error_delete);
destroy_entry(entry);
entry=NULL;
free(inode);
inode=NULL;
fuse_reply_err(req, error);
}
uid_keep=setfsuid(uid_keep);
gid_keep=setfsgid(gid_keep);
umask_keep=umask(umask_keep);
} else {
destroy_entry(entry);
entry=NULL;
free(inode);
inode=NULL;
if (error==0) error=EEXIST;
fuse_reply_err(req, error);
}
} else {
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
fuse_reply_err(req, ENOMEM);
}
}
static void overlay_lookup_noncached(fuse_req_t req, struct inode_struct *pinode, struct name_struct *xname, struct call_info_struct *call_info)
{
struct resource_struct *resource=call_info->object->resource;
struct localfile_struct *localfile=(struct localfile_struct *) resource->data;
struct pathinfo_struct *pathinfo=&call_info->pathinfo;
unsigned int len0=pathinfo->len - call_info->relpath, len1=localfile->pathinfo.len;
char path[len0 + len1 + 1];
struct stat st;
memcpy(path, localfile->pathinfo.path, len1);
if (len0>0) {
memcpy(path+len1, pathinfo->path + call_info->relpath, len0);
len1+=len0;
}
path[len1]='\0';
memset(&st, 0, sizeof(struct stat));
logoutput("overlayfs_lookup_cached, path %s", path);
if (lstat(path, &st)==-1) {
fuse_reply_err(req, ENOENT);
} else {
struct entry_struct *entry=NULL, *parent=pinode->alias;
struct inode_struct *inode;
entry=create_entry(parent, xname);
inode=create_inode();
if (entry && inode) {
struct fuse_entry_param e;
unsigned int error=0;
add_inode_hashtable(inode, increase_inodes_workspace, (void *) call_info->workspace_mount);
insert_entry(entry, &error, 0);
adjust_pathmax(call_info->pathinfo.len);
e.ino = inode->ino;
e.generation = 1;
e.attr_timeout = fs_options.attr_timeout;
e.entry_timeout = fs_options.entry_timeout;
e.attr.st_ino = e.ino;
e.attr.st_mode = st.st_mode;
e.attr.st_nlink = st.st_nlink;
e.attr.st_uid = st.st_uid;
e.attr.st_gid = st.st_gid;
e.attr.st_rdev = st.st_rdev;
e.attr.st_atim.tv_sec = st.st_atim.tv_sec;
e.attr.st_atim.tv_nsec = st.st_atim.tv_nsec;
e.attr.st_mtim.tv_sec = st.st_mtim.tv_sec;
e.attr.st_mtim.tv_nsec = st.st_mtim.tv_nsec;
e.attr.st_ctim.tv_sec = st.st_ctim.tv_sec;
e.attr.st_ctim.tv_nsec = st.st_ctim.tv_nsec;
e.attr.st_blksize=4096;
e.attr.st_blocks=0;
inode->mode=st.st_mode;
inode->nlink=st.st_nlink;
inode->uid=st.st_uid;
inode->gid=st.st_gid;
inode->rdev=st.st_rdev;
if (S_ISDIR(st.st_mode)) {
e.attr.st_size = 0;
} else {
inode->size=st.st_size;
e.attr.st_size = st.st_size;
}
inode->mtim.tv_sec=st.st_mtim.tv_sec;
inode->mtim.tv_nsec=st.st_mtim.tv_nsec;
inode->ctim.tv_sec=st.st_ctim.tv_sec;
inode->ctim.tv_nsec=st.st_ctim.tv_nsec;
fuse_reply_entry(req, &e);
} else {
/* not enough memory to allocate entry and/or inode */
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
fuse_reply_err(req, ENOMEM);
}
}
free_path_pathinfo(&call_info->pathinfo);
}
static void overlay_readdirplus_full(fuse_req_t req, size_t size, off_t offset, struct workspace_dh_struct *dh)
{
unsigned int error=0;
char *buff=NULL;
size_t pos=0;
size_t dirent_size;
struct fuse_entry_param e;
char *name=NULL;
struct directory_struct *directory=dh->directory;
struct overlay_readdir_struct *overlay_readdir=(struct overlay_readdir_struct *)dh->handle.data;
struct entry_struct *entry, *result;
struct inode_struct *inode;
unsigned char dtype;
struct name_struct xname={NULL, 0, 0};
int res=0;
memset(&e, 0, sizeof(struct fuse_entry_param));
e.generation = 1;
e.attr_timeout = fs_options.attr_timeout;
e.entry_timeout = fs_options.entry_timeout;
e.attr.st_blksize=4096;
e.attr.st_blocks=0;
buff=malloc(size);
if (! buff) {
error=ENOMEM;
goto error;
}
if (lock_directory(directory, _DIRECTORY_LOCK_EXCL)==-1) {
free(buff);
buff=NULL;
error=EAGAIN;
goto error;
}
while (pos<size) {
if (offset==0) {
inode=dh->parent->inode;
/* the . entry */
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = 0;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
name = (char *) dotname;
inode->nlookup++;
} else if (offset==1) {
/* the .. entry */
if ( ! dh->parent->parent ) {
inode=dh->parent->inode;
} else {
inode=dh->parent->parent->inode;
}
e.ino = inode->ino;
e.attr.st_ino = e.ino;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
e.attr.st_size = 0;
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
name = (char *) dotdotname;
inode->nlookup++;
} else {
if (! dh->entry) {
readdir:
res=get_direntry(overlay_readdir, &xname, &dtype, &error);
if (res<=0) {
if (res==-1) {
free(buff);
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
goto error;
}
dh->mode |= _WORKSPACE_READDIR_MODE_FINISH;
break;
}
if (fstatat(overlay_readdir->fd, xname.name, &e.attr, AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT)==-1) {
goto readdir;
}
logoutput("overlayfs_readdirplus_real_full: read %s", xname.name);
xname.len=strlen(xname.name);
calculate_nameindex(&xname);
error=0;
entry=create_entry(dh->parent, &xname);
inode=create_inode();
if (entry && inode) {
result=insert_entry_batch(directory, entry, &error, 0);
if (result==entry) {
memcpy(&entry->synctime, &dh->synctime, sizeof(struct timespec));
inode->mode=DTTOIF(dtype);
add_inode_hashtable(inode, increase_inodes_workspace, (void *) dh->object->workspace_mount);
inode->alias=entry;
entry->inode=inode;
adjust_pathmax(dh->pathinfo.len + 1 + xname.len);
} else {
if (error==EEXIST) {
destroy_entry(entry);
entry=result;
memcpy(&entry->synctime, &dh->synctime, sizeof(struct timespec));
free(inode);
inode=entry->inode;
} else {
free(buff);
destroy_entry(entry);
free(inode);
goto error;
}
}
e.attr.st_ino=inode->ino;
e.ino=inode->ino;
e.attr.st_rdev = inode->rdev;
e.attr.st_dev = 0;
name=entry->name.name;
} else {
if (entry) {
destroy_entry(entry);
entry=NULL;
}
if (inode) {
free(inode);
inode=NULL;
}
error=ENOMEM;
free(buff);
goto error;
}
name=entry->name.name;
dh->entry=entry;
inode->mode = e.attr.st_mode;
inode->nlink = e.attr.st_nlink;
inode->uid = e.attr.st_uid;
inode->gid = e.attr.st_gid;
inode->rdev = e.attr.st_rdev;
inode->mtim.tv_sec = e.attr.st_mtim.tv_sec;
inode->mtim.tv_nsec = e.attr.st_mtim.tv_nsec;
inode->ctim.tv_sec = e.attr.st_ctim.tv_sec;
inode->ctim.tv_nsec = e.attr.st_ctim.tv_nsec;
if (S_ISDIR(e.attr.st_mode)) {
e.attr.st_size=0;
} else {
inode->size=e.attr.st_size;
}
} else {
entry=dh->entry;
inode=entry->inode;
name=entry->name.name;
e.attr.st_mode = inode->mode;
e.attr.st_nlink = inode->nlink;
e.attr.st_uid = inode->uid;
e.attr.st_gid = inode->gid;
e.attr.st_rdev = inode->rdev;
if (S_ISDIR(inode->mode)) {
e.attr.st_size = 0;
} else {
e.attr.st_size = inode->size;
}
e.attr.st_atim.tv_sec = 0;
e.attr.st_atim.tv_nsec = 0;
e.attr.st_mtim.tv_sec = inode->mtim.tv_sec;
e.attr.st_mtim.tv_nsec = inode->mtim.tv_nsec;
e.attr.st_ctim.tv_sec = inode->ctim.tv_sec;
e.attr.st_ctim.tv_nsec = inode->ctim.tv_nsec;
inode->nlookup++;
}
e.ino = inode->ino;
e.attr.st_ino = e.ino;
}
dirent_size=fuse_add_direntry_plus(req, buff+pos, size-pos, name, &e, offset+1);
if (pos + dirent_size > size) {
dh->offset=offset+1;
break;
}
/* increase counter and clear the various fields */
dh->entry=NULL; /* forget current entry to force readdir */
offset++;
pos += dirent_size;
}
unlock_directory(directory, _DIRECTORY_LOCK_EXCL);
fuse_reply_buf(req, buff, pos);
free(buff);
buff=NULL;
return;
error:
fuse_reply_err(req, error);
}
