int
freeL1desc( int l1descInx ) {
if ( l1descInx < 3 || l1descInx >= NUM_L1_DESC ) {
rodsLog( LOG_NOTICE,
"freeL1desc: l1descInx %d out of range", l1descInx );
return SYS_FILE_DESC_OUT_OF_RANGE;
}
if ( L1desc[l1descInx].dataObjInfo != NULL ) {
freeDataObjInfo( L1desc[l1descInx].dataObjInfo );
}
if ( L1desc[l1descInx].otherDataObjInfo != NULL ) {
freeAllDataObjInfo( L1desc[l1descInx].otherDataObjInfo );
}
if ( L1desc[l1descInx].replDataObjInfo != NULL ) {
freeDataObjInfo( L1desc[l1descInx].replDataObjInfo );
}
if ( L1desc[l1descInx].dataObjInpReplFlag == 1 &&
L1desc[l1descInx].dataObjInp != NULL ) {
clearDataObjInp( L1desc[l1descInx].dataObjInp );
free( L1desc[l1descInx].dataObjInp );
}
memset( &L1desc[l1descInx], 0, sizeof( l1desc_t ) );
return 0;
}
int
freeL1desc (int l1descInx)
{
if (l1descInx < 3 || l1descInx >= NUM_L1_DESC) {
rodsLog (LOG_NOTICE,
"freeL1desc: l1descInx %d out of range", l1descInx);
return (SYS_FILE_DESC_OUT_OF_RANGE);
}
if (L1desc[l1descInx].dataObjInfo != NULL) {
/* for remote zone type L1desc, rescInfo is not from local cache
* but malloc'ed */
if (L1desc[l1descInx].remoteZoneHost != NULL &&
L1desc[l1descInx].dataObjInfo->rescInfo != NULL)
free (L1desc[l1descInx].dataObjInfo->rescInfo);
#if 0 /* no longer need this with irsDataObjClose */
/* will be freed in _rsDataObjReplS since it needs the new
* replNum and dataID */
if (L1desc[l1descInx].oprType != REPLICATE_DEST)
freeDataObjInfo (L1desc[l1descInx].dataObjInfo);
#endif
if (L1desc[l1descInx].dataObjInfo != NULL)
freeDataObjInfo (L1desc[l1descInx].dataObjInfo);
}
if (L1desc[l1descInx].otherDataObjInfo != NULL) {
freeAllDataObjInfo (L1desc[l1descInx].otherDataObjInfo);
}
if (L1desc[l1descInx].replDataObjInfo != NULL) {
freeDataObjInfo (L1desc[l1descInx].replDataObjInfo);
}
if (L1desc[l1descInx].dataObjInpReplFlag == 1 &&
L1desc[l1descInx].dataObjInp != NULL) {
clearDataObjInp (L1desc[l1descInx].dataObjInp);
free (L1desc[l1descInx].dataObjInp);
}
memset (&L1desc[l1descInx], 0, sizeof (l1desc_t));
return (0);
}
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
openSpecColl( rsComm_t *rsComm, dataObjInp_t *dataObjInp, int parentInx ) {
int specCollInx;
dataObjInfo_t *dataObjInfo = NULL;
int status;
int l3descInx;
status = resolvePathInSpecColl( rsComm, dataObjInp->objPath,
//READ_COLL_PERM, 0, &dataObjInfo);
UNKNOWN_COLL_PERM, 0, &dataObjInfo );
if ( status < 0 || NULL == dataObjInfo ) { // JMC cppcheck - nullptr
rodsLog( LOG_NOTICE,
"rsQuerySpecColl: resolveSpecColl error for %s, status = %d",
dataObjInp->objPath, status );
return status;
}
if ( dataObjInfo->specColl->collClass == LINKED_COLL ) {
rodsLog( LOG_ERROR,
"rsQuerySpecColl: %s is a linked collection",
dataObjInp->objPath );
return SYS_UNKNOWN_SPEC_COLL_CLASS;
}
char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
if ( resc_hier ) {
strncpy( dataObjInfo->rescHier, resc_hier, MAX_NAME_LEN );
irods::error ret = resc_mgr.hier_to_leaf_id(resc_hier,dataObjInfo->rescId);
if( !ret.ok() ) {
irods::log(PASS(ret));
}
}
l3descInx = l3Opendir( rsComm, dataObjInfo );
if ( l3descInx < 0 ) {
rodsLog( LOG_NOTICE,
"openSpecColl: specCollOpendir error for %s, status = %d",
dataObjInp->objPath, l3descInx );
return l3descInx;
}
specCollInx = allocSpecCollDesc();
if ( specCollInx < 0 ) {
freeDataObjInfo( dataObjInfo );
return specCollInx;
}
SpecCollDesc[specCollInx].l3descInx = l3descInx;
SpecCollDesc[specCollInx].dataObjInfo = dataObjInfo;
SpecCollDesc[specCollInx].parentInx = parentInx;
return specCollInx;
}
int
freeSpecCollDesc( int specCollInx ) {
if ( specCollInx < 1 || specCollInx >= NUM_SPEC_COLL_DESC ) {
rodsLog( LOG_NOTICE,
"freeSpecCollDesc: specCollInx %d out of range", specCollInx );
return SYS_FILE_DESC_OUT_OF_RANGE;
}
if ( SpecCollDesc[specCollInx].dataObjInfo != NULL ) {
freeDataObjInfo( SpecCollDesc[specCollInx].dataObjInfo );
}
memset( &SpecCollDesc[specCollInx], 0, sizeof( specCollDesc_t ) );
return 0;
}
int
specCollSubCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) {
int status;
int l1descInx;
dataObjInfo_t *dataObjInfo = NULL;
status = resolvePathInSpecColl( rsComm, dataObjInp->objPath,
WRITE_COLL_PERM, 0, &dataObjInfo );
if ( dataObjInfo == NULL ) { // JMC cppcheck
rodsLog( LOG_ERROR, "specCollSubCreate :: dataObjInp is null" );
return status;
}
if ( status >= 0 ) {
rodsLog( LOG_ERROR,
"specCollSubCreate: phyPath %s already exist",
dataObjInfo->filePath );
freeDataObjInfo( dataObjInfo );
return ( SYS_COPY_ALREADY_IN_RESC );
}
else if ( status != SYS_SPEC_COLL_OBJ_NOT_EXIST ) {
return ( status );
}
l1descInx = allocL1desc();
if ( l1descInx < 0 ) {
return l1descInx;
}
dataObjInfo->replStatus = NEWLY_CREATED_COPY;
fillL1desc( l1descInx, dataObjInp, dataObjInfo, NEWLY_CREATED_COPY,
dataObjInp->dataSize );
if ( getValByKey( &dataObjInp->condInput, NO_OPEN_FLAG_KW ) == NULL ) {
status = dataCreate( rsComm, l1descInx );
if ( status < 0 ) {
freeL1desc( l1descInx );
return ( status );
}
}
return l1descInx;
}
int
_rsRmColl( rsComm_t *rsComm, collInp_t *rmCollInp,
collOprStat_t **collOprStat ) {
int status;
dataObjInfo_t *dataObjInfo = NULL;
if ( getValByKey( &rmCollInp->condInput, UNREG_COLL_KW ) != NULL ) {
status = svrUnregColl( rsComm, rmCollInp );
}
else {
/* need to check if it is spec coll */
status = resolvePathInSpecColl( rsComm, rmCollInp->collName,
WRITE_COLL_PERM, 0, &dataObjInfo );
if ( status < 0 && status != CAT_NO_ROWS_FOUND ) {
return status;
}
else if ( status == COLL_OBJ_T && dataObjInfo->specColl != NULL ) {
if ( dataObjInfo->specColl->collClass == LINKED_COLL ) {
rstrcpy( rmCollInp->collName, dataObjInfo->objPath,
MAX_NAME_LEN );
status = svrUnregColl( rsComm, rmCollInp );
}
else {
status = l3Rmdir( rsComm, dataObjInfo );
}
freeDataObjInfo( dataObjInfo );
}
else {
status = svrUnregColl( rsComm, rmCollInp );
}
}
if ( status >= 0 && 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;
}
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
rsCollCreate( rsComm_t *rsComm, collInp_t *collCreateInp ) {
int status;
rodsServerHost_t *rodsServerHost = NULL;
ruleExecInfo_t rei;
collInfo_t collInfo;
specCollCache_t *specCollCache = NULL;
dataObjInfo_t *dataObjInfo = NULL;
irods::error ret = validate_logical_path( collCreateInp->collName );
if ( !ret.ok() ) {
if ( rsComm->rError.len < MAX_ERROR_MESSAGES ) {
char error_msg[ERR_MSG_LEN];
snprintf(error_msg, ERR_MSG_LEN, "%s", ret.user_result().c_str());
addRErrorMsg( &rsComm->rError, ret.code(), error_msg );
}
irods::log( ret );
return SYS_INVALID_INPUT_PARAM;
}
// Issue 3913: retain status in case string too long
status = resolveLinkedPath( rsComm, collCreateInp->collName, &specCollCache,
&collCreateInp->condInput );
// Issue 3913: retain status in case string too long
if (status == USER_STRLEN_TOOLONG) {
return USER_STRLEN_TOOLONG;
}
status = getAndConnRcatHost(
rsComm,
MASTER_RCAT,
( const char* )collCreateInp->collName,
&rodsServerHost );
if ( status < 0 || rodsServerHost == NULL ) { // JMC cppcheck
return status;
}
if ( rodsServerHost->localFlag == LOCAL_HOST ) {
initReiWithCollInp( &rei, rsComm, collCreateInp, &collInfo );
status = applyRule( "acPreprocForCollCreate", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
if ( rei.status < 0 ) {
status = rei.status;
}
rodsLog( LOG_ERROR,
"rsCollCreate:acPreprocForCollCreate error for %s,stat=%d",
collCreateInp->collName, status );
return status;
}
if ( getValByKey( &collCreateInp->condInput, RECURSIVE_OPR__KW ) !=
NULL ) {
status = rsMkCollR( rsComm, "/", collCreateInp->collName );
return status;
}
std::string svc_role;
irods::error ret = get_catalog_service_role(svc_role);
if(!ret.ok()) {
irods::log(PASS(ret));
return ret.code();
}
if( irods::CFG_SERVICE_ROLE_PROVIDER == svc_role ) {
/* for STRUCT_FILE_COLL to make a directory in the structFile, the
* COLLECTION_TYPE_KW must be set */
status = resolvePathInSpecColl( rsComm, collCreateInp->collName,
WRITE_COLL_PERM, 0, &dataObjInfo );
if ( status >= 0 ) {
freeDataObjInfo( dataObjInfo );
if ( status == COLL_OBJ_T ) {
return 0;
}
else if ( status == DATA_OBJ_T ) {
return USER_INPUT_PATH_ERR;
}
}
else if ( status == SYS_SPEC_COLL_OBJ_NOT_EXIST ) {
/* for STRUCT_FILE_COLL to make a directory in the structFile, the
* COLLECTION_TYPE_KW must be set */
if ( dataObjInfo != NULL && dataObjInfo->specColl != NULL &&
dataObjInfo->specColl->collClass == LINKED_COLL ) {
/* should not be here because if has been translated */
return SYS_COLL_LINK_PATH_ERR;
}
else {
status = l3Mkdir( rsComm, dataObjInfo );
}
freeDataObjInfo( dataObjInfo );
return status;
}
else {
if ( isColl( rsComm, collCreateInp->collName, NULL ) >= 0 ) {
return CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME;
}
status = _rsRegColl( rsComm, collCreateInp );
}
rei.status = status;
if ( status >= 0 ) {
rei.status = applyRule( "acPostProcForCollCreate", NULL, &rei,
NO_SAVE_REI );
if ( rei.status < 0 ) {
rodsLog( LOG_ERROR,
"rsCollCreate:acPostProcForCollCreate error for %s,stat=%d",
collCreateInp->collName, status );
}
}
} else if( irods::CFG_SERVICE_ROLE_CONSUMER == svc_role ) {
status = SYS_NO_RCAT_SERVER_ERR;
} else {
rodsLog(
LOG_ERROR,
"role not supported [%s]",
svc_role.c_str() );
status = SYS_SERVICE_ROLE_NOT_SUPPORTED;
}
}
else {
status = rcCollCreate( rodsServerHost->conn, collCreateInp );
}
return status;
}
int
rsCollCreate( rsComm_t *rsComm, collInp_t *collCreateInp ) {
int status;
rodsServerHost_t *rodsServerHost = NULL;
ruleExecInfo_t rei;
collInfo_t collInfo;
specCollCache_t *specCollCache = NULL;
#ifdef RODS_CAT
dataObjInfo_t *dataObjInfo = NULL;
#endif
irods::error ret = validate_collection_path( collCreateInp->collName );
if ( !ret.ok() ) {
irods::log( ret );
return SYS_INVALID_INPUT_PARAM;
}
resolveLinkedPath( rsComm, collCreateInp->collName, &specCollCache,
&collCreateInp->condInput );
status = getAndConnRcatHost(
rsComm,
MASTER_RCAT,
( const char* )collCreateInp->collName,
&rodsServerHost );
if ( status < 0 || rodsServerHost == NULL ) { // JMC cppcheck
return status;
}
if ( rodsServerHost->localFlag == LOCAL_HOST ) {
initReiWithCollInp( &rei, rsComm, collCreateInp, &collInfo );
status = applyRule( "acPreprocForCollCreate", NULL, &rei, NO_SAVE_REI );
if ( status < 0 ) {
if ( rei.status < 0 ) {
status = rei.status;
}
rodsLog( LOG_ERROR,
"rsCollCreate:acPreprocForCollCreate error for %s,stat=%d",
collCreateInp->collName, status );
return status;
}
if ( getValByKey( &collCreateInp->condInput, RECURSIVE_OPR__KW ) !=
NULL ) {
status = rsMkCollR( rsComm, "/", collCreateInp->collName );
return status;
}
#ifdef RODS_CAT
/* for STRUCT_FILE_COLL to make a directory in the structFile, the
* COLLECTION_TYPE_KW must be set */
status = resolvePathInSpecColl( rsComm, collCreateInp->collName,
WRITE_COLL_PERM, 0, &dataObjInfo );
if ( status >= 0 ) {
freeDataObjInfo( dataObjInfo );
if ( status == COLL_OBJ_T ) {
return 0;
}
else if ( status == DATA_OBJ_T ) {
return USER_INPUT_PATH_ERR;
}
}
else if ( status == SYS_SPEC_COLL_OBJ_NOT_EXIST ) {
/* for STRUCT_FILE_COLL to make a directory in the structFile, the
* COLLECTION_TYPE_KW must be set */
if ( dataObjInfo != NULL && dataObjInfo->specColl != NULL &&
dataObjInfo->specColl->collClass == LINKED_COLL ) {
/* should not be here because if has been translated */
return SYS_COLL_LINK_PATH_ERR;
}
else {
status = l3Mkdir( rsComm, dataObjInfo );
}
freeDataObjInfo( dataObjInfo );
return status;
}
else {
if ( isColl( rsComm, collCreateInp->collName, NULL ) >= 0 ) {
return CATALOG_ALREADY_HAS_ITEM_BY_THAT_NAME;
}
status = _rsRegColl( rsComm, collCreateInp );
}
rei.status = status;
if ( status >= 0 ) {
rei.status = applyRule( "acPostProcForCollCreate", NULL, &rei,
NO_SAVE_REI );
if ( rei.status < 0 ) {
rodsLog( LOG_ERROR,
"rsCollCreate:acPostProcForCollCreate error for %s,stat=%d",
collCreateInp->collName, status );
}
}
#else
status = SYS_NO_RCAT_SERVER_ERR;
#endif
}
else {
status = rcCollCreate( rodsServerHost->conn, collCreateInp );
}
return status;
}
