1
0
mirror of https://github.com/samba-team/samba.git synced 2025-01-27 14:04:05 +03:00
samba-mirror/source3/smbd/statcache.c
Alexander Bokovoy e7c8c15888 Fix VFS layer:
1. Finally work with cascaded modules with private data storage per module
2. Convert VFS API to macro calls to simplify cascading
3. Add quota support to VFS layer (prepare to NT quota support)

Patch by Stefan (metze) Metzemacher, with review of Jelmer and me
Tested in past few weeks. Documentation to new VFS API for third-party developers to follow
(This used to be commit 91984ef5caa2d13c5d52e1f535bd3bbbae1ec978)
2003-05-11 23:34:18 +00:00

284 lines
8.0 KiB
C

/*
Unix SMB/CIFS implementation.
stat cache code
Copyright (C) Andrew Tridgell 1992-2000
Copyright (C) Jeremy Allison 1999-2000
Copyright (C) Andrew Bartlett <abartlet@samba.org> 2003
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "includes.h"
extern BOOL case_sensitive;
/****************************************************************************
Stat cache code used in unix_convert.
*****************************************************************************/
typedef struct {
char *original_path;
char *translated_path;
size_t translated_path_length;
char names[2]; /* This is extended via malloc... */
} stat_cache_entry;
#define INIT_STAT_CACHE_SIZE 512
static hash_table stat_cache;
/**
* Add an entry into the stat cache.
*
* @param full_orig_name The original name as specified by the client
* @param orig_translated_path The name on our filesystem.
*
* @note Only the first strlen(orig_translated_path) characters are stored
* into the cache. This means that full_orig_name will be internally
* truncated.
*
*/
void stat_cache_add( const char *full_orig_name, const char *orig_translated_path)
{
stat_cache_entry *scp;
stat_cache_entry *found_scp;
char *translated_path;
size_t translated_path_length;
char *original_path;
size_t original_path_length;
hash_element *hash_elem;
if (!lp_stat_cache()) return;
/*
* Don't cache trivial valid directory entries.
*/
if((*full_orig_name == '\0') || (strcmp(full_orig_name, ".") == 0) ||
(strcmp(full_orig_name, "..") == 0))
return;
/*
* If we are in case insentive mode, we don't need to
* store names that need no translation - else, it
* would be a waste.
*/
if(case_sensitive && (strcmp(full_orig_name, orig_translated_path) == 0))
return;
/*
* Remove any trailing '/' characters from the
* translated path.
*/
translated_path = strdup(orig_translated_path);
if (!translated_path)
return;
translated_path_length = strlen(translated_path);
if(translated_path[translated_path_length-1] == '/') {
translated_path[translated_path_length-1] = '\0';
translated_path_length--;
}
original_path = strdup(full_orig_name);
if (!original_path) {
SAFE_FREE(translated_path);
return;
}
original_path_length = strlen(original_path);
if(original_path[original_path_length-1] == '/') {
original_path[original_path_length-1] = '\0';
original_path_length--;
}
if(!case_sensitive)
strupper(original_path);
if (original_path_length != translated_path_length) {
if (original_path_length < translated_path_length) {
DEBUG(0, ("OOPS - tried to store stat cache entry for werid length paths [%s] %u and [%s] %u)!\n", original_path, original_path_length, translated_path, translated_path_length));
SAFE_FREE(original_path);
SAFE_FREE(translated_path);
return;
}
/* we only want to store the first part of original_path,
up to the length of translated_path */
original_path[translated_path_length] = '\0';
original_path_length = translated_path_length;
}
/*
* Check this name doesn't exist in the cache before we
* add it.
*/
if ((hash_elem = hash_lookup(&stat_cache, original_path))) {
found_scp = (stat_cache_entry *)(hash_elem->value);
if (strcmp((found_scp->translated_path), orig_translated_path) == 0) {
/* already in hash table */
SAFE_FREE(original_path);
SAFE_FREE(translated_path);
return;
}
/* hash collision - remove before we re-add */
hash_remove(&stat_cache, hash_elem);
}
/*
* New entry.
*/
if((scp = (stat_cache_entry *)malloc(sizeof(stat_cache_entry)
+original_path_length
+translated_path_length)) == NULL) {
DEBUG(0,("stat_cache_add: Out of memory !\n"));
SAFE_FREE(original_path);
SAFE_FREE(translated_path);
return;
}
scp->original_path = scp->names;
scp->translated_path = scp->names + original_path_length + 1;
safe_strcpy(scp->original_path, original_path, original_path_length);
safe_strcpy(scp->translated_path, translated_path, translated_path_length);
scp->translated_path_length = translated_path_length;
hash_insert(&stat_cache, (char *)scp, original_path);
SAFE_FREE(original_path);
SAFE_FREE(translated_path);
DEBUG(5,("stat_cache_add: Added entry %s -> %s\n", scp->original_path, scp->translated_path));
}
/**
* Look through the stat cache for an entry
*
* The hash-table's internals will promote it to the top if found.
*
* @param conn A connection struct to do the stat() with.
* @param name The path we are attempting to cache, modified by this routine
* to be correct as far as the cache can tell us
* @param dirpath The path as far as the stat cache told us.
* @param start A pointer into name, for where to 'start' in fixing the rest of the name up.
* @param psd A stat buffer, NOT from the cache, but just a side-effect.
*
* @return True if we translated (and did a scuccessful stat on) the entire name.
*
*/
BOOL stat_cache_lookup(connection_struct *conn, pstring name, pstring dirpath,
char **start, SMB_STRUCT_STAT *pst)
{
stat_cache_entry *scp;
pstring chk_name;
size_t namelen;
hash_element *hash_elem;
char *sp;
if (!lp_stat_cache())
return False;
namelen = strlen(name);
*start = name;
DO_PROFILE_INC(statcache_lookups);
/*
* Don't lookup trivial valid directory entries.
*/
if((*name == '\0') || (strcmp(name, ".") == 0) || (strcmp(name, "..") == 0)) {
DO_PROFILE_INC(statcache_misses);
return False;
}
pstrcpy(chk_name, name);
if(!case_sensitive)
strupper( chk_name );
while (1) {
hash_elem = hash_lookup(&stat_cache, chk_name);
if(hash_elem == NULL) {
/*
* Didn't find it - remove last component for next try.
*/
sp = strrchr_m(chk_name, '/');
if (sp) {
*sp = '\0';
} else {
/*
* We reached the end of the name - no match.
*/
DO_PROFILE_INC(statcache_misses);
return False;
}
if((*chk_name == '\0') || (strcmp(chk_name, ".") == 0)
|| (strcmp(chk_name, "..") == 0)) {
DO_PROFILE_INC(statcache_misses);
return False;
}
} else {
scp = (stat_cache_entry *)(hash_elem->value);
DO_PROFILE_INC(statcache_hits);
if(VFS_STAT(conn,scp->translated_path, pst) != 0) {
/* Discard this entry - it doesn't exist in the filesystem. */
hash_remove(&stat_cache, hash_elem);
return False;
}
memcpy(name, scp->translated_path, MIN(sizeof(pstring)-1, scp->translated_path_length));
/* set pointer for 'where to start' on fixing the rest of the name */
*start = &name[scp->translated_path_length];
if(**start == '/')
++*start;
pstrcpy(dirpath, scp->translated_path);
return (namelen == scp->translated_path_length);
}
}
}
/*************************************************************************** **
* Initializes or clears the stat cache.
*
* Input: none.
* Output: none.
*
* ************************************************************************** **
*/
BOOL reset_stat_cache( void )
{
static BOOL initialised;
if (!lp_stat_cache()) return True;
if (initialised) {
hash_clear(&stat_cache);
}
initialised = hash_table_init( &stat_cache, INIT_STAT_CACHE_SIZE,
(compare_function)(strcmp));
return initialised;
} /* reset_stat_cache */