/**
*
* nfs_build_fsal_context: Builds the FSAL context according to the request and the export entry.
*
* Builds the FSAL credentials according to the request and the export entry.
*
* @param ptr_req [IN] incoming request.
* @param pexport_client [IN] related export client
* @param pexport [IN] related export entry
* @param pcred [IN/OUT] initialized credential of caller thread.
* @param user_credentials [OUT] Filled in structure with uid and gids
*
* @return TRUE if successful, FALSE otherwise
*
*/
int nfs_build_fsal_context(struct svc_req *ptr_req,
exportlist_client_entry_t * pexport_client,
exportlist_t * pexport, fsal_op_context_t * pcontext,
struct user_cred *user_credentials)
{
fsal_status_t fsal_status;
if (user_credentials == NULL)
return FALSE;
/* Build the credentials */
fsal_status = FSAL_GetClientContext(pcontext,
&pexport->FS_export_context,
user_credentials->caller_uid, user_credentials->caller_gid,
user_credentials->caller_garray, user_credentials->caller_glen);
if(FSAL_IS_ERROR(fsal_status))
{
LogEvent(COMPONENT_DISPATCH,
"NFS DISPATCHER: FAILURE: Could not get credentials for (uid=%d,gid=%d), fsal error=(%d,%d)",
user_credentials->caller_uid, user_credentials->caller_gid,
fsal_status.major, fsal_status.minor);
return FALSE;
}
else
LogDebug(COMPONENT_DISPATCH,
"NFS DISPATCHER: FSAL Cred acquired for (uid=%d,gid=%d)",
user_credentials->caller_uid, user_credentials->caller_gid);
return TRUE;
} /* nfs_build_fsal_context */
int _9p_tools_get_fsal_op_context_by_uid( u32 uid, _9p_fid_t * pfid )
{
char buff[1024];
struct passwd p;
struct passwd *pp;
gid_t gid ;
fsal_status_t fsal_status ;
if((getpwuid_r( uid, &p, buff, MAXPATHLEN, &pp) != 0) || (pp == NULL))
{
LogFullDebug(COMPONENT_IDMAPPER, "getpwuid_r %d failed", uid ) ;
return -ENOENT;
}
else
gid = p.pw_gid ;
fsal_status = FSAL_GetClientContext( &pfid->fsal_op_context,
&pfid->pexport->FS_export_context,
uid, gid, NULL, 0 ) ;
if( FSAL_IS_ERROR( fsal_status ) )
return -fsal_status.major ;
return 0 ;
} /* _9p_tools_get_fsal_cred */
bool_t nlm_block_data_to_fsal_context(state_block_data_t * block_data,
fsal_op_context_t * fsal_context)
{
exportlist_t * pexport = NULL;
short exportid;
fsal_status_t fsal_status;
state_nlm_block_data_t * nlm_block_data = &block_data->sbd_block_data.sbd_nlm_block_data;
/* Get export ID from handle */
exportid = nlm4_FhandleToExportId(&nlm_block_data->sbd_nlm_fh);
/* Get export matching export ID */
if(exportid < 0 ||
(pexport = nfs_Get_export_by_id(nfs_param.pexportlist, exportid)) == NULL ||
(pexport->export_perms.options & EXPORT_OPTION_NFSV3) == 0)
{
/* Reject the request for authentication reason (incompatible file handle) */
if(isInfo(COMPONENT_NLM))
{
char dumpfh[1024];
char *reason;
char addrbuf[SOCK_NAME_MAX];
sprint_sockaddr(&nlm_block_data->sbd_nlm_hostaddr,
addrbuf,
sizeof(addrbuf));
if(exportid < 0)
reason = "has badly formed handle";
else if(pexport == NULL)
reason = "has invalid export";
else
reason = "V3 not allowed on this export";
sprint_fhandle_nlm(dumpfh, &nlm_block_data->sbd_nlm_fh);
LogMajor(COMPONENT_NLM,
"NLM4 granted lock from host %s %s, FH=%s",
addrbuf, reason, dumpfh);
}
return FALSE;
}
LogFullDebug(COMPONENT_NLM,
"Found export entry for path=%s as exportid=%d",
pexport->fullpath, pexport->id);
/* Build the credentials */
fsal_status = FSAL_GetClientContext(fsal_context,
&pexport->FS_export_context,
block_data->sbd_credential.user,
block_data->sbd_credential.group,
block_data->sbd_credential.alt_groups,
block_data->sbd_credential.nbgroups);
if(FSAL_IS_ERROR(fsal_status))
{
LogEvent(COMPONENT_NLM,
"Could not get credentials for (uid=%d,gid=%d), fsal error=(%d,%d)",
block_data->sbd_credential.user,
block_data->sbd_credential.group,
fsal_status.major, fsal_status.minor);
return FALSE;
}
else
LogDebug(COMPONENT_NLM,
"FSAL Cred acquired for (uid=%d,gid=%d)",
block_data->sbd_credential.user,
block_data->sbd_credential.group);
return TRUE;
}
int main(int argc, char **argv)
{
char localmachine[256];
char *test;
fsal_parameter_t init_param;
fsal_status_t st;
uid_t uid;
fsal_export_context_t export_ctx;
fsal_op_context_t op_ctx;
fsal_handle_t root_handle, handle;
fsal_name_t name;
fsal_path_t path;
fsal_attrib_list_t attribs;
fsal_attrib_mask_t mask;
char tracebuff[256];
if(argc < 2)
{
usage();
exit(-1);
}
test = argv[1];
/* retrieving params */
#ifndef _NO_BUDDY_SYSTEM
BuddyInit(NULL);
#endif
/* init debug */
SetNamePgm("test_fsal");
SetDefaultLogging("TEST");
SetNameFunction("main");
InitLogging();
/* Obtention du nom de la machine */
if(gethostname(localmachine, sizeof(localmachine)) != 0)
{
LogError(COMPONENT_STDOUT,ERR_SYS, ERR_GETHOSTNAME, errno);
exit(1);
}
else
SetNameHost(localmachine);
AddFamilyError(ERR_FSAL, "FSAL related Errors", tab_errstatus_FSAL);
/* prepare fsal_init */
/* 1 - fs specific info */
#ifdef _USE_HPSS_51
init_param.fs_specific_info.behaviors.PrincipalName = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.hpss_config.PrincipalName, "hpss_nfs");
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.hpss_config.KeytabPath, "/krb5/hpssserver.keytab");
#elif defined _USE_HPSS_62
init_param.fs_specific_info.behaviors.AuthnMech = FSAL_INIT_FORCE_VALUE;
init_param.fs_specific_info.hpss_config.AuthnMech = hpss_authn_mech_krb5;
init_param.fs_specific_info.behaviors.Principal = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.Principal, "hpssfs");
init_param.fs_specific_info.behaviors.KeytabPath = FSAL_INIT_FORCE_VALUE;
strcpy(init_param.fs_specific_info.KeytabPath, "/var/hpss/etc/hpss.keytab");
#endif
/* 2-common info (default) */
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxfilesize);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxlink);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxnamelen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxpathlen);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, no_trunc);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, chown_restricted);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_insensitive);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, case_preserving);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, fh_expire_type);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, link_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, symlink_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, named_attr);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, unique_handles);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, lease_time);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, acl_support);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, cansettime);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, homogenous);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, supported_attrs);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxread);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, maxwrite);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, umask);
FSAL_SET_INIT_DEFAULT(init_param.fs_common_info, auth_exportpath_xdev);
/* 3- fsal info */
init_param.fsal_info.max_fs_calls = 0;
/* Init */
if(FSAL_IS_ERROR(st = FSAL_Init(&init_param)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
/* getting creds */
uid = getuid();
LogTest("uid = %d", uid);
st = FSAL_BuildExportContext(&export_ctx, NULL, NULL);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
st = FSAL_InitClientContext(&op_ctx);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
st = FSAL_GetClientContext(&op_ctx, &export_ctx, uid, -1, NULL, 0);
if(FSAL_IS_ERROR(st))
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
/* getting root handle */
if(FSAL_IS_ERROR(st = FSAL_lookup(NULL, NULL, &op_ctx, &root_handle, NULL)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &root_handle);
LogTest("Root handle = %s", tracebuff);
/* getting what are the supported attributes */
attribs.asked_attributes = 0;
FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR);
LogTest("asked attributes :");
printmask(attribs.asked_attributes);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("supported attributes :");
printmask(attribs.supported_attributes);
mask = attribs.supported_attributes;
/* TEST 1 */
if(test[0] == '1')
{
attribs.asked_attributes = 0;
FSAL_SET_MASK(attribs.asked_attributes, FSAL_ATTR_SUPPATTR);
LogTest("asked attributes :");
printmask(attribs.asked_attributes);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("supported attributes :");
/* getting all spported attributes of root */
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&root_handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
printattributes(attribs);
}
else
/* TEST 2 */
if(test[0] == '2')
{
/* getting handle and attributes for subdirectory "OSF1_V5" */
if(FSAL_IS_ERROR(st = FSAL_str2name("cea", 4, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* getting handle and attributes for subdirectory "bin" */
if(FSAL_IS_ERROR(st = FSAL_str2name("prot", 5, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
root_handle = handle;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* getting handle and attributes for symlink "AglaePwrSW" */
if(FSAL_IS_ERROR(st = FSAL_str2name("lama", 5, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
root_handle = handle;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookup(&root_handle, &name, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/lama handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
}
else
/* TEST 3 */
if(test[0] == '3')
{
/* lookup root */
if(FSAL_IS_ERROR(st = FSAL_str2path("/", 30, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/ handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
/* lookup path */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/lama", 15, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/lama handle = %s", tracebuff);
/* displaying attributes */
printattributes(attribs);
}
else
/* TEST 4 */
if(test[0] == '4')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
unsigned int i;
char cookiebuff[256];
snprintCookie(cookiebuff, 256, &from);
LogTest("\nReaddir cookie = %s", cookiebuff);
if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from,
mask, READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
for(i = 0; (!error) && (i < number); i++)
{
snprintHandle(tracebuff, 256, &entries[i].handle);
snprintCookie(cookiebuff, 256, &entries[i].cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
entries[i].name.name, cookiebuff);
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 5 */
if(test[0] == '5')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
fsal_dirent_t *curr;
char cookiebuff[256];
snprintCookie(cookiebuff, 256, &from);
LogTest("\nReaddir cookie = %s", cookiebuff);
if(FSAL_IS_ERROR(st = FSAL_readdir(&dir, from,
mask, READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
if(number > 0)
{
curr = entries;
do
{
snprintHandle(tracebuff, 256, &curr->handle);
snprintCookie(cookiebuff, 256, &curr->cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
curr->name.name, cookiebuff);
}
while(curr = curr->nextentry);
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 6 */
if(test[0] == '6')
{
/* readdir on root */
fsal_dir_t dir;
fsal_cookie_t from, to;
fsal_dirent_t entries[READDIR_SIZE];
fsal_count_t number;
fsal_boolean_t eod = FALSE;
int error = FALSE;
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_opendir(&root_handle, &op_ctx, &dir, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
LogTest("'/' attributes :");
/* displaying attributes */
printattributes(attribs);
from = FSAL_READDIR_FROM_BEGINNING;
while(!error && !eod)
{
unsigned int i;
snprintCookie(tracebuff, 256, &from);
LogTest("\nReaddir cookie = %s", tracebuff);
st = FSAL_readdir(&dir, from, mask,
READDIR_SIZE * sizeof(fsal_dirent_t),
entries, &to, &number, &eod);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
error = TRUE;
}
/* for each entry, we compare the result of FSAL_access
* to FSAL_test_access. */
for(i = 0; (!error) && (i < number); i++)
{
fsal_status_t st1, st2;
char cookiebuff[256];
snprintHandle(tracebuff, 256, &entries[i].handle);
snprintCookie(cookiebuff, 256, &entries[i].cookie);
LogTest("\t%s : %s (cookie %s)", tracebuff,
entries[i].name.name, cookiebuff);
if(FSAL_IS_ERROR(st = ZFSFSAL_getattrs(&entries[i].handle, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
/* 1 - test R access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_R_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_R_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
/* 2 - test W access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_W_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_W_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
/* 3 - test X access */
st1 = FSAL_access(&entries[i].handle, &op_ctx, FSAL_X_OK, NULL);
st2 = FSAL_test_access(&op_ctx, FSAL_X_OK, &attribs);
LogError(COMPONENT_STDOUT, ERR_FSAL, st1.major, st1.minor);
LogError(COMPONENT_STDOUT, ERR_FSAL, st2.major, st2.minor);
if(st1.major != st2.major)
{
LogTest
("Error : different access permissions given by FSAL_access and FSAL_test_access : %d <>%d",
st1.major, st2.major);
}
}
/* preparing next call */
from = to;
}
LogTest("Fin de boucle : error=%d ; eod=%d", error, eod);
}
else
/* TEST 7 */
if(test[0] == '7')
{
/* test snprintmem and sscanmem */
char test_string[] =
"Ceci est une chaine d'essai.\nLes chiffres : 0123456789\nLes lettres : ABCDEFGHIJKLMNOPQRSTUVWXYZ";
char buffer[256];
char string[200]; /* 200 suffit car test_string fait <100 */
int size1, size2, size3, i;
/* we put bad values in string, to see if it is correctly set. */
for(i = 0; i < 200; i++)
string[i] = (char)i;
LogTest("Initial data (%d Bytes) = <<%s>>", strlen(test_string), test_string);
/* Write test_string to a buffer. */
/* We don't give the final '\0'. */
snprintmem(buffer, 256, test_string, strlen(test_string));
LogTest("Dest_Buffer (%d Bytes) = <<%s>>", strlen(buffer), buffer);
/* read the value from the buffer */
sscanmem(string, strlen(test_string), buffer);
/* sets the final 0 to print the content of the buffer */
LogTest("Retrieved string : following byte = %d",
(int)string[strlen(test_string)]);
string[strlen(test_string)] = '\0';
LogTest("Retrieved string (%d Bytes) = <<%s>>", strlen(string), string);
/* Automatic tests : */
size1 = strlen(test_string);
size2 = strlen(buffer);
size3 = strlen(string);
LogTest("-------------------------------------");
if(size1 <= 0)
LogTest("***** ERROR: source size=0 !!!");
if(size1 != size3)
LogTest("***** ERROR: source size <> target size");
else
LogTest("OK: source size = target size");
if((size1 * 2) != size2)
LogTest("***** ERROR: hexa size <> 2 * source size");
else
LogTest("OK: hexa size = 2 * source size");
if(strcmp(test_string, string))
LogTest("***** ERROR: source string <> target string");
else
LogTest("OK: source string = target string");
}
else
/* TEST 8 */
if(test[0] == '8')
{
fsal_handle_t dir_hdl, subdir_hdl;
fsal_name_t subdir_name;
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
sleep(1);
/* creates a directory */
LogTest("------- Create a directory -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA", 30, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &dir_hdl);
LogTest("newly created dir handle = %s", tracebuff);
printattributes(attribs);
}
sleep(1);
/* Try to create it again */
LogTest("------- Try to create it again -------");
if(FSAL_IS_ERROR(st = FSAL_mkdir(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("**** Error: FSAL should have returned ERR_FSAL_EXIST");
}
sleep(1);
/* creates a subdirectory */
LogTest("------- Create a subdirectory -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("subdir_GANESHA", 30, &subdir_name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
if(FSAL_IS_ERROR(st = FSAL_mkdir(&dir_hdl, &subdir_name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &subdir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &subdir_hdl);
LogTest("newly created subdir handle = %s", tracebuff);
printattributes(attribs);
}
/* try to removes the parent directory */
LogTest("------- Try to removes the parent directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("FSAL should not have unlinked %s because it is not empty", name.name);
}
sleep(1);
/* removes the subdirectory */
LogTest("------- Removes the subdirectory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&dir_hdl, &subdir_name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("New attributes for parent directory:");
printattributes(attribs);
}
/* removes the parent directory */
LogTest("------- Removes the parent directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("Unlink %s OK", name.name);
}
}
/* TEST 9 */
else if(test[0] == '9')
{
fsal_handle_t dir_hdl, subdir_hdl;
fsal_name_t subdir_name;
fsal_attrib_list_t attr_set;
fsal_fsid_t set_fsid = { 1LL, 2LL };
#ifdef _LINUX
struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0, 0, 0 };
#else
struct tm jour_heure = { 56, 34, 12, 31, 12, 110, 0, 0, 0 };
#endif
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
sleep(1);
/* creates a file */
LogTest("------- Create a file -------");
if(FSAL_IS_ERROR(st = FSAL_str2name("tests_GANESHA_setattrs", 30, &name)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_create(&handle, &name, &op_ctx,
FSAL_MODE_RUSR | FSAL_MODE_WUSR
| FSAL_MODE_XUSR | FSAL_MODE_RGRP
| FSAL_MODE_WGRP, &dir_hdl, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
snprintHandle(tracebuff, 256, &dir_hdl);
LogTest("newly created file handle = %s", tracebuff);
printattributes(attribs);
}
sleep(1);
LogTest("------- Try to change its attributes -------");
/* Macro that try to change the value for an attribute */
#define CHANGE_ATTRS( str_nom, nom, flag, new_val ) do {\
memset(&attr_set, 0, sizeof(fsal_attrib_list_t) ); \
LogTest("\nTry to change '%s' :",str_nom); \
FSAL_SET_MASK( attr_set.asked_attributes , flag ); \
attr_set.nom = new_val; \
attribs.asked_attributes = attr_set.asked_attributes; \
/* attribs.asked_attributes = mask; */\
st = FSAL_setattrs( &dir_hdl, &op_ctx, &attr_set, &attribs );\
if ( FSAL_IS_ERROR(st) ) \
LogError(COMPONENT_STDOUT,ERR_FSAL,st.major,st.minor);\
else \
printattributes( attribs ); \
} while(0)
CHANGE_ATTRS("supported_attributes", supported_attributes,
FSAL_ATTR_SUPPATTR, FSAL_ATTRS_MANDATORY);
CHANGE_ATTRS("type", type, FSAL_ATTR_TYPE, FSAL_TYPE_LNK);
sleep(1); /* to see mtime modification by truncate */
CHANGE_ATTRS("filesize", filesize, FSAL_ATTR_SIZE, (fsal_size_t) 12);
sleep(1); /* to see mtime modification by truncate */
CHANGE_ATTRS("fsid", fsid, FSAL_ATTR_FSID, set_fsid);
/* @todo : ACLs */
CHANGE_ATTRS("fileid", fileid, FSAL_ATTR_FILEID, (fsal_u64_t) 1234);
CHANGE_ATTRS("mode", mode, FSAL_ATTR_MODE,
(FSAL_MODE_RUSR | FSAL_MODE_WUSR | FSAL_MODE_RGRP));
CHANGE_ATTRS("numlinks", numlinks, FSAL_ATTR_NUMLINKS, 7);
/* FSAL_ATTR_RAWDEV */
CHANGE_ATTRS("atime", atime.seconds, FSAL_ATTR_ATIME, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("creation", creation.seconds, FSAL_ATTR_CREATION, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("mtime", mtime.seconds, FSAL_ATTR_MTIME, mktime(&jour_heure));
jour_heure.tm_min++;
CHANGE_ATTRS("ctime", ctime.seconds, FSAL_ATTR_CTIME, mktime(&jour_heure));
CHANGE_ATTRS("spaceused", spaceused, FSAL_ATTR_SPACEUSED, (fsal_size_t) 12345);
CHANGE_ATTRS("mounted_on_fileid", mounted_on_fileid,
FSAL_ATTR_MOUNTFILEID, (fsal_u64_t) 3210);
CHANGE_ATTRS("owner", owner, FSAL_ATTR_OWNER, 3051); /* deniel */
CHANGE_ATTRS("group", group, FSAL_ATTR_GROUP, 5953); /* sr */
sleep(1);
/* removes the parent directory */
LogTest("------- Removes the directory -------");
if(FSAL_IS_ERROR(st = FSAL_unlink(&handle, &name, &op_ctx, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
LogTest("Unlink %s OK", name.name);
}
}
else if(test[0] == 'A')
{
char digest_buff[FSAL_DIGEST_SIZE_HDLV3];
/* lookup on /cea/prot/S/lama/s8/leibovic */
if(FSAL_IS_ERROR(st = FSAL_str2path("/cea/prot/S/lama/s8/leibovic", 40, &path)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
attribs.asked_attributes = mask;
if(FSAL_IS_ERROR(st = FSAL_lookupPath(&path, &op_ctx, &handle, &attribs)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle = %s", tracebuff);
/* building digest */
st = FSAL_DigestHandle(&export_ctx, FSAL_DIGEST_NFSV3, &handle, digest_buff);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
/* print digest */
snprintmem(tracebuff, 256, digest_buff, FSAL_DIGEST_SIZE_HDLV3);
LogTest("/cea/prot/S/lama/s8/leibovic: handle_digest = %s", tracebuff);
}
memset(&handle, 0, sizeof(fsal_handle_t));
/* expend digest */
st = FSAL_ExpandHandle(&export_ctx, FSAL_DIGEST_NFSV3, digest_buff, &handle);
if(FSAL_IS_ERROR(st))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
}
else
{
/* print expended handle */
snprintHandle(tracebuff, 256, &handle);
LogTest("/cea/prot/S/lama/s8/leibovic: handle expended = %s", tracebuff);
}
}
else if(test[0] == 'B')
{
fsal_dynamicfsinfo_t dyninfo;
if(FSAL_IS_ERROR(st = FSAL_dynamic_fsinfo(&root_handle, &op_ctx, &dyninfo)))
{
LogError(COMPONENT_STDOUT, ERR_FSAL, st.major, st.minor);
exit(st.major);
}
LogTest("total_bytes = %llu", dyninfo.total_bytes);
LogTest("free_bytes = %llu", dyninfo.free_bytes);
LogTest("avail_bytes = %llu", dyninfo.avail_bytes);
LogTest("total_files = %llu", dyninfo.total_files);
LogTest("free_files = %llu", dyninfo.free_files);
LogTest("avail_files = %llu", dyninfo.avail_files);
LogTest("time_delta = %u.%u", dyninfo.time_delta.seconds,
dyninfo.time_delta.nseconds);
}
else
LogTest("%s : test inconnu", test);
return 0;
}
int main(int argc, char *argv[])
{
int c;
int exportid = 0;
char buffer[CMD_BUFFER_SIZE];
char str[2 * CMD_BUFFER_SIZE];
fhandle2 filehandle_v2;
struct nfs_fh3 filehandle_v3;
nfs_fh4 filehandle_v4;
int flag_i = FALSE;
char exec_name[MAXPATHLEN];
char *tempo_exec_name = NULL;
cache_inode_fsal_data_t fsal_data;
fsal_op_context_t fsal_op_context;
fsal_export_context_t fsal_export_context;
exportlist_t *pexportlist = NULL;
exportlist_t *pexport = NULL;
nfs_start_info_t nfs_start_info;
fsal_status_t fsal_status;
unsigned int nfs_version = 3;
path_str_t fsal_path_lib[NB_AVAILABLE_FSAL];
#ifdef _USE_SHARED_FSAL
int lentab = NB_AVAILABLE_FSAL ;
#endif
short cache_content_hash;
char entry_path[MAXPATHLEN];
int i, nb_char;
fsal_path_t export_path = FSAL_PATH_INITIALIZER;
unsigned int cookie;
fsal_xattrent_t xattr_array[256];
unsigned int nb_returned;
int eol;
char attr_buffer[4096];
size_t sz_returned;
fsal_u64_t objid;
char options[] = "h@f:v:i:";
char usage[] = "%s [-h][-f <cfg_path>] {-v 2|3|4 <NFS_FileHandle> | -i <inum>}\n"
" -h : prints this help\n"
" -f <config_file> : sets the ganesha configuration file to be used\n"
" -v <nfs_version> : sets the NFS version the file handle passed as argument\n"
" -i <inum> : get datacache path for the given inode number (decimal)\n";
ServerBootTime = time(NULL);
SetDefaultLogging("STDERR");
/* What is the executable file's name */
if((tempo_exec_name = strrchr(argv[0], '/')) != NULL)
strcpy((char *)exec_name, tempo_exec_name + 1);
strncpy(config_path, DEFAULT_CONFIG_FILE, MAXPATHLEN);
/* now parsing options with getopt */
while((c = getopt(argc, argv, options)) != EOF)
{
switch (c)
{
case '@':
printf("%s compiled on %s at %s\n", exec_name, __DATE__, __TIME__);
exit(0);
break;
case 'h':
printf(usage, exec_name);
exit(0);
break;
case 'f':
strncpy(config_path, optarg, MAXPATHLEN);
break;
case 'i':
if(sscanf(optarg, "%llu", &objid) != 1)
{
fprintf(stderr, "Invalid object_id %s (base-10 integer expected)\n",
optarg);
exit(1);
}
flag_i = TRUE;
break;
case 'v':
nfs_version = atoi(optarg);
if((nfs_version < 2) || (nfs_version > 4))
{
fprintf(stderr, "Invalid nfs version %u\n", nfs_version);
exit(1);
}
break;
case '?':
printf("Unknown option: %c\n", optopt);
printf(usage, exec_name);
exit(1);
}
}
if(!flag_i && (optind != argc - 1))
{
printf("Missing argument: <NFS_FileHandle>\n");
printf(usage, exec_name);
exit(1);
}
/* initialize memory and logging */
nfs_prereq_init("convert_fh", "localhost", NIV_MAJ, "/dev/tty");
#ifdef _USE_SHARED_FSAL
if(nfs_get_fsalpathlib_conf(config_path, fsal_path_lib, &lentab))
{
fprintf(stderr, "NFS MAIN: Error parsing configuration file.");
exit(1);
}
#endif /* _USE_SHARED_FSAL */
/* Load the FSAL library (if needed) */
if(!FSAL_LoadLibrary((char *)fsal_path_lib)) /** @todo: this part of the code and this utility has to be checked */
{
fprintf(stderr, "NFS MAIN: Could not load FSAL dynamic library %s", (char *)fsal_path_lib[0]);
exit(1);
}
/* Get the FSAL functions */
FSAL_LoadFunctions();
/* Get the FSAL consts */
FSAL_LoadConsts();
/* initialize default parameters */
nfs_set_param_default();
/* parse configuration file */
if(nfs_set_param_from_conf(&nfs_start_info))
{
fprintf(stderr, "Error parsing configuration file '%s'", config_path);
exit(1);
}
/* check parameters consitency */
if(nfs_check_param_consistency())
{
fprintf(stderr, "Inconsistent parameters found");
exit(1);
}
if(!nfs_param.pexportlist)
{
fprintf(stderr, "No export entries found in configuration file !!!\n");
return -1;
}
pexportlist = nfs_param.pexportlist;
/* not initialization is needed for converting fileid to path in datacache */
if(!flag_i)
{
#ifdef _USE_SHARED_FSAL
fsal_status = FSAL_Init(&nfs_param.fsal_param[0]);
#else
fsal_status = FSAL_Init(&nfs_param.fsal_param);
#endif
if(FSAL_IS_ERROR(fsal_status))
{
/* Failed init */
fprintf(stderr, "FSAL library could not be initialized, major=%d minor=%d\n",
fsal_status.major, fsal_status.minor);
exit(1);
}
strncpy(str, argv[optind], 2 * CMD_BUFFER_SIZE);
switch (nfs_version)
{
case 2:
if(sscanmem(filehandle_v2, sizeof(file_handle_v2_t), (char *)str) == -1)
{
fprintf(stderr, "Bad FH as input (expected size: %lu bytes)\n",
(unsigned long)sizeof(file_handle_v2_t));
exit(1);
}
exportid = nfs2_FhandleToExportId(&filehandle_v2);
break;
case 3:
if(sscanmem(buffer, sizeof(file_handle_v3_t), (char *)str) == -1)
{
fprintf(stderr, "Bad FH as input (expected size: %lu bytes)\n",
(unsigned long)sizeof(file_handle_v3_t));
exit(1);
}
filehandle_v3.data.data_val = (char *)buffer;
filehandle_v3.data.data_len = sizeof(file_handle_v3_t);
exportid = nfs3_FhandleToExportId(&filehandle_v3);
break;
case 4:
if(sscanmem(buffer, sizeof(file_handle_v4_t), (char *)str) == -1)
{
fprintf(stderr, "Bad FH as input (expected size: %lu bytes)\n",
(unsigned long)sizeof(file_handle_v4_t));
exit(1);
}
filehandle_v4.nfs_fh4_val = (char *)buffer;
filehandle_v4.nfs_fh4_len = sizeof(file_handle_v4_t);
exportid = nfs4_FhandleToExportId(&filehandle_v4);
break;
}
if((pexport = nfs_Get_export_by_id(pexportlist, exportid)) == NULL)
{
fprintf(stderr, "NFS FH has exportid %u which is invalid....\n", exportid);
exit(1);
}
/* INITIALIZING A CLIENT CONTEXT FOR FSAL */
FSAL_str2path(pexport->fullpath, MAXPATHLEN, &export_path);
if(FSAL_IS_ERROR
(fsal_status =
FSAL_BuildExportContext(&fsal_export_context, &export_path,
pexport->FS_specific)))
{
fprintf(stderr, "Error in FSAL_BuildExportContext, major=%u, minor=%u\n",
fsal_status.major, fsal_status.minor);
exit(1);
}
fsal_status = FSAL_InitClientContext(&fsal_op_context);
if(FSAL_IS_ERROR(fsal_status))
{
/* Failed init */
fprintf(stderr, "Could not init client context... major=%d minor=%d\n",
fsal_status.major, fsal_status.minor);
exit(1);
}
fsal_status = FSAL_GetClientContext(&fsal_op_context,
&fsal_export_context, 0, 0, NULL, 0);
if(FSAL_IS_ERROR(fsal_status))
{
/* Failed init */
fprintf(stderr, "Could not get cred for uid=%d gid=%d, major=%d minor=%d\n",
getuid(), getgid(), fsal_status.major, fsal_status.minor);
exit(1);
}
/* now, can use the fsal_op_context */
switch (nfs_version)
{
case 2:
if(!nfs2_FhandleToFSAL(&filehandle_v2, &fsal_data.handle, &fsal_op_context))
{
fprintf(stderr, "Cannot convert Fhandle to FSAL\n");
exit(1);
}
break;
case 3:
if(!nfs3_FhandleToFSAL(&filehandle_v3, &fsal_data.handle, &fsal_op_context))
{
fprintf(stderr, "Cannot convert Fhandle to FSAL\n");
exit(1);
}
break;
case 4:
if(!nfs4_FhandleToFSAL(&filehandle_v4, &fsal_data.handle, &fsal_op_context))
{
fprintf(stderr, "Cannot convert Fhandle to FSAL\n");
exit(1);
}
break;
}
printf("\n");
snprintmem((caddr_t) str, 2 * CMD_BUFFER_SIZE, (caddr_t) & fsal_data.handle,
sizeof(fsal_data.handle));
printf("%-18s = %s\n", "FSAL Handle", str);
/* Now, list FSAL extended attributes */
cookie = XATTRS_READLIST_FROM_BEGINNING;
eol = FALSE;
while(!eol)
{
unsigned int index;
fsal_status = FSAL_ListXAttrs(&fsal_data.handle, cookie, &fsal_op_context,
xattr_array, 256, &nb_returned, &eol);
if(FSAL_IS_ERROR(fsal_status))
{
fprintf(stderr, "Error executing FSAL_ListXAttrs\n");
exit(1);
}
/* list attributes and get their value */
for(index = 0; index < nb_returned; index++)
{
cookie = xattr_array[index].xattr_cookie;
printf("%-18s = ", xattr_array[index].xattr_name.name);
fsal_status =
FSAL_GetXAttrValueByName(&fsal_data.handle,
&xattr_array[index].xattr_name,
&fsal_op_context, attr_buffer, 4096,
&sz_returned);
if(FSAL_IS_ERROR(fsal_status))
{
fprintf(stderr, "Error executing FSAL_GetXAttrValueByName\n");
}
/* Display it */
print_buffer(attr_buffer, sz_returned);
}
}
/* get object ID */
fsal_status =
FSAL_DigestHandle(&fsal_export_context, FSAL_DIGEST_FILEID4, &fsal_data.handle,
(caddr_t) & objid);
if(FSAL_IS_ERROR(fsal_status))
{
fprintf(stderr, "Error retrieving fileid from handle\n");
}
else
{
printf("%-18s = %llu\n", "FileId", objid);
}
}
/* end of retrieval of objid */
/* build the path in the datacache */
cache_content_hash = HashFileID4(objid);
/* for limiting the number of entries into each datacache directory
* we create 256 subdirectories on 2 levels, depending on the entry's fileid.
*/
nb_char = snprintf(entry_path, MAXPATHLEN, "export_id=%d", 0);
for(i = 0; i <= 8; i += 8)
{
/* concatenation of hashval */
nb_char += snprintf((char *)(entry_path + nb_char), MAXPATHLEN - nb_char,
"/%02hhX", (char)((cache_content_hash >> i) & 0xFF));
}
/* displays the node name */
printf("%-18s = %s/%s/node=%llx*\n", "DataCache path",
nfs_param.cache_layers_param.cache_content_client_param.cache_dir, entry_path,
objid);
exit(0);
}
