00001
00002
00003
00004
00005
00006
00007 #include "dataObjRename.h"
00008 #include "objMetaOpr.h"
00009 #include "dataObjOpr.h"
00010 #include "collection.h"
00011 #include "resource.h"
00012 #include "specColl.h"
00013 #include "physPath.h"
00014 #include "subStructFileRename.h"
00015 #include "icatHighLevelRoutines.h"
00016 #include "dataObjUnlink.h"
00017 #include "phyBundleColl.h"
00018 #include "regDataObj.h"
00019 #include "fileOpendir.h"
00020 #include "fileReaddir.h"
00021 #include "fileClosedir.h"
00022 #include "rmCollOld.h"
00023
00024
00025
00026 #include "eirods_resource_backport.h"
00027 #include "eirods_stacktrace.h"
00028 #include "eirods_hierarchy_parser.h"
00029
00030 int
00031 rsDataObjRename (rsComm_t *rsComm, dataObjCopyInp_t *dataObjRenameInp)
00032 {
00033 int status;
00034 dataObjInp_t *srcDataObjInp, *destDataObjInp;
00035 rodsServerHost_t *rodsServerHost = NULL;
00036 dataObjInfo_t *srcDataObjInfo = NULL;
00037 dataObjInfo_t *destDataObjInfo = NULL;
00038 specCollCache_t *specCollCache = NULL;
00039 int srcType, destType;
00040
00041 srcDataObjInp = &dataObjRenameInp->srcDataObjInp;
00042 destDataObjInp = &dataObjRenameInp->destDataObjInp;
00043
00044
00045 addKeyVal (&srcDataObjInp->condInput, NO_TRANSLATE_LINKPT_KW, "");
00046 resolveLinkedPath (rsComm, srcDataObjInp->objPath, &specCollCache,
00047 &srcDataObjInp->condInput);
00048 rmKeyVal (&srcDataObjInp->condInput, NO_TRANSLATE_LINKPT_KW);
00049
00050 resolveLinkedPath (rsComm, destDataObjInp->objPath, &specCollCache,
00051 &destDataObjInp->condInput);
00052
00053 if (strcmp (srcDataObjInp->objPath, destDataObjInp->objPath) == 0) {
00054 return (SAME_SRC_DEST_PATHS_ERR);
00055 }
00056
00057
00058 status = getAndConnRcatHost (rsComm, MASTER_RCAT,
00059 srcDataObjInp->objPath, &rodsServerHost);
00060
00061 if (status < 0 || NULL == rodsServerHost ) {
00062 return (status);
00063 } else if (rodsServerHost->rcatEnabled == REMOTE_ICAT) {
00064 status = rcDataObjRename (rodsServerHost->conn, dataObjRenameInp);
00065 return status;
00066 }
00067
00068 srcType = resolvePathInSpecColl (rsComm, srcDataObjInp->objPath,
00069 WRITE_COLL_PERM, 0, &srcDataObjInfo);
00070
00071 destType = resolvePathInSpecColl (rsComm, destDataObjInp->objPath,
00072 WRITE_COLL_PERM, 0, &destDataObjInfo);
00073
00074 if( srcDataObjInfo != NULL &&
00075 srcDataObjInfo->specColl != NULL &&
00076 strcmp( srcDataObjInfo->specColl->collection,
00077 srcDataObjInp->objPath ) == 0) {
00078
00079 freeDataObjInfo (srcDataObjInfo);
00080 srcDataObjInfo = NULL;
00081 srcType = SYS_SPEC_COLL_NOT_IN_CACHE;
00082 }
00083
00084 if (!isSameZone (srcDataObjInp->objPath, destDataObjInp->objPath))
00085 return SYS_CROSS_ZONE_MV_NOT_SUPPORTED;
00086
00087 if (destType >= 0) {
00088 rodsLog (LOG_ERROR,
00089 "rsDataObjRename: dest specColl objPath %s exists",
00090 destDataObjInp->objPath);
00091 freeDataObjInfo (srcDataObjInfo);
00092 freeDataObjInfo (destDataObjInfo);
00093 return (SYS_DEST_SPEC_COLL_SUB_EXIST);
00094 }
00095
00096 if (srcType >= 0) {
00097 if (destType == SYS_SPEC_COLL_OBJ_NOT_EXIST) {
00098 status = specCollObjRename (rsComm, srcDataObjInfo,
00099 destDataObjInfo);
00100 } else {
00101
00102
00103 if (srcDataObjInfo->specColl->collClass == MOUNTED_COLL) {
00104
00105
00106 status = moveMountedCollObj (rsComm, srcDataObjInfo, srcType,
00107 destDataObjInp);
00108 } else {
00109 rodsLog (LOG_ERROR,
00110 "rsDataObjRename: src %s is in spec coll but dest %s is not",
00111 srcDataObjInp->objPath, destDataObjInp->objPath);
00112 status = SYS_SRC_DEST_SPEC_COLL_CONFLICT;
00113 }
00114 }
00115 freeDataObjInfo (srcDataObjInfo);
00116 freeDataObjInfo (destDataObjInfo);
00117 return (status);
00118 } else if (srcType == SYS_SPEC_COLL_OBJ_NOT_EXIST) {
00119 #if 0
00120
00121
00122 if (getSpecCollOpr (&srcDataObjInp->condInput,
00123 srcDataObjInfo->specColl) != NORMAL_OPR_ON_STRUCT_FILE_COLL) {
00124 return (SYS_SPEC_COLL_OBJ_NOT_EXIST);
00125 }
00126 #endif
00127 return (SYS_SPEC_COLL_OBJ_NOT_EXIST);
00128 } else if (destType == SYS_SPEC_COLL_OBJ_NOT_EXIST) {
00129
00130 rodsLog (LOG_ERROR,
00131 "rsDataObjRename: src %s is not in spec coll but dest %s is",
00132 srcDataObjInp->objPath, destDataObjInp->objPath);
00133 return (SYS_SRC_DEST_SPEC_COLL_CONFLICT);
00134 }
00135
00136 status = getAndConnRcatHost (rsComm, MASTER_RCAT,
00137 dataObjRenameInp->srcDataObjInp.objPath,
00138 &rodsServerHost);
00139 if (status < 0) {
00140 return(status);
00141 }
00142 if (rodsServerHost->localFlag == LOCAL_HOST) {
00143 #ifdef RODS_CAT
00144 status = _rsDataObjRename (rsComm, dataObjRenameInp);
00145 #else
00146 status = SYS_NO_RCAT_SERVER_ERR;
00147 #endif
00148 } else {
00149 status = rcDataObjRename (rodsServerHost->conn, dataObjRenameInp);
00150 }
00151
00152 return (status);
00153 }
00154
00155 int
00156 getMultiCopyPerResc ( rsComm_t *rsComm )
00157 {
00158 ruleExecInfo_t rei;
00159
00160 memset (&rei, 0, sizeof (rei));
00161 rei.rsComm = rsComm;
00162 applyRule ("acSetMultiReplPerResc", NULL, &rei, NO_SAVE_REI);
00163 if (strcmp (rei.statusStr, MULTI_COPIES_PER_RESC) == 0) {
00164 return 1;
00165 } else {
00166 return 0;
00167 }
00168 }
00169
00170
00171 int
00172 _rsDataObjRename (rsComm_t *rsComm, dataObjCopyInp_t *dataObjRenameInp)
00173 {
00174 #ifdef RODS_CAT
00175 int status;
00176 char srcColl[MAX_NAME_LEN], srcObj[MAX_NAME_LEN];
00177 char destColl[MAX_NAME_LEN], destObj[MAX_NAME_LEN];
00178 dataObjInp_t *srcDataObjInp, *destDataObjInp;
00179 dataObjInfo_t *dataObjInfoHead = NULL;
00180 rodsLong_t srcId, destId;
00181 int multiCopyFlag;
00182 int acPreProcFromRenameFlag = 0;
00183
00184 char *args[MAX_NUM_OF_ARGS_IN_ACTION];
00185 int i, argc;
00186 ruleExecInfo_t rei2;
00187
00188 memset ((char*)&rei2, 0, sizeof (ruleExecInfo_t));
00189 rei2.rsComm = rsComm;
00190 if (rsComm != NULL) {
00191 rei2.uoic = &rsComm->clientUser;
00192 rei2.uoip = &rsComm->proxyUser;
00193 }
00194 rei2.doinp = &dataObjRenameInp->srcDataObjInp;
00195
00196 srcDataObjInp = &dataObjRenameInp->srcDataObjInp;
00197 destDataObjInp = &dataObjRenameInp->destDataObjInp;
00198
00199 if ((status = splitPathByKey (
00200 srcDataObjInp->objPath, srcColl, srcObj, '/')) < 0) {
00201 rodsLog (LOG_ERROR,
00202 "_rsDataObjRename: splitPathByKey for %s error, status = %d",
00203 srcDataObjInp->objPath, status);
00204 return (status);
00205 }
00206
00207 if ((status = splitPathByKey (
00208 destDataObjInp->objPath, destColl, destObj, '/')) < 0) {
00209 rodsLog (LOG_ERROR,
00210 "_rsDataObjRename: splitPathByKey for %s error, status = %d",
00211 destDataObjInp->objPath, status);
00212 return (status);
00213 }
00214
00215 multiCopyFlag = getMultiCopyPerResc ( rsComm );
00216
00217 if (srcDataObjInp->oprType == RENAME_DATA_OBJ) {
00218
00219 status = getDataObjInfo( rsComm, srcDataObjInp, &dataObjInfoHead, ACCESS_DELETE_OBJECT, 0 );
00220
00221 if (status >= 0 || NULL != dataObjInfoHead ) {
00222 srcId = dataObjInfoHead->dataId;
00223 } else {
00224 rodsLog (LOG_ERROR,
00225 "_rsDataObjRename: src data %s does not exist, status = %d",
00226 srcDataObjInp->objPath, status);
00227 return (status);
00228 }
00229 } else if (srcDataObjInp->oprType == RENAME_COLL) {
00230 status = isColl (rsComm, srcDataObjInp->objPath, &srcId);
00231 if (status < 0) {
00232 rodsLog (LOG_ERROR,
00233 "_rsDataObjRename: src coll %s does not exist, status = %d",
00234 srcDataObjInp->objPath, status);
00235 return (status);
00236 }
00237 } else {
00238 if ((status = isData (rsComm, srcDataObjInp->objPath, &srcId)) >= 0) {
00239 if (isData (rsComm, destDataObjInp->objPath, &destId) >= 0 &&
00240 getValByKey (&srcDataObjInp->condInput, FORCE_FLAG_KW) != NULL) {
00241
00242 rsDataObjUnlink (rsComm, destDataObjInp);
00243 }
00244 srcDataObjInp->oprType = destDataObjInp->oprType = RENAME_DATA_OBJ;
00245 status = getDataObjInfo (rsComm, srcDataObjInp, &dataObjInfoHead,
00246 ACCESS_DELETE_OBJECT, 0);
00247
00248 if (status < 0) {
00249 rodsLog (LOG_ERROR,
00250 "_rsDataObjRename: src data %s does not exist, status = %d",
00251 srcDataObjInp->objPath, status);
00252 return (status);
00253 }
00254 } else if ((status = isColl (rsComm, srcDataObjInp->objPath, &srcId))
00255 >= 0) {
00256 srcDataObjInp->oprType = destDataObjInp->oprType = RENAME_COLL;
00257 } else {
00258 rodsLog (LOG_ERROR,
00259 "_rsDataObjRename: src obj %s does not exist, status = %d",
00260 srcDataObjInp->objPath, status);
00261 return (status);
00262 }
00263 }
00264
00265 if (srcDataObjInp->oprType == RENAME_DATA_OBJ) {
00266 if (strstr (dataObjInfoHead->dataType, BUNDLE_STR) != NULL) {
00267 rodsLog (LOG_ERROR,
00268 "_rsDataObjRename: cannot rename tar bundle type obj %s",
00269 srcDataObjInp->objPath);
00270 return CANT_RM_MV_BUNDLE_TYPE;
00271 }
00272 }
00273
00274 if (strcmp (srcObj, destObj) != 0) {
00275
00276 if (srcId < 0) {
00277 status = srcId;
00278 return (status);
00279 }
00280
00281
00282 argc = 2;
00283 args[0] = srcDataObjInp->objPath;
00284 args[1] = destDataObjInp->objPath;
00285 acPreProcFromRenameFlag = 1;
00286 i = applyRuleArg("acPreProcForObjRename",args,argc, &rei2, NO_SAVE_REI);
00287 if (i < 0) {
00288 if (rei2.status < 0) {
00289 i = rei2.status;
00290 }
00291 rodsLog (LOG_ERROR,
00292 "rsDataObjRename: acPreProcForObjRename error for source %s and destination %s,stat=%d",
00293 args[0], args[1], i);
00294 return i;
00295 }
00296
00297
00298 status = chlRenameObject (rsComm, srcId, destObj);
00299 }
00300
00301 if (status < 0) {
00302 return (status);
00303 }
00304
00305 if (strcmp (srcColl, destColl) != 0) {
00306
00307 status = isColl (rsComm, destColl, &destId);
00308 if (status < 0) {
00309 rodsLog (LOG_ERROR,
00310 "_rsDataObjRename: dest coll %s does not exist, status = %d",
00311 destColl, status);
00312 return (status);
00313 }
00314
00315
00316 if (acPreProcFromRenameFlag == 0) {
00317 args[0] = srcDataObjInp->objPath;
00318 args[1] = destDataObjInp->objPath;
00319 argc = 2;
00320 i = applyRuleArg("acPreProcForObjRename",args,argc, &rei2, NO_SAVE_REI);
00321 if (i < 0) {
00322 if (rei2.status < 0) {
00323 i = rei2.status;
00324 }
00325 rodsLog (LOG_ERROR,
00326 "rsDataObjRename: acPreProcForObjRename error for source %s and destination %s,stat=%d",
00327 args[0], args[1], i);
00328 return i;
00329 }
00330 }
00331
00332
00333 status = chlMoveObject (rsComm, srcId, destId);
00334 }
00335 if (status >= 0) {
00336 if (multiCopyFlag > 0) {
00337 status = chlCommit(rsComm);
00338 return (status);
00339 } else {
00340
00341 if (srcDataObjInp->oprType == RENAME_DATA_OBJ) {
00342 dataObjInfo_t *tmpDataObjInfo;
00343
00344
00345 tmpDataObjInfo = dataObjInfoHead;
00346 while (tmpDataObjInfo != NULL) {
00347 rstrcpy( tmpDataObjInfo->objPath, destDataObjInp->objPath, MAX_NAME_LEN );
00348
00349 tmpDataObjInfo = tmpDataObjInfo->next;
00350 }
00351 status = syncDataObjPhyPath( rsComm, destDataObjInp, dataObjInfoHead, NULL );
00352 freeAllDataObjInfo (dataObjInfoHead);
00353 } else {
00354 status = syncCollPhyPath (rsComm, destDataObjInp->objPath);
00355 }
00356
00357 if (status >= 0) {
00358 status = chlCommit(rsComm);
00359 } else {
00360 chlRollback (rsComm);
00361 }
00362 }
00363 if (status >= 0) {
00364 args[0] = srcDataObjInp->objPath;
00365 args[1] = destDataObjInp->objPath;
00366 argc = 2;
00367 status = applyRuleArg ("acPostProcForObjRename", args, argc,
00368 &rei2, NO_SAVE_REI);
00369 if (status < 0) {
00370 if (rei2.status < 0) status = rei2.status;
00371 rodsLog (LOG_ERROR,
00372 "rsDataObjRename: acPostProc err for src %s dest %s,stat=%d",
00373 args[0], args[1], status);
00374 }
00375 }
00376 } else {
00377 chlRollback(rsComm);
00378 }
00379 return(status);
00380 #else
00381 return SYS_NO_ICAT_SERVER_ERR;
00382 #endif
00383 }
00384
00385 int
00386 specCollObjRename (rsComm_t *rsComm, dataObjInfo_t *srcDataObjInfo,
00387 dataObjInfo_t *destDataObjInfo)
00388 {
00389 int status;
00390 char *newPath;
00391
00392 if (getStructFileType (srcDataObjInfo->specColl) >= 0) {
00393
00394 newPath = destDataObjInfo->subPath;
00395 } else {
00396
00397 newPath = destDataObjInfo->filePath;
00398 }
00399
00400 status = l3Rename (rsComm, srcDataObjInfo, newPath);
00401
00402 if (status < 0) {
00403 rodsLog (LOG_ERROR,
00404 "specCollObjRename: l3Rename error from %s to %s, status = %d",
00405 srcDataObjInfo->subPath, newPath, status);
00406 return (status);
00407 }
00408 return (status);
00409 }
00410
00411 int
00412 l3Rename (rsComm_t *rsComm, dataObjInfo_t *dataObjInfo, char *newFileName)
00413 {
00414 fileRenameInp_t fileRenameInp;
00415 int status;
00416
00417 if (dataObjInfo->rescInfo->rescStatus == INT_RESC_STATUS_DOWN)
00418 return SYS_RESC_IS_DOWN;
00419
00420 std::string location;
00421 eirods::error ret = eirods::get_loc_for_hier_string( dataObjInfo->rescHier, location );
00422 if( !ret.ok() ) {
00423 eirods::log( PASSMSG( "specCollReaddir - failed in specColl open", ret ) );
00424 return -1;
00425 }
00426
00427 if (getStructFileType (dataObjInfo->specColl) >= 0) {
00428 subStructFileRenameInp_t subStructFileRenameInp;
00429 memset (&subStructFileRenameInp, 0, sizeof (subStructFileRenameInp));
00430 rstrcpy (subStructFileRenameInp.subFile.subFilePath, dataObjInfo->subPath,
00431 MAX_NAME_LEN);
00432 rstrcpy (subStructFileRenameInp.newSubFilePath, newFileName, MAX_NAME_LEN);
00433 rstrcpy (subStructFileRenameInp.subFile.addr.hostAddr, location.c_str(), NAME_LEN);
00434 subStructFileRenameInp.subFile.specColl = dataObjInfo->specColl;
00435 status = rsSubStructFileRename (rsComm, &subStructFileRenameInp);
00436 } else {
00437 #if 0 // JMC legacy resource
00438 rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00439
00440 switch (RescTypeDef[rescTypeInx].rescCat) {
00441 case FILE_CAT:
00442 #endif // JMC legacy resource
00443 memset (&fileRenameInp, 0, sizeof (fileRenameInp));
00444 fileRenameInp.fileType = static_cast< fileDriverType_t >( -1 );
00445 rstrcpy( fileRenameInp.oldFileName, dataObjInfo->filePath, MAX_NAME_LEN );
00446 rstrcpy( fileRenameInp.newFileName, newFileName, MAX_NAME_LEN );
00447 rstrcpy (fileRenameInp.rescHier, dataObjInfo->rescHier, MAX_NAME_LEN);
00448 rstrcpy( fileRenameInp.objPath, dataObjInfo->objPath, MAX_NAME_LEN );
00449 rstrcpy( fileRenameInp.addr.hostAddr, location.c_str(), NAME_LEN );
00450 status = rsFileRename (rsComm, &fileRenameInp);
00451 #if 0 // JMC legacy resource
00452 break;
00453 default:
00454 rodsLog (LOG_NOTICE,
00455 "l3Rename: rescCat type %d is not recognized",
00456 RescTypeDef[rescTypeInx].rescCat);
00457 status = SYS_INVALID_RESC_TYPE;
00458 break;
00459 }
00460 #endif // JMC legacy resource
00461 }
00462 return (status);
00463 }
00464
00465
00466 int
00467 moveMountedCollObj (rsComm_t *rsComm, dataObjInfo_t *srcDataObjInfo,
00468 int srcType, dataObjInp_t *destDataObjInp)
00469 {
00470 int status;
00471
00472 if (srcType == DATA_OBJ_T) {
00473 status = moveMountedCollDataObj (rsComm, srcDataObjInfo,
00474 destDataObjInp);
00475 } else if (srcType == COLL_OBJ_T) {
00476 status = moveMountedCollCollObj (rsComm, srcDataObjInfo,
00477 destDataObjInp);
00478 } else {
00479 status = SYS_UNMATCHED_SPEC_COLL_TYPE;
00480 }
00481 return status;
00482 }
00483
00484 int
00485 moveMountedCollDataObj (rsComm_t *rsComm, dataObjInfo_t *srcDataObjInfo,
00486 dataObjInp_t *destDataObjInp)
00487 {
00488 dataObjInfo_t destDataObjInfo;
00489 fileRenameInp_t fileRenameInp;
00490 int status;
00491
00492 if (rsComm == NULL || srcDataObjInfo == NULL || destDataObjInp == NULL)
00493 return USER__NULL_INPUT_ERR;
00494 bzero (&destDataObjInfo, sizeof (destDataObjInfo));
00495 bzero (&fileRenameInp, sizeof (fileRenameInp));
00496 rstrcpy (destDataObjInfo.objPath, destDataObjInp->objPath, MAX_NAME_LEN);
00497 rstrcpy (destDataObjInfo.dataType, srcDataObjInfo->dataType, NAME_LEN);
00498 destDataObjInfo.dataSize = srcDataObjInfo->dataSize;
00499 destDataObjInfo.rescInfo = srcDataObjInfo->rescInfo;
00500 rstrcpy (destDataObjInfo.rescName, srcDataObjInfo->rescInfo->rescName, NAME_LEN);
00501 rstrcpy (destDataObjInfo.rescHier, srcDataObjInfo->rescHier, MAX_NAME_LEN);
00502 status = getFilePathName (rsComm, &destDataObjInfo, destDataObjInp);
00503 if (status < 0) {
00504 rodsLog (LOG_ERROR,
00505 "moveMountedCollDataObj: getFilePathName err for %s. status = %d",
00506 destDataObjInfo.objPath, status);
00507 return (status);
00508 }
00509
00510 status = filePathTypeInResc (rsComm, destDataObjInfo.objPath, destDataObjInfo.filePath, destDataObjInfo.rescHier,
00511 destDataObjInfo.rescInfo);
00512 if (status == LOCAL_DIR_T) {
00513 status = SYS_PATH_IS_NOT_A_FILE;
00514 rodsLog (LOG_ERROR,
00515 "moveMountedCollDataObj: targ path %s is a dir. status = %d",
00516 destDataObjInfo.filePath, status);
00517 return status;
00518 } else if (status == LOCAL_FILE_T) {
00519 dataObjInfo_t myDataObjInfo;
00520 status = chkOrphanFile (rsComm, destDataObjInfo.filePath,
00521 destDataObjInfo.rescInfo->rescName, &myDataObjInfo);
00522 if (status == 1) {
00523
00524 rstrcpy (fileRenameInp.oldFileName, destDataObjInfo.filePath, MAX_NAME_LEN);
00525 renameFilePathToNewDir (rsComm, ORPHAN_DIR, &fileRenameInp, destDataObjInfo.rescInfo, 1);
00526 } else if (status == 0) {
00527
00528 return SYS_COPY_ALREADY_IN_RESC;
00529 } else {
00530 return status;
00531 }
00532 }
00533 status = l3Rename (rsComm, srcDataObjInfo, destDataObjInfo.filePath);
00534
00535 if (status < 0) {
00536 rodsLog (LOG_ERROR,
00537 "moveMountedCollDataObj: l3Rename error from %s to %s, status = %d",
00538 srcDataObjInfo->filePath, destDataObjInfo.filePath, status);
00539 return (status);
00540 }
00541 status = svrRegDataObj (rsComm, &destDataObjInfo);
00542 if (status < 0) {
00543 l3Rename (rsComm, &destDataObjInfo, srcDataObjInfo->filePath);
00544 rodsLog (LOG_ERROR,
00545 "moveMountedCollDataObj: rsRegDataObj for %s failed, status = %d",
00546 destDataObjInfo.objPath, status);
00547 }
00548 return (status);
00549 }
00550
00551 int
00552 moveMountedCollCollObj (rsComm_t *rsComm, dataObjInfo_t *srcDataObjInfo,
00553 dataObjInp_t *destDataObjInp)
00554 {
00555 int l3descInx;
00556 fileReaddirInp_t fileReaddirInp;
00557 rodsDirent_t *rodsDirent = NULL;
00558 rodsStat_t *fileStatOut = NULL;
00559 dataObjInfo_t subSrcDataObjInfo;
00560 dataObjInp_t subDestDataObjInp;
00561 int status;
00562 int savedStatus = 0;
00563
00564 subSrcDataObjInfo = *srcDataObjInfo;
00565 bzero (&subDestDataObjInp, sizeof (subDestDataObjInp));
00566 l3descInx = l3Opendir (rsComm, srcDataObjInfo);
00567 fileReaddirInp.fileInx = l3descInx;
00568 rsMkCollR (rsComm, "/", destDataObjInp->objPath);
00569 while (rsFileReaddir (rsComm, &fileReaddirInp, &rodsDirent) >= 0) {
00570 rodsDirent_t myRodsDirent;
00571
00572 myRodsDirent = *rodsDirent;
00573 free (rodsDirent);
00574
00575 if (strcmp (myRodsDirent.d_name, ".") == 0 ||
00576 strcmp (myRodsDirent.d_name, "..") == 0) {
00577 continue;
00578 }
00579
00580 snprintf (subSrcDataObjInfo.objPath, MAX_NAME_LEN, "%s/%s",
00581 srcDataObjInfo->objPath, myRodsDirent.d_name);
00582 snprintf (subSrcDataObjInfo.subPath, MAX_NAME_LEN, "%s/%s",
00583 srcDataObjInfo->subPath, myRodsDirent.d_name);
00584 snprintf (subSrcDataObjInfo.filePath, MAX_NAME_LEN, "%s/%s",
00585 srcDataObjInfo->filePath, myRodsDirent.d_name);
00586
00587 status = l3Stat (rsComm, &subSrcDataObjInfo, &fileStatOut);
00588 if (status < 0 || fileStatOut == NULL ) {
00589 rodsLog (LOG_ERROR,
00590 "moveMountedCollCollObj: l3Stat for %s error, status = %d",
00591 subSrcDataObjInfo.filePath, status);
00592 return (status);
00593 }
00594 snprintf (subSrcDataObjInfo.dataCreate, TIME_LEN, "%d",
00595 fileStatOut->st_ctim);
00596 snprintf (subSrcDataObjInfo.dataModify, TIME_LEN, "%d",
00597 fileStatOut->st_mtim);
00598 snprintf (subDestDataObjInp.objPath, MAX_NAME_LEN, "%s/%s",
00599 destDataObjInp->objPath, myRodsDirent.d_name);
00600 if ((fileStatOut->st_mode & S_IFREG) != 0) {
00601 subSrcDataObjInfo.dataSize = fileStatOut->st_size;
00602 status = moveMountedCollDataObj (rsComm, &subSrcDataObjInfo,
00603 &subDestDataObjInp);
00604 } else {
00605 status = moveMountedCollCollObj (rsComm, &subSrcDataObjInfo,
00606 &subDestDataObjInp);
00607 }
00608 if (status < 0) {
00609 savedStatus = status;
00610 rodsLog (LOG_ERROR,
00611 "moveMountedCollCollObj: moveMountedColl for %s error, stat = %d",
00612 subSrcDataObjInfo.objPath, status);
00613 }
00614
00615 free (fileStatOut);
00616 fileStatOut = NULL;
00617
00618 }
00619 l3Rmdir (rsComm, srcDataObjInfo);
00620 return savedStatus;
00621 }
00622