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