int test_access(char *addr, char *hostname,
hash_table_t *ht_ip_stats,
struct prealloc_pool *ip_stats_pool,
exportlist_t *pexport, int uid, int operation)
{
struct svc_req ptr_req;
exportlist_client_entry_t pclient_found;
struct user_cred user_credentials;
unsigned int nfs_prog;
unsigned int mnt_prog;
sockaddr_t ssaddr;
sockaddr_t *pssaddr = &ssaddr;
int errcode;
int export_check_result;
bool_t proc_makes_write;
if (operation == TEST_WRITE || operation == MDONLY_WRITE)
proc_makes_write = TRUE;
else
proc_makes_write = FALSE;
/*pssaddr*/
errcode = ipstring_to_sockaddr(addr, pssaddr);
if (errcode != 0)
{
perror ("getaddrinfo");
return -1;
}
/* ptr_req */
memset(&ptr_req, 0, sizeof(struct svc_req));
ptr_req.rq_cred.oa_flavor = AUTH_UNIX;
ptr_req.rq_proc = 23232;
/*nfs_prog*/
nfs_prog = nfs_param.core_param.program[P_NFS];
/*mnt_prog*/
mnt_prog = nfs_param.core_param.program[P_MNT];
if (operation == TEST_MOUNT)
ptr_req.rq_prog = mnt_prog;
else
ptr_req.rq_prog = nfs_prog;
/*user_credentials*/
user_credentials.caller_uid = uid;
export_check_result = nfs_export_check_access(pssaddr,
&ptr_req,
pexport,
nfs_prog,
mnt_prog,
ht_ip_stats,
ip_stats_pool,
&pclient_found,
&user_credentials,
proc_makes_write);
return export_check_result;
}
state_nsm_client_t *get_nsm_client(care_t care,
SVCXPRT * xprt,
char * caller_name)
{
state_nsm_client_t key;
state_nsm_client_t * pclient;
char sock_name[SOCK_NAME_MAX];
char str[HASHTABLE_DISPLAY_STRLEN];
struct hash_latch latch;
hash_error_t rc;
hash_buffer_t buffkey;
hash_buffer_t buffval;
if(caller_name == NULL)
return NULL;
memset(&key, 0, sizeof(key));
if(nfs_param.core_param.nsm_use_caller_name)
{
key.ssc_nlm_caller_name_len = strlen(caller_name);
if(key.ssc_nlm_caller_name_len > LM_MAXSTRLEN)
{
return NULL;
}
key.ssc_nlm_caller_name = caller_name;
}
else if(xprt == NULL)
{
int rc = ipstring_to_sockaddr(caller_name, &key.ssc_client_addr);
if(rc != 0)
{
LogEvent(COMPONENT_STATE,
"Error %s, converting caller_name %s to an ipaddress",
gai_strerror(rc), caller_name);
return NULL;
}
key.ssc_nlm_caller_name_len = strlen(caller_name);
if(key.ssc_nlm_caller_name_len > LM_MAXSTRLEN)
{
return NULL;
}
key.ssc_nlm_caller_name = caller_name;
}
else
{
key.ssc_nlm_caller_name = sock_name;
if(copy_xprt_addr(&key.ssc_client_addr, xprt) == 0)
{
LogCrit(COMPONENT_STATE,
"Error converting caller_name %s to an ipaddress",
caller_name);
return NULL;
}
if(sprint_sockip(&key.ssc_client_addr,
key.ssc_nlm_caller_name,
sizeof(sock_name)) == 0)
{
LogCrit(COMPONENT_STATE,
"Error converting caller_name %s to an ipaddress",
caller_name);
return NULL;
}
key.ssc_nlm_caller_name_len = strlen(key.ssc_nlm_caller_name);
}
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(&key, str);
LogFullDebug(COMPONENT_STATE,
"Find {%s}", str);
}
buffkey.pdata = &key;
buffkey.len = sizeof(key);
rc = HashTable_GetLatch(ht_nsm_client,
&buffkey,
&buffval,
TRUE,
&latch);
/* If we found it, return it */
if(rc == HASHTABLE_SUCCESS)
{
pclient = buffval.pdata;
/* Return the found NSM Client */
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(pclient, str);
LogFullDebug(COMPONENT_STATE,
"Found {%s}",
str);
}
/* Increment refcount under hash latch.
* This prevents dec ref from removing this entry from hash if a race
* occurs.
*/
inc_nsm_client_ref(pclient);
HashTable_ReleaseLatched(ht_nsm_client, &latch);
if(care == CARE_MONITOR && !nsm_monitor(pclient))
{
dec_nsm_client_ref(pclient);
pclient = NULL;
}
return pclient;
}
/* An error occurred, return NULL */
if(rc != HASHTABLE_ERROR_NO_SUCH_KEY)
{
display_nsm_client(&key, str);
LogCrit(COMPONENT_STATE,
"Error %s, could not find {%s}",
hash_table_err_to_str(rc), str);
return NULL;
}
/* Not found, but we don't care, return NULL */
if(care == CARE_NOT)
{
/* Return the found NSM Client */
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(&key, str);
LogFullDebug(COMPONENT_STATE,
"Ignoring {%s}",
str);
}
HashTable_ReleaseLatched(ht_nsm_client, &latch);
return NULL;
}
pclient = gsh_malloc(sizeof(*pclient));
if(pclient == NULL)
{
display_nsm_client(&key, str);
LogCrit(COMPONENT_STATE,
"No memory for {%s}",
str);
return NULL;
}
/* Copy everything over */
memcpy(pclient, &key, sizeof(key));
if(pthread_mutex_init(&pclient->ssc_mutex, NULL) == -1)
{
/* Mutex initialization failed, free the created client */
display_nsm_client(&key, str);
LogCrit(COMPONENT_STATE,
"Could not init mutex for {%s}",
str);
gsh_free(pclient);
return NULL;
}
pclient->ssc_nlm_caller_name = gsh_strdup(key.ssc_nlm_caller_name);
if(pclient->ssc_nlm_caller_name == NULL)
{
/* Discard the created client */
free_nsm_client(pclient);
return NULL;
}
init_glist(&pclient->ssc_lock_list);
init_glist(&pclient->ssc_share_list);
pclient->ssc_refcount = 1;
if(isFullDebug(COMPONENT_STATE))
{
display_nsm_client(pclient, str);
LogFullDebug(COMPONENT_STATE,
"New {%s}", str);
}
buffkey.pdata = pclient;
buffkey.len = sizeof(*pclient);
buffval.pdata = pclient;
buffval.len = sizeof(*pclient);
rc = HashTable_SetLatched(ht_nsm_client,
&buffval,
&buffval,
&latch,
FALSE,
NULL,
NULL);
/* An error occurred, return NULL */
if(rc != HASHTABLE_SUCCESS)
{
display_nsm_client(pclient, str);
LogCrit(COMPONENT_STATE,
"Error %s, inserting {%s}",
hash_table_err_to_str(rc), str);
free_nsm_client(pclient);
return NULL;
}
if(care != CARE_MONITOR || nsm_monitor(pclient))
return pclient;
/* Failed to monitor, release client reference
* and almost certainly remove it from the hash table.
*/
dec_nsm_client_ref(pclient);
return NULL;
}
int nfs_ip_name_populate(char *path)
{
config_file_t config_file;
config_item_t block;
int var_max;
int var_index;
int err;
char *key_name;
char *key_value;
char label[MAXNAMLEN];
sockaddr_t ipaddr;
nfs_ip_name_t *nfs_ip_name;
sockaddr_t *pipaddr;
hash_buffer_t buffkey;
hash_buffer_t buffdata;
config_file = config_ParseFile(path);
if(!config_file)
{
LogCrit(COMPONENT_CONFIG, "Can't open file %s", path);
return IP_NAME_NOT_FOUND;
}
/* Get the config BLOCK */
if((block = config_FindItemByName(config_file, CONF_LABEL_IP_NAME_HOSTS)) == NULL)
{
LogCrit(COMPONENT_CONFIG,
"Can't get label %s in file %s",
CONF_LABEL_IP_NAME_HOSTS, path);
return IP_NAME_NOT_FOUND;
}
else if(config_ItemType(block) != CONFIG_ITEM_BLOCK)
{
/* Expected to be a block */
return IP_NAME_NOT_FOUND;
}
var_max = config_GetNbItems(block);
for(var_index = 0; var_index < var_max; var_index++)
{
config_item_t item;
item = config_GetItemByIndex(block, var_index);
/* Get key's name */
if((err = config_GetKeyValue(item, &key_name, &key_value)) != 0)
{
LogCrit(COMPONENT_CONFIG,
"Error reading key[%d] from section \"%s\" of configuration file.",
var_index, label);
return IP_NAME_NOT_FOUND;
}
err = ipstring_to_sockaddr(key_value, &ipaddr);
if(err != 0)
{
LogCrit(COMPONENT_CONFIG,
"Error converting %s to an ipaddress %s",
key_value, gai_strerror(err));
return IP_NAME_NOT_FOUND;
}
/* Entry to be cached */
nfs_ip_name = gsh_malloc(sizeof(nfs_ip_name_t));
if(nfs_ip_name == NULL)
return IP_NAME_INSERT_MALLOC_ERROR;
pipaddr = gsh_malloc(sizeof(sockaddr_t));
if(pipaddr == NULL)
{
gsh_free(nfs_ip_name);
return IP_NAME_INSERT_MALLOC_ERROR;
}
strncpy(nfs_ip_name->hostname, key_name, MAXHOSTNAMELEN);
nfs_ip_name->timestamp = time(NULL);
memcpy(pipaddr, &ipaddr, sizeof(sockaddr_t));
buffdata.pdata = (caddr_t) nfs_ip_name;
buffdata.len = sizeof(nfs_ip_name_t);
buffkey.pdata = (caddr_t) pipaddr;
buffkey.len = sizeof(sockaddr_t);
if(HashTable_Set(ht_ip_name, &buffkey, &buffdata) != HASHTABLE_SUCCESS)
{
gsh_free(nfs_ip_name);
gsh_free(pipaddr);
return IP_NAME_INSERT_MALLOC_ERROR;
}
}
if(isFullDebug(COMPONENT_CONFIG))
HashTable_Log(COMPONENT_CONFIG, ht_ip_name);
return IP_NAME_SUCCESS;
} /* nfs_ip_name_populate */
