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; }