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