int getAndConnRemoteZoneForCopy( rsComm_t *rsComm, dataObjCopyInp_t *dataObjCopyInp, rodsServerHost_t **rodsServerHost ) { int status; dataObjInp_t *srcDataObjInp, *destDataObjInp; rodsServerHost_t *srcIcatServerHost = NULL; rodsServerHost_t *destIcatServerHost = NULL; srcDataObjInp = &dataObjCopyInp->srcDataObjInp; destDataObjInp = &dataObjCopyInp->destDataObjInp; status = getRcatHost( MASTER_RCAT, srcDataObjInp->objPath, &srcIcatServerHost ); if ( status < 0 || NULL == srcIcatServerHost ) { // JMC cppcheck - nullptr rodsLog( LOG_ERROR, "getAndConnRemoteZoneForCopy: getRcatHost error for %s", srcDataObjInp->objPath ); return status; } if ( srcIcatServerHost->rcatEnabled != REMOTE_ICAT ) { /* local zone. nothing to do */ return LOCAL_HOST; } status = getRcatHost( MASTER_RCAT, destDataObjInp->objPath, &destIcatServerHost ); if ( status < 0 || NULL == destIcatServerHost ) { // JMC cppcheck - nullptr rodsLog( LOG_ERROR, "getAndConnRemoteZoneForCopy: getRcatHost error for %s", destDataObjInp->objPath ); return status; } if ( destIcatServerHost->rcatEnabled != REMOTE_ICAT ) { /* local zone. nothing to do */ return LOCAL_HOST; } /* remote zone to different remote zone copy. Have to handle it * locally because of proxy admin user privilege issue */ if ( srcIcatServerHost != destIcatServerHost ) { return LOCAL_HOST; } /* from the same remote zone. do it in the remote zone */ status = getAndConnRemoteZone( rsComm, destDataObjInp, rodsServerHost, REMOTE_CREATE ); return status; }
int rsDataObjGet (rsComm_t *rsComm, dataObjInp_t *dataObjInp, portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf) { int status; 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 == LOCAL_HOST) { status = _rsDataObjGet (rsComm, dataObjInp, portalOprOut, dataObjOutBBuf, BRANCH_MSG); } else { int l1descInx; status = _rcDataObjGet (rodsServerHost->conn, dataObjInp, portalOprOut, dataObjOutBBuf); if (status < 0) { return (status); } if (status == 0 || (dataObjOutBBuf != NULL && dataObjOutBBuf->len > 0)) { /* data included in buf */ 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 rsSyncMountedColl (rsComm_t *rsComm, dataObjInp_t *syncMountedCollInp) { int status; rodsObjStat_t *rodsObjStatOut = NULL; dataObjInp_t myDataObjInp; int remoteFlag; rodsServerHost_t *rodsServerHost; status = collStat (rsComm, syncMountedCollInp, &rodsObjStatOut); if (status < 0) return status; if (rodsObjStatOut->specColl == NULL) { freeRodsObjStat (rodsObjStatOut); rodsLog (LOG_ERROR, "rsSyncMountedColl: %s not a mounted collection", syncMountedCollInp->objPath); return (SYS_COLL_NOT_MOUNTED_ERR); } bzero (&myDataObjInp, sizeof (myDataObjInp)); rstrcpy (myDataObjInp.objPath, rodsObjStatOut->specColl->objPath, MAX_NAME_LEN); remoteFlag = getAndConnRemoteZone (rsComm, &myDataObjInp, &rodsServerHost, REMOTE_OPEN); if (remoteFlag < 0) { return (remoteFlag); } else if (remoteFlag == REMOTE_HOST) { status = rcSyncMountedColl (rodsServerHost->conn, syncMountedCollInp); } else { status = _rsSyncMountedColl (rsComm, rodsObjStatOut->specColl, syncMountedCollInp->oprType); } freeRodsObjStat (rodsObjStatOut); 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 rsDataObjCreate( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) { int l1descInx; int status; rodsObjStat_t *rodsObjStatOut = NULL; int remoteFlag; rodsServerHost_t *rodsServerHost; specCollCache_t *specCollCache = NULL; char *lockType = NULL; // JMC - backport 4604 int lockFd = -1; // JMC - backport 4604 resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache, &dataObjInp->condInput ); remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost, REMOTE_CREATE ); if ( remoteFlag < 0 ) { return ( remoteFlag ); } else if ( remoteFlag == REMOTE_HOST ) { openStat_t *openStat = NULL; addKeyVal( &dataObjInp->condInput, CROSS_ZONE_CREATE_KW, "" ); status = rcDataObjCreateAndStat( rodsServerHost->conn, dataObjInp, &openStat ); /* rm it to avoid confusion */ rmKeyVal( &dataObjInp->condInput, CROSS_ZONE_CREATE_KW ); if ( status < 0 ) { return status; } l1descInx = allocAndSetL1descForZoneOpr( status, dataObjInp, rodsServerHost, openStat ); if ( openStat != NULL ) { free( openStat ); } return ( l1descInx ); } // =-=-=-=-=-=-=- // 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 char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ); if ( NULL == resc_hier ) { std::string hier; irods::error ret = irods::resolve_resource_hierarchy( irods::CREATE_OPERATION, rsComm, dataObjInp, hier ); if ( !ret.ok() ) { std::stringstream msg; 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 // =-=-=-=-=-=-=- // JMC - backport 4604 lockType = getValByKey( &dataObjInp->condInput, LOCK_TYPE_KW ); if ( lockType != NULL ) { lockFd = rsDataObjLock( rsComm, dataObjInp ); 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, "rsDataObjCreate: rsDataObjLock error for %s. lockType = %s", dataObjInp->objPath, lockType ); return lockFd; } } // =-=-=-=-=-=-=- // Gets here means local zone operation stat dataObj addKeyVal( &dataObjInp->condInput, SEL_OBJ_TYPE_KW, "dataObj" ); status = rsObjStat( rsComm, dataObjInp, &rodsObjStatOut ); if ( rodsObjStatOut != NULL && rodsObjStatOut->objType == COLL_OBJ_T ) { if ( lockFd >= 0 ) { rsDataObjUnlock( rsComm, dataObjInp, lockFd ); // JMC - backport 4604 } return ( USER_INPUT_PATH_ERR ); } if ( rodsObjStatOut != NULL && rodsObjStatOut->specColl != NULL && rodsObjStatOut->specColl->collClass == LINKED_COLL ) { /* should not be here because if has been translated */ if ( lockFd >= 0 ) { rsDataObjUnlock( rsComm, dataObjInp, lockFd ); // JMC - backport 4604 } return SYS_COLL_LINK_PATH_ERR; } if ( rodsObjStatOut == NULL || ( rodsObjStatOut->objType == UNKNOWN_OBJ_T && rodsObjStatOut->specColl == NULL ) ) { /* does not exist. have to create one */ /* use L1desc[l1descInx].replStatus & OPEN_EXISTING_COPY instead */ /* newly created. take out FORCE_FLAG since it could be used by put */ /* rmKeyVal (&dataObjInp->condInput, FORCE_FLAG_KW); */ l1descInx = _rsDataObjCreate( rsComm, dataObjInp ); } else if ( rodsObjStatOut->specColl != NULL && rodsObjStatOut->objType == UNKNOWN_OBJ_T ) { /* newly created. take out FORCE_FLAG since it could be used by put */ /* rmKeyVal (&dataObjInp->condInput, FORCE_FLAG_KW); */ l1descInx = specCollSubCreate( rsComm, dataObjInp ); } else { /* dataObj exist */ if ( getValByKey( &dataObjInp->condInput, FORCE_FLAG_KW ) != NULL ) { dataObjInp->openFlags |= O_TRUNC | O_RDWR; // =-=-=-=-=-=-=- // re-determine the resource hierarchy since this is an open instead of a create std::string hier; irods::error ret = irods::resolve_resource_hierarchy( irods::WRITE_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() ); std::string top_resc; irods::hierarchy_parser parser; parser.set_string( hier ); parser.first_resc( top_resc ); addKeyVal( &dataObjInp->condInput, DEST_RESC_NAME_KW, top_resc.c_str() ); l1descInx = _rsDataObjOpen( rsComm, dataObjInp ); } else { l1descInx = OVERWRITE_WITHOUT_FORCE_FLAG; } } if ( rodsObjStatOut != NULL ) { freeRodsObjStat( rodsObjStatOut ); } // =-=-=-=-=-=-=- // JMC - backport 4604 if ( lockFd >= 0 ) { if ( l1descInx >= 0 ) { L1desc[l1descInx].lockFd = lockFd; } else { rsDataObjUnlock( rsComm, dataObjInp, lockFd ); } } // =-=-=-=-=-=-=- return ( l1descInx ); }
int rsDataObjOpen( rsComm_t *rsComm, dataObjInp_t *dataObjInp ) { int status, l1descInx; int remoteFlag; rodsServerHost_t *rodsServerHost; remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost, REMOTE_OPEN ); if ( remoteFlag < 0 ) { return remoteFlag; } else if ( remoteFlag == REMOTE_HOST ) { openStat_t *openStat = NULL; status = rcDataObjOpenAndStat( rodsServerHost->conn, dataObjInp, &openStat ); if ( status < 0 ) { return status; } l1descInx = allocAndSetL1descForZoneOpr( status, dataObjInp, rodsServerHost, openStat ); if ( openStat != NULL ) { free( openStat ); } return l1descInx; } else { // dataObjInfo_t linked list dataObjInfo_t *dataObjInfoHead = NULL; // resource hierarchy std::string hier; // =-=-=-=-=-=-=- // determine the resource hierarchy if one is not provided if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) { irods::error ret = irods::resolve_resource_hierarchy( irods::OPEN_OPERATION, rsComm, dataObjInp, hier, &dataObjInfoHead ); if (ret.ok()) { // =-=-=-=-=-=-=- // 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() ); } } else { // file object for file_object_factory irods::file_object_ptr file_obj( new irods::file_object() ); // get resource hierarchy from condInput hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ); // get replicas vector populated irods::error fac_err = irods::file_object_factory(rsComm, dataObjInp, file_obj, &dataObjInfoHead); }// if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) l1descInx = _rsDataObjOpen( rsComm, dataObjInp, dataObjInfoHead ); } return l1descInx; }
int rsStructFileBundle( rsComm_t *rsComm, structFileExtAndRegInp_t *structFileBundleInp ) { int status; rodsServerHost_t *rodsServerHost; int remoteFlag; dataObjInp_t dataObjInp; memset( &dataObjInp, 0, sizeof( dataObjInp ) ); rstrcpy( dataObjInp.objPath, structFileBundleInp->objPath, MAX_NAME_LEN ); remoteFlag = getAndConnRemoteZone( rsComm, &dataObjInp, &rodsServerHost, REMOTE_CREATE ); if ( remoteFlag < 0 ) { return remoteFlag; } else if ( remoteFlag == REMOTE_HOST ) { status = rcStructFileBundle( rodsServerHost->conn, structFileBundleInp ); 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 std::string hier; int local = LOCAL_HOST; rodsServerHost_t* host = 0; dataObjInp_t data_inp; bzero( &data_inp, sizeof( data_inp ) ); rstrcpy( data_inp.objPath, structFileBundleInp->objPath, MAX_NAME_LEN ); copyKeyValPairStruct( &structFileBundleInp->condInput, &data_inp.condInput ); if ( getValByKey( &structFileBundleInp->condInput, RESC_HIER_STR_KW ) == NULL ) { irods::error ret = irods::resource_redirect( irods::CREATE_OPERATION, rsComm, &data_inp, hier, host, local ); if ( !ret.ok() ) { std::stringstream msg; msg << "rsStructFileBundle :: failed in irods::resource_redirect for ["; msg << &data_inp.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( &structFileBundleInp->condInput, RESC_HIER_STR_KW, hier.c_str() ); } // if keyword if ( LOCAL_HOST == local ) { status = _rsStructFileBundle( rsComm, structFileBundleInp ); } else { status = rcStructFileBundle( host->conn, structFileBundleInp ); } // else remote host return status; }
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 rsDataObjGet( rsComm_t *rsComm, dataObjInp_t *dataObjInp, portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf ) { int status; 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 == LOCAL_HOST ) { // =-=-=-=-=-=-=- // 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 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 << "rsDataObjGet :: failed in irods::resolve_resource_redirect 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 status = _rsDataObjGet( rsComm, dataObjInp, portalOprOut, dataObjOutBBuf, BRANCH_MSG ); } else { int l1descInx; status = _rcDataObjGet( rodsServerHost->conn, dataObjInp, portalOprOut, dataObjOutBBuf ); if ( status < 0 ) { return status; } if ( status == 0 || ( dataObjOutBBuf != NULL && dataObjOutBBuf->len > 0 ) ) { /* data included in buf */ 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 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 rsDataObjRsync (rsComm_t *rsComm, dataObjInp_t *dataObjInp, msParamArray_t **outParamArray) { int status; char *rsyncMode; char *remoteZoneOpr; int remoteFlag; rodsServerHost_t *rodsServerHost; specCollCache_t *specCollCache = NULL; *outParamArray = NULL; if (dataObjInp == NULL) { rodsLog(LOG_ERROR, "rsDataObjRsync error. NULL input"); return (SYS_INTERNAL_NULL_INPUT_ERR); } rsyncMode = getValByKey (&dataObjInp->condInput, RSYNC_MODE_KW); if (rsyncMode == NULL) { rodsLog (LOG_ERROR, "rsDataObjRsync: RSYNC_MODE_KW input is missing"); return (USER_RSYNC_NO_MODE_INPUT_ERR); } if (strcmp (rsyncMode, LOCAL_TO_IRODS) == 0) { remoteZoneOpr = REMOTE_CREATE; } else { remoteZoneOpr = REMOTE_OPEN; } resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache, &dataObjInp->condInput); if (strcmp (rsyncMode, IRODS_TO_IRODS) == 0) { if (isLocalZone (dataObjInp->objPath) == 0) { dataObjInp_t myDataObjInp; char *destObjPath; /* source in a remote zone. try dest */ destObjPath = getValByKey (&dataObjInp->condInput, RSYNC_DEST_PATH_KW); if (destObjPath == NULL) { rodsLog (LOG_ERROR, "rsDataObjRsync: RSYNC_DEST_PATH_KW input is missing for %s", dataObjInp->objPath); return (USER_RSYNC_NO_MODE_INPUT_ERR); } myDataObjInp = *dataObjInp; remoteZoneOpr = REMOTE_CREATE; rstrcpy (myDataObjInp.objPath, destObjPath, MAX_NAME_LEN); remoteFlag = getAndConnRemoteZone (rsComm, &myDataObjInp, &rodsServerHost, remoteZoneOpr); } else { remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost, remoteZoneOpr); } } else { remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost, remoteZoneOpr); } if (remoteFlag < 0) { return (remoteFlag); } else if (remoteFlag == REMOTE_HOST) { status = _rcDataObjRsync (rodsServerHost->conn, dataObjInp, outParamArray); #if 0 int l1descInx; if (status < 0) { return (status); } if (status == SYS_SVR_TO_CLI_MSI_REQUEST) { /* server request to client */ l1descInx = allocAndSetL1descForZoneOpr (0, dataObjInp, rodsServerHost, NULL); if (l1descInx < 0) return l1descInx; if (*outParamArray == NULL) { *outParamArray = malloc (sizeof (msParamArray_t)); bzero (*outParamArray, sizeof (msParamArray_t)); } addIntParamToArray (*outParamArray, CL_ZONE_OPR_INX, l1descInx); } #endif return status; } if (strcmp (rsyncMode, IRODS_TO_LOCAL) == 0) { status = rsRsyncFileToData (rsComm, dataObjInp); } else if (strcmp (rsyncMode, LOCAL_TO_IRODS) == 0) { status = rsRsyncDataToFile (rsComm, dataObjInp); } else if (strcmp (rsyncMode, IRODS_TO_IRODS) == 0) { status = rsRsyncDataToData (rsComm, dataObjInp); } else { rodsLog (LOG_ERROR, "rsDataObjRsync: rsyncMode %s not supported"); return (USER_RSYNC_NO_MODE_INPUT_ERR); } return (status); }
int rsStructFileBundle (rsComm_t *rsComm, structFileExtAndRegInp_t *structFileBundleInp) { #if 0 char *destRescName = NULL; #endif int status; rodsServerHost_t *rodsServerHost; int remoteFlag; rodsHostAddr_t rescAddr; dataObjInp_t dataObjInp; rescGrpInfo_t *rescGrpInfo = NULL; memset (&dataObjInp, 0, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, structFileBundleInp->objPath, MAX_NAME_LEN); remoteFlag = getAndConnRemoteZone (rsComm, &dataObjInp, &rodsServerHost, REMOTE_CREATE); if (remoteFlag < 0) { return (remoteFlag); } else if (remoteFlag == REMOTE_HOST) { status = rcStructFileBundle (rodsServerHost->conn, structFileBundleInp); return status; } #if 0 if ((destRescName = getValByKey (&structFileBundleInp->condInput, DEST_RESC_NAME_KW)) == NULL && (destRescName = getValByKey (&structFileBundleInp->condInput, DEF_RESC_NAME_KW)) == NULL) { return USER_NO_RESC_INPUT_ERR; } status = _getRescInfo (rsComm, destRescName, &rescGrpInfo); if (status < 0) { rodsLog (LOG_ERROR, "rsStructFileBundle: _getRescInfo of %s error for %s. stat = %d", destRescName, structFileBundleInp->collection, status); return status; } #else /* borrow conInput */ dataObjInp.condInput = structFileBundleInp->condInput; status = getRescGrpForCreate (rsComm, &dataObjInp, &rescGrpInfo); if (status < 0) return status; #endif bzero (&rescAddr, sizeof (rescAddr)); rstrcpy (rescAddr.hostAddr, rescGrpInfo->rescInfo->rescLoc, NAME_LEN); remoteFlag = resolveHost (&rescAddr, &rodsServerHost); if (remoteFlag == LOCAL_HOST) { status = _rsStructFileBundle (rsComm, structFileBundleInp); } else if (remoteFlag == REMOTE_HOST) { status = remoteStructFileBundle (rsComm, structFileBundleInp, rodsServerHost); } else if (remoteFlag < 0) { status = remoteFlag; } freeAllRescGrpInfo (rescGrpInfo); return status; }
int rsNcCreate( rsComm_t *rsComm, ncOpenInp_t *ncCreateInp, int **ncid ) { int remoteFlag; rodsServerHost_t *rodsServerHost; specCollCache_t *specCollCache = NULL; int status; dataObjInp_t dataObjInp; int l1descInx, myncid; if ( getValByKey( &ncCreateInp->condInput, NATIVE_NETCDF_CALL_KW ) != NULL ) { /* just do nc_open with objPath as file nc file path */ /* must to be called internally */ if ( rsComm->proxyUser.authInfo.authFlag < REMOTE_PRIV_USER_AUTH ) { return( CAT_INSUFFICIENT_PRIVILEGE_LEVEL ); } status = nc_create( ncCreateInp->objPath, ncCreateInp->mode, &myncid ); if ( status == NC_NOERR ) { *ncid = ( int * ) malloc( sizeof( int ) ); *( *ncid ) = myncid; return 0; } else { rodsLog( LOG_ERROR, "rsNccreate: nc_create %s error, status = %d, %s", ncCreateInp->objPath, status, nc_strerror( status ) ); return ( NETCDF_OPEN_ERR + status ); } } bzero( &dataObjInp, sizeof( dataObjInp ) ); rstrcpy( dataObjInp.objPath, ncCreateInp->objPath, MAX_NAME_LEN ); replKeyVal( &ncCreateInp->condInput, &dataObjInp.condInput ); resolveLinkedPath( rsComm, dataObjInp.objPath, &specCollCache, &dataObjInp.condInput ); remoteFlag = getAndConnRemoteZone( rsComm, &dataObjInp, &rodsServerHost, REMOTE_OPEN ); if ( remoteFlag < 0 ) { return ( remoteFlag ); } else if ( remoteFlag == LOCAL_HOST ) { addKeyVal( &dataObjInp.condInput, NO_OPEN_FLAG_KW, "" ); l1descInx = _rsDataObjCreate( rsComm, &dataObjInp ); clearKeyVal( &dataObjInp.condInput ); if ( l1descInx < 0 ) { return l1descInx; } l1desc_t& my_desc = irods::get_l1desc( l1descInx ); remoteFlag = resoAndConnHostByDataObjInfo( rsComm, my_desc.dataObjInfo, &rodsServerHost ); if ( remoteFlag < 0 ) { return ( remoteFlag ); } else if ( remoteFlag == LOCAL_HOST ) { status = nc_create( my_desc.dataObjInfo->filePath, ncCreateInp->mode, &myncid ); if ( status != NC_NOERR ) { rodsLog( LOG_ERROR, "rsNcCreate: nc_open %s error, status = %d, %s", ncCreateInp->objPath, status, nc_strerror( status ) ); freeL1desc( l1descInx ); return ( NETCDF_CREATE_ERR + status ); } } else { /* execute it remotely with dataObjInfo->filePath */ ncOpenInp_t myNcCreateInp; bzero( &myNcCreateInp, sizeof( myNcCreateInp ) ); rstrcpy( myNcCreateInp.objPath, my_desc.dataObjInfo->filePath, MAX_NAME_LEN ); addKeyVal( &myNcCreateInp.condInput, NATIVE_NETCDF_CALL_KW, "" ); status = rcNcCreate( rodsServerHost->conn, &myNcCreateInp, &myncid ); clearKeyVal( &myNcCreateInp.condInput ); if ( status < 0 ) { rodsLog( LOG_ERROR, "rsNcCreate: _rcNcCreate %s error, status = %d", myNcCreateInp.objPath, status ); freeL1desc( l1descInx ); return ( status ); } } my_desc.l3descInx = myncid; /* need to reg here since NO_OPEN_FLAG_KW does not do it */ if ( my_desc.dataObjInfo->specColl == NULL ) { status = svrRegDataObj( rsComm, my_desc.dataObjInfo ); if ( status < 0 ) { ncCloseInp_t myNcCloseInp; bzero( &myNcCloseInp, sizeof( myNcCloseInp ) ); myNcCloseInp.ncid = l1descInx; irods::server_api_call ( NC_CLOSE_AN, rsComm, &myNcCloseInp ); l3Unlink( rsComm, my_desc.dataObjInfo ); rodsLog( LOG_ERROR, "rsNcCreate: svrRegDataObj for %s failed, status = %d", my_desc.dataObjInfo->objPath, status ); freeL1desc( l1descInx ); return ( NETCDF_CREATE_ERR + status ); } } } else { addKeyVal( &dataObjInp.condInput, CROSS_ZONE_CREATE_KW, "" ); status = rcNcCreate( rodsServerHost->conn, ncCreateInp, &myncid ); /* rm it to avoid confusion */ rmKeyVal( &dataObjInp.condInput, CROSS_ZONE_CREATE_KW ); if ( status < 0 ) { rodsLog( LOG_ERROR, "rsNcCreate: _rcNcCreate %s error, status = %d", ncCreateInp->objPath, status ); return ( status ); } l1descInx = allocAndSetL1descForZoneOpr( myncid, &dataObjInp, rodsServerHost, NULL ); } l1desc_t& my_desc = irods::get_l1desc( l1descInx ); my_desc.oprType = NC_CREATE; *ncid = ( int * ) malloc( sizeof( int ) ); *( *ncid ) = l1descInx; return 0; }
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 ); remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost, REMOTE_CREATE ); if ( const char* acl_string = getValByKey( &dataObjInp->condInput, ACL_INCLUDED_KW ) ) { try { irods::deserialize_acl( acl_string ); } catch ( const irods::exception& e ) { rodsLog( LOG_ERROR, "%s", e.what() ); return e.code(); } } if ( const char* metadata_string = getValByKey( &dataObjInp->condInput, METADATA_INCLUDED_KW ) ) { try { irods::deserialize_metadata( metadata_string ); } catch ( const irods::exception& e ) { rodsLog( LOG_ERROR, "%s", e.what() ); return e.code(); } } if ( remoteFlag < 0 ) { return remoteFlag; } else if ( remoteFlag == LOCAL_HOST ) { // =-=-=-=-=-=-=- // 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 std::string hier; if ( getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW ) == NULL ) { irods::error ret = irods::resolve_resource_hierarchy( irods::CREATE_OPERATION, rsComm, dataObjInp, hier ); if ( !ret.ok() ) { std::stringstream msg; msg << __FUNCTION__; msg << " :: failed in irods::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 status2 = applyRuleForPostProcForWrite( rsComm, dataObjInpBBuf, dataObjInp->objPath ); if ( status2 < 0 ) { return ( status2 ); } dataObjInp->openFlags = O_RDWR; status = _rsDataObjPut( rsComm, dataObjInp, dataObjInpBBuf, portalOprOut ); } 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 rsDataObjRsync( rsComm_t *rsComm, dataObjInp_t *dataObjInp, msParamArray_t **outParamArray ) { int status; char *rsyncMode; char *remoteZoneOpr; int remoteFlag; rodsServerHost_t *rodsServerHost; specCollCache_t *specCollCache = NULL; *outParamArray = NULL; if ( dataObjInp == NULL ) { rodsLog( LOG_ERROR, "rsDataObjRsync error. NULL input" ); return SYS_INTERNAL_NULL_INPUT_ERR; } rsyncMode = getValByKey( &dataObjInp->condInput, RSYNC_MODE_KW ); if ( rsyncMode == NULL ) { rodsLog( LOG_ERROR, "rsDataObjRsync: RSYNC_MODE_KW input is missing" ); return USER_RSYNC_NO_MODE_INPUT_ERR; } if ( strcmp( rsyncMode, LOCAL_TO_IRODS ) == 0 ) { remoteZoneOpr = REMOTE_CREATE; } else { remoteZoneOpr = REMOTE_OPEN; } resolveLinkedPath( rsComm, dataObjInp->objPath, &specCollCache, &dataObjInp->condInput ); if ( strcmp( rsyncMode, IRODS_TO_IRODS ) == 0 ) { if ( isLocalZone( dataObjInp->objPath ) == 0 ) { dataObjInp_t myDataObjInp; char *destObjPath; /* source in a remote zone. try dest */ destObjPath = getValByKey( &dataObjInp->condInput, RSYNC_DEST_PATH_KW ); if ( destObjPath == NULL ) { rodsLog( LOG_ERROR, "rsDataObjRsync: RSYNC_DEST_PATH_KW input is missing for %s", dataObjInp->objPath ); return USER_RSYNC_NO_MODE_INPUT_ERR; } myDataObjInp = *dataObjInp; remoteZoneOpr = REMOTE_CREATE; rstrcpy( myDataObjInp.objPath, destObjPath, MAX_NAME_LEN ); remoteFlag = getAndConnRemoteZone( rsComm, &myDataObjInp, &rodsServerHost, remoteZoneOpr ); } else { remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost, remoteZoneOpr ); } } else { remoteFlag = getAndConnRemoteZone( rsComm, dataObjInp, &rodsServerHost, remoteZoneOpr ); } // =-=-=-=-=-=-=- // 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 if ( remoteFlag < 0 ) { return remoteFlag; } else if ( remoteFlag == REMOTE_HOST ) { status = _rcDataObjRsync( rodsServerHost->conn, dataObjInp, outParamArray ); return status; } if ( strcmp( rsyncMode, IRODS_TO_LOCAL ) == 0 ) { status = rsRsyncFileToData( rsComm, dataObjInp ); } else if ( strcmp( rsyncMode, LOCAL_TO_IRODS ) == 0 ) { status = rsRsyncDataToFile( rsComm, dataObjInp ); } else if ( strcmp( rsyncMode, IRODS_TO_IRODS ) == 0 ) { status = rsRsyncDataToData( rsComm, dataObjInp ); } else { rodsLog( LOG_ERROR, "rsDataObjRsync: rsyncMode %s not supported" ); return USER_RSYNC_NO_MODE_INPUT_ERR; } return status; }
int rsCollRepl (rsComm_t *rsComm, collInp_t *collReplInp, collOprStat_t **collOprStat) { int status; dataObjInp_t dataObjInp; collEnt_t *collEnt; int handleInx; transferStat_t myTransStat; int totalFileCnt; int fileCntPerStatOut; int savedStatus = 0; int remoteFlag; rodsServerHost_t *rodsServerHost; /* try to connect to dest resc */ bzero (&dataObjInp, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, collReplInp->collName, MAX_NAME_LEN); remoteFlag = getAndConnRemoteZone (rsComm, &dataObjInp, &rodsServerHost, REMOTE_CREATE); if (remoteFlag < 0) { return (remoteFlag); } else if (remoteFlag == REMOTE_HOST) { int retval; retval = _rcCollRepl (rodsServerHost->conn, collReplInp, collOprStat); if (retval < 0) return retval; status = svrSendZoneCollOprStat (rsComm, rodsServerHost->conn, *collOprStat, retval); return status; } fileCntPerStatOut = FILE_CNT_PER_STAT_OUT; if (collOprStat != NULL) *collOprStat = NULL; collReplInp->flags = RECUR_QUERY_FG; handleInx = rsOpenCollection (rsComm, collReplInp); if (handleInx < 0) { rodsLog (LOG_ERROR, "rsCollRepl: rsOpenCollection of %s error. status = %d", collReplInp->collName, handleInx); return (handleInx); } if (collOprStat != NULL) { *collOprStat = (collOprStat_t*)malloc (sizeof (collOprStat_t)); memset (*collOprStat, 0, sizeof (collOprStat_t)); } if (CollHandle[handleInx].rodsObjStat->specColl != NULL) { rodsLog (LOG_ERROR, "rsCollRepl: unable to replicate mounted collection %s", collReplInp->collName); rsCloseCollection (rsComm, &handleInx); return (0); } while ((status = rsReadCollection (rsComm, &handleInx, &collEnt)) >= 0) { if (collEnt->objType == DATA_OBJ_T) { if (totalFileCnt == 0) totalFileCnt = CollHandle[handleInx].dataObjSqlResult.totalRowCount; bzero (&dataObjInp, sizeof (dataObjInp)); snprintf (dataObjInp.objPath, MAX_NAME_LEN, "%s/%s", collEnt->collName, collEnt->dataName); dataObjInp.condInput = collReplInp->condInput; memset (&myTransStat, 0, sizeof (myTransStat)); status = _rsDataObjRepl (rsComm, &dataObjInp, &myTransStat, NULL); if (status == SYS_COPY_ALREADY_IN_RESC) { savedStatus = status; status = 0; } if (status < 0) { rodsLogError (LOG_ERROR, status, "rsCollRepl: rsDataObjRepl failed for %s. status = %d", dataObjInp.objPath, status); savedStatus = status; break; } else { if (collOprStat != NULL) { (*collOprStat)->bytesWritten += myTransStat.bytesWritten; (*collOprStat)->filesCnt ++; } } if (collOprStat != NULL && (*collOprStat)->filesCnt >= fileCntPerStatOut) { rstrcpy ((*collOprStat)->lastObjPath, dataObjInp.objPath, MAX_NAME_LEN); (*collOprStat)->totalFileCnt = totalFileCnt; status = svrSendCollOprStat (rsComm, *collOprStat); if (status < 0) { rodsLogError (LOG_ERROR, status, "rsCollRepl: svrSendCollOprStat failed for %s. status = %d", dataObjInp.objPath, status); *collOprStat = NULL; savedStatus = status; break; } *collOprStat = (collOprStat_t*)malloc (sizeof (collOprStat_t)); memset (*collOprStat, 0, sizeof (collOprStat_t)); } } free (collEnt); /* just free collEnt but not content */ } rsCloseCollection (rsComm, &handleInx); return (savedStatus); }
int rsStructFileExtAndReg (rsComm_t *rsComm, structFileExtAndRegInp_t *structFileExtAndRegInp) { int status; dataObjInp_t dataObjInp; openedDataObjInp_t dataObjCloseInp; dataObjInfo_t *dataObjInfo; int l1descInx; rescInfo_t *rescInfo; char *rescGroupName; int remoteFlag; rodsServerHost_t *rodsServerHost; char phyBunDir[MAX_NAME_LEN], *tmpStr; int flags = 0; #if 0 dataObjInp_t dirRegInp; structFileOprInp_t structFileOprInp; #endif specCollCache_t *specCollCache = NULL; resolveLinkedPath (rsComm, structFileExtAndRegInp->objPath, &specCollCache, &structFileExtAndRegInp->condInput); resolveLinkedPath (rsComm, structFileExtAndRegInp->collection, &specCollCache, NULL); if (!isSameZone (structFileExtAndRegInp->objPath, structFileExtAndRegInp->collection)) return SYS_CROSS_ZONE_MV_NOT_SUPPORTED; memset (&dataObjInp, 0, sizeof (dataObjInp)); rstrcpy (dataObjInp.objPath, structFileExtAndRegInp->objPath, MAX_NAME_LEN); /* replicate the condInput. may have resource input */ replKeyVal (&structFileExtAndRegInp->condInput, &dataObjInp.condInput); dataObjInp.openFlags = O_RDONLY; remoteFlag = getAndConnRemoteZone (rsComm, &dataObjInp, &rodsServerHost, REMOTE_OPEN); if (remoteFlag < 0) { return (remoteFlag); } else if (remoteFlag == REMOTE_HOST) { status = rcStructFileExtAndReg (rodsServerHost->conn, structFileExtAndRegInp); return status; } /* open the structured file */ addKeyVal (&dataObjInp.condInput, NO_OPEN_FLAG_KW, ""); l1descInx = _rsDataObjOpen (rsComm, &dataObjInp); if (l1descInx < 0) { rodsLog (LOG_ERROR, "rsStructFileExtAndReg: _rsDataObjOpen of %s error. status = %d", dataObjInp.objPath, l1descInx); return (l1descInx); } rescInfo = L1desc[l1descInx].dataObjInfo->rescInfo; rescGroupName = L1desc[l1descInx].dataObjInfo->rescGroupName; remoteFlag = resolveHostByRescInfo (rescInfo, &rodsServerHost); bzero (&dataObjCloseInp, sizeof (dataObjCloseInp)); dataObjCloseInp.l1descInx = l1descInx; if (remoteFlag == REMOTE_HOST) { addKeyVal (&structFileExtAndRegInp->condInput, RESC_NAME_KW, rescInfo->rescName); if ((status = svrToSvrConnect (rsComm, rodsServerHost)) < 0) { return status; } status = rcStructFileExtAndReg (rodsServerHost->conn, structFileExtAndRegInp); rsDataObjClose (rsComm, &dataObjCloseInp); return status; } status = chkCollForExtAndReg (rsComm, structFileExtAndRegInp->collection, NULL); if (status < 0) return status; dataObjInfo = L1desc[l1descInx].dataObjInfo; createPhyBundleDir (rsComm, dataObjInfo->filePath, phyBunDir); status = unbunPhyBunFile (rsComm, dataObjInp.objPath, rescInfo, dataObjInfo->filePath, phyBunDir, dataObjInfo->dataType, 0); if (status == SYS_DIR_IN_VAULT_NOT_EMPTY) { /* rename the phyBunDir */ tmpStr = strdup(phyBunDir); // cppcheck - Undefined behavior: same parameter and destination in snprintf(). snprintf (phyBunDir, MAX_NAME_LEN, "%s.%-d", tmpStr, (int) random ()); free(tmpStr); status = unbunPhyBunFile (rsComm, dataObjInp.objPath, rescInfo, dataObjInfo->filePath, phyBunDir, dataObjInfo->dataType, 0); } if (status < 0) { rodsLog (LOG_ERROR, "rsStructFileExtAndReg:unbunPhyBunFile err for %s to dir %s.stat=%d", dataObjInfo->filePath, phyBunDir, status); rsDataObjClose (rsComm, &dataObjCloseInp); return status; } if (getValByKey (&structFileExtAndRegInp->condInput, FORCE_FLAG_KW) != NULL) { flags = flags | FORCE_FLAG_FLAG; } if (getValByKey (&structFileExtAndRegInp->condInput, BULK_OPR_KW) != NULL) { status = bulkRegUnbunSubfiles (rsComm, rescInfo, rescGroupName, structFileExtAndRegInp->collection, phyBunDir, flags, NULL); } else { status = regUnbunSubfiles (rsComm, rescInfo, rescGroupName, structFileExtAndRegInp->collection, phyBunDir, flags, NULL); } if (status == CAT_NO_ROWS_FOUND) { /* some subfiles have been deleted. harmless */ status = 0; } else if (status < 0) { rodsLog (LOG_ERROR, "_rsUnbunAndRegPhyBunfile: rsStructFileExtAndReg for dir %s.stat=%d", phyBunDir, status); } rsDataObjClose (rsComm, &dataObjCloseInp); return status; }