int
l3Open( rsComm_t *rsComm, int l1descInx ) {
dataObjInfo_t *dataObjInfo;
int l3descInx;
int mode, flags;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3Open - failed in get_loc_for_hier_string", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subFile;
memset( &subFile, 0, sizeof( subFile ) );
rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
subFile.specColl = dataObjInfo->specColl;
subFile.mode = getFileMode( L1desc[l1descInx].dataObjInp );
subFile.flags = getFileFlags( l1descInx );
l3descInx = rsSubStructFileOpen( rsComm, &subFile );
}
else {
mode = getFileMode( L1desc[l1descInx].dataObjInp );
flags = getFileFlags( l1descInx );
l3descInx = _l3Open( rsComm, dataObjInfo, mode, flags );
}
return l3descInx;
}
int
l3Mkdir( rsComm_t *rsComm, dataObjInfo_t *dataObjInfo ) {
//int rescTypeInx;
fileMkdirInp_t fileMkdirInp;
int status;
// =-=-=-=-=-=-=-
// extract the host location from the resource hierarchy
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3Mkdir - failed in get_loc_for_hier_string", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subFile;
memset( &subFile, 0, sizeof( subFile ) );
rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
subFile.mode = getDefDirMode();
//rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc, NAME_LEN );
rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
subFile.specColl = dataObjInfo->specColl;
status = rsSubStructFileMkdir( rsComm, &subFile );
}
else {
memset( &fileMkdirInp, 0, sizeof( fileMkdirInp ) );
rstrcpy( fileMkdirInp.dirName, dataObjInfo->filePath, MAX_NAME_LEN );
rstrcpy( fileMkdirInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN );
rstrcpy( fileMkdirInp.addr.hostAddr, location.c_str(), NAME_LEN );
fileMkdirInp.mode = getDefDirMode();
status = rsFileMkdir( rsComm, &fileMkdirInp );
}
return status;
}
int
l3Create( rsComm_t *rsComm, int l1descInx ) {
dataObjInfo_t *dataObjInfo;
int l3descInx;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
// =-=-=-=-=-=-=-
// extract the host location from the resource hierarchy
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3Create - failed in get_loc_for_hier_String", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subFile;
memset( &subFile, 0, sizeof( subFile ) );
rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
subFile.specColl = dataObjInfo->specColl;
subFile.mode = getFileMode( L1desc[l1descInx].dataObjInp );
l3descInx = rsSubStructFileCreate( rsComm, &subFile );
}
else {
/* normal or mounted file */
l3descInx = l3CreateByObjInfo( rsComm, L1desc[l1descInx].dataObjInp,
L1desc[l1descInx].dataObjInfo );
}
return ( l3descInx );
}
int
_rsSyncMountedColl (rsComm_t *rsComm, specColl_t *specColl, int oprType)
{
int status;
if (getStructFileType (specColl) >= 0) { /* a struct file */
structFileOprInp_t structFileOprInp;
rescInfo_t *rescInfo;
if (strlen (specColl->resource) == 0) {
/* nothing to sync */
return (0);
}
memset (&structFileOprInp, 0, sizeof (structFileOprInp));
status = resolveResc (specColl->resource, &rescInfo);
if (status < 0) {
rodsLog (LOG_NOTICE,
"_rsSyncMountedColl: resolveResc error for %s, status = %d",
specColl->resource, status);
return (status);
}
rstrcpy (structFileOprInp.addr.hostAddr, rescInfo->rescLoc, NAME_LEN);
structFileOprInp.oprType = oprType;
structFileOprInp.specColl = specColl;
status = rsStructFileSync (rsComm, &structFileOprInp);
} else { /* not a struct file */
status = SYS_COLL_NOT_MOUNTED_ERR;
}
return (status);
}
int
l3Rmdir( rsComm_t *rsComm, dataObjInfo_t *dataObjInfo ) {
fileRmdirInp_t fileRmdirInp;
int status;
// =-=-=-=-=-=-=-
// get the resc location of the hier leaf
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3Rmdir - failed in get_loc_for_hier_string", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subFile;
memset( &subFile, 0, sizeof( subFile ) );
rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
subFile.specColl = dataObjInfo->specColl;
status = rsSubStructFileRmdir( rsComm, &subFile );
}
else {
memset( &fileRmdirInp, 0, sizeof( fileRmdirInp ) );
rstrcpy( fileRmdirInp.dirName, dataObjInfo->filePath, MAX_NAME_LEN );
rstrcpy( fileRmdirInp.addr.hostAddr, location.c_str(), NAME_LEN );
rstrcpy( fileRmdirInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN );
status = rsFileRmdir( rsComm, &fileRmdirInp );
}
return status;
}
int
l3FileGetSingleBuf (rsComm_t *rsComm, int l1descInx,
bytesBuf_t *dataObjOutBBuf)
{
dataObjInfo_t *dataObjInfo;
int rescTypeInx;
fileOpenInp_t fileGetInp;
int bytesRead;
dataObjInp_t *dataObjInp;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
if (getStructFileType (dataObjInfo->specColl) >= 0) {
subFile_t subFile;
memset (&subFile, 0, sizeof (subFile));
rstrcpy (subFile.subFilePath, dataObjInfo->subPath,
MAX_NAME_LEN);
rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
NAME_LEN);
subFile.specColl = dataObjInfo->specColl;
subFile.mode = getFileMode (L1desc[l1descInx].dataObjInp);
subFile.flags = O_RDONLY;
subFile.offset = dataObjInfo->dataSize;
bytesRead = rsSubStructFileGet (rsComm, &subFile, dataObjOutBBuf);
return (bytesRead);
}
rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
switch (RescTypeDef[rescTypeInx].rescCat) {
case FILE_CAT:
memset (&fileGetInp, 0, sizeof (fileGetInp));
dataObjInp = L1desc[l1descInx].dataObjInp;
fileGetInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
rstrcpy (fileGetInp.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
NAME_LEN);
rstrcpy (fileGetInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
fileGetInp.mode = getFileMode (dataObjInp);
fileGetInp.flags = O_RDONLY;
fileGetInp.dataSize = dataObjInfo->dataSize;
/* XXXXX need to be able to handle structured file */
bytesRead = rsFileGet (rsComm, &fileGetInp, dataObjOutBBuf);
break;
default:
rodsLog (LOG_NOTICE,
"l3Open: rescCat type %d is not recognized",
RescTypeDef[rescTypeInx].rescCat);
bytesRead = SYS_INVALID_RESC_TYPE;
break;
}
return (bytesRead);
}
int
l3FileGetSingleBuf( rsComm_t *rsComm, int l1descInx,
bytesBuf_t *dataObjOutBBuf ) {
dataObjInfo_t *dataObjInfo;
fileOpenInp_t fileGetInp;
int bytesRead;
dataObjInp_t *dataObjInp;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
// =-=-=-=-=-=-=-
// extract the host location from the resource hierarchy
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3FileGetSingleBuf - failed in get_loc_for_hier_String", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subFile;
memset( &subFile, 0, sizeof( subFile ) );
rstrcpy( subFile.subFilePath, dataObjInfo->subPath,
MAX_NAME_LEN );
//rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,NAME_LEN);
rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
subFile.specColl = dataObjInfo->specColl;
subFile.mode = getFileMode( L1desc[l1descInx].dataObjInp );
subFile.flags = O_RDONLY;
subFile.offset = dataObjInfo->dataSize;
bytesRead = rsSubStructFileGet( rsComm, &subFile, dataObjOutBBuf );
return bytesRead;
}
memset( &fileGetInp, 0, sizeof( fileGetInp ) );
dataObjInp = L1desc[l1descInx].dataObjInp;
rstrcpy( fileGetInp.addr.hostAddr, location.c_str(), NAME_LEN );
rstrcpy( fileGetInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN );
rstrcpy( fileGetInp.resc_name_, dataObjInfo->rescInfo->rescName, MAX_NAME_LEN );
rstrcpy( fileGetInp.resc_hier_, dataObjInfo->rescHier, MAX_NAME_LEN );
rstrcpy( fileGetInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN );
fileGetInp.mode = getFileMode( dataObjInp );
fileGetInp.flags = O_RDONLY;
fileGetInp.dataSize = dataObjInfo->dataSize;
/* XXXXX need to be able to handle structured file */
bytesRead = rsFileGet( rsComm, &fileGetInp, dataObjOutBBuf );
return bytesRead;
}
int
l3Read( rsComm_t *rsComm, int l1descInx, int len,
bytesBuf_t *dataObjReadOutBBuf ) {
int bytesRead;
dataObjInfo_t *dataObjInfo;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
// =-=-=-=-=-=-=-
// extract the host location from the resource hierarchy
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "failed in get_loc_for_hier_String", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subStructFileFdOprInp_t subStructFileReadInp;
memset( &subStructFileReadInp, 0, sizeof( subStructFileReadInp ) );
subStructFileReadInp.type = dataObjInfo->specColl->type;
subStructFileReadInp.fd = L1desc[l1descInx].l3descInx;
subStructFileReadInp.len = len;
rstrcpy( subStructFileReadInp.addr.hostAddr, location.c_str(), NAME_LEN );
rstrcpy( subStructFileReadInp.resc_hier, dataObjInfo->rescHier, MAX_NAME_LEN );
bytesRead = rsSubStructFileRead( rsComm, &subStructFileReadInp, dataObjReadOutBBuf );
}
else {
fileReadInp_t fileReadInp;
int category = FILE_CAT; // do not support DB type
switch ( category ) {
case FILE_CAT:
memset( &fileReadInp, 0, sizeof( fileReadInp ) );
fileReadInp.fileInx = L1desc[l1descInx].l3descInx;
fileReadInp.len = len;
bytesRead = rsFileRead( rsComm, &fileReadInp, dataObjReadOutBBuf );
break;
default:
rodsLog( LOG_NOTICE,
"l3Read: rescCat type %d is not recognized", category );
bytesRead = SYS_INVALID_RESC_TYPE;
break;
}
}
return bytesRead;
}
int
specCollReaddir( rsComm_t *rsComm, int specCollInx, rodsDirent_t **rodsDirent ) {
fileReaddirInp_t fileReaddirInp;
specColl_t *specColl;
int status;
dataObjInfo_t *dataObjInfo = SpecCollDesc[specCollInx].dataObjInfo;
if ( dataObjInfo == NULL || ( specColl = dataObjInfo->specColl ) == NULL ) {
return SYS_INTERNAL_NULL_INPUT_ERR;
}
// =-=-=-=-=-=-=-
// get the resc location of the hier leaf
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "specCollReaddir - failed in get_loc_for_hier_string", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subStructFileFdOprInp_t subStructFileReaddirInp;
memset( &subStructFileReaddirInp, 0, sizeof( subStructFileReaddirInp ) );
subStructFileReaddirInp.type = dataObjInfo->specColl->type;
subStructFileReaddirInp.fd = SpecCollDesc[specCollInx].l3descInx;
rstrcpy( subStructFileReaddirInp.addr.hostAddr,
location.c_str(), NAME_LEN );
rstrcpy( subStructFileReaddirInp.resc_hier,
dataObjInfo->rescHier,
MAX_NAME_LEN );
status = rsSubStructFileReaddir( rsComm, &subStructFileReaddirInp,
rodsDirent );
}
else if ( specColl->collClass == MOUNTED_COLL ) {
fileReaddirInp.fileInx = SpecCollDesc[specCollInx].l3descInx;
status = rsFileReaddir( rsComm, &fileReaddirInp, rodsDirent );
}
else {
rodsLog( LOG_ERROR,
"specCollReaddir: Unknown specColl collClass = %d",
specColl->collClass );
status = SYS_UNKNOWN_SPEC_COLL_CLASS;
}
return status;
}
int
l3Unlink (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo)
{
int rescTypeInx;
fileUnlinkInp_t fileUnlinkInp;
int status;
if (getRescClass (dataObjInfo->rescInfo) == BUNDLE_CL) return 0;
if (dataObjInfo->rescInfo->rescStatus == INT_RESC_STATUS_DOWN)
return SYS_RESC_IS_DOWN;
if (getStructFileType (dataObjInfo->specColl) >= 0) {
subFile_t subFile;
memset (&subFile, 0, sizeof (subFile));
rstrcpy (subFile.subFilePath, dataObjInfo->subPath,
MAX_NAME_LEN);
rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
NAME_LEN);
subFile.specColl = dataObjInfo->specColl;
status = rsSubStructFileUnlink (rsComm, &subFile);
} else {
rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
switch (RescTypeDef[rescTypeInx].rescCat) {
case FILE_CAT:
memset (&fileUnlinkInp, 0, sizeof (fileUnlinkInp));
fileUnlinkInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
rstrcpy (fileUnlinkInp.fileName, dataObjInfo->filePath,
MAX_NAME_LEN);
rstrcpy (fileUnlinkInp.addr.hostAddr,
dataObjInfo->rescInfo->rescLoc, NAME_LEN);
status = rsFileUnlink (rsComm, &fileUnlinkInp);
break;
default:
rodsLog (LOG_NOTICE,
"l3Unlink: rescCat type %d is not recognized",
RescTypeDef[rescTypeInx].rescCat);
status = SYS_INVALID_RESC_TYPE;
break;
}
}
return (status);
}
int
l3Opendir( rsComm_t *rsComm, dataObjInfo_t *dataObjInfo ) {
fileOpendirInp_t fileOpendirInp;
int status;
if ( dataObjInfo == NULL ) {
return SYS_INTERNAL_NULL_INPUT_ERR;
}
// =-=-=-=-=-=-=-
// get the resc location of the hier leaf
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3Opendir - failed in get_loc_for_hier_string", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subStructFileOpendirInp;
status = 0;
memset( &subStructFileOpendirInp, 0, sizeof( subStructFileOpendirInp ) );
rstrcpy( subStructFileOpendirInp.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
//rstrcpy( subStructFileOpendirInp.addr.hostAddr, dataObjInfo->rescInfo->rescLoc, NAME_LEN );
rstrcpy( subStructFileOpendirInp.addr.hostAddr, location.c_str(), NAME_LEN );
subStructFileOpendirInp.specColl = dataObjInfo->specColl;
status = rsSubStructFileOpendir( rsComm, &subStructFileOpendirInp );
}
else {
memset( &fileOpendirInp, 0, sizeof( fileOpendirInp ) );
rstrcpy( fileOpendirInp.dirName, dataObjInfo->filePath, MAX_NAME_LEN );
rstrcpy( fileOpendirInp.resc_name_, dataObjInfo->rescInfo->rescName, MAX_NAME_LEN );
rstrcpy( fileOpendirInp.resc_hier_, dataObjInfo->rescHier, MAX_NAME_LEN );
rstrcpy( fileOpendirInp.addr.hostAddr, location.c_str(), NAME_LEN );
status = rsFileOpendir( rsComm, &fileOpendirInp );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"l3Opendir: rsFileOpendir for %s error, status = %d",
dataObjInfo->filePath, status );
}
}
return status;
}
int
unmountFileDir (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp)
{
int status;
collInp_t modCollInp;
rodsObjStat_t *rodsObjStatOut = NULL;
status = collStat (rsComm, phyPathRegInp, &rodsObjStatOut);
if (status < 0) {
return status;
} else if (rodsObjStatOut->specColl == NULL) {
freeRodsObjStat (rodsObjStatOut);
rodsLog (LOG_ERROR,
"unmountFileDir: %s not mounted", phyPathRegInp->objPath);
return (SYS_COLL_NOT_MOUNTED_ERR);
}
if (getStructFileType (rodsObjStatOut->specColl) >= 0) {
/* a struct file */
status = _rsSyncMountedColl (rsComm, rodsObjStatOut->specColl,
PURGE_STRUCT_FILE_CACHE);
#if 0
if (status < 0) {
freeRodsObjStat (rodsObjStatOut);
return (status);
}
#endif
}
freeRodsObjStat (rodsObjStatOut);
memset (&modCollInp, 0, sizeof (modCollInp));
rstrcpy (modCollInp.collName, phyPathRegInp->objPath, MAX_NAME_LEN);
addKeyVal (&modCollInp.condInput, COLLECTION_TYPE_KW,
"NULL_SPECIAL_VALUE");
addKeyVal (&modCollInp.condInput, COLLECTION_INFO1_KW, "NULL_SPECIAL_VALUE");
addKeyVal (&modCollInp.condInput, COLLECTION_INFO2_KW, "NULL_SPECIAL_VALUE");
status = rsModColl (rsComm, &modCollInp);
return (status);
}
int
specCollSubStat( rsComm_t *rsComm, specColl_t *specColl,
char *subPath, specCollPerm_t specCollPerm, dataObjInfo_t **dataObjInfo ) {
int status;
int objType;
rodsStat_t *rodsStat = NULL;
dataObjInfo_t *myDataObjInfo = NULL;;
if ( dataObjInfo == NULL ) {
return USER__NULL_INPUT_ERR;
}
*dataObjInfo = NULL;
if ( specColl->collClass == MOUNTED_COLL ) {
/* a mount point */
myDataObjInfo = *dataObjInfo = ( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
/*status = resolveResc (specColl->resource, &myDataObjInfo->rescInfo);
if (status < 0) {
rodsLog( LOG_ERROR,"specCollSubStat: resolveResc error for %s, status = %d",
specColl->resource, status);
freeDataObjInfo (myDataObjInfo);
*dataObjInfo = NULL;
return status;
}*/
rstrcpy( myDataObjInfo->objPath, subPath, MAX_NAME_LEN );
rstrcpy( myDataObjInfo->subPath, subPath, MAX_NAME_LEN );
rstrcpy( myDataObjInfo->rescName, specColl->resource, NAME_LEN );
rstrcpy( myDataObjInfo->rescHier, specColl->rescHier, MAX_NAME_LEN );
rstrcpy( myDataObjInfo->dataType, "generic", NAME_LEN );
status = getMountedSubPhyPath( specColl->collection,
specColl->phyPath, subPath, myDataObjInfo->filePath );
if ( status < 0 ) {
freeDataObjInfo( myDataObjInfo );
*dataObjInfo = NULL;
return status;
}
replSpecColl( specColl, &myDataObjInfo->specColl );
}
else if ( specColl->collClass == LINKED_COLL ) {
/* a link point */
specCollCache_t *specCollCache = NULL;
char newPath[MAX_NAME_LEN];
specColl_t *curSpecColl;
char *accessStr;
dataObjInp_t myDataObjInp;
rodsObjStat_t *rodsObjStatOut = NULL;
*dataObjInfo = NULL;
curSpecColl = specColl;
status = getMountedSubPhyPath( curSpecColl->collection,
curSpecColl->phyPath, subPath, newPath );
if ( status < 0 ) {
return status;
}
status = resolveLinkedPath( rsComm, newPath, &specCollCache, NULL );
if ( status < 0 ) {
return status;
}
if ( specCollCache != NULL &&
specCollCache->specColl.collClass != LINKED_COLL ) {
status = specCollSubStat( rsComm, &specCollCache->specColl,
newPath, specCollPerm, dataObjInfo );
return status;
}
bzero( &myDataObjInp, sizeof( myDataObjInp ) );
rstrcpy( myDataObjInp.objPath, newPath, MAX_NAME_LEN );
status = collStat( rsComm, &myDataObjInp, &rodsObjStatOut );
if ( status >= 0 && NULL != rodsObjStatOut ) { /* a collection */ // JMC cppcheck - nullptr
myDataObjInfo = *dataObjInfo =
( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
replSpecColl( curSpecColl, &myDataObjInfo->specColl );
rstrcpy( myDataObjInfo->objPath, newPath, MAX_NAME_LEN );
myDataObjInfo->dataId = strtoll( rodsObjStatOut->dataId, 0, 0 );
rstrcpy( myDataObjInfo->dataOwnerName, rodsObjStatOut->ownerName, NAME_LEN );
rstrcpy( myDataObjInfo->dataOwnerZone, rodsObjStatOut->ownerZone, NAME_LEN );
rstrcpy( myDataObjInfo->dataCreate, rodsObjStatOut->createTime, TIME_LEN );
rstrcpy( myDataObjInfo->dataModify, rodsObjStatOut->modifyTime, TIME_LEN );
freeRodsObjStat( rodsObjStatOut );
return COLL_OBJ_T;
}
freeRodsObjStat( rodsObjStatOut );
/* data object */
if ( specCollPerm == READ_COLL_PERM ) {
accessStr = ACCESS_READ_OBJECT;
}
else if ( specCollPerm == WRITE_COLL_PERM ) {
accessStr = ACCESS_DELETE_OBJECT;
}
else {
accessStr = NULL;
}
status = getDataObjInfo( rsComm, &myDataObjInp, dataObjInfo,
accessStr, 0 );
if ( status < 0 ) {
myDataObjInfo = *dataObjInfo =
( dataObjInfo_t * ) malloc( sizeof( dataObjInfo_t ) );
memset( myDataObjInfo, 0, sizeof( dataObjInfo_t ) );
replSpecColl( curSpecColl, &myDataObjInfo->specColl );
rstrcpy( myDataObjInfo->objPath, newPath, MAX_NAME_LEN );
rodsLog( LOG_DEBUG,
"specCollSubStat: getDataObjInfo error for %s, status = %d",
newPath, status );
return status;
}
else {
replSpecColl( curSpecColl, &( *dataObjInfo )->specColl );
return DATA_OBJ_T;
}
}
else if ( getStructFileType( specColl ) >= 0 ) {
/* bundle */
dataObjInp_t myDataObjInp;
dataObjInfo_t *tmpDataObjInfo;
bzero( &myDataObjInp, sizeof( myDataObjInp ) );
rstrcpy( myDataObjInp.objPath, specColl->objPath, MAX_NAME_LEN );
// add the resource hierarchy to the condInput of the inp
addKeyVal( &myDataObjInp.condInput, RESC_HIER_STR_KW, specColl->rescHier );
status = getDataObjInfo( rsComm, &myDataObjInp, dataObjInfo, NULL, 1 );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"specCollSubStat: getDataObjInfo error for %s, status = %d",
myDataObjInp.objPath, status );
*dataObjInfo = NULL;
return status;
}
/* screen out any stale copies */
status = sortObjInfoForOpen( dataObjInfo, &myDataObjInp.condInput, 0 );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"specCollSubStat: sortObjInfoForOpen error for %s. status = %d",
myDataObjInp.objPath, status );
return status;
}
if ( strlen( specColl->resource ) > 0 ) {
if ( requeDataObjInfoByResc( dataObjInfo, specColl->resource,
0, 1 ) >= 0 ) {
if ( strcmp( specColl->resource,
( *dataObjInfo )->rescName ) != 0 ) {
rodsLog( LOG_ERROR,
"specCollSubStat: %s in %s does not match cache resc %s",
myDataObjInp.objPath, ( *dataObjInfo )->rescName,
specColl->resource );
freeAllDataObjInfo( *dataObjInfo );
*dataObjInfo = NULL;
return SYS_CACHE_STRUCT_FILE_RESC_ERR;
}
}
else {
rodsLog( LOG_ERROR,
"specCollSubStat: requeDataObjInfoByResc %s, resc %s error",
myDataObjInp.objPath, specColl->resource );
freeAllDataObjInfo( *dataObjInfo );
*dataObjInfo = NULL;
return SYS_CACHE_STRUCT_FILE_RESC_ERR;
}
}
/* free all the other dataObjInfo */
if ( ( *dataObjInfo )->next != NULL ) {
freeAllDataObjInfo( ( *dataObjInfo )->next );
( *dataObjInfo )->next = NULL;
}
/* fill in DataObjInfo */
tmpDataObjInfo = *dataObjInfo;
replSpecColl( specColl, &tmpDataObjInfo->specColl );
rstrcpy( specColl->resource, tmpDataObjInfo->rescName, NAME_LEN );
rstrcpy( specColl->rescHier, tmpDataObjInfo->rescHier, MAX_NAME_LEN );
rstrcpy( specColl->phyPath, tmpDataObjInfo->filePath, MAX_NAME_LEN );
rstrcpy( tmpDataObjInfo->subPath, subPath, MAX_NAME_LEN );
specColl->replNum = tmpDataObjInfo->replNum;
if ( strcmp( ( *dataObjInfo )->subPath, specColl->collection ) == 0 ) {
/* no need to go down */
return COLL_OBJ_T;
}
}
else {
rodsLog( LOG_ERROR,
"specCollSubStat: Unknown specColl collClass = %d",
specColl->collClass );
return SYS_UNKNOWN_SPEC_COLL_CLASS;
}
status = l3Stat( rsComm, *dataObjInfo, &rodsStat );
if ( status < 0 ) {
return status;
}
if ( rodsStat->st_ctim != 0 ) {
snprintf( ( *dataObjInfo )->dataCreate, TIME_LEN, "%d", rodsStat->st_ctim );
snprintf( ( *dataObjInfo )->dataModify, TIME_LEN, "%d", rodsStat->st_mtim );
}
if ( rodsStat->st_mode & S_IFDIR ) {
objType = COLL_OBJ_T;
}
else {
objType = DATA_OBJ_T;
( *dataObjInfo )->dataSize = rodsStat->st_size;
}
free( rodsStat );
return objType;
}
int
_rsDataObjOpen( rsComm_t *rsComm, dataObjInp_t *dataObjInp, dataObjInfo_t *dataObjInfoHead ) {
int status = 0;
int phyOpenFlag = DO_PHYOPEN;
if ( getValByKey( &dataObjInp->condInput, NO_OPEN_FLAG_KW ) != NULL ) {
phyOpenFlag = DO_NOT_PHYOPEN;
}
else if ( getValByKey( &dataObjInp->condInput, PHYOPEN_BY_SIZE_KW )
!= NULL ) {
phyOpenFlag = PHYOPEN_BY_SIZE;
}
// =-=-=-=-=-=-=-
// JMC - backport 4604
char * lockType = getValByKey( &dataObjInp->condInput, LOCK_TYPE_KW );
int lockFd = -1; // JMC - backport 4604
if ( lockType != NULL ) {
lockFd = irods::server_api_call(
DATA_OBJ_LOCK_AN,
rsComm,
dataObjInp,
NULL,
( void** ) NULL,
NULL );
if ( lockFd > 0 ) {
/* rm it so it won't be done again causing deadlock */
rmKeyVal( &dataObjInp->condInput, LOCK_TYPE_KW );
}
else {
rodsLogError( LOG_ERROR, lockFd,
"_rsDataObjOpen: lock error for %s. lockType = %s",
dataObjInp->objPath, lockType );
return lockFd;
}
}
int writeFlag = getWriteFlag( dataObjInp->openFlags );
// check earlier attempt at resolving resource hierarchy
if (!getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW)) {
int l1descInx = 0;
if ( dataObjInp->openFlags & O_CREAT && writeFlag > 0 ) {
l1descInx = rsDataObjCreate( rsComm, dataObjInp );
status = l1descInx; // JMC - backport 4604
}
// =-=-=-=-=-=-=-
// JMC - backport 4604
if ( lockFd >= 0 ) {
if ( status > 0 ) {
L1desc[l1descInx].lockFd = lockFd;
}
else {
char fd_string[NAME_LEN];
snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd );
addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string );
irods::server_api_call(
DATA_OBJ_UNLOCK_AN,
rsComm,
dataObjInp,
NULL,
( void** ) NULL,
NULL );
}
}
return status;
}
else {
//////
/* screen out any stale copies */
status = sortObjInfoForOpen( &dataObjInfoHead, &dataObjInp->condInput, writeFlag );
if ( status < 0 ) { // JMC - backport 4604
if ( lockFd > 0 ) {
char fd_string[NAME_LEN];
snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd );
addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string );
irods::server_api_call(
DATA_OBJ_UNLOCK_AN,
rsComm,
dataObjInp,
NULL,
( void** ) NULL,
NULL );
}
std::stringstream msg;
msg << __FUNCTION__;
msg << " - Unable to select a data obj info matching the resource hierarchy from the keywords.";
irods::log( ERROR( status, msg.str() ) );
return status;
}
//////
status = applyPreprocRuleForOpen( rsComm, dataObjInp, &dataObjInfoHead );
if ( status < 0 ) { // JMC - backport 4604
if ( lockFd > 0 ) {
char fd_string[NAME_LEN];
snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd );
addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string );
irods::server_api_call(
DATA_OBJ_UNLOCK_AN,
rsComm,
dataObjInp,
NULL,
( void** ) NULL,
NULL );
}
return status;
}
}
dataObjInfo_t * compDataObjInfo = NULL;
if ( getStructFileType( dataObjInfoHead->specColl ) >= 0 ) {
/* special coll. Nothing to do */
}
else if ( writeFlag > 0 ) {
// JMC :: had to reformat this code to find a missing {
// :: i seriously hope its in the right place...
status = procDataObjOpenForWrite( rsComm, dataObjInp, &dataObjInfoHead, &compDataObjInfo );
}
if ( status < 0 ) {
if ( lockFd > 0 ) {
char fd_string[NAME_LEN];
snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd );
addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string );
irods::server_api_call(
DATA_OBJ_UNLOCK_AN,
rsComm,
dataObjInp,
NULL,
( void** ) NULL,
NULL );
}
freeAllDataObjInfo( dataObjInfoHead );
return status;
}
std::string resc_class;
irods::error prop_err = irods::get_resource_property<std::string>(
dataObjInfoHead->rescId, "class", resc_class );
if ( prop_err.ok() ) {
if ( resc_class == "bundle" ) {
status = stageBundledData( rsComm, &dataObjInfoHead );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"_rsDataObjOpen: stageBundledData of %s failed stat=%d",
dataObjInfoHead->objPath, status );
freeAllDataObjInfo( dataObjInfoHead );
if ( lockFd >= 0 ) {
char fd_string[NAME_LEN];
snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd );
addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string );
irods::server_api_call(
DATA_OBJ_UNLOCK_AN,
rsComm,
dataObjInp,
NULL,
( void** ) NULL,
NULL );
}
return status;
}
}
}
/* If compDataObjInfo != NULL, an existing COMPOUND_CL DataObjInfo exist.
* Need to replicate to * this DataObjInfo in rsdataObjClose.
* For read, compDataObjInfo should be NULL. */
dataObjInfo_t * tmpDataObjInfo = dataObjInfoHead;
while ( tmpDataObjInfo != NULL ) {
dataObjInfo_t * nextDataObjInfo = tmpDataObjInfo->next;
tmpDataObjInfo->next = NULL;
int l1descInx = status = _rsDataObjOpenWithObjInfo( rsComm, dataObjInp, phyOpenFlag, tmpDataObjInfo );
if ( l1descInx >= 0 ) {
if ( compDataObjInfo != NULL ) {
L1desc[l1descInx].replDataObjInfo = compDataObjInfo;
}
dataObjInfo_t *otherDataObjInfo = NULL;
queDataObjInfo( &otherDataObjInfo, nextDataObjInfo, 0, 1 ); // JMC - backport 4542
L1desc[l1descInx].otherDataObjInfo = otherDataObjInfo; // JMC - backport 4542
if ( writeFlag > 0 ) {
L1desc[l1descInx].openType = OPEN_FOR_WRITE_TYPE;
}
else {
L1desc[l1descInx].openType = OPEN_FOR_READ_TYPE;
}
if ( lockFd >= 0 ) {
L1desc[l1descInx].lockFd = lockFd;
}
return l1descInx;
} // if l1descInx >= 0
tmpDataObjInfo = nextDataObjInfo;
} // while
return status;
} // BAD
int
rsDataObjLseek( rsComm_t *rsComm, openedDataObjInp_t *dataObjLseekInp,
fileLseekOut_t **dataObjLseekOut ) {
int status;
int l1descInx, l3descInx;
int rescTypeInx;
dataObjInfo_t *dataObjInfo;
l1descInx = dataObjLseekInp->l1descInx;
if ( l1descInx <= 2 || l1descInx >= NUM_L1_DESC ) {
rodsLog( LOG_NOTICE,
"rsDataObjLseek: l1descInx %d out of range",
l1descInx );
return ( SYS_FILE_DESC_OUT_OF_RANGE );
}
if ( L1desc[l1descInx].inuseFlag != FD_INUSE ) {
return BAD_INPUT_DESC_INDEX;
}
if ( L1desc[l1descInx].remoteZoneHost != NULL ) {
/* cross zone operation */
dataObjLseekInp->l1descInx = L1desc[l1descInx].remoteL1descInx;
status = rcDataObjLseek( L1desc[l1descInx].remoteZoneHost->conn,
dataObjLseekInp, dataObjLseekOut );
dataObjLseekInp->l1descInx = l1descInx;
return status;
}
l3descInx = L1desc[l1descInx].l3descInx;
if ( l3descInx <= 2 ) {
rodsLog( LOG_NOTICE,
"rsDataObjLseek: l3descInx %d out of range",
l3descInx );
return ( SYS_FILE_DESC_OUT_OF_RANGE );
}
dataObjInfo = L1desc[l1descInx].dataObjInfo;
// =-=-=-=-=-=-=-
// extract the host location from the resource hierarchy
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "rsDataObjLseek - failed in get_loc_for_hier_String", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subStructFileLseekInp_t subStructFileLseekInp;
memset( &subStructFileLseekInp, 0, sizeof( subStructFileLseekInp ) );
subStructFileLseekInp.type = dataObjInfo->specColl->type;
subStructFileLseekInp.fd = L1desc[l1descInx].l3descInx;
subStructFileLseekInp.offset = dataObjLseekInp->offset;
subStructFileLseekInp.whence = dataObjLseekInp->whence;
rstrcpy( subStructFileLseekInp.addr.hostAddr,
location.c_str(),
NAME_LEN );
rstrcpy( subStructFileLseekInp.resc_hier,
dataObjInfo->rescHier,
NAME_LEN );
status = rsSubStructFileLseek( rsComm, &subStructFileLseekInp, dataObjLseekOut );
}
else {
*dataObjLseekOut = ( fileLseekOut_t* )malloc( sizeof( fileLseekOut_t ) );
memset( *dataObjLseekOut, 0, sizeof( fileLseekOut_t ) );
rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
( *dataObjLseekOut )->offset = _l3Lseek( rsComm, rescTypeInx, l3descInx,
dataObjLseekInp->offset, dataObjLseekInp->whence );
if ( ( *dataObjLseekOut )->offset >= 0 ) {
status = 0;
}
else {
status = ( *dataObjLseekOut )->offset;
}
}
return ( status );
}
int
l3DataPutSingleBuf( rsComm_t* rsComm,
dataObjInp_t* dataObjInp,
bytesBuf_t* dataObjInpBBuf ) {
int bytesWritten;
int l1descInx;
dataObjInfo_t *myDataObjInfo;
char rescGroupName[NAME_LEN];
rescInfo_t *rescInfo = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
rescGrpInfo_t *tmpRescGrpInfo = NULL;
rescInfo_t *tmpRescInfo = NULL;
int status;
openedDataObjInp_t dataObjCloseInp;
/* don't actually physically open the file */
addKeyVal( &dataObjInp->condInput, NO_OPEN_FLAG_KW, "" );
l1descInx = rsDataObjCreate( rsComm, dataObjInp );
if ( l1descInx <= 2 ) {
if ( l1descInx >= 0 ) {
rodsLog( LOG_ERROR,
"l3DataPutSingleBuf: rsDataObjCreate of %s error, status = %d",
dataObjInp->objPath,
l1descInx );
return SYS_FILE_DESC_OUT_OF_RANGE;
}
else {
return l1descInx;
}
}
bytesWritten = _l3DataPutSingleBuf( rsComm, l1descInx, dataObjInp, dataObjInpBBuf );
if ( bytesWritten < 0 ) {
myDataObjInfo = L1desc[l1descInx].dataObjInfo;
if ( getStructFileType( myDataObjInfo->specColl ) < 0 &&
strlen( myDataObjInfo->rescGroupName ) > 0 &&
( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) == 0 ) {
/* getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) == NULL) { */
/* File not in specColl and resc is a resc group and not
* overwriting existing data. Save resc info in case the put fail
*/
rstrcpy( rescGroupName, myDataObjInfo->rescGroupName, NAME_LEN );
rescInfo = myDataObjInfo->rescInfo;
}
else {
rescGroupName[0] = '\0';
rescInfo = NULL;
}
}
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = bytesWritten;
status = rsDataObjClose( rsComm, &dataObjCloseInp );
if ( status < 0 ) {
rodsLog( LOG_DEBUG,
"l3DataPutSingleBuf: rsDataObjClose of %d error, status = %d",
l1descInx, status );
}
if ( bytesWritten >= 0 ) {
return status;
}
else if ( strlen( rescGroupName ) == 0 ) {
return bytesWritten;
}
/* get here when Put failed. and rescGroupName is a valid resc group.
* Try other resc in the resc group */
status = getRescGrpForCreate( rsComm, dataObjInp, &myRescGrpInfo );
if ( status < 0 ) {
return bytesWritten;
}
tmpRescGrpInfo = myRescGrpInfo;
while ( tmpRescGrpInfo != NULL ) {
tmpRescInfo = tmpRescGrpInfo->rescInfo;
if ( rescInfo == tmpRescInfo ) {
/* already tried this resc */
tmpRescGrpInfo = tmpRescGrpInfo->next;
continue;
}
l1descInx = _rsDataObjCreateWithRescInfo( rsComm,
dataObjInp, tmpRescInfo, myRescGrpInfo->rescGroupName );
if ( l1descInx <= 2 ) {
if ( l1descInx >= 0 ) {
rodsLog( LOG_ERROR,
"l3DataPutSingleBuf:_rsDataObjCreateWithRI %s err,stat = %d",
dataObjInp->objPath, l1descInx );
}
}
else {
bytesWritten = _l3DataPutSingleBuf( rsComm, l1descInx, dataObjInp,
dataObjInpBBuf );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = bytesWritten;
status = rsDataObjClose( rsComm, &dataObjCloseInp );
if ( status < 0 ) {
rodsLog( LOG_DEBUG,
"l3DataPutSingleBuf: rsDataObjClose of %d error, status = %d",
l1descInx, status );
}
if ( bytesWritten >= 0 ) {
bytesWritten = status;
break;
}
}
tmpRescGrpInfo = tmpRescGrpInfo->next;
}
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return bytesWritten;
}
int
l3FilePutSingleBuf (rsComm_t *rsComm, int l1descInx, bytesBuf_t *dataObjInpBBuf)
{
dataObjInfo_t *dataObjInfo;
int rescTypeInx;
fileOpenInp_t filePutInp;
int bytesWritten;
dataObjInp_t *dataObjInp;
int retryCnt = 0;
int chkType;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
dataObjInp = L1desc[l1descInx].dataObjInp;
if (getStructFileType (dataObjInfo->specColl) >= 0) {
subFile_t subFile;
memset (&subFile, 0, sizeof (subFile));
rstrcpy (subFile.subFilePath, dataObjInfo->subPath,
MAX_NAME_LEN);
rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
NAME_LEN);
subFile.specColl = dataObjInfo->specColl;
subFile.mode = getFileMode (dataObjInp);
subFile.flags = O_WRONLY | dataObjInp->openFlags;
#if 0
if (getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) != NULL) {
#else
if ((L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY) != 0) {
#endif
subFile.flags |= FORCE_FLAG;
}
bytesWritten = rsSubStructFilePut (rsComm, &subFile, dataObjInpBBuf);
return (bytesWritten);
}
rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
switch (RescTypeDef[rescTypeInx].rescCat) {
case FILE_CAT:
memset (&filePutInp, 0, sizeof (filePutInp));
#if 0
if (getValByKey (&dataObjInp->condInput, FORCE_FLAG_KW) != NULL) {
#else
if ((L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY) != 0) {
#endif
filePutInp.otherFlags |= FORCE_FLAG;
}
filePutInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
rstrcpy (filePutInp.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
NAME_LEN);
rstrcpy (filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
filePutInp.mode = getFileMode (dataObjInp);
#ifdef FILESYSTEM_META
copyFilesystemMetadata(&dataObjInfo->condInput,
&filePutInp.condInput);
#endif
filePutInp.flags = O_WRONLY | dataObjInp->openFlags;
chkType = getchkPathPerm (rsComm, L1desc[l1descInx].dataObjInp,
L1desc[l1descInx].dataObjInfo);
if (chkType == DISALLOW_PATH_REG) {
return PATH_REG_NOT_ALLOWED;
} else if (chkType == NO_CHK_PATH_PERM) {
filePutInp.otherFlags |= NO_CHK_PERM_FLAG;
}
bytesWritten = rsFilePut (rsComm, &filePutInp, dataObjInpBBuf);
/* file already exists ? */
while (bytesWritten < 0 && retryCnt < 10 &&
(filePutInp.otherFlags & FORCE_FLAG) == 0 &&
getErrno (bytesWritten) == EEXIST) {
if (resolveDupFilePath (rsComm, dataObjInfo, dataObjInp) < 0) {
break;
}
rstrcpy (filePutInp.fileName, dataObjInfo->filePath,
MAX_NAME_LEN);
bytesWritten = rsFilePut (rsComm, &filePutInp, dataObjInpBBuf);
retryCnt ++;
}
break;
default:
rodsLog (LOG_NOTICE,
"l3Open: rescCat type %d is not recognized",
RescTypeDef[rescTypeInx].rescCat);
bytesWritten = SYS_INVALID_RESC_TYPE;
break;
}
return (bytesWritten);
}
int
_rsDataObjGet( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf, int handlerFlag ) {
int status;
dataObjInfo_t *dataObjInfo;
int l1descInx;
char *chksumStr = NULL;
int retval;
openedDataObjInp_t dataObjCloseInp;
/* PHYOPEN_BY_SIZE ask it to check whether "dataInclude" should be done */
addKeyVal( &dataObjInp->condInput, PHYOPEN_BY_SIZE_KW, "" );
l1descInx = _rsDataObjOpen( rsComm, dataObjInp );
if ( l1descInx < 0 ) {
return l1descInx;
}
L1desc[l1descInx].oprType = GET_OPR;
dataObjInfo = L1desc[l1descInx].dataObjInfo;
if ( getStructFileType( dataObjInfo->specColl ) >= 0 && // JMC - backport 4682
L1desc[l1descInx].l3descInx > 0 ) {
/* l3descInx == 0 if included */
*portalOprOut = ( portalOprOut_t * ) malloc( sizeof( portalOprOut_t ) );
bzero( *portalOprOut, sizeof( portalOprOut_t ) );
( *portalOprOut )->l1descInx = l1descInx;
return l1descInx;
}
if ( getValByKey( &dataObjInp->condInput, VERIFY_CHKSUM_KW ) != NULL ) {
if ( strlen( dataObjInfo->chksum ) > 0 ) {
/* a chksum already exists */
chksumStr = strdup( dataObjInfo->chksum );
}
else {
status = dataObjChksumAndReg( rsComm, dataObjInfo, &chksumStr );
if ( status < 0 ) {
return status;
}
rstrcpy( dataObjInfo->chksum, chksumStr, NAME_LEN );
}
}
if ( L1desc[l1descInx].l3descInx <= 2 ) {
/* no physical file was opened */
status = l3DataGetSingleBuf( rsComm, l1descInx, dataObjOutBBuf,
portalOprOut );
if ( status >= 0 ) {
int status2;
/** since the object is read here, we apply post procesing RAJA
* Dec 2 2010 **/
status2 = applyRuleForPostProcForRead( rsComm, dataObjOutBBuf,
dataObjInp->objPath );
if ( status2 >= 0 ) {
status = 0;
}
else {
status = status2;
}
/** since the object is read here, we apply post procesing
* RAJA Dec 2 2010 **/
if ( chksumStr != NULL ) {
rstrcpy( ( *portalOprOut )->chksum, chksumStr, NAME_LEN );
free( chksumStr );
}
}
return status;
}
status = preProcParaGet( rsComm, l1descInx, portalOprOut );
if ( status < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
rsDataObjClose( rsComm, &dataObjCloseInp );
if ( chksumStr != NULL ) {
free( chksumStr );
}
return status;
}
status = l1descInx; /* means file not included */
if ( chksumStr != NULL ) {
rstrcpy( ( *portalOprOut )->chksum, chksumStr, NAME_LEN );
free( chksumStr );
}
/* return portalOprOut to the client and wait for the rcOprComplete
* call. That is when the parallel I/O is done */
retval = sendAndRecvBranchMsg( rsComm, rsComm->apiInx, status,
( void * ) * portalOprOut, dataObjOutBBuf );
if ( retval < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
rsDataObjClose( rsComm, &dataObjCloseInp );
}
if ( handlerFlag & INTERNAL_SVR_CALL ) {
/* internal call. want to know the real status */
return retval;
}
else {
/* already send the client the status */
return SYS_NO_HANDLER_REPLY_MSG;
}
}
int
_rsDataObjPut( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut ) {
int status;
int l1descInx;
int retval;
openedDataObjInp_t dataObjCloseInp;
int allFlag;
transferStat_t *transStat = NULL;
dataObjInp_t replDataObjInp;
if ( getValByKey( &dataObjInp->condInput, ALL_KW ) != NULL ) {
allFlag = 1;
}
else {
allFlag = 0;
}
if ( getValByKey( &dataObjInp->condInput, DATA_INCLUDED_KW ) != NULL ) {
/* single buffer put */
status = l3DataPutSingleBuf( rsComm, dataObjInp, dataObjInpBBuf );
if ( status >= 0 && allFlag == 1 ) {
/* update the rest of copies */
addKeyVal( &dataObjInp->condInput, UPDATE_REPL_KW, "" );
status = rsDataObjRepl( rsComm, dataObjInp, &transStat );
if ( transStat != NULL ) {
free( transStat );
}
}
if ( status >= 0 ) {
status = applyRuleForPostProcForWrite(
rsComm, dataObjInpBBuf, dataObjInp->objPath );
if ( status >= 0 ) {
status = 0;
}
}
return status;
}
/* get down here. will do parallel I/O */
/* so that mmap will work */
dataObjInp->openFlags |= O_RDWR;
l1descInx = rsDataObjCreate( rsComm, dataObjInp );
if ( l1descInx < 0 ) {
return l1descInx;
}
L1desc[l1descInx].oprType = PUT_OPR;
L1desc[l1descInx].dataSize = dataObjInp->dataSize;
if ( getStructFileType( L1desc[l1descInx].dataObjInfo->specColl ) >= 0 ) { // JMC - backport 4682
*portalOprOut = ( portalOprOut_t * ) malloc( sizeof( portalOprOut_t ) );
bzero( *portalOprOut, sizeof( portalOprOut_t ) );
( *portalOprOut )->l1descInx = l1descInx;
return l1descInx;
}
status = preProcParaPut( rsComm, l1descInx, portalOprOut );
if ( status < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = status;
rsDataObjClose( rsComm, &dataObjCloseInp );
return status;
}
if ( allFlag == 1 ) {
/* need to save dataObjInp. get freed in sendAndRecvBranchMsg */
memset( &replDataObjInp, 0, sizeof( replDataObjInp ) );
rstrcpy( replDataObjInp.objPath, dataObjInp->objPath, MAX_NAME_LEN );
addKeyVal( &replDataObjInp.condInput, UPDATE_REPL_KW, "" );
addKeyVal( &replDataObjInp.condInput, ALL_KW, "" );
}
/* return portalOprOut to the client and wait for the rcOprComplete
* call. That is when the parallel I/O is done */
retval = sendAndRecvBranchMsg( rsComm, rsComm->apiInx, status,
( void * ) * portalOprOut, NULL );
if ( retval < 0 ) {
memset( &dataObjCloseInp, 0, sizeof( dataObjCloseInp ) );
dataObjCloseInp.l1descInx = l1descInx;
L1desc[l1descInx].oprStatus = retval;
rsDataObjClose( rsComm, &dataObjCloseInp );
if ( allFlag == 1 ) {
clearKeyVal( &replDataObjInp.condInput );
}
}
else if ( allFlag == 1 ) {
status = rsDataObjRepl( rsComm, &replDataObjInp, &transStat );
if ( transStat != NULL ) {
free( transStat );
}
clearKeyVal( &replDataObjInp.condInput );
}
/* already send the client the status */
return SYS_NO_HANDLER_REPLY_MSG;
}
int
rsDataObjLseek (rsComm_t *rsComm, openedDataObjInp_t *dataObjLseekInp,
fileLseekOut_t **dataObjLseekOut)
{
int status;
int l1descInx, l3descInx;
int rescTypeInx;
dataObjInfo_t *dataObjInfo;
l1descInx = dataObjLseekInp->l1descInx;
if (l1descInx <= 2 || l1descInx >= NUM_L1_DESC) {
rodsLog (LOG_NOTICE,
"rsDataObjLseek: l1descInx %d out of range",
l1descInx);
return (SYS_FILE_DESC_OUT_OF_RANGE);
}
if (L1desc[l1descInx].inuseFlag != FD_INUSE) return BAD_INPUT_DESC_INDEX;
if (L1desc[l1descInx].remoteZoneHost != NULL) {
/* cross zone operation */
dataObjLseekInp->l1descInx = L1desc[l1descInx].remoteL1descInx;
status = rcDataObjLseek (L1desc[l1descInx].remoteZoneHost->conn,
dataObjLseekInp, dataObjLseekOut);
dataObjLseekInp->l1descInx = l1descInx;
return status;
}
l3descInx = L1desc[l1descInx].l3descInx;
if (l3descInx <= 2) {
rodsLog (LOG_NOTICE,
"rsDataObjLseek: l3descInx %d out of range",
l3descInx);
return (SYS_FILE_DESC_OUT_OF_RANGE);
}
dataObjInfo = L1desc[l1descInx].dataObjInfo;
if (getStructFileType (dataObjInfo->specColl) >= 0) {
subStructFileLseekInp_t subStructFileLseekInp;
memset (&subStructFileLseekInp, 0, sizeof (subStructFileLseekInp));
subStructFileLseekInp.type = dataObjInfo->specColl->type;
subStructFileLseekInp.fd = L1desc[l1descInx].l3descInx;
subStructFileLseekInp.offset = dataObjLseekInp->offset;
subStructFileLseekInp.whence = dataObjLseekInp->whence;
rstrcpy (subStructFileLseekInp.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
NAME_LEN);
status = rsSubStructFileLseek (rsComm, &subStructFileLseekInp, dataObjLseekOut);
} else {
*dataObjLseekOut = (fileLseekOut_t*)malloc (sizeof (fileLseekOut_t));
memset (*dataObjLseekOut, 0, sizeof (fileLseekOut_t));
rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
(*dataObjLseekOut)->offset = _l3Lseek (rsComm, rescTypeInx, l3descInx,
dataObjLseekInp->offset, dataObjLseekInp->whence);
if ((*dataObjLseekOut)->offset >= 0) {
status = 0;
} else {
status = (*dataObjLseekOut)->offset;
}
}
return (status);
}
int
l3FilePutSingleBuf( rsComm_t *rsComm, int l1descInx, bytesBuf_t *dataObjInpBBuf ) {
dataObjInfo_t *dataObjInfo;
fileOpenInp_t filePutInp;
int bytesWritten;
dataObjInp_t *dataObjInp;
int retryCnt = 0;
int chkType = 0; // JMC - backport 4774
dataObjInfo = L1desc[l1descInx].dataObjInfo;
dataObjInp = L1desc[l1descInx].dataObjInp;
// =-=-=-=-=-=-=-
// extract the host location from the resource hierarchy
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3FilePutSingleBuf - failed in get_loc_for_hier_string", ret ) );
return -1;
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subFile;
memset( &subFile, 0, sizeof( subFile ) );
rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
subFile.specColl = dataObjInfo->specColl;
subFile.mode = getFileMode( dataObjInp );
subFile.flags = O_WRONLY | dataObjInp->openFlags;
if ( ( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) != 0 ) {
subFile.flags |= FORCE_FLAG;
}
bytesWritten = rsSubStructFilePut( rsComm, &subFile, dataObjInpBBuf );
return bytesWritten;
} // struct file type >= 0
std::string prev_resc_hier;
memset( &filePutInp, 0, sizeof( filePutInp ) );
rstrcpy( filePutInp.resc_hier_, dataObjInfo->rescHier, MAX_NAME_LEN );
rstrcpy( filePutInp.objPath, dataObjInp->objPath, MAX_NAME_LEN );
if ( ( L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY ) != 0 ) {
filePutInp.otherFlags |= FORCE_FLAG;
}
rstrcpy( filePutInp.addr.hostAddr, location.c_str(), NAME_LEN );
rstrcpy( filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN );
filePutInp.mode = getFileMode( dataObjInp );
filePutInp.flags = O_WRONLY | dataObjInp->openFlags;
rstrcpy( filePutInp.in_pdmo, L1desc[l1descInx].in_pdmo, MAX_NAME_LEN );
// kv pasthru
copyKeyVal(
&dataObjInfo->condInput,
&filePutInp.condInput );
// =-=-=-=-=-=-=-
// JMC - backport 4774
chkType = getchkPathPerm( rsComm, L1desc[l1descInx].dataObjInp, L1desc[l1descInx].dataObjInfo );
if ( chkType == DISALLOW_PATH_REG ) {
clearKeyVal( &filePutInp.condInput );
return PATH_REG_NOT_ALLOWED;
}
else if ( chkType == NO_CHK_PATH_PERM ) {
// =-=-=-=-=-=-=-
filePutInp.otherFlags |= NO_CHK_PERM_FLAG; // JMC - backport 4758
}
filePutOut_t* put_out = 0;
prev_resc_hier = filePutInp.resc_hier_;
bytesWritten = rsFilePut( rsComm, &filePutInp, dataObjInpBBuf, &put_out );
// update the dataObjInfo with the potential changes made by the resource - hcj
rstrcpy( dataObjInfo->rescHier, filePutInp.resc_hier_, MAX_NAME_LEN );
if ( put_out ) {
rstrcpy( dataObjInfo->filePath, put_out->file_name, MAX_NAME_LEN );
free( put_out );
}
/* file already exists ? */
while ( bytesWritten < 0 && retryCnt < 10 &&
( filePutInp.otherFlags & FORCE_FLAG ) == 0 &&
getErrno( bytesWritten ) == EEXIST ) {
if ( resolveDupFilePath( rsComm, dataObjInfo, dataObjInp ) < 0 ) {
break;
}
rstrcpy( filePutInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN );
filePutOut_t* put_out = 0;
bytesWritten = rsFilePut( rsComm, &filePutInp, dataObjInpBBuf, &put_out );
// update the dataObjInfo with the potential changes made by the resource - hcj
rstrcpy( dataObjInfo->rescHier, filePutInp.resc_hier_, MAX_NAME_LEN );
if ( put_out ) {
rstrcpy( dataObjInfo->filePath, put_out->file_name, MAX_NAME_LEN );
free( put_out );
}
retryCnt ++;
} // while
clearKeyVal( &filePutInp.condInput );
return bytesWritten;
} // l3FilePutSingleBuf
int
l3Unlink( rsComm_t *rsComm, dataObjInfo_t *dataObjInfo ) {
fileUnlinkInp_t fileUnlinkInp;
int status;
// =-=-=-=-=-=-=-
// JMC - legacy resource if (getRescClass (dataObjInfo->rescInfo) == BUNDLE_CL) return 0;
std::string resc_class;
irods::error prop_err = irods::get_resource_property<std::string>(
dataObjInfo->rescName,
irods::RESOURCE_CLASS,
resc_class );
if ( prop_err.ok() ) {
if ( resc_class == irods::RESOURCE_CLASS_BUNDLE ) { //BUNDLE_CL ) {
return 0;
}
}
else {
std::stringstream msg;
msg << "failed to get property [class] for resource [";
msg << dataObjInfo->rescName;
msg << "]";
irods::log( PASSMSG( msg.str(), prop_err ) );
return -1;
}
// =-=-=-=-=-=-=-
// =-=-=-=-=-=-=-
// extract the host location from the resource hierarchy
std::string location;
irods::error ret = irods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "l3Unlink - failed in get_loc_for_hier_string", ret ) );
return -1;
}
// irods::error resc_err = irods::is_resc_live( dataObjInfo->rescName );
irods::error resc_err = irods::is_hier_live( dataObjInfo->rescHier );
if ( !resc_err.ok() ) {
return resc_err.code();
}
if ( getStructFileType( dataObjInfo->specColl ) >= 0 ) {
subFile_t subFile;
memset( &subFile, 0, sizeof( subFile ) );
rstrcpy( subFile.subFilePath, dataObjInfo->subPath, MAX_NAME_LEN );
rstrcpy( subFile.addr.hostAddr, location.c_str(), NAME_LEN );
subFile.specColl = dataObjInfo->specColl;
status = rsSubStructFileUnlink( rsComm, &subFile );
}
else {
memset( &fileUnlinkInp, 0, sizeof( fileUnlinkInp ) );
rstrcpy( fileUnlinkInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN );
rstrcpy( fileUnlinkInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN );
rstrcpy( fileUnlinkInp.addr.hostAddr, location.c_str(), NAME_LEN );
rstrcpy( fileUnlinkInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN );
rstrcpy( fileUnlinkInp.in_pdmo, dataObjInfo->in_pdmo, MAX_NAME_LEN );
status = rsFileUnlink( rsComm, &fileUnlinkInp );
}
return status;
}
