int freeRuleExecInfoInternals(ruleExecInfo_t *rs, int freeSpeialStructFlag) { if (rs->msParamArray != NULL && (freeSpeialStructFlag & FREE_MS_PARAM) > 0) { clearMsParamArray (rs->msParamArray, 1); free (rs->msParamArray); } if (rs->doinp != NULL && (freeSpeialStructFlag & FREE_DOINP) > 0) { clearDataObjInp (rs->doinp); free (rs->doinp); } if (rs->doi != NULL) freeAllDataObjInfo(rs->doi); if (rs->rgi != NULL) freeRescGrpInfo(rs->rgi); if (rs->uoic != NULL) freeUserInfo(rs->uoic); if (rs->uoip != NULL) freeUserInfo(rs->uoip); if (rs->coi != NULL) freeCollInfo(rs->coi); #if 0 /* XXXXX deplicate rgio */ if (rs->rgio != NULL) freeRescGrpInfo(rs->rgio); #endif if (rs->uoio != NULL) freeUserInfo(rs->uoio); if (rs->condInputData != NULL) freeKeyValPairStruct(rs->condInputData); if (rs->next != NULL) freeRuleExecInfoStruct(rs->next, freeSpeialStructFlag); 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 ) { 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 rsRsyncFileToData( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) { char * fileChksumStr = getValByKey( &dataObjInp->condInput, RSYNC_CHKSUM_KW ); if ( fileChksumStr == NULL ) { rodsLog( LOG_ERROR, "rsRsyncFileToData: RSYNC_CHKSUM_KW input is missing" ); return CHKSUM_EMPTY_IN_STRUCT_ERR; } addKeyVal( &dataObjInp->condInput, ORIG_CHKSUM_KW, fileChksumStr ); // =-=-=-=-=-=-=- // determine the resource hierarchy if one is not provided 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 char *dataObjChksumStr = NULL; dataObjInfo_t *dataObjInfoHead = NULL; int status = _rsDataObjChksum( rsComm, dataObjInp, &dataObjChksumStr, &dataObjInfoHead ); if ( status < 0 && status != CAT_NO_ACCESS_PERMISSION && status != CAT_NO_ROWS_FOUND ) { /* XXXXX CAT_NO_ACCESS_PERMISSION mean the chksum was calculated but * cannot be registered. But the chksum value is OK. */ rodsLog( LOG_ERROR, "rsRsyncFileToData: _rsDataObjChksum of %s error. status = %d", dataObjInp->objPath, status ); } freeAllDataObjInfo( dataObjInfoHead ); if ( dataObjChksumStr != NULL && strcmp( dataObjChksumStr, fileChksumStr ) == 0 ) { free( dataObjChksumStr ); return 0; } free( dataObjChksumStr ); return SYS_SVR_TO_CLI_PUT_ACTION; }
/* resolveDataObjReplStatus - a dirty copy may be deleted leaving no * dirty copy. In that case, pick the newest copy and mark it dirty */ int resolveDataObjReplStatus( rsComm_t *rsComm, dataObjInp_t *dataObjUnlinkInp ) { int status; dataObjInfo_t *dataObjInfoHead = NULL; dataObjInfo_t *newestDataObjInfo = NULL; dataObjInfo_t *tmpDataObjInfo; if ( getValByKey( &dataObjUnlinkInp->condInput, RESC_NAME_KW ) == NULL && getValByKey( &dataObjUnlinkInp->condInput, REPL_NUM_KW ) == NULL ) { return 0; } status = getDataObjInfo( rsComm, dataObjUnlinkInp, &dataObjInfoHead, ACCESS_DELETE_OBJECT, 1 ); if ( status < 0 ) { return status; } tmpDataObjInfo = dataObjInfoHead; while ( tmpDataObjInfo != NULL ) { if ( tmpDataObjInfo->replStatus == 0 ) { if ( newestDataObjInfo == NULL ) { newestDataObjInfo = tmpDataObjInfo; } else if ( atoi( tmpDataObjInfo->dataModify ) > atoi( newestDataObjInfo->dataModify ) ) { newestDataObjInfo = tmpDataObjInfo; } } else { newestDataObjInfo = NULL; break; } tmpDataObjInfo = tmpDataObjInfo->next; } /* modify the repl status */ if ( newestDataObjInfo != NULL ) { keyValPair_t regParam; char tmpStr[MAX_NAME_LEN]; modDataObjMeta_t modDataObjMetaInp; memset( ®Param, 0, sizeof( regParam ) ); memset( &modDataObjMetaInp, 0, sizeof( modDataObjMetaInp ) ); snprintf( tmpStr, MAX_NAME_LEN, "%d", NEWLY_CREATED_COPY ); addKeyVal( ®Param, REPL_STATUS_KW, tmpStr ); modDataObjMetaInp.dataObjInfo = newestDataObjInfo; modDataObjMetaInp.regParam = ®Param; status = rsModDataObjMeta( rsComm, &modDataObjMetaInp ); clearKeyVal( ®Param ); } freeAllDataObjInfo( dataObjInfoHead ); return status; }
int computeHostAddress(rsComm_t *rsComm, char *inStr, rodsHostAddr_t *addr) { int status; dataObjInp_t dataObjInp; dataObjInfo_t *dataObjInfoHead = NULL; char *path; rescGrpInfo_t *rescGrpInfo = NULL; if (inStr[0] == '@') path = inStr + 1; else path = inStr; if (path[0] == '/') { /* objpath */ memset (&dataObjInp, 0, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, path, MAX_NAME_LEN); status = getDataObjInfo (rsComm, &dataObjInp, &dataObjInfoHead, ACCESS_READ_OBJECT, 0); if (status < 0) { rodsLog (LOG_ERROR, "computeHostAddress: getDataObjInfo error for Path %s", path); return (status); } status = sortObjInfoForOpen (rsComm, &dataObjInfoHead, NULL, 0); if (status < 0) { rodsLog (LOG_ERROR, "computeHostAddress: sortObjInfoForOpen error for Path %s", path); return status; } rstrcpy (addr->zoneName, dataObjInfoHead->rescInfo->zoneName, NAME_LEN); rstrcpy (addr->hostAddr, dataObjInfoHead->rescInfo->rescLoc, LONG_NAME_LEN); freeAllDataObjInfo (dataObjInfoHead); } else { /* it is a logical resource (or group) name */ status = getRescInfo (rsComm, path, NULL, &rescGrpInfo); if (status < 0) { rodsLog (LOG_ERROR, "computeHostAddress: getRescInfo error for Path %s", path); return (status); } status = sortResc(rsComm, &rescGrpInfo, "random"); if (status < 0) { rodsLog (LOG_ERROR, "computeHostAddress: sortResc error for Path %s", path); return status; } rstrcpy (addr->zoneName, rescGrpInfo->rescInfo->zoneName, NAME_LEN); rstrcpy (addr->hostAddr, rescGrpInfo->rescInfo->rescLoc, LONG_NAME_LEN); freeAllRescGrpInfo (rescGrpInfo); } return(0); }
int getRescForGetInDataObj( rsComm_t *rsComm, dataObjInp_t *dataObjInp, hostSearchStat_t *hostSearchStat ) { int status, i; dataObjInfo_t *dataObjInfoHead = NULL; if ( dataObjInp == NULL || hostSearchStat == NULL ) { return USER__NULL_INPUT_ERR; } status = getDataObjInfoIncSpecColl( rsComm, dataObjInp, &dataObjInfoHead ); if ( status < 0 ) { return status; } sortObjInfoForOpen( &dataObjInfoHead, &dataObjInp->condInput, 0 ); if ( dataObjInfoHead ) { if ( hostSearchStat->numHost >= MAX_HOST_TO_SEARCH || hostSearchStat->totalCount >= MAX_HOST_TO_SEARCH ) { freeAllDataObjInfo( dataObjInfoHead ); return 0; } for ( i = 0; i < hostSearchStat->numHost; i++ ) { if ( dataObjInfoHead->rescInfo == hostSearchStat->rescInfo[i] ) { hostSearchStat->count[i]++; hostSearchStat->totalCount++; freeAllDataObjInfo( dataObjInfoHead ); return 0; } } /* no match. add one */ hostSearchStat->rescInfo[hostSearchStat->numHost] = dataObjInfoHead->rescInfo; hostSearchStat->count[hostSearchStat->numHost] = 1; hostSearchStat->numHost++; hostSearchStat->totalCount++; } freeAllDataObjInfo( dataObjInfoHead ); return 0; }
int filePathRegRepl (rsComm_t *rsComm, dataObjInp_t *phyPathRegInp, char *filePath, rescInfo_t *rescInfo) { dataObjInfo_t destDataObjInfo, *dataObjInfoHead = NULL; regReplica_t regReplicaInp; char *rescGroupName = NULL; int status; status = getDataObjInfo (rsComm, phyPathRegInp, &dataObjInfoHead, ACCESS_READ_OBJECT, 0); if (status < 0) { rodsLog (LOG_ERROR, "filePathRegRepl: getDataObjInfo for %s", phyPathRegInp->objPath); return (status); } status = sortObjInfoForOpen (rsComm, &dataObjInfoHead, NULL, 0); if (status < 0) return status; destDataObjInfo = *dataObjInfoHead; rstrcpy (destDataObjInfo.filePath, filePath, MAX_NAME_LEN); destDataObjInfo.rescInfo = rescInfo; rstrcpy (destDataObjInfo.rescName, rescInfo->rescName, NAME_LEN); if ((rescGroupName = getValByKey (&phyPathRegInp->condInput, RESC_GROUP_NAME_KW)) != NULL) { rstrcpy (destDataObjInfo.rescGroupName, rescGroupName, NAME_LEN); } memset (®ReplicaInp, 0, sizeof (regReplicaInp)); regReplicaInp.srcDataObjInfo = dataObjInfoHead; regReplicaInp.destDataObjInfo = &destDataObjInfo; if (getValByKey (&phyPathRegInp->condInput, SU_CLIENT_USER_KW) != NULL) { addKeyVal (®ReplicaInp.condInput, SU_CLIENT_USER_KW, ""); addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, ""); } else if (getValByKey (&phyPathRegInp->condInput, IRODS_ADMIN_KW) != NULL) { addKeyVal (®ReplicaInp.condInput, IRODS_ADMIN_KW, ""); } status = rsRegReplica (rsComm, ®ReplicaInp); clearKeyVal (®ReplicaInp.condInput); freeAllDataObjInfo (dataObjInfoHead); return status; }
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 rsRsyncDataToFile( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) { int status; char *fileChksumStr = NULL; char *dataObjChksumStr = NULL; dataObjInfo_t *dataObjInfoHead = NULL; fileChksumStr = getValByKey( &dataObjInp->condInput, RSYNC_CHKSUM_KW ); if ( fileChksumStr == NULL ) { rodsLog( LOG_ERROR, "rsRsyncDataToFile: RSYNC_CHKSUM_KW input is missing for %s", dataObjInp->objPath ); return CHKSUM_EMPTY_IN_STRUCT_ERR; } addKeyVal( &dataObjInp->condInput, ORIG_CHKSUM_KW, fileChksumStr ); status = _rsDataObjChksum( rsComm, dataObjInp, &dataObjChksumStr, &dataObjInfoHead ); if ( status < 0 && status != CAT_NO_ACCESS_PERMISSION && status != CAT_NO_ROWS_FOUND ) { /* XXXXX CAT_NO_ACCESS_PERMISSION mean the chksum was calculated but * cannot be registered. But the chksum value is OK. */ rodsLog( LOG_ERROR, "rsRsyncDataToFile: _rsDataObjChksum of %s error. status = %d", dataObjInp->objPath, status ); return status; } freeAllDataObjInfo( dataObjInfoHead ); status = dataObjChksumStr && strcmp( dataObjChksumStr, fileChksumStr ) == 0 ? 0 : SYS_SVR_TO_CLI_GET_ACTION; free( dataObjChksumStr ); 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 statPathInSpecColl( rsComm_t *rsComm, char *objPath, int inCachOnly, rodsObjStat_t **rodsObjStatOut ) { int status; dataObjInfo_t *dataObjInfo = NULL; specColl_t *specColl; specCollCache_t *specCollCache; if ( ( status = getSpecCollCache( rsComm, objPath, inCachOnly, &specCollCache ) ) < 0 ) { if ( status != SYS_SPEC_COLL_NOT_IN_CACHE && status != CAT_NO_ROWS_FOUND ) { rodsLog( LOG_ERROR, "statPathInSpecColl: getSpecCollCache for %s, status = %d", objPath, status ); } return status; } if ( *rodsObjStatOut == NULL ) { *rodsObjStatOut = ( rodsObjStat_t * ) malloc( sizeof( rodsObjStat_t ) ); } memset( *rodsObjStatOut, 0, sizeof( rodsObjStat_t ) ); specColl = &specCollCache->specColl; rstrcpy( ( *rodsObjStatOut )->dataId, specCollCache->collId, NAME_LEN ); rstrcpy( ( *rodsObjStatOut )->ownerName, specCollCache->ownerName, NAME_LEN ); rstrcpy( ( *rodsObjStatOut )->ownerZone, specCollCache->ownerZone, NAME_LEN ); status = specCollSubStat( rsComm, specColl, objPath, UNKNOWN_COLL_PERM, &dataObjInfo ); if ( status < 0 ) { if ( dataObjInfo != NULL ) { if ( dataObjInfo->specColl != NULL ) { ( *rodsObjStatOut )->specColl = dataObjInfo->specColl; } else { replSpecColl( &specCollCache->specColl, &( *rodsObjStatOut )->specColl ); } if ( specColl->collClass == LINKED_COLL ) { rstrcpy( ( *rodsObjStatOut )->specColl->objPath, dataObjInfo->objPath, MAX_NAME_LEN ); } else { ( *rodsObjStatOut )->specColl->objPath[0] = '\0'; } dataObjInfo->specColl = NULL; } ( *rodsObjStatOut )->objType = UNKNOWN_OBJ_T; rstrcpy( ( *rodsObjStatOut )->createTime, specCollCache->createTime, TIME_LEN ); rstrcpy( ( *rodsObjStatOut )->modifyTime, specCollCache->modifyTime, TIME_LEN ); freeAllDataObjInfo( dataObjInfo ); /* XXXXX 0 return is creating a problem for fuse */ return 0; } else { ( *rodsObjStatOut )->specColl = dataObjInfo->specColl; dataObjInfo->specColl = NULL; if ( specColl->collClass == LINKED_COLL ) { rstrcpy( ( *rodsObjStatOut )->ownerName, dataObjInfo->dataOwnerName, NAME_LEN ); rstrcpy( ( *rodsObjStatOut )->ownerZone, dataObjInfo->dataOwnerZone, NAME_LEN ); snprintf( ( *rodsObjStatOut )->dataId, NAME_LEN, "%lld", dataObjInfo->dataId ); /* save the linked path here */ rstrcpy( ( *rodsObjStatOut )->specColl->objPath, dataObjInfo->objPath, MAX_NAME_LEN ); } ( *rodsObjStatOut )->objType = ( objType_t )status; ( *rodsObjStatOut )->objSize = dataObjInfo->dataSize; rstrcpy( ( *rodsObjStatOut )->createTime, dataObjInfo->dataCreate, TIME_LEN ); rstrcpy( ( *rodsObjStatOut )->modifyTime, dataObjInfo->dataModify, TIME_LEN ); freeAllDataObjInfo( dataObjInfo ); } 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 _rsDataObjOpen( rsComm_t *rsComm, dataObjInp_t *dataObjInp, dataObjInfo_t *dataObjInfoHead ) { int status = 0; int phyOpenFlag = DO_PHYOPEN; if ( getValByKey( &dataObjInp->condInput, NO_OPEN_FLAG_KW ) != NULL ) { phyOpenFlag = DO_NOT_PHYOPEN; } else if ( getValByKey( &dataObjInp->condInput, PHYOPEN_BY_SIZE_KW ) != NULL ) { phyOpenFlag = PHYOPEN_BY_SIZE; } // =-=-=-=-=-=-=- // JMC - backport 4604 char * lockType = getValByKey( &dataObjInp->condInput, LOCK_TYPE_KW ); int lockFd = -1; // JMC - backport 4604 if ( lockType != NULL ) { lockFd = irods::server_api_call( DATA_OBJ_LOCK_AN, rsComm, dataObjInp, NULL, ( void** ) NULL, NULL ); if ( lockFd > 0 ) { /* rm it so it won't be done again causing deadlock */ rmKeyVal( &dataObjInp->condInput, LOCK_TYPE_KW ); } else { rodsLogError( LOG_ERROR, lockFd, "_rsDataObjOpen: lock error for %s. lockType = %s", dataObjInp->objPath, lockType ); return lockFd; } } int writeFlag = getWriteFlag( dataObjInp->openFlags ); // check earlier attempt at resolving resource hierarchy if (!getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW)) { int l1descInx = 0; if ( dataObjInp->openFlags & O_CREAT && writeFlag > 0 ) { l1descInx = rsDataObjCreate( rsComm, dataObjInp ); status = l1descInx; // JMC - backport 4604 } // =-=-=-=-=-=-=- // JMC - backport 4604 if ( lockFd >= 0 ) { if ( status > 0 ) { L1desc[l1descInx].lockFd = lockFd; } else { char fd_string[NAME_LEN]; snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd ); addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string ); irods::server_api_call( DATA_OBJ_UNLOCK_AN, rsComm, dataObjInp, NULL, ( void** ) NULL, NULL ); } } return status; } else { ////// /* screen out any stale copies */ status = sortObjInfoForOpen( &dataObjInfoHead, &dataObjInp->condInput, writeFlag ); if ( status < 0 ) { // JMC - backport 4604 if ( lockFd > 0 ) { char fd_string[NAME_LEN]; snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd ); addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string ); irods::server_api_call( DATA_OBJ_UNLOCK_AN, rsComm, dataObjInp, NULL, ( void** ) NULL, NULL ); } std::stringstream msg; msg << __FUNCTION__; msg << " - Unable to select a data obj info matching the resource hierarchy from the keywords."; irods::log( ERROR( status, msg.str() ) ); return status; } ////// status = applyPreprocRuleForOpen( rsComm, dataObjInp, &dataObjInfoHead ); if ( status < 0 ) { // JMC - backport 4604 if ( lockFd > 0 ) { char fd_string[NAME_LEN]; snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd ); addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string ); irods::server_api_call( DATA_OBJ_UNLOCK_AN, rsComm, dataObjInp, NULL, ( void** ) NULL, NULL ); } return status; } } dataObjInfo_t * compDataObjInfo = NULL; if ( getStructFileType( dataObjInfoHead->specColl ) >= 0 ) { /* special coll. Nothing to do */ } else if ( writeFlag > 0 ) { // JMC :: had to reformat this code to find a missing { // :: i seriously hope its in the right place... status = procDataObjOpenForWrite( rsComm, dataObjInp, &dataObjInfoHead, &compDataObjInfo ); } if ( status < 0 ) { if ( lockFd > 0 ) { char fd_string[NAME_LEN]; snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd ); addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string ); irods::server_api_call( DATA_OBJ_UNLOCK_AN, rsComm, dataObjInp, NULL, ( void** ) NULL, NULL ); } freeAllDataObjInfo( dataObjInfoHead ); return status; } std::string resc_class; irods::error prop_err = irods::get_resource_property<std::string>( dataObjInfoHead->rescId, "class", resc_class ); if ( prop_err.ok() ) { if ( resc_class == "bundle" ) { status = stageBundledData( rsComm, &dataObjInfoHead ); if ( status < 0 ) { rodsLog( LOG_ERROR, "_rsDataObjOpen: stageBundledData of %s failed stat=%d", dataObjInfoHead->objPath, status ); freeAllDataObjInfo( dataObjInfoHead ); if ( lockFd >= 0 ) { char fd_string[NAME_LEN]; snprintf( fd_string, sizeof( fd_string ), "%-d", lockFd ); addKeyVal( &dataObjInp->condInput, LOCK_FD_KW, fd_string ); irods::server_api_call( DATA_OBJ_UNLOCK_AN, rsComm, dataObjInp, NULL, ( void** ) NULL, NULL ); } return status; } } } /* If compDataObjInfo != NULL, an existing COMPOUND_CL DataObjInfo exist. * Need to replicate to * this DataObjInfo in rsdataObjClose. * For read, compDataObjInfo should be NULL. */ dataObjInfo_t * tmpDataObjInfo = dataObjInfoHead; while ( tmpDataObjInfo != NULL ) { dataObjInfo_t * nextDataObjInfo = tmpDataObjInfo->next; tmpDataObjInfo->next = NULL; int l1descInx = status = _rsDataObjOpenWithObjInfo( rsComm, dataObjInp, phyOpenFlag, tmpDataObjInfo ); if ( l1descInx >= 0 ) { if ( compDataObjInfo != NULL ) { L1desc[l1descInx].replDataObjInfo = compDataObjInfo; } dataObjInfo_t *otherDataObjInfo = NULL; queDataObjInfo( &otherDataObjInfo, nextDataObjInfo, 0, 1 ); // JMC - backport 4542 L1desc[l1descInx].otherDataObjInfo = otherDataObjInfo; // JMC - backport 4542 if ( writeFlag > 0 ) { L1desc[l1descInx].openType = OPEN_FOR_WRITE_TYPE; } else { L1desc[l1descInx].openType = OPEN_FOR_READ_TYPE; } if ( lockFd >= 0 ) { L1desc[l1descInx].lockFd = lockFd; } return l1descInx; } // if l1descInx >= 0 tmpDataObjInfo = nextDataObjInfo; } // while return status; } // BAD
int rsDataObjPut (rsComm_t *rsComm, dataObjInp_t *dataObjInp, bytesBuf_t *dataObjInpBBuf, portalOprOut_t **portalOprOut) { int status; int status2; int remoteFlag; rodsServerHost_t *rodsServerHost; specCollCache_t *specCollCache = NULL; resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache, &dataObjInp->condInput); #if 0 status = resolvePathInSpecColl (rsComm, dataObjInp->objPath, READ_COLL_PERM, 0, &dataObjInfo); if (dataObjInfo != NULL) { if (dataObjInfo->specColl != NULL && dataObjInfo->specColl->collClass == LINKED_COLL) { rstrcpy (dataObjInp->objPath, dataObjInfo->objPath, MAX_NAME_LEN); } freeAllDataObjInfo (dataObjInfo); } #endif remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost, REMOTE_CREATE); if (remoteFlag < 0) { return (remoteFlag); } else if (remoteFlag == LOCAL_HOST) { /** since the object is written here, we apply pre procesing RAJA * Dec 2 2010 **/ status2 = applyRuleForPostProcForWrite(rsComm, dataObjInpBBuf, dataObjInp->objPath); if (status2 < 0) return(status2); /* need to dealloc anything??? */ /** since the object is written here, we apply pre procesing RAJA * Dec 2 2010 **/ dataObjInp->openFlags = O_RDWR; status = _rsDataObjPut (rsComm, dataObjInp, dataObjInpBBuf, portalOprOut, BRANCH_MSG); } else { int l1descInx; status = _rcDataObjPut (rodsServerHost->conn, dataObjInp, dataObjInpBBuf, portalOprOut); if (status < 0 || getValByKey (&dataObjInp->condInput, DATA_INCLUDED_KW) != NULL) { return (status); } else { /* have to allocate a local l1descInx to keep track of things * since the file is in remote zone. It sets remoteL1descInx, * oprType = REMOTE_ZONE_OPR and remoteZoneHost so that * rsComplete knows what to do */ l1descInx = allocAndSetL1descForZoneOpr ( (*portalOprOut)->l1descInx, dataObjInp, rodsServerHost, NULL); if (l1descInx < 0) return l1descInx; (*portalOprOut)->l1descInx = l1descInx; return status; } } return (status); }
int _rsModDataObjMeta( rsComm_t *rsComm, modDataObjMeta_t *modDataObjMetaInp ) { #ifdef RODS_CAT int status = 0; dataObjInfo_t *dataObjInfo; keyValPair_t *regParam; int i; ruleExecInfo_t rei2; memset( ( char* )&rei2, 0, sizeof( ruleExecInfo_t ) ); rei2.rsComm = rsComm; if ( rsComm != NULL ) { rei2.uoic = &rsComm->clientUser; rei2.uoip = &rsComm->proxyUser; } rei2.doi = modDataObjMetaInp->dataObjInfo; rei2.condInputData = modDataObjMetaInp->regParam; regParam = modDataObjMetaInp->regParam; dataObjInfo = modDataObjMetaInp->dataObjInfo; if ( regParam->len == 0 ) { return ( 0 ); } /* In dataObjInfo, need just dataId. But it will accept objPath too, * but less efficient */ /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ rei2.doi = dataObjInfo; i = applyRule( "acPreProcForModifyDataObjMeta", NULL, &rei2, NO_SAVE_REI ); if ( i < 0 ) { if ( rei2.status < 0 ) { i = rei2.status; } rodsLog( LOG_ERROR, "_rsModDataObjMeta:acPreProcForModifyDataObjMeta error stat=%d", i ); return i; } /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ if ( getValByKey( regParam, ALL_KW ) != NULL ) { /* all copies */ dataObjInfo_t *dataObjInfoHead = NULL; dataObjInfo_t *tmpDataObjInfo; dataObjInp_t dataObjInp; bzero( &dataObjInp, sizeof( dataObjInp ) ); rstrcpy( dataObjInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN ); status = getDataObjInfoIncSpecColl( rsComm, &dataObjInp, &dataObjInfoHead ); if ( status < 0 ) { rodsLog( LOG_NOTICE, "%s - Failed to get data objects.", __FUNCTION__ ); return status; } tmpDataObjInfo = dataObjInfoHead; while ( tmpDataObjInfo != NULL ) { if ( tmpDataObjInfo->specColl != NULL ) { break; } status = chlModDataObjMeta( rsComm, tmpDataObjInfo, regParam ); if ( status < 0 ) { rodsLog( LOG_ERROR, "_rsModDataObjMeta:chlModDataObjMeta %s error stat=%d", tmpDataObjInfo->objPath, status ); } tmpDataObjInfo = tmpDataObjInfo->next; } freeAllDataObjInfo( dataObjInfoHead ); } else { status = chlModDataObjMeta( rsComm, dataObjInfo, regParam ); if ( status < 0 ) { char* sys_error; char* rods_error = rodsErrorName( status, &sys_error ); std::stringstream msg; msg << __FUNCTION__; msg << " - Failed to modify the database for object \""; msg << dataObjInfo->objPath; msg << "\" - " << rods_error << " " << sys_error; irods::error ret = ERROR( status, msg.str() ); irods::log( ret ); } } /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ if ( status >= 0 ) { i = applyRule( "acPostProcForModifyDataObjMeta", NULL, &rei2, NO_SAVE_REI ); if ( i < 0 ) { if ( rei2.status < 0 ) { i = rei2.status; } rodsLog( LOG_ERROR, "_rsModDataObjMeta:acPostProcForModifyDataObjMeta error stat=%d", i ); return i; } } else { rodsLog( LOG_NOTICE, "%s - Failed updating the database with object info.", __FUNCTION__ ); return status; } /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ return ( status ); #else return ( SYS_NO_RCAT_SERVER_ERR ); #endif }
int _call_file_modified_for_modification( rsComm_t* rsComm, modDataObjMeta_t* modDataObjMetaInp ) { int status = 0; dataObjInfo_t *dataObjInfo; keyValPair_t *regParam; ruleExecInfo_t rei2; memset( ( char* )&rei2, 0, sizeof( ruleExecInfo_t ) ); rei2.rsComm = rsComm; if ( rsComm != NULL ) { rei2.uoic = &rsComm->clientUser; rei2.uoip = &rsComm->proxyUser; } rei2.doi = modDataObjMetaInp->dataObjInfo; rei2.condInputData = modDataObjMetaInp->regParam; regParam = modDataObjMetaInp->regParam; dataObjInfo = modDataObjMetaInp->dataObjInfo; if ( regParam->len == 0 ) { return ( 0 ); } if ( getValByKey( regParam, ALL_KW ) != NULL ) { /* all copies */ dataObjInfo_t *dataObjInfoHead = NULL; dataObjInfo_t *tmpDataObjInfo; dataObjInp_t dataObjInp; bzero( &dataObjInp, sizeof( dataObjInp ) ); rstrcpy( dataObjInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN ); status = getDataObjInfoIncSpecColl( rsComm, &dataObjInp, &dataObjInfoHead ); if ( status < 0 ) { rodsLog( LOG_NOTICE, "%s - Failed to get data objects.", __FUNCTION__ ); return status; } tmpDataObjInfo = dataObjInfoHead; while ( tmpDataObjInfo != NULL ) { if ( tmpDataObjInfo->specColl != NULL ) { break; } irods::file_object_ptr file_obj( new irods::file_object( rsComm, tmpDataObjInfo ) ); char* pdmo_kw = getValByKey( regParam, IN_PDMO_KW ); if ( pdmo_kw != NULL ) { file_obj->in_pdmo( pdmo_kw ); } irods::error ret = fileModified( rsComm, file_obj ); if ( !ret.ok() ) { std::stringstream msg; msg << __FUNCTION__; msg << " - Failed to signal resource that the data object \""; msg << tmpDataObjInfo->objPath; msg << " was modified."; ret = PASSMSG( msg.str(), ret ); irods::log( ret ); status = ret.code(); } tmpDataObjInfo = tmpDataObjInfo->next; } freeAllDataObjInfo( dataObjInfoHead ); } else { irods::file_object_ptr file_obj( new irods::file_object( rsComm, dataObjInfo ) ); char* pdmo_kw = getValByKey( regParam, IN_PDMO_KW ); if ( pdmo_kw != NULL ) { file_obj->in_pdmo( pdmo_kw ); } irods::error ret = fileModified( rsComm, file_obj ); if ( !ret.ok() ) { std::stringstream msg; msg << __FUNCTION__; msg << " - Failed to signal the resource that the data object \""; msg << dataObjInfo->objPath; msg << "\" was modified."; ret = PASSMSG( msg.str(), ret ); irods::log( ret ); status = ret.code(); } } 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 rsExecCmd (rsComm_t *rsComm, execCmd_t *execCmdInp, execCmdOut_t **execCmdOut) { int status; dataObjInfo_t *dataObjInfoHead = NULL; rodsServerHost_t *rodsServerHost; int remoteFlag; rodsHostAddr_t addr; /* some sanity check on the cmd path */ if (strchr (execCmdInp->cmd, '/') != NULL) { rodsLog (LOG_ERROR, "rsExecCmd: bad cmd path %s", execCmdInp->cmd); return (BAD_EXEC_CMD_PATH); } memset (&addr, 0, sizeof (addr)); if (*execCmdInp->hintPath != '\0') { dataObjInp_t dataObjInp; memset (&dataObjInp, 0, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, execCmdInp->hintPath, MAX_NAME_LEN); status = getDataObjInfo (rsComm, &dataObjInp, &dataObjInfoHead, ACCESS_READ_OBJECT, 0); if (status < 0) { rodsLog (LOG_ERROR, "rsExecCmd: getDataObjInfo error for hintPath %s", execCmdInp->hintPath); return (status); } status = sortObjInfoForOpen (rsComm, &dataObjInfoHead, &execCmdInp->condInput, 0); if (status < 0) return status; if (execCmdInp->addPathToArgv > 0) { char tmpArgv[LONG_NAME_LEN]; rstrcpy (tmpArgv, execCmdInp->cmdArgv, HUGE_NAME_LEN); snprintf (execCmdInp->cmdArgv, HUGE_NAME_LEN, "%s %s", dataObjInfoHead->filePath, tmpArgv); } rstrcpy (addr.zoneName, dataObjInfoHead->rescInfo->zoneName, NAME_LEN); rstrcpy (addr.hostAddr, dataObjInfoHead->rescInfo->rescLoc, LONG_NAME_LEN); /* just in case we have to do it remote */ *execCmdInp->hintPath = '\0'; /* no need for hint */ rstrcpy (execCmdInp->execAddr, dataObjInfoHead->rescInfo->rescLoc, LONG_NAME_LEN); freeAllDataObjInfo (dataObjInfoHead); remoteFlag = resolveHost (&addr, &rodsServerHost); } else if (*execCmdInp->execAddr != '\0') { rstrcpy (addr.hostAddr, execCmdInp->execAddr, LONG_NAME_LEN); remoteFlag = resolveHost (&addr, &rodsServerHost); } else { rodsServerHost = LocalServerHost; remoteFlag = LOCAL_HOST; } if (remoteFlag == LOCAL_HOST) { status = _rsExecCmd (rsComm, execCmdInp, execCmdOut); } else if (remoteFlag == REMOTE_HOST) { status = remoteExecCmd (rsComm, execCmdInp, execCmdOut, rodsServerHost); } else { rodsLog (LOG_NOTICE, "rsFileOpenByHost: resolveHost of %s error, status = %d", addr.hostAddr, remoteFlag); status = SYS_UNRECOGNIZED_REMOTE_FLAG; } 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; 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 rsRsyncFileToData (rsComm_t *rsComm, dataObjInp_t *dataObjInp) { int status; char *fileChksumStr = NULL; char *dataObjChksumStr = NULL; dataObjInfo_t *dataObjInfoHead = NULL; fileChksumStr = getValByKey (&dataObjInp->condInput, RSYNC_CHKSUM_KW); if (fileChksumStr == NULL) { rodsLog (LOG_ERROR, "rsRsyncFileToData: RSYNC_CHKSUM_KW input is missing"); return (CHKSUM_EMPTY_IN_STRUCT_ERR); } status = _rsDataObjChksum (rsComm, dataObjInp, &dataObjChksumStr, &dataObjInfoHead); if (status < 0 && status != CAT_NO_ACCESS_PERMISSION && status != CAT_NO_ROWS_FOUND) { /* XXXXX CAT_NO_ACCESS_PERMISSION mean the chksum was calculated but * cannot be registered. But the chksum value is OK. */ rodsLog (LOG_ERROR, "rsRsyncFileToData: _rsDataObjChksum of %s error. status = %d", dataObjInp->objPath, status); } freeAllDataObjInfo (dataObjInfoHead); if (dataObjChksumStr != NULL && strcmp (dataObjChksumStr, fileChksumStr) == 0) { free (dataObjChksumStr); return (0); } return SYS_SVR_TO_CLI_PUT_ACTION; #if 0 msParamArray_t *myMsParamArray; dataObjInp_t *myDataObjInp; myMsParamArray = malloc (sizeof (msParamArray_t)); memset (myMsParamArray, 0, sizeof (msParamArray_t)); /* have to get its own dataObjInp_t */ myDataObjInp = malloc (sizeof (dataObjInp_t)); replDataObjInp (dataObjInp, myDataObjInp); addKeyVal (&myDataObjInp->condInput, REG_CHKSUM_KW, fileChksumStr); status = addMsParam (myMsParamArray, CL_PUT_ACTION, DataObjInp_MS_T, (void *) myDataObjInp, NULL); if (status < 0) { rodsLogAndErrorMsg (LOG_ERROR, &rsComm->rError, status, "rsRsyncDataToFile: addMsParam error. status = %d", status); return (status); } /* tell the client to do the put */ status = sendAndRecvBranchMsg (rsComm, rsComm->apiInx, SYS_SVR_TO_CLI_MSI_REQUEST, (void *) myMsParamArray, NULL); return (status); #endif }
int _rsModDataObjMeta (rsComm_t *rsComm, modDataObjMeta_t *modDataObjMetaInp) { #ifdef RODS_CAT int status; dataObjInfo_t *dataObjInfo; keyValPair_t *regParam; int i; ruleExecInfo_t rei2; memset ((char*)&rei2, 0, sizeof (ruleExecInfo_t)); rei2.rsComm = rsComm; if (rsComm != NULL) { rei2.uoic = &rsComm->clientUser; rei2.uoip = &rsComm->proxyUser; } rei2.doi = modDataObjMetaInp->dataObjInfo; rei2.condInputData = modDataObjMetaInp->regParam; regParam = modDataObjMetaInp->regParam; dataObjInfo = modDataObjMetaInp->dataObjInfo; if (regParam->len == 0) { rodsLog(LOG_NOTICE, "Warning, _rsModDataObjMeta called with empty regParam, returning success"); return (0); } /* In dataObjInfo, need just dataId. But it will accept objPath too, * but less efficient */ /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ rei2.doi = dataObjInfo; i = applyRule("acPreProcForModifyDataObjMeta",NULL, &rei2, NO_SAVE_REI); if (i < 0) { if (rei2.status < 0) { i = rei2.status; } rodsLog (LOG_ERROR, "_rsModDataObjMeta:acPreProcForModifyDataObjMeta error stat=%d", i); return i; } /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ if (getValByKey (regParam, ALL_KW) != NULL) { /* all copies */ dataObjInfo_t *dataObjInfoHead = NULL; dataObjInfo_t *tmpDataObjInfo; dataObjInp_t dataObjInp; bzero (&dataObjInp, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN); status = getDataObjInfoIncSpecColl (rsComm, &dataObjInp, &dataObjInfoHead); if (status < 0) return status; tmpDataObjInfo = dataObjInfoHead; while (tmpDataObjInfo != NULL) { if (tmpDataObjInfo->specColl != NULL) break; status = chlModDataObjMeta (rsComm, tmpDataObjInfo, regParam); if (status < 0) { rodsLog (LOG_ERROR, "_rsModDataObjMeta:chlModDataObjMeta %s error stat=%d", tmpDataObjInfo->objPath, status); } tmpDataObjInfo = tmpDataObjInfo->next; } freeAllDataObjInfo (dataObjInfoHead); } else { status = chlModDataObjMeta (rsComm, dataObjInfo, regParam); } /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ if (status >= 0) { i = applyRule("acPostProcForModifyDataObjMeta",NULL, &rei2, NO_SAVE_REI); if (i < 0) { if (rei2.status < 0) { i = rei2.status; } rodsLog (LOG_ERROR, "_rsModDataObjMeta:acPostProcForModifyDataObjMeta error stat=%d",i); return i; } } /** RAJA ADDED June 1 2009 for pre-post processing rule hooks **/ return (status); #else return (SYS_NO_RCAT_SERVER_ERR); #endif }