int
chkPreProcDeleteRule (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp,
dataObjInfo_t *dataObjInfoHead)
{
dataObjInfo_t *tmpDataObjInfo;
ruleExecInfo_t rei;
int status = 0;
initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp);
tmpDataObjInfo = dataObjInfoHead;
while (tmpDataObjInfo != NULL) {
/* have to go through the loop to test each copy (resource). */
rei.doi = tmpDataObjInfo;
status = applyRule ("acDataDeletePolicy", NULL, &rei, NO_SAVE_REI);
if (status < 0 && status != NO_MORE_RULES_ERR &&
status != SYS_DELETE_DISALLOWED) {
rodsLog (LOG_ERROR,
"chkPreProcDeleteRule: acDataDeletePolicy err for %s. stat = %d",
dataObjUnlinkInp->objPath, status);
return (status);
}
if (rei.status == SYS_DELETE_DISALLOWED) {
rodsLog (LOG_ERROR,
"chkPreProcDeleteRule:acDataDeletePolicy disallowed delete of %s",
dataObjUnlinkInp->objPath);
return (rei.status);
}
tmpDataObjInfo = tmpDataObjInfo->next;
}
return status;
}
int
applyPreprocRuleForOpen( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
dataObjInfo_t **dataObjInfoHead ) {
int status;
ruleExecInfo_t rei;
initReiWithDataObjInp( &rei, rsComm, dataObjInp );
rei.doi = *dataObjInfoHead;
// make resource properties available as rule session variables
irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData);
status = applyRule( "acPreprocForDataObjOpen", NULL, &rei, NO_SAVE_REI );
clearKeyVal(rei.condInputData);
free(rei.condInputData);
if ( status < 0 ) {
if ( rei.status < 0 ) {
status = rei.status;
}
rodsLog( LOG_ERROR,
"applyPreprocRuleForOpen:acPreprocForDataObjOpen error for %s,stat=%d",
dataObjInp->objPath, status );
}
else {
*dataObjInfoHead = rei.doi;
}
return status;
}
int getRescGrpForCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp, rescGrpInfo_t** myRescGrpInfo ) {
int status;
ruleExecInfo_t rei;
/* query rcat for resource info and sort it */
initReiWithDataObjInp( &rei, rsComm, dataObjInp );
if ( dataObjInp->oprType == REPLICATE_OPR ) { // JMC - backport 4660
status = applyRule( "acSetRescSchemeForRepl", NULL, &rei, NO_SAVE_REI );
}
else {
status = applyRule( "acSetRescSchemeForCreate", NULL, &rei, NO_SAVE_REI );
}
if ( status < 0 ) {
if ( rei.status < 0 ) {
status = rei.status;
}
rodsLog( LOG_NOTICE, "getRescGrpForCreate:acSetRescSchemeForCreate error for %s,status=%d",
dataObjInp->objPath, status );
return ( status );
}
if ( rei.rgi == NULL ) {
/* def resc group has not been initialized yet */
// JMC - legacy resource status = setDefaultResc (rsComm, NULL, NULL, &dataObjInp->condInput, myRescGrpInfo );
//if( !(*myRescGrpInfo) ) {
( *myRescGrpInfo ) = new rescGrpInfo_t;
bzero( ( *myRescGrpInfo ), sizeof( rescGrpInfo_t ) );
( *myRescGrpInfo )->rescInfo = new rescInfo_t;
//}
irods::error set_err = irods::set_default_resource( rsComm, "", "", &dataObjInp->condInput, *( *myRescGrpInfo ) );
if ( !set_err.ok() ) {
irods::log( PASS( set_err ) );
return SYS_INVALID_RESC_INPUT;
}
}
else {
*myRescGrpInfo = rei.rgi;
}
status = setRescQuota( rsComm, dataObjInp->objPath, myRescGrpInfo, dataObjInp->dataSize );
if ( status == SYS_RESC_QUOTA_EXCEEDED ) {
return SYS_RESC_QUOTA_EXCEEDED;
}
return 0; // JMC - should this be 1 per above block?
}
int getRescForCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp, std::string& _resc_name ) {
int status;
ruleExecInfo_t rei;
/* query rcat for resource info and sort it */
initReiWithDataObjInp( &rei, rsComm, dataObjInp );
if ( dataObjInp->oprType == REPLICATE_OPR ) { // JMC - backport 4660
status = applyRule( "acSetRescSchemeForRepl", NULL, &rei, NO_SAVE_REI );
}
else {
status = applyRule( "acSetRescSchemeForCreate", NULL, &rei, NO_SAVE_REI );
}
if ( status < 0 ) {
if ( rei.status < 0 ) {
status = rei.status;
}
rodsLog( LOG_NOTICE, "getRescForCreate:acSetRescSchemeForCreate error for %s,status=%d",
dataObjInp->objPath, status );
return status;
}
// get resource name
if ( !strlen( rei.rescName ) ) {
irods::error set_err = irods::set_default_resource( rsComm, "", "", &dataObjInp->condInput, _resc_name );
if ( !set_err.ok() ) {
irods::log( PASS( set_err ) );
return SYS_INVALID_RESC_INPUT;
}
}
else {
_resc_name = rei.rescName;
}
#if 0 // #1472
status = setRescQuota( rsComm, dataObjInp->objPath, myRescGrpInfo, dataObjInp->dataSize );
if ( status == SYS_RESC_QUOTA_EXCEEDED ) {
if ( rei.rgi == NULL ) {
delete( *myRescGrpInfo )->rescInfo;
delete( *myRescGrpInfo );
*myRescGrpInfo = NULL;
}
return SYS_RESC_QUOTA_EXCEEDED;
}
#endif
return 0; // JMC - should this be 1 per above block?
}
int
_rsRmCollRecur( rsComm_t *rsComm, collInp_t *rmCollInp,
collOprStat_t **collOprStat ) {
int status;
ruleExecInfo_t rei;
int trashPolicy;
dataObjInfo_t *dataObjInfo = NULL;
/* check for specColl and permission */
status = resolvePathInSpecColl( rsComm, rmCollInp->collName,
WRITE_COLL_PERM, 0, &dataObjInfo );
if ( status < 0 && status != CAT_NO_ROWS_FOUND ) {
return status;
}
if ( status == COLL_OBJ_T && dataObjInfo->specColl != NULL &&
dataObjInfo->specColl->collClass == LINKED_COLL ) {
rstrcpy( rmCollInp->collName, dataObjInfo->objPath,
MAX_NAME_LEN );
free( dataObjInfo->specColl );
dataObjInfo->specColl = NULL;
}
if ( status != COLL_OBJ_T || dataObjInfo->specColl == NULL ) {
/* a normal coll */
if ( rmCollInp->oprType != UNREG_OPR &&
getValByKey( &rmCollInp->condInput, FORCE_FLAG_KW ) == NULL &&
getValByKey( &rmCollInp->condInput, RMTRASH_KW ) == NULL &&
getValByKey( &rmCollInp->condInput, ADMIN_RMTRASH_KW ) == NULL ) {
initReiWithDataObjInp( &rei, rsComm, NULL );
status = applyRule( "acTrashPolicy", NULL, &rei, NO_SAVE_REI );
trashPolicy = rei.status;
if ( trashPolicy != NO_TRASH_CAN ) {
status = rsMvCollToTrash( rsComm, rmCollInp );
if ( status >= 0 && collOprStat != NULL ) {
if ( *collOprStat == NULL ) {
*collOprStat = ( collOprStat_t* )malloc( sizeof( collOprStat_t ) );
memset( *collOprStat, 0, sizeof( collOprStat_t ) );
}
( *collOprStat )->filesCnt = 1;
( *collOprStat )->totalFileCnt = 1;
rstrcpy( ( *collOprStat )->lastObjPath, rmCollInp->collName,
MAX_NAME_LEN );
}
return status;
}
}
}
/* got here. will recursively phy delete the collection */
status = _rsPhyRmColl( rsComm, rmCollInp, dataObjInfo, collOprStat );
if ( dataObjInfo != NULL ) {
freeDataObjInfo( dataObjInfo );
}
return status;
}
int
chkRescQuotaPolicy( rsComm_t *rsComm ) {
int status;
ruleExecInfo_t rei;
if ( RescQuotaPolicy == RESC_QUOTA_UNINIT ) {
initReiWithDataObjInp( &rei, rsComm, NULL );
status = applyRule( "acRescQuotaPolicy", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"queRescQuota: acRescQuotaPolicy error status = %d", status );
RescQuotaPolicy = RESC_QUOTA_OFF;
}
}
return RescQuotaPolicy;
}
int
chkPreProcDeleteRule( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp,
dataObjInfo_t *dataObjInfoHead ) {
dataObjInfo_t *tmpDataObjInfo;
ruleExecInfo_t rei;
int status = 0;
initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp );
tmpDataObjInfo = dataObjInfoHead;
while ( tmpDataObjInfo != NULL ) {
/* have to go through the loop to test each copy (resource). */
rei.doi = tmpDataObjInfo;
// make resource properties available as rule session variables
rei.condInputData = (keyValPair_t *)malloc(sizeof(keyValPair_t));
memset(rei.condInputData, 0, sizeof(keyValPair_t));
irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData);
status = applyRule( "acDataDeletePolicy", NULL, &rei, NO_SAVE_REI );
if ( status < 0 && status != NO_MORE_RULES_ERR &&
status != SYS_DELETE_DISALLOWED ) {
rodsLog( LOG_ERROR,
"chkPreProcDeleteRule: acDataDeletePolicy err for %s. stat = %d",
dataObjUnlinkInp->objPath, status );
return status;
}
if ( rei.status == SYS_DELETE_DISALLOWED ) {
rodsLog( LOG_ERROR,
"chkPreProcDeleteRule:acDataDeletePolicy disallowed delete of %s",
dataObjUnlinkInp->objPath );
return rei.status;
}
tmpDataObjInfo = tmpDataObjInfo->next;
}
return status;
}
int
filePathReg (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath,
rescInfo_t *rescInfo)
{
dataObjInfo_t dataObjInfo;
int status;
initDataObjInfoWithInp (&dataObjInfo, phyPathRegInp);
dataObjInfo.replStatus = NEWLY_CREATED_COPY;
dataObjInfo.rescInfo = rescInfo;
rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN);
if (dataObjInfo.dataSize <= 0 &&
(dataObjInfo.dataSize = getSizeInVault (rsComm, &dataObjInfo)) < 0) {
status = (int) dataObjInfo.dataSize;
rodsLog (LOG_ERROR,
"filePathReg: getSizeInVault for %s failed, status = %d",
dataObjInfo.objPath, status);
return (status);
}
status = svrRegDataObj (rsComm, &dataObjInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"filePathReg: rsRegDataObj for %s failed, status = %d",
dataObjInfo.objPath, status);
} else {
ruleExecInfo_t rei;
initReiWithDataObjInp (&rei, rsComm, phyPathRegInp);
rei.doi = &dataObjInfo;
rei.status = status;
rei.status = applyRule ("acPostProcForFilePathReg", NULL, &rei,
NO_SAVE_REI);
}
return (status);
}
int
getNumThreads (rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr,
keyValPair_t *condInput, char *destRescName, char *srcRescName)
{
ruleExecInfo_t rei;
dataObjInp_t doinp;
int status;
int numDestThr = -1;
int numSrcThr = -1;
rescGrpInfo_t *rescGrpInfo;
if (inpNumThr == NO_THREADING)
return 0;
if (dataSize < 0)
return 0;
if (dataSize <= MIN_SZ_FOR_PARA_TRAN) {
if (inpNumThr > 0) {
inpNumThr = 1;
} else {
return 0;
}
}
if (getValByKey (condInput, NO_PARA_OP_KW) != NULL) {
/* client specify no para opr */
return (1);
}
#ifndef PARA_OPR
return (1);
#endif
memset (&doinp, 0, sizeof (doinp));
doinp.numThreads = inpNumThr;
doinp.dataSize = dataSize;
initReiWithDataObjInp (&rei, rsComm, &doinp);
if (destRescName != NULL) {
rescGrpInfo = NULL;
status = resolveAndQueResc (destRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numDestThr = rei.status;
if (numDestThr == 0) {
return 0;
} else if (numDestThr == 1 && srcRescName == NULL &&
isLocalHost (rescGrpInfo->rescInfo->rescLoc)) {
/* one thread and resouce on local host */
return 0;
}
}
}
}
if (srcRescName != NULL) {
if (numDestThr > 0 && strcmp (destRescName, srcRescName) == 0)
return numDestThr;
rescGrpInfo = NULL;
status = resolveAndQueResc (srcRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numSrcThr = rei.status;
if (numSrcThr == 0) return 0;
}
}
}
/* At this point, number of threads for both source and destination
have been set based on acSetNumThreads policy point, and neither
of them are set to 0 (to turn off threading). If both numDestThr
and numSrcThr are set, choose the smallest one. The reasoning is
that acSetNumThreads is used by a site to limit the default
maximum parallel threads, so we should honor the most restrictive
setting. */
if (numDestThr > 0 && numSrcThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else if (numDestThr < numSrcThr) {
return numDestThr;
} else {
return numSrcThr;
}
}
if (numDestThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numDestThr;
}
}
if (numSrcThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numSrcThr;
}
}
/* should not be here. do one with no resource */
rei.rgi = NULL;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
return 0;
} else {
if (rei.status > 0)
return rei.status;
else
return 0;
}
}
int
getNumThreads( rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr,
keyValPair_t *condInput, char *destRescHier, char *srcRescHier, int oprType ) {
ruleExecInfo_t rei;
dataObjInp_t doinp;
int status;
int numDestThr = -1;
int numSrcThr = -1;
if ( inpNumThr == NO_THREADING ) {
return 0;
}
if ( dataSize < 0 ) {
return 0;
}
if ( dataSize <= MIN_SZ_FOR_PARA_TRAN ) {
if ( inpNumThr > 0 ) {
inpNumThr = 1;
}
else {
return 0;
}
}
if ( getValByKey( condInput, NO_PARA_OP_KW ) != NULL ) {
/* client specify no para opr */
return 1;
}
memset( &doinp, 0, sizeof( doinp ) );
doinp.numThreads = inpNumThr;
doinp.dataSize = dataSize;
doinp.oprType = oprType;
initReiWithDataObjInp( &rei, rsComm, &doinp );
if (destRescHier && strlen(destRescHier)) {
// get resource (hierarchy) location
std::string location;
irods::error ret = irods::get_loc_for_hier_string( destRescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "getNumThreads - failed in get_loc_for_hier_string", ret ) );
return -1;
}
irods::hierarchy_parser parser;
parser.set_string( destRescHier );
std::string last_resc;
parser.last_resc( last_resc );
irods::error err = irods::is_resc_live( last_resc.c_str() );
if ( err.ok() ) {
status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status );
}
else {
numDestThr = rei.status;
if ( numDestThr == 0 ) {
return 0;
}
else if ( numDestThr == 1 && srcRescHier == NULL &&
isLocalHost( location.c_str() ) ) {
/* one thread and resource on local host */
return 0;
}
}
}
}
if (destRescHier && strlen(destRescHier) && srcRescHier && strlen(srcRescHier)) {
if ( numDestThr > 0 && strcmp( destRescHier, srcRescHier ) == 0 ) {
return numDestThr;
}
// get resource (hierarchy) location
std::string location;
irods::error ret = irods::get_loc_for_hier_string( destRescHier, location );
if ( !ret.ok() ) {
irods::log( PASSMSG( "getNumThreads - failed in get_loc_for_hier_string", ret ) );
return -1;
}
irods::hierarchy_parser parser;
parser.set_string( srcRescHier );
std::string last_resc;
parser.last_resc( last_resc );
irods::error err = irods::is_resc_live( last_resc.c_str() );
if ( err.ok() ) {
status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status );
}
else {
numSrcThr = rei.status;
if ( numSrcThr == 0 ) {
return 0;
}
}
}
}
if ( numDestThr > 0 ) {
if ( getValByKey( condInput, RBUDP_TRANSFER_KW ) != NULL ) {
return 1;
}
else {
return numDestThr;
}
}
if ( numSrcThr > 0 ) {
if ( getValByKey( condInput, RBUDP_TRANSFER_KW ) != NULL ) {
return 1;
}
else {
return numSrcThr;
}
}
/* should not be here. do one with no resource */
status = applyRule( "acSetNumThreads", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status );
return 0;
}
else {
if ( rei.status > 0 ) {
return rei.status;
}
else {
return 0;
}
}
}
int
filePathReg (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath,
rescInfo_t *rescInfo)
{
dataObjInfo_t dataObjInfo;
int status;
char *rescGroupName = NULL;
char *chksum;
initDataObjInfoWithInp (&dataObjInfo, phyPathRegInp);
if ((rescGroupName = getValByKey (&phyPathRegInp->condInput,
RESC_GROUP_NAME_KW)) != NULL) {
rstrcpy (dataObjInfo.rescGroupName, rescGroupName, NAME_LEN);
}
dataObjInfo.replStatus = NEWLY_CREATED_COPY;
dataObjInfo.rescInfo = rescInfo;
rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN);
if (dataObjInfo.dataSize <= 0 &&
#ifdef FILESYSTEM_META
(dataObjInfo.dataSize = getFileMetadataFromVault (rsComm, &dataObjInfo)) < 0 &&
#else
(dataObjInfo.dataSize = getSizeInVault (rsComm, &dataObjInfo)) < 0 &&
#endif
dataObjInfo.dataSize != UNKNOWN_FILE_SZ) {
status = (int) dataObjInfo.dataSize;
rodsLog (LOG_ERROR,
#ifdef FILESYSTEM_META
"filePathReg: getFileMetadataFromVault for %s failed, status = %d",
#else
"filePathReg: getSizeInVault for %s failed, status = %d",
#endif
dataObjInfo.objPath, status);
return (status);
}
#ifdef FILESYSTEM_META
addKeyVal(&dataObjInfo.condInput, FILE_SOURCE_PATH_KW, filePath);
#endif
if ((chksum = getValByKey (&phyPathRegInp->condInput,
REG_CHKSUM_KW)) != NULL) {
rstrcpy (dataObjInfo.chksum, chksum, NAME_LEN);
}
else if ((chksum = getValByKey (&phyPathRegInp->condInput,
VERIFY_CHKSUM_KW)) != NULL) {
status = _dataObjChksum (rsComm, &dataObjInfo, &chksum);
if (status < 0) {
rodsLog (LOG_ERROR,
"rodsPathReg: _dataObjChksum for %s failed, status = %d",
dataObjInfo.objPath, status);
return (status);
}
rstrcpy (dataObjInfo.chksum, chksum, NAME_LEN);
}
status = svrRegDataObj (rsComm, &dataObjInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"filePathReg: rsRegDataObj for %s failed, status = %d",
dataObjInfo.objPath, status);
} else {
ruleExecInfo_t rei;
initReiWithDataObjInp (&rei, rsComm, phyPathRegInp);
rei.doi = &dataObjInfo;
rei.status = status;
rei.status = applyRule ("acPostProcForFilePathReg", NULL, &rei,
NO_SAVE_REI);
}
return (status);
}
int
getNumThreads (rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr,
keyValPair_t *condInput, char *destRescName, char *srcRescName)
{
ruleExecInfo_t rei;
dataObjInp_t doinp;
int status;
int numDestThr = -1;
int numSrcThr = -1;
rescGrpInfo_t *rescGrpInfo;
if (inpNumThr == NO_THREADING)
return 0;
if (dataSize < 0)
return 0;
if (dataSize <= MIN_SZ_FOR_PARA_TRAN) {
if (inpNumThr > 0) {
inpNumThr = 1;
} else {
return 0;
}
}
if (getValByKey (condInput, NO_PARA_OP_KW) != NULL) {
/* client specify no para opr */
return (1);
}
#ifndef PARA_OPR
return (1);
#endif
memset (&doinp, 0, sizeof (doinp));
doinp.numThreads = inpNumThr;
doinp.dataSize = dataSize;
initReiWithDataObjInp (&rei, rsComm, &doinp);
if (destRescName != NULL) {
rescGrpInfo = NULL;
status = resolveAndQueResc (destRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numDestThr = rei.status;
if (numDestThr == 0) {
return 0;
} else if (numDestThr == 1 && srcRescName == NULL &&
isLocalHost (rescGrpInfo->rescInfo->rescLoc)) {
/* one thread and resouce on local host */
return 0;
}
}
}
}
if (srcRescName != NULL) {
if (numDestThr > 0 && strcmp (destRescName, srcRescName) == 0)
return numDestThr;
rescGrpInfo = NULL;
status = resolveAndQueResc (srcRescName, NULL, &rescGrpInfo);
if (status >= 0) {
rei.rgi = rescGrpInfo;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
freeRescGrpInfo (rescGrpInfo);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
} else {
numSrcThr = rei.status;
if (numSrcThr == 0) return 0;
}
}
}
if (numDestThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numDestThr;
}
}
if (numSrcThr > 0) {
if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
return 1;
} else {
return numSrcThr;
}
}
/* should not be here. do one with no resource */
rei.rgi = NULL;
status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
if (status < 0) {
rodsLog (LOG_ERROR,
"getNumThreads: acGetNumThreads error, status = %d",
status);
return 0;
} else {
if (rei.status > 0)
return rei.status;
else
return 0;
}
}
int
dataObjUnlinkS (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp,
dataObjInfo_t *dataObjInfo)
{
int status;
unregDataObj_t unregDataObjInp;
if (dataObjInfo->specColl == NULL) {
if (dataObjUnlinkInp->oprType == UNREG_OPR &&
rsComm->clientUser.authInfo.authFlag != LOCAL_PRIV_USER_AUTH) {
ruleExecInfo_t rei;
initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp);
rei.doi = dataObjInfo;
rei.status = DO_CHK_PATH_PERM; /* default */
applyRule ("acSetChkFilePathPerm", NULL, &rei, NO_SAVE_REI);
if (rei.status != NO_CHK_PATH_PERM) {
char *outVaultPath;
rodsServerHost_t *rodsServerHost;
status = resolveHostByRescInfo (dataObjInfo->rescInfo,
&rodsServerHost);
if (status < 0) return status;
/* unregistering but not an admin user */
status = matchVaultPath (rsComm, dataObjInfo->filePath,
rodsServerHost, &outVaultPath);
if (status != 0) {
/* in the vault */
rodsLog (LOG_DEBUG,
"dataObjUnlinkS: unregistering in vault file %s",
dataObjInfo->filePath);
return CANT_UNREG_IN_VAULT_FILE;
}
}
#if 0 /* don't need this since we are doing orphan */
} else if (RescTypeDef[dataObjInfo->rescInfo->rescTypeInx].driverType
== WOS_FILE_TYPE && dataObjUnlinkInp->oprType != UNREG_OPR) {
/* WOS_FILE_TYPE, unlink first before unreg because orphan files
* cannot be reclaimed */
status = l3Unlink (rsComm, dataObjInfo);
if (status < 0) {
rodsLog (LOG_NOTICE,
"dataObjUnlinkS: l3Unlink error for WOS file %s. status = %d",
dataObjUnlinkInp->objPath, status);
return status;
}
unregDataObjInp.dataObjInfo = dataObjInfo;
unregDataObjInp.condInput = &dataObjUnlinkInp->condInput;
status = rsUnregDataObj (rsComm, &unregDataObjInp);
if (status < 0) {
rodsLog (LOG_NOTICE,
"dataObjUnlinkS: rsUnregDataObj error for %s. status = %d",
dataObjUnlinkInp->objPath, status);
}
return status;
#endif
}
unregDataObjInp.dataObjInfo = dataObjInfo;
unregDataObjInp.condInput = &dataObjUnlinkInp->condInput;
status = rsUnregDataObj (rsComm, &unregDataObjInp);
if (status < 0) {
rodsLog (LOG_NOTICE,
"dataObjUnlinkS: rsUnregDataObj error for %s. status = %d",
dataObjUnlinkInp->objPath, status);
return status;
}
}
if (dataObjUnlinkInp->oprType != UNREG_OPR) {
status = l3Unlink (rsComm, dataObjInfo);
if (status < 0) {
int myError = getErrno (status);
rodsLog (LOG_NOTICE,
"dataObjUnlinkS: l3Unlink error for %s. status = %d",
dataObjUnlinkInp->objPath, status);
/* allow ENOENT to go on and unregister */
if (myError != ENOENT && myError != EACCES) {
char orphanPath[MAX_NAME_LEN];
int status1 = 0;
rodsLog (LOG_NOTICE,
"dataObjUnlinkS: orphan file %s", dataObjInfo->filePath);
while (1) {
if (isOrphanPath (dataObjUnlinkInp->objPath) ==
NOT_ORPHAN_PATH) {
/* don't rename orphan path */
status1 = rsMkOrphanPath (rsComm, dataObjInfo->objPath,
orphanPath);
if (status1 < 0) break;
/* reg the orphan path */
rstrcpy (dataObjInfo->objPath, orphanPath,MAX_NAME_LEN);
}
status1 = svrRegDataObj (rsComm, dataObjInfo);
if (status1 == CAT_NAME_EXISTS_AS_DATAOBJ ||
status1 == CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME) {
continue;
} else if (status1 < 0) {
rodsLogError (LOG_ERROR, status1,
"dataObjUnlinkS: svrRegDataObj of orphan %s error",
dataObjInfo->objPath);
}
break;
}
return (status);
} else {
status = 0;
}
}
}
return (status);
}
int
rsMvCollToTrash( rsComm_t *rsComm, collInp_t *rmCollInp ) {
int status;
char trashPath[MAX_NAME_LEN];
dataObjCopyInp_t dataObjRenameInp;
genQueryInp_t genQueryInp;
genQueryOut_t *genQueryOut = NULL;
int continueInx;
dataObjInfo_t dataObjInfo;
/* check permission of files */
memset( &genQueryInp, 0, sizeof( genQueryInp ) );
status = rsQueryDataObjInCollReCur( rsComm, rmCollInp->collName,
&genQueryInp, &genQueryOut, ACCESS_DELETE_OBJECT, 0 );
memset( &dataObjInfo, 0, sizeof( dataObjInfo ) );
while ( status >= 0 ) {
sqlResult_t *subColl, *dataObj, *rescName;
ruleExecInfo_t rei;
/* check if allow to delete */
if ( ( subColl = getSqlResultByInx( genQueryOut, COL_COLL_NAME ) )
== NULL ) {
rodsLog( LOG_ERROR,
"rsMvCollToTrash: getSqlResultByInx for COL_COLL_NAME failed" );
return UNMATCHED_KEY_OR_INDEX;
}
if ( ( dataObj = getSqlResultByInx( genQueryOut, COL_DATA_NAME ) )
== NULL ) {
rodsLog( LOG_ERROR,
"rsMvCollToTrash: getSqlResultByInx for COL_DATA_NAME failed" );
return UNMATCHED_KEY_OR_INDEX;
}
if ( ( rescName = getSqlResultByInx( genQueryOut, COL_D_RESC_NAME ) )
== NULL ) {
rodsLog( LOG_ERROR,
"rsMvCollToTrash: getSqlResultByInx for COL_D_RESC_NAME failed" );
return UNMATCHED_KEY_OR_INDEX;
}
snprintf( dataObjInfo.objPath, MAX_NAME_LEN, "%s/%s",
subColl->value, dataObj->value );
rstrcpy( dataObjInfo.rescName, rescName->value, NAME_LEN );
initReiWithDataObjInp( &rei, rsComm, NULL );
rei.doi = &dataObjInfo;
status = applyRule( "acDataDeletePolicy", NULL, &rei, NO_SAVE_REI );
if ( status < 0 && status != NO_MORE_RULES_ERR &&
status != SYS_DELETE_DISALLOWED ) {
rodsLog( LOG_NOTICE,
"rsMvCollToTrash: acDataDeletePolicy error for %s. status = %d",
dataObjInfo.objPath, status );
return status;
}
if ( rei.status == SYS_DELETE_DISALLOWED ) {
rodsLog( LOG_NOTICE,
"rsMvCollToTrash:disallowed for %s via DataDeletePolicy,status=%d",
dataObjInfo.objPath, rei.status );
return rei.status;
}
continueInx = genQueryOut->continueInx;
freeGenQueryOut( &genQueryOut );
if ( continueInx > 0 ) {
/* More to come */
genQueryInp.continueInx = continueInx;
status = rsGenQuery( rsComm, &genQueryInp, &genQueryOut );
}
else {
break;
}
}
if ( status < 0 && status != CAT_NO_ROWS_FOUND ) {
rodsLog( LOG_ERROR,
"rsMvCollToTrash: rsQueryDataObjInCollReCur error for %s, stat=%d",
rmCollInp->collName, status );
return status;
}
status = rsMkTrashPath( rsComm, rmCollInp->collName, trashPath );
if ( status < 0 ) {
appendRandomToPath( trashPath );
status = rsMkTrashPath( rsComm, rmCollInp->collName, trashPath );
if ( status < 0 ) {
return status;
}
}
memset( &dataObjRenameInp, 0, sizeof( dataObjRenameInp ) );
dataObjRenameInp.srcDataObjInp.oprType =
dataObjRenameInp.destDataObjInp.oprType = RENAME_COLL;
rstrcpy( dataObjRenameInp.destDataObjInp.objPath, trashPath, MAX_NAME_LEN );
rstrcpy( dataObjRenameInp.srcDataObjInp.objPath, rmCollInp->collName,
MAX_NAME_LEN );
status = rsDataObjRename( rsComm, &dataObjRenameInp );
while ( status == CAT_NAME_EXISTS_AS_COLLECTION ) {
appendRandomToPath( dataObjRenameInp.destDataObjInp.objPath );
status = rsDataObjRename( rsComm, &dataObjRenameInp );
}
if ( status < 0 ) {
rodsLog( LOG_ERROR,
"mvCollToTrash: rcDataObjRename error for %s, status = %d",
dataObjRenameInp.destDataObjInp.objPath, status );
return status;
}
return status;
}
int
dataObjUnlinkS( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp,
dataObjInfo_t *dataObjInfo ) {
int status = 0;
unregDataObj_t unregDataObjInp;
if ( dataObjInfo->specColl == NULL ) {
if ( dataObjUnlinkInp->oprType == UNREG_OPR &&
rsComm->clientUser.authInfo.authFlag != LOCAL_PRIV_USER_AUTH ) {
ruleExecInfo_t rei;
initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp );
rei.doi = dataObjInfo;
rei.status = DO_CHK_PATH_PERM; /* default */ // JMC - backport 4758
// make resource properties available as rule session variables
rei.condInputData = (keyValPair_t *)malloc(sizeof(keyValPair_t));
memset(rei.condInputData, 0, sizeof(keyValPair_t));
irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData);
applyRule( "acSetChkFilePathPerm", NULL, &rei, NO_SAVE_REI );
if ( rei.status != NO_CHK_PATH_PERM ) {
// =-=-=-=-=-=-=-
// 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( "dataObjUnlinkS - failed in get_loc_for_hier_string", ret ) );
return ret.code();
}
rodsHostAddr_t addr;
rodsServerHost_t *rodsServerHost = 0;
memset( &addr, 0, sizeof( addr ) );
rstrcpy( addr.hostAddr, location.c_str(), NAME_LEN );
int remoteFlag = resolveHost( &addr, &rodsServerHost );
if ( remoteFlag < 0 ) {
// error condition?
}
/* unregistering but not an admin user */
std::string out_path;
ret = resc_mgr.validate_vault_path( dataObjInfo->filePath, rodsServerHost, out_path );
if ( !ret.ok() ) {
/* in the vault */
std::stringstream msg;
msg << "unregistering a data object which is in a vault [";
msg << dataObjInfo->filePath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return CANT_UNREG_IN_VAULT_FILE;
}
}
}
unregDataObjInp.dataObjInfo = dataObjInfo;
unregDataObjInp.condInput = &dataObjUnlinkInp->condInput;
status = rsUnregDataObj( rsComm, &unregDataObjInp );
if ( status < 0 ) {
rodsLog( LOG_NOTICE,
"dataObjUnlinkS: rsUnregDataObj error for %s. status = %d",
dataObjUnlinkInp->objPath, status );
return status;
}
}
if ( dataObjUnlinkInp->oprType != UNREG_OPR ) {
// Set the in_pdmo flag
char* in_pdmo = getValByKey( &dataObjUnlinkInp->condInput, IN_PDMO_KW );
if ( in_pdmo != NULL ) {
rstrcpy( dataObjInfo->in_pdmo, in_pdmo, MAX_NAME_LEN );
}
else {
dataObjInfo->in_pdmo[0] = '\0';
}
status = l3Unlink( rsComm, dataObjInfo );
if ( status < 0 ) {
int myError = getErrno( status );
rodsLog( LOG_NOTICE,
"dataObjUnlinkS: l3Unlink error for %s. status = %d",
dataObjUnlinkInp->objPath, status );
/* allow ENOENT to go on and unregister */
if ( myError != ENOENT && myError != EACCES ) {
char orphanPath[MAX_NAME_LEN];
int status1 = 0;
rodsLog( LOG_NOTICE,
"dataObjUnlinkS: orphan file %s", dataObjInfo->filePath );
while ( 1 ) {
if ( isOrphanPath( dataObjUnlinkInp->objPath ) ==
NOT_ORPHAN_PATH ) {
/* don't rename orphan path */
status1 = rsMkOrphanPath( rsComm, dataObjInfo->objPath,
orphanPath );
if ( status1 < 0 ) {
break;
}
/* reg the orphan path */
rstrcpy( dataObjInfo->objPath, orphanPath, MAX_NAME_LEN );
}
status1 = svrRegDataObj( rsComm, dataObjInfo );
if ( status1 == CAT_NAME_EXISTS_AS_DATAOBJ ||
status1 == CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME ) {
continue;
}
else if ( status1 < 0 ) {
rodsLogError( LOG_ERROR, status1,
"dataObjUnlinkS: svrRegDataObj of orphan %s error",
dataObjInfo->objPath );
}
break;
}
return status;
}
else {
status = 0;
}
}
}
return status;
}
int
rsDataObjPhymv (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
transferStat_t **transStat)
{
int status;
dataObjInfo_t *dataObjInfoHead = NULL;
dataObjInfo_t *oldDataObjInfoHead = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
ruleExecInfo_t rei;
int multiCopyFlag;
char *accessPerm;
int remoteFlag;
rodsServerHost_t *rodsServerHost;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput);
remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN);
if (remoteFlag < 0) {
return (remoteFlag);
} else if (remoteFlag == REMOTE_HOST) {
status = _rcDataObjPhymv (rodsServerHost->conn, dataObjInp,
transStat);
return status;
}
*transStat = (transferStat_t*)malloc (sizeof (transferStat_t));
memset (*transStat, 0, sizeof (transferStat_t));
if (getValByKey (&dataObjInp->condInput, IRODS_ADMIN_KW) != NULL) {
if (rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
return (CAT_INSUFFICIENT_PRIVILEGE_LEVEL);
}
accessPerm = NULL;
} else {
accessPerm = ACCESS_DELETE_OBJECT;
}
/* query rcat for resource info and sort it */
status = getRescGrpForCreate (rsComm, dataObjInp, &myRescGrpInfo);
if (status < 0) return status;
initReiWithDataObjInp (&rei, rsComm, dataObjInp);
status = applyRule ("acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI);
if (strcmp (rei.statusStr, MULTI_COPIES_PER_RESC) == 0) {
multiCopyFlag = 1;
} else {
multiCopyFlag = 0;
}
/* query rcat for dataObjInfo and sort it */
status = getDataObjInfo (rsComm, dataObjInp, &dataObjInfoHead,
accessPerm, 1);
if (status < 0) {
rodsLog (LOG_NOTICE,
"rsDataObjPhymv: getDataObjInfo for %s", dataObjInp->objPath);
return (status);
}
status = resolveInfoForPhymv (&dataObjInfoHead, &oldDataObjInfoHead,
&myRescGrpInfo, &dataObjInp->condInput, multiCopyFlag);
if (status < 0) {
freeAllDataObjInfo (dataObjInfoHead);
freeAllDataObjInfo (oldDataObjInfoHead);
freeAllRescGrpInfo (myRescGrpInfo);
if (status == CAT_NO_ROWS_FOUND) {
return (0);
} else {
return (status);
}
}
status = _rsDataObjPhymv (rsComm, dataObjInp, dataObjInfoHead,
myRescGrpInfo, *transStat, multiCopyFlag);
freeAllDataObjInfo (dataObjInfoHead);
freeAllDataObjInfo (oldDataObjInfoHead);
freeAllRescGrpInfo (myRescGrpInfo);
return (status);
}
int
chkCollForExtAndReg (rsComm_t *rsComm, char *collection,
rodsObjStat_t **rodsObjStatOut)
{
dataObjInp_t dataObjInp;
int status;
rodsObjStat_t *myRodsObjStat = NULL;
bzero (&dataObjInp, sizeof (dataObjInp));
rstrcpy (dataObjInp.objPath, collection, MAX_NAME_LEN);
#if 0 /* allow mounted coll */
status = collStat (rsComm, &dataObjInp, &myRodsObjStat);
#endif
status = collStatAllKinds (rsComm, &dataObjInp, &myRodsObjStat);
#if 0
if (status == CAT_NO_ROWS_FOUND || status == OBJ_PATH_DOES_NOT_EXIST ||
status == USER_FILE_DOES_NOT_EXIST) {
#endif
if (status < 0) {
status = rsMkCollR (rsComm, "/", collection);
if (status < 0) {
rodsLog (LOG_ERROR,
"chkCollForExtAndReg: rsMkCollR of %s error. status = %d",
collection, status);
return (status);
} else {
#if 0 /* allow mounted coll */
status = collStat (rsComm, &dataObjInp, &myRodsObjStat);
#endif
status = collStatAllKinds (rsComm, &dataObjInp, &myRodsObjStat);
}
}
if (status < 0) {
rodsLog (LOG_ERROR,
"chkCollForExtAndReg: collStat of %s error. status = %d",
dataObjInp.objPath, status);
return (status);
} else if (myRodsObjStat->specColl != NULL &&
myRodsObjStat->specColl->collClass != MOUNTED_COLL) {
/* only do mounted coll */
freeRodsObjStat (myRodsObjStat);
rodsLog (LOG_ERROR,
"chkCollForExtAndReg: %s is a struct file collection",
dataObjInp.objPath);
return (SYS_STRUCT_FILE_INMOUNTED_COLL);
}
if (myRodsObjStat->specColl == NULL) {
status = checkCollAccessPerm (rsComm, collection, ACCESS_DELETE_OBJECT);
} else {
status = checkCollAccessPerm (rsComm,
myRodsObjStat->specColl->collection, ACCESS_DELETE_OBJECT);
}
if (status < 0) {
rodsLog (LOG_ERROR,
"chkCollForExtAndReg: no permission to write %s, status = %d",
collection, status);
freeRodsObjStat (myRodsObjStat);
} else {
if (rodsObjStatOut != NULL) {
*rodsObjStatOut = myRodsObjStat;
} else {
freeRodsObjStat (myRodsObjStat);
}
}
return (status);
}
/* regUnbunSubfiles - non bulk version of registering all files in phyBunDir
* to the collection. Valid values for flags are:
* FORCE_FLAG_FLAG.
*/
int
regUnbunSubfiles (rsComm_t *rsComm, rescInfo_t *rescInfo, char *rescGroupName,
char *collection, char *phyBunDir, int flags, genQueryOut_t *attriArray)
{
#ifndef USE_BOOST_FS
DIR *dirPtr;
struct dirent *myDirent;
struct stat statbuf;
#endif
char subfilePath[MAX_NAME_LEN];
char subObjPath[MAX_NAME_LEN];
dataObjInp_t dataObjInp;
int status;
int savedStatus = 0;
rodsLong_t st_size;
#ifdef USE_BOOST_FS
path srcDirPath (phyBunDir);
if (!exists(srcDirPath) || !is_directory(srcDirPath)) {
#else
dirPtr = opendir (phyBunDir);
if (dirPtr == NULL) {
#endif
rodsLog (LOG_ERROR,
"regUnbunphySubfiles: opendir error for %s, errno = %d",
phyBunDir, errno);
return (UNIX_FILE_OPENDIR_ERR - errno);
}
bzero (&dataObjInp, sizeof (dataObjInp));
#ifdef USE_BOOST_FS
directory_iterator end_itr; // default construction yields past-the-end
for (directory_iterator itr(srcDirPath); itr != end_itr;++itr) {
path p = itr->path();
snprintf (subfilePath, MAX_NAME_LEN, "%s",
p.c_str ());
#else
while ((myDirent = readdir (dirPtr)) != NULL) {
if (strcmp (myDirent->d_name, ".") == 0 ||
strcmp (myDirent->d_name, "..") == 0) {
continue;
}
snprintf (subfilePath, MAX_NAME_LEN, "%s/%s",
phyBunDir, myDirent->d_name);
#endif
#ifdef USE_BOOST_FS
if (!exists (p)) {
#else
status = lstat (subfilePath, &statbuf);
if (status != 0) {
#endif
rodsLog (LOG_ERROR,
"regUnbunphySubfiles: stat error for %s, errno = %d",
subfilePath, errno);
savedStatus = UNIX_FILE_STAT_ERR - errno;
unlink (subfilePath);
continue;
}
#ifdef USE_BOOST_FS
if (is_symlink (p)) {
#else
if ((statbuf.st_mode & S_IFLNK) == S_IFLNK) {
#endif
rodsLogError (LOG_ERROR, SYMLINKED_BUNFILE_NOT_ALLOWED,
"regUnbunSubfiles: %s is a symlink",
subfilePath);
savedStatus = SYMLINKED_BUNFILE_NOT_ALLOWED;
continue;
}
#ifdef USE_BOOST_FS
path childPath = p.filename();
snprintf (subObjPath, MAX_NAME_LEN, "%s/%s",
collection, childPath.c_str());
if (is_directory (p)) {
#else
snprintf (subObjPath, MAX_NAME_LEN, "%s/%s",
collection, myDirent->d_name);
if ((statbuf.st_mode & S_IFDIR) != 0) {
#endif
status = rsMkCollR (rsComm, "/", subObjPath);
if (status < 0) {
rodsLog (LOG_ERROR,
"regUnbunSubfiles: rsMkCollR of %s error. status = %d",
subObjPath, status);
savedStatus = status;
continue;
}
status = regUnbunSubfiles (rsComm, rescInfo, rescGroupName,
subObjPath, subfilePath, flags, attriArray);
if (status < 0) {
rodsLog (LOG_ERROR,
"regUnbunSubfiles: regUnbunSubfiles of %s error. status=%d",
subObjPath, status);
savedStatus = status;
continue;
}
#ifdef USE_BOOST_FS
} else if (is_regular_file (p)) {
st_size = file_size (p);
#else
} else if ((statbuf.st_mode & S_IFREG) != 0) {
st_size = statbuf.st_size;
#endif
status = regSubfile (rsComm, rescInfo, rescGroupName,
subObjPath, subfilePath, st_size, flags);
unlink (subfilePath);
if (status < 0) {
rodsLog (LOG_ERROR,
"regUnbunSubfiles: regSubfile of %s error. status=%d",
subObjPath, status);
savedStatus = status;
continue;
}
}
}
#ifndef USE_BOOST_FS
closedir (dirPtr);
#endif
rmdir (phyBunDir);
return savedStatus;
}
int
regSubfile (rsComm_t *rsComm, rescInfo_t *rescInfo, char *rescGroupName,
char *subObjPath, char *subfilePath, rodsLong_t dataSize, int flags)
{
dataObjInfo_t dataObjInfo;
dataObjInp_t dataObjInp;
#ifndef USE_BOOST_FS
struct stat statbuf;
#endif
int status;
int modFlag = 0;
bzero (&dataObjInp, sizeof (dataObjInp));
bzero (&dataObjInfo, sizeof (dataObjInfo));
rstrcpy (dataObjInp.objPath, subObjPath, MAX_NAME_LEN);
rstrcpy (dataObjInfo.objPath, subObjPath, MAX_NAME_LEN);
rstrcpy (dataObjInfo.rescName, rescInfo->rescName, NAME_LEN);
rstrcpy (dataObjInfo.dataType, "generic", NAME_LEN);
dataObjInfo.rescInfo = rescInfo;
rstrcpy (dataObjInfo.rescGroupName, rescGroupName, NAME_LEN);
dataObjInfo.dataSize = dataSize;
status = getFilePathName (rsComm, &dataObjInfo, &dataObjInp);
if (status < 0) {
rodsLog (LOG_ERROR,
"regSubFile: getFilePathName err for %s. status = %d",
dataObjInp.objPath, status);
return (status);
}
#ifdef USE_BOOST_FS
path p (dataObjInfo.filePath);
if (exists (p)) {
if (is_directory (p)) {
#else
status = stat (dataObjInfo.filePath, &statbuf);
if (status == 0 || errno != ENOENT) {
if ((statbuf.st_mode & S_IFDIR) != 0) {
#endif
return SYS_PATH_IS_NOT_A_FILE;
}
if (chkOrphanFile (rsComm, dataObjInfo.filePath, rescInfo->rescName,
&dataObjInfo) > 0) {
/* an orphan file. just rename it */
fileRenameInp_t fileRenameInp;
bzero (&fileRenameInp, sizeof (fileRenameInp));
rstrcpy (fileRenameInp.oldFileName, dataObjInfo.filePath,
MAX_NAME_LEN);
status = renameFilePathToNewDir (rsComm, ORPHAN_DIR,
&fileRenameInp, rescInfo, 1);
if (status < 0) {
rodsLog (LOG_ERROR,
"regSubFile: renameFilePathToNewDir err for %s. status = %d",
fileRenameInp.oldFileName, status);
return (status);
}
} else {
/* not an orphan file */
if ((flags & FORCE_FLAG_FLAG) != 0 && dataObjInfo.dataId > 0 &&
strcmp (dataObjInfo.objPath, subObjPath) == 0) {
/* overwrite the current file */
modFlag = 1;
unlink (dataObjInfo.filePath);
} else {
status = SYS_COPY_ALREADY_IN_RESC;
rodsLog (LOG_ERROR,
"regSubFile: phypath %s is already in use. status = %d",
dataObjInfo.filePath, status);
return (status);
}
}
}
/* make the necessary dir */
mkDirForFilePath (UNIX_FILE_TYPE, rsComm, "/", dataObjInfo.filePath,
getDefDirMode ());
/* add a link */
#ifndef windows_platform /* Windows does not support link */
status = link (subfilePath, dataObjInfo.filePath);
if (status < 0) {
rodsLog (LOG_ERROR,
"regSubFile: link error %s to %s. errno = %d",
subfilePath, dataObjInfo.filePath, errno);
return (UNIX_FILE_LINK_ERR - errno);
}
#endif
if (modFlag == 0) {
status = svrRegDataObj (rsComm, &dataObjInfo);
} else {
char tmpStr[MAX_NAME_LEN];
modDataObjMeta_t modDataObjMetaInp;
keyValPair_t regParam;
bzero (&modDataObjMetaInp, sizeof (modDataObjMetaInp));
bzero (®Param, sizeof (regParam));
snprintf (tmpStr, MAX_NAME_LEN, "%lld", dataSize);
addKeyVal (®Param, DATA_SIZE_KW, tmpStr);
addKeyVal (®Param, ALL_REPL_STATUS_KW, tmpStr);
snprintf (tmpStr, MAX_NAME_LEN, "%d", (int) time (NULL));
addKeyVal (®Param, DATA_MODIFY_KW, tmpStr);
modDataObjMetaInp.dataObjInfo = &dataObjInfo;
modDataObjMetaInp.regParam = ®Param;
status = rsModDataObjMeta (rsComm, &modDataObjMetaInp);
clearKeyVal (®Param);
}
if (status < 0) {
rodsLog (LOG_ERROR,
"regSubFile: svrRegDataObj of %s. errno = %d",
dataObjInfo.objPath, errno);
unlink (dataObjInfo.filePath);
} else {
ruleExecInfo_t rei;
dataObjInp_t dataObjInp;
bzero (&dataObjInp, sizeof (dataObjInp));
rstrcpy (dataObjInp.objPath, dataObjInfo.objPath, MAX_NAME_LEN);
initReiWithDataObjInp (&rei, rsComm, &dataObjInp);
rei.doi = &dataObjInfo;
rei.status = applyRule ("acPostProcForTarFileReg", NULL, &rei,
NO_SAVE_REI);
if (rei.status < 0) {
rodsLogError (LOG_ERROR, rei.status,
"regSubFile: acPostProcForTarFileReg error for %s. status = %d",
dataObjInfo.objPath);
}
}
return status;
}
int
rsMvDataObjToTrash (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
dataObjInfo_t **dataObjInfoHead)
{
int status;
char trashPath[MAX_NAME_LEN];
dataObjCopyInp_t dataObjRenameInp;
if (strstr ((*dataObjInfoHead)->dataType, BUNDLE_STR) != NULL) {
return SYS_CANT_MV_BUNDLE_DATA_TO_TRASH;
}
if (getValByKey (&dataObjInp->condInput, DATA_ACCESS_KW) == NULL) {
addKeyVal (&dataObjInp->condInput, DATA_ACCESS_KW,
ACCESS_DELETE_OBJECT);
}
status = getDataObjInfo (rsComm, dataObjInp, dataObjInfoHead,
ACCESS_DELETE_OBJECT, 0);
if (status < 0) {
rodsLog (LOG_NOTICE,
"rsMvDataObjToTrash: getDataObjInfo error for %s. status = %d",
dataObjInp->objPath, status);
return (status);
}
status = chkPreProcDeleteRule (rsComm, dataObjInp, *dataObjInfoHead);
if (status < 0) return status;
#if 0 /* done in chkPreProcDeleteRule */
initReiWithDataObjInp (&rei, rsComm, dataObjInp);
rei.doi = *dataObjInfoHead;
status = applyRule ("acDataDeletePolicy", NULL, &rei, NO_SAVE_REI);
if (status < 0 && status != NO_MORE_RULES_ERR &&
status != SYS_DELETE_DISALLOWED) {
rodsLog (LOG_NOTICE,
"rsMvDataObjToTrash: acDataDeletePolicy error for %s. status = %d",
dataObjInp->objPath, status);
return (status);
}
if (rei.status == SYS_DELETE_DISALLOWED) {
rodsLog (LOG_NOTICE,
"rsMvDataObjToTrash:disallowed for %s via DataDeletePolicy,status=%d",
dataObjInp->objPath, rei.status);
return (rei.status);
}
#endif
status = rsMkTrashPath (rsComm, dataObjInp->objPath, trashPath);
if (status < 0) {
return (status);
}
memset (&dataObjRenameInp, 0, sizeof (dataObjRenameInp));
dataObjRenameInp.srcDataObjInp.oprType =
dataObjRenameInp.destDataObjInp.oprType = RENAME_DATA_OBJ;
rstrcpy (dataObjRenameInp.destDataObjInp.objPath, trashPath, MAX_NAME_LEN);
rstrcpy (dataObjRenameInp.srcDataObjInp.objPath, dataObjInp->objPath,
MAX_NAME_LEN);
status = rsDataObjRename (rsComm, &dataObjRenameInp);
while (status == CAT_NAME_EXISTS_AS_DATAOBJ ||
status == CAT_NAME_EXISTS_AS_COLLECTION ||
status == SYS_PHY_PATH_INUSE ||
getErrno (status) == EISDIR) {
appendRandomToPath (dataObjRenameInp.destDataObjInp.objPath);
status = rsDataObjRename (rsComm, &dataObjRenameInp);
#if 0
if (status1 < 0) {
rodsLog (LOG_ERROR,
"rsMvDataObjToTrash: rsDataObjRename error for %s",
dataObjRenameInp.destDataObjInp.objPath);
} else {
status = 0;
}
#endif
}
if (status < 0) {
rodsLog (LOG_ERROR,
"rsMvDataObjToTrash: rcDataObjRename error for %s, status = %d",
dataObjRenameInp.destDataObjInp.objPath, status);
return (status);
}
return (status);
}
int
rsDataObjUnlink (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp)
{
int status;
ruleExecInfo_t rei;
int trashPolicy;
dataObjInfo_t *dataObjInfoHead = NULL;
rodsServerHost_t *rodsServerHost = NULL;
int rmTrashFlag = 0;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath (rsComm, dataObjUnlinkInp->objPath, &specCollCache,
&dataObjUnlinkInp->condInput);
status = getAndConnRcatHost (rsComm, MASTER_RCAT,
dataObjUnlinkInp->objPath, &rodsServerHost);
if (status < 0) {
return (status);
} else if (rodsServerHost->rcatEnabled == REMOTE_ICAT) {
int retval;
retval = rcDataObjUnlink (rodsServerHost->conn, dataObjUnlinkInp);
return status;
}
if (getValByKey (
&dataObjUnlinkInp->condInput, IRODS_ADMIN_RMTRASH_KW) != NULL ||
getValByKey (
&dataObjUnlinkInp->condInput, IRODS_RMTRASH_KW) != NULL) {
if (isTrashPath (dataObjUnlinkInp->objPath) == False) {
return (SYS_INVALID_FILE_PATH);
}
rmTrashFlag = 1;
}
dataObjUnlinkInp->openFlags = O_WRONLY; /* set the permission checking */
status = getDataObjInfoIncSpecColl (rsComm, dataObjUnlinkInp,
&dataObjInfoHead);
if (status < 0) return (status);
if (rmTrashFlag == 1) {
char *tmpAge;
int ageLimit;
if ((tmpAge = getValByKey (&dataObjUnlinkInp->condInput, AGE_KW))
!= NULL) {
ageLimit = atoi (tmpAge) * 60;
if ((time (0) - atoi (dataObjInfoHead->dataModify)) < ageLimit) {
/* younger than ageLimit. Nothing to do */
freeAllDataObjInfo (dataObjInfoHead);
return 0;
}
}
}
if (dataObjUnlinkInp->oprType == UNREG_OPR ||
getValByKey (&dataObjUnlinkInp->condInput, FORCE_FLAG_KW) != NULL ||
getValByKey (&dataObjUnlinkInp->condInput, REPL_NUM_KW) != NULL ||
dataObjInfoHead->specColl != NULL || rmTrashFlag == 1) {
status = _rsDataObjUnlink (rsComm, dataObjUnlinkInp, &dataObjInfoHead);
} else {
initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp);
status = applyRule ("acTrashPolicy", NULL, &rei, NO_SAVE_REI);
trashPolicy = rei.status;
if (trashPolicy != NO_TRASH_CAN) {
status = rsMvDataObjToTrash (rsComm, dataObjUnlinkInp,
&dataObjInfoHead);
freeAllDataObjInfo (dataObjInfoHead);
return status;
} else {
status = _rsDataObjUnlink (rsComm, dataObjUnlinkInp,
&dataObjInfoHead);
}
}
initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp);
rei.doi = dataObjInfoHead;
rei.status = status;
rei.status = applyRule ("acPostProcForDelete", NULL, &rei, NO_SAVE_REI);
if (rei.status < 0) {
rodsLog (LOG_NOTICE,
"rsDataObjUnlink: acPostProcForDelete error for %s. status = %d",
dataObjUnlinkInp->objPath, rei.status);
}
/* dataObjInfoHead may be outdated */
freeAllDataObjInfo (dataObjInfoHead);
return (status);
}
int
rsDataObjUnlink( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp ) {
int status;
ruleExecInfo_t rei;
int trashPolicy;
dataObjInfo_t *dataObjInfoHead = NULL;
rodsServerHost_t *rodsServerHost = NULL;
int rmTrashFlag = 0;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath( rsComm, dataObjUnlinkInp->objPath, &specCollCache,
&dataObjUnlinkInp->condInput );
status = getAndConnRcatHost( rsComm, MASTER_RCAT,
( const char* )dataObjUnlinkInp->objPath, &rodsServerHost );
if ( status < 0 || NULL == rodsServerHost ) { // JMC cppcheck - nullptr
return status;
}
else if ( rodsServerHost->rcatEnabled == REMOTE_ICAT ) {
rcDataObjUnlink( rodsServerHost->conn, dataObjUnlinkInp );
return status;
}
// =-=-=-=-=-=-=-
// working on the "home zone", determine if we need to redirect to a different
// server in this zone for this operation. if there is a RESC_HIER_STR_KW then
// we know that the redirection decision has already been made
// =-=-=-=-=-=-=-
// determine the resource hierarchy if one is not provided
addKeyVal(
&dataObjUnlinkInp->condInput,
irods::UNLINK_OPERATION.c_str(),
"true" );
if ( getValByKey( &dataObjUnlinkInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION,
rsComm, dataObjUnlinkInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << "failed in irods::resolve_resource_hierarchy for [";
msg << dataObjUnlinkInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjUnlinkInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
if ( getValByKey(
&dataObjUnlinkInp->condInput, ADMIN_RMTRASH_KW ) != NULL ||
getValByKey(
&dataObjUnlinkInp->condInput, RMTRASH_KW ) != NULL ) {
if ( isTrashPath( dataObjUnlinkInp->objPath ) == False ) {
return SYS_INVALID_FILE_PATH;
}
rmTrashFlag = 1;
}
dataObjUnlinkInp->openFlags = O_WRONLY; /* set the permission checking */
status = getDataObjInfoIncSpecColl( rsComm, dataObjUnlinkInp,
&dataObjInfoHead );
if ( status < 0 ) {
char* sys_error = NULL;
const char* rods_error = rodsErrorName( status, &sys_error );
std::stringstream msg;
msg << __FUNCTION__;
msg << " - Failed to get data objects.";
msg << " - " << rods_error << " " << sys_error;
irods::error result = ERROR( status, msg.str() );
irods::log( result );
free( sys_error );
return status;
}
if ( rmTrashFlag == 1 ) {
char *tmpAge;
int ageLimit;
if ( ( tmpAge = getValByKey( &dataObjUnlinkInp->condInput, AGE_KW ) )
!= NULL ) {
ageLimit = atoi( tmpAge ) * 60;
if ( ( time( 0 ) - atoi( dataObjInfoHead->dataModify ) ) < ageLimit ) {
/* younger than ageLimit. Nothing to do */
freeAllDataObjInfo( dataObjInfoHead );
return 0;
}
}
}
if ( dataObjUnlinkInp->oprType == UNREG_OPR ||
getValByKey( &dataObjUnlinkInp->condInput, FORCE_FLAG_KW ) != NULL ||
getValByKey( &dataObjUnlinkInp->condInput, REPL_NUM_KW ) != NULL ||
getValByKey( &dataObjUnlinkInp->condInput, EMPTY_BUNDLE_ONLY_KW ) != NULL ||
dataObjInfoHead->specColl != NULL || rmTrashFlag == 1 ) {
status = _rsDataObjUnlink( rsComm, dataObjUnlinkInp, &dataObjInfoHead );
}
else {
initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp );
status = applyRule( "acTrashPolicy", NULL, &rei, NO_SAVE_REI );
trashPolicy = rei.status;
if ( trashPolicy != NO_TRASH_CAN ) {
status = rsMvDataObjToTrash( rsComm, dataObjUnlinkInp,
&dataObjInfoHead );
freeAllDataObjInfo( dataObjInfoHead );
return status;
}
else {
status = _rsDataObjUnlink( rsComm, dataObjUnlinkInp,
&dataObjInfoHead );
}
}
initReiWithDataObjInp( &rei, rsComm, dataObjUnlinkInp );
rei.doi = dataObjInfoHead;
rei.status = status;
// make resource properties available as rule session variables
rei.condInputData = (keyValPair_t *)malloc(sizeof(keyValPair_t));
memset(rei.condInputData, 0, sizeof(keyValPair_t));
irods::get_resc_properties_as_kvp(rei.doi->rescHier, rei.condInputData);
rei.status = applyRule( "acPostProcForDelete", NULL, &rei, NO_SAVE_REI );
if ( rei.status < 0 ) {
rodsLog( LOG_NOTICE,
"rsDataObjUnlink: acPostProcForDelete error for %s. status = %d",
dataObjUnlinkInp->objPath, rei.status );
}
/* dataObjInfoHead may be outdated */
freeAllDataObjInfo( dataObjInfoHead );
return status;
}
int
rsDataObjPhymv( rsComm_t *rsComm, dataObjInp_t *dataObjInp,
transferStat_t **transStat ) {
int status = 0;
dataObjInfo_t *dataObjInfoHead = NULL;
dataObjInfo_t *oldDataObjInfoHead = NULL;
rescGrpInfo_t *myRescGrpInfo = NULL;
ruleExecInfo_t rei;
int multiCopyFlag = 0;
char *accessPerm = NULL;
int remoteFlag = 0;
rodsServerHost_t *rodsServerHost = NULL;
specCollCache_t *specCollCache = NULL;
resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache,
&dataObjInp->condInput );
remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost,
REMOTE_OPEN );
if ( remoteFlag < 0 ) {
return remoteFlag;
}
else if ( remoteFlag == REMOTE_HOST ) {
status = _rcDataObjPhymv( rodsServerHost->conn, dataObjInp,
transStat );
return status;
}
// =-=-=-=-=-=-=-
// determine hierarchy string
if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) {
std::string hier;
irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm,
dataObjInp, hier );
if ( !ret.ok() ) {
std::stringstream msg;
msg << __FUNCTION__;
msg << " :: failed in irods::resolve_resource_hierarchy for [";
msg << dataObjInp->objPath << "]";
irods::log( PASSMSG( msg.str(), ret ) );
return ret.code();
}
// =-=-=-=-=-=-=-
// we resolved the redirect and have a host, set the hier str for subsequent
// api calls, etc.
addKeyVal( &dataObjInp->condInput, RESC_HIER_STR_KW, hier.c_str() );
} // if keyword
*transStat = ( transferStat_t* )malloc( sizeof( transferStat_t ) );
memset( *transStat, 0, sizeof( transferStat_t ) );
if ( getValByKey( &dataObjInp->condInput, ADMIN_KW ) != NULL ) {
if ( rsComm->clientUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH ) {
return CAT_INSUFFICIENT_PRIVILEGE_LEVEL;
}
accessPerm = NULL;
}
else {
accessPerm = ACCESS_DELETE_OBJECT;
}
/* query rcat for resource info and sort it */
status = getRescGrpForCreate( rsComm, dataObjInp, &myRescGrpInfo );
if ( status < 0 ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return status;
}
initReiWithDataObjInp( &rei, rsComm, dataObjInp );
status = applyRule( "acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI );
if ( strcmp( rei.statusStr, MULTI_COPIES_PER_RESC ) == 0 ) {
multiCopyFlag = 1;
}
else {
multiCopyFlag = 0;
}
/* query rcat for dataObjInfo and sort it */
status = getDataObjInfo( rsComm, dataObjInp, &dataObjInfoHead,
accessPerm, 1 );
if ( status < 0 ) {
rodsLog( LOG_NOTICE,
"rsDataObjPhymv: getDataObjInfo for %s", dataObjInp->objPath );
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
return status;
}
status = resolveInfoForPhymv( &dataObjInfoHead, &oldDataObjInfoHead, &myRescGrpInfo, &dataObjInp->condInput, multiCopyFlag );
if ( status < 0 ) {
freeAllDataObjInfo( dataObjInfoHead );
freeAllDataObjInfo( oldDataObjInfoHead );
if ( myRescGrpInfo ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
}
if ( status == CAT_NO_ROWS_FOUND ) {
return 0;
}
else {
return status;
}
}
status = _rsDataObjPhymv( rsComm, dataObjInp, dataObjInfoHead,
myRescGrpInfo, *transStat, multiCopyFlag );
freeAllDataObjInfo( dataObjInfoHead );
freeAllDataObjInfo( oldDataObjInfoHead );
if ( myRescGrpInfo ) {
delete myRescGrpInfo->rescInfo;
delete myRescGrpInfo;
}
return status;
}
int
_rsDataObjUnlink (rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp,
dataObjInfo_t **dataObjInfoHead)
{
int status;
int retVal = 0;
dataObjInfo_t *tmpDataObjInfo, *myDataObjInfoHead;
status = chkPreProcDeleteRule (rsComm, dataObjUnlinkInp, *dataObjInfoHead);
if (status < 0) return status;
#if 0 /* done in chkPreProcDeleteRule */
ruleExecInfo_t rei;
initReiWithDataObjInp (&rei, rsComm, dataObjUnlinkInp);
rei.doi = *dataObjInfoHead;
status = applyRule ("acDataDeletePolicy", NULL, &rei, NO_SAVE_REI);
if (status < 0 && status != NO_MORE_RULES_ERR &&
status != SYS_DELETE_DISALLOWED) {
rodsLog (LOG_NOTICE,
"_rsDataObjUnlink: acDataDeletePolicy error for %s. status = %d",
dataObjUnlinkInp->objPath, status);
return (status);
}
if (rei.status == SYS_DELETE_DISALLOWED) {
rodsLog (LOG_NOTICE,
"_rsDataObjUnlink:disallowed for %s via acDataDeletePolicy,stat=%d",
dataObjUnlinkInp->objPath, rei.status);
return (rei.status);
}
#endif
myDataObjInfoHead = *dataObjInfoHead;
if (strstr (myDataObjInfoHead->dataType, BUNDLE_STR) != NULL) {
int numSubfiles;
if (rsComm->proxyUser.authInfo.authFlag < LOCAL_PRIV_USER_AUTH) {
return CAT_INSUFFICIENT_PRIVILEGE_LEVEL;
}
if (getValByKey (&dataObjUnlinkInp->condInput, REPL_NUM_KW) != NULL) {
return SYS_CANT_MV_BUNDLE_DATA_BY_COPY;
}
numSubfiles = getNumSubfilesInBunfileObj (rsComm,
myDataObjInfoHead->objPath);
if (numSubfiles > 0) {
if (getValByKey (&dataObjUnlinkInp->condInput,
EMPTY_BUNDLE_ONLY_KW) != NULL) {
/* not empty. Nothing yo do */
return 0;
} else {
status = _unbunAndStageBunfileObj (rsComm, dataObjInfoHead,
NULL, 1);
if (status < 0) {
/* go ahead and unlink the obj if the phy file does not
* exist or have problem untaring it */
if (getErrno (status) != EEXIST &&
getIrodsErrno (status) !=
SYS_TAR_STRUCT_FILE_EXTRACT_ERR) {
rodsLogError (LOG_ERROR, status,
"_rsDataObjUnlink:_unbunAndStageBunfileObj err for %s",
myDataObjInfoHead->objPath);
return (status);
}
}
/* dataObjInfoHead may be outdated */
*dataObjInfoHead = NULL;
status = getDataObjInfoIncSpecColl (rsComm, dataObjUnlinkInp,
dataObjInfoHead);
if (status < 0) return (status);
}
}
}
tmpDataObjInfo = *dataObjInfoHead;
while (tmpDataObjInfo != NULL) {
status = dataObjUnlinkS (rsComm, dataObjUnlinkInp, tmpDataObjInfo);
if (status < 0) {
if (retVal == 0) {
retVal = status;
}
}
if (dataObjUnlinkInp->specColl != NULL) /* do only one */
break;
tmpDataObjInfo = tmpDataObjInfo->next;
}
if ((*dataObjInfoHead)->specColl == NULL)
resolveDataObjReplStatus (rsComm, dataObjUnlinkInp);
return (retVal);
}
