00001
00002
00003
00004
00005
00006
00007
00008
00009 #include "rodsDef.h"
00010 #include "objDesc.h"
00011 #include "dataObjOpr.h"
00012 #include "rodsDef.h"
00013 #include "rsGlobalExtern.h"
00014 #include "fileChksum.h"
00015 #include "modDataObjMeta.h"
00016 #include "objMetaOpr.h"
00017 #include "collection.h"
00018 #include "resource.h"
00019 #include "dataObjClose.h"
00020 #include "rcGlobalExtern.h"
00021 #include "reGlobalsExtern.h"
00022 #include "reDefines.h"
00023 #include "reSysDataObjOpr.h"
00024 #include "genQuery.h"
00025 #include "rodsClient.h"
00026 #ifdef LOG_TRANSFERS
00027 #include <sys/time.h>
00028 #endif
00029
00030
00031
00032 #include "eirods_resource_backport.h"
00033 #include "eirods_hierarchy_parser.h"
00034 #include "eirods_stacktrace.h"
00035
00036 int
00037 initL1desc ()
00038 {
00039 memset (L1desc, 0, sizeof (l1desc_t) * NUM_L1_DESC);
00040 return (0);
00041 }
00042
00043 int
00044 allocL1desc ()
00045 {
00046 int i;
00047
00048 for (i = 3; i < NUM_L1_DESC; i++) {
00049 if (L1desc[i].inuseFlag <= FD_FREE) {
00050 L1desc[i].inuseFlag = FD_INUSE;
00051 return (i);
00052 };
00053 }
00054
00055 rodsLog (LOG_NOTICE,
00056 "allocL1desc: out of L1desc");
00057
00058 return (SYS_OUT_OF_FILE_DESC);
00059 }
00060
00061 int
00062 isL1descInuse ()
00063 {
00064 int i;
00065
00066 for (i = 3; i < NUM_L1_DESC; i++) {
00067 if (L1desc[i].inuseFlag == FD_INUSE) {
00068 return 1;
00069 };
00070 }
00071 return 0;
00072 }
00073
00074 int
00075 initSpecCollDesc ()
00076 {
00077 memset (SpecCollDesc, 0, sizeof (specCollDesc_t) * NUM_SPEC_COLL_DESC);
00078 return (0);
00079 }
00080
00081 int
00082 allocSpecCollDesc ()
00083 {
00084 int i;
00085
00086 for (i = 1; i < NUM_SPEC_COLL_DESC; i++) {
00087 if (SpecCollDesc[i].inuseFlag <= FD_FREE) {
00088 SpecCollDesc[i].inuseFlag = FD_INUSE;
00089 return (i);
00090 };
00091 }
00092
00093 rodsLog (LOG_NOTICE,
00094 "allocSpecCollDesc: out of SpecCollDesc");
00095
00096 return (SYS_OUT_OF_FILE_DESC);
00097 }
00098
00099 int
00100 freeSpecCollDesc (int specCollInx)
00101 {
00102 if (specCollInx < 1 || specCollInx >= NUM_SPEC_COLL_DESC) {
00103 rodsLog (LOG_NOTICE,
00104 "freeSpecCollDesc: specCollInx %d out of range", specCollInx);
00105 return (SYS_FILE_DESC_OUT_OF_RANGE);
00106 }
00107
00108 if (SpecCollDesc[specCollInx].dataObjInfo != NULL) {
00109 freeDataObjInfo (SpecCollDesc[specCollInx].dataObjInfo);
00110 }
00111
00112 memset (&SpecCollDesc[specCollInx], 0, sizeof (specCollDesc_t));
00113
00114 return (0);
00115 }
00116
00117 int
00118 closeAllL1desc (rsComm_t *rsComm)
00119 {
00120 int i;
00121
00122 if (rsComm == NULL) {
00123 return 0;
00124 }
00125 for (i = 3; i < NUM_L1_DESC; i++) {
00126 if (L1desc[i].inuseFlag == FD_INUSE &&
00127 L1desc[i].l3descInx > 2) {
00128 l3Close (rsComm, i);
00129 }
00130 }
00131 return (0);
00132 }
00133
00134 int
00135 freeL1desc (int l1descInx)
00136 {
00137 if (l1descInx < 3 || l1descInx >= NUM_L1_DESC) {
00138 rodsLog (LOG_NOTICE,
00139 "freeL1desc: l1descInx %d out of range", l1descInx);
00140 return (SYS_FILE_DESC_OUT_OF_RANGE);
00141 }
00142
00143 if (L1desc[l1descInx].dataObjInfo != NULL) {
00144
00145
00146 if (L1desc[l1descInx].remoteZoneHost != NULL &&
00147 L1desc[l1descInx].dataObjInfo->rescInfo != NULL)
00148 free (L1desc[l1descInx].dataObjInfo->rescInfo);
00149 #if 0
00150
00151
00152 if (L1desc[l1descInx].oprType != REPLICATE_DEST)
00153 freeDataObjInfo (L1desc[l1descInx].dataObjInfo);
00154 #endif
00155 if (L1desc[l1descInx].dataObjInfo != NULL)
00156 freeDataObjInfo (L1desc[l1descInx].dataObjInfo);
00157 }
00158
00159 if (L1desc[l1descInx].otherDataObjInfo != NULL) {
00160 freeAllDataObjInfo (L1desc[l1descInx].otherDataObjInfo);
00161 }
00162
00163 if (L1desc[l1descInx].replDataObjInfo != NULL) {
00164 freeDataObjInfo (L1desc[l1descInx].replDataObjInfo);
00165 }
00166
00167 if (L1desc[l1descInx].dataObjInpReplFlag == 1 &&
00168 L1desc[l1descInx].dataObjInp != NULL) {
00169 clearDataObjInp (L1desc[l1descInx].dataObjInp);
00170 free (L1desc[l1descInx].dataObjInp);
00171 }
00172 memset (&L1desc[l1descInx], 0, sizeof (l1desc_t));
00173
00174 return (0);
00175 }
00176
00177 int
00178 fillL1desc (int l1descInx, dataObjInp_t *dataObjInp,
00179 dataObjInfo_t *dataObjInfo, int replStatus, rodsLong_t dataSize)
00180 {
00181 keyValPair_t *condInput;
00182 char *tmpPtr;
00183
00184
00185 char* resc_hier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
00186 if( dataObjInfo->rescHier[0] == '\0' && resc_hier ) {
00187 strncpy( dataObjInfo->rescHier, resc_hier, MAX_NAME_LEN );
00188 }
00189
00190
00191 condInput = &dataObjInp->condInput;
00192 char* in_pdmo = getValByKey(condInput, IN_PDMO_KW);
00193 if(in_pdmo != NULL) {
00194 L1desc[l1descInx].in_pdmo = 1;
00195 } else {
00196 L1desc[l1descInx].in_pdmo = 0;
00197 }
00198
00199 if (dataObjInp != NULL) {
00200
00201 L1desc[l1descInx].dataObjInp = (dataObjInp_t*)malloc (sizeof (dataObjInp_t));
00202 replDataObjInp (dataObjInp, L1desc[l1descInx].dataObjInp);
00203 L1desc[l1descInx].dataObjInpReplFlag = 1;
00204 } else {
00205
00206 L1desc[l1descInx].dataObjInp = NULL;
00207 }
00208
00209 L1desc[l1descInx].dataObjInfo = dataObjInfo;
00210 if (dataObjInp != NULL) {
00211 L1desc[l1descInx].oprType = dataObjInp->oprType;
00212 }
00213 L1desc[l1descInx].replStatus = replStatus;
00214 L1desc[l1descInx].dataSize = dataSize;
00215 if (condInput != NULL && condInput->len > 0) {
00216 if ((tmpPtr = getValByKey (condInput, REG_CHKSUM_KW)) != NULL) {
00217 L1desc[l1descInx].chksumFlag = REG_CHKSUM;
00218 rstrcpy (L1desc[l1descInx].chksum, tmpPtr, NAME_LEN);
00219 } else if ((tmpPtr = getValByKey (condInput, VERIFY_CHKSUM_KW)) !=
00220 NULL) {
00221 L1desc[l1descInx].chksumFlag = VERIFY_CHKSUM;
00222 rstrcpy (L1desc[l1descInx].chksum, tmpPtr, NAME_LEN);
00223 }
00224 }
00225 #ifdef LOG_TRANSFERS
00226 (void)gettimeofday(&L1desc[l1descInx].openStartTime,
00227 (struct timezone *)0);
00228 #endif
00229 return (0);
00230 }
00231
00232 int
00233 initDataObjInfoWithInp (dataObjInfo_t *dataObjInfo, dataObjInp_t *dataObjInp)
00234 {
00235 char *rescName = 0, *dataType = 0, *filePath = 0;
00236 keyValPair_t *condInput = 0;
00237
00238 condInput = &dataObjInp->condInput;
00239 memset (dataObjInfo, 0, sizeof (dataObjInfo_t));
00240 rstrcpy (dataObjInfo->objPath, dataObjInp->objPath, MAX_NAME_LEN);
00241
00242 rescName = getValByKey (condInput, RESC_NAME_KW);
00243 if (rescName != NULL) {
00244 rstrcpy (dataObjInfo->rescName, rescName, LONG_NAME_LEN);
00245 }
00246
00247 char* rescHier = getValByKey( &dataObjInp->condInput, RESC_HIER_STR_KW );
00248 if( rescHier ) {
00249 rstrcpy (dataObjInfo->rescHier, rescHier, MAX_NAME_LEN);
00250 } else {
00251 rstrcpy (dataObjInfo->rescHier, rescName, MAX_NAME_LEN);
00252 }
00253
00254 snprintf (dataObjInfo->dataMode, SHORT_STR_LEN, "%d", dataObjInp->createMode);
00255
00256 dataType = getValByKey (condInput, DATA_TYPE_KW);
00257 if (dataType != NULL) {
00258 rstrcpy (dataObjInfo->dataType, dataType, NAME_LEN);
00259 } else {
00260 rstrcpy (dataObjInfo->dataType, "generic", NAME_LEN);
00261 }
00262
00263 filePath = getValByKey (condInput, FILE_PATH_KW);
00264 if (filePath != NULL) {
00265 rstrcpy (dataObjInfo->filePath, filePath, MAX_NAME_LEN);
00266 }
00267
00268 return (0);
00269 }
00270
00271
00272
00273
00274
00275
00276
00277 int
00278 getNumThreads (rsComm_t *rsComm, rodsLong_t dataSize, int inpNumThr,
00279
00280 keyValPair_t *condInput, char *destRescHier, char *srcRescHier )
00281 {
00282 ruleExecInfo_t rei;
00283 dataObjInp_t doinp;
00284 int status;
00285 int numDestThr = -1;
00286 int numSrcThr = -1;
00287 rescGrpInfo_t *rescGrpInfo;
00288
00289 if (inpNumThr == NO_THREADING)
00290 return 0;
00291
00292 if (dataSize < 0)
00293 return 0;
00294
00295 if (dataSize <= MIN_SZ_FOR_PARA_TRAN) {
00296 if (inpNumThr > 0) {
00297 inpNumThr = 1;
00298 } else {
00299 return 0;
00300 }
00301 }
00302
00303 if (getValByKey (condInput, NO_PARA_OP_KW) != NULL) {
00304
00305 return (1);
00306 }
00307
00308 #ifndef PARA_OPR
00309 return (1);
00310 #endif
00311
00312 memset (&doinp, 0, sizeof (doinp));
00313 doinp.numThreads = inpNumThr;
00314
00315 doinp.dataSize = dataSize;
00316
00317 initReiWithDataObjInp (&rei, rsComm, &doinp);
00318
00319 if (destRescHier != NULL) {
00320 eirods::hierarchy_parser parser;
00321 parser.set_string( destRescHier );
00322
00323 std::string last_resc;
00324 parser.last_resc( last_resc );
00325
00326
00327 rescGrpInfo = new rescGrpInfo_t;
00328 rescGrpInfo->rescInfo = new rescInfo_t;
00329
00330
00331
00332
00333 eirods::error err = eirods::get_resc_grp_info( last_resc.c_str(), *rescGrpInfo );
00334 if ( err.ok() ) {
00335 rei.rgi = rescGrpInfo;
00336 status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
00337
00338
00339 if (status < 0) {
00340 rodsLog (LOG_ERROR,
00341 "getNumThreads: acGetNumThreads error, status = %d",
00342 status);
00343 } else {
00344 numDestThr = rei.status;
00345 if (numDestThr == 0) {
00346 return 0;
00347 } else if (numDestThr == 1 && srcRescHier == NULL &&
00348 isLocalHost (rescGrpInfo->rescInfo->rescLoc)) {
00349
00350
00351 return 0;
00352 }
00353 }
00354 }
00355 }
00356
00357 if (destRescHier != NULL && srcRescHier != NULL) {
00358 if (numDestThr > 0 && strcmp (destRescHier, srcRescHier) == 0)
00359 return numDestThr;
00360
00361 eirods::hierarchy_parser parser;
00362 parser.set_string( srcRescHier );
00363
00364 std::string last_resc;
00365 parser.last_resc( last_resc );
00366
00367 rescGrpInfo = new rescGrpInfo_t;
00368 rescGrpInfo->rescInfo = new rescInfo_t;
00369
00370
00371 eirods::error err = eirods::get_resc_grp_info( last_resc.c_str(), *rescGrpInfo );
00372
00373
00374 if ( err.ok() ) {
00375 rei.rgi = rescGrpInfo;
00376 status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
00377
00378 if (status < 0) {
00379 rodsLog (LOG_ERROR,
00380 "getNumThreads: acGetNumThreads error, status = %d",
00381 status);
00382 } else {
00383 numSrcThr = rei.status;
00384 if (numSrcThr == 0) return 0;
00385 }
00386 }
00387 }
00388
00389 if (numDestThr > 0) {
00390 if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
00391 return 1;
00392 } else {
00393 return numDestThr;
00394 }
00395 }
00396 if (numSrcThr > 0) {
00397 if (getValByKey (condInput, RBUDP_TRANSFER_KW) != NULL) {
00398 return 1;
00399 } else {
00400 return numSrcThr;
00401 }
00402 }
00403
00404 rei.rgi = NULL;
00405 status = applyRule ("acSetNumThreads", NULL, &rei, NO_SAVE_REI);
00406 if (status < 0) {
00407 rodsLog (LOG_ERROR,
00408 "getNumThreads: acGetNumThreads error, status = %d",
00409 status);
00410 return 0;
00411 } else {
00412 if (rei.status > 0)
00413 return rei.status;
00414 else
00415 return 0;
00416 }
00417 }
00418
00419 int
00420 initDataOprInp (dataOprInp_t *dataOprInp, int l1descInx, int oprType)
00421 {
00422 dataObjInfo_t *dataObjInfo;
00423 dataObjInp_t *dataObjInp;
00424 #ifdef RBUDP_TRANSFER
00425 char *tmpStr;
00426 #endif
00427
00428
00429 dataObjInfo = L1desc[l1descInx].dataObjInfo;
00430 dataObjInp = L1desc[l1descInx].dataObjInp;
00431
00432 memset (dataOprInp, 0, sizeof (dataOprInp_t));
00433
00434 dataOprInp->oprType = oprType;
00435 dataOprInp->numThreads = dataObjInp->numThreads;
00436 dataOprInp->offset = dataObjInp->offset;
00437 if (oprType == PUT_OPR) {
00438 if (dataObjInp->dataSize > 0)
00439 dataOprInp->dataSize = dataObjInp->dataSize;
00440 dataOprInp->destL3descInx = L1desc[l1descInx].l3descInx;
00441 if (L1desc[l1descInx].remoteZoneHost == NULL)
00442 dataOprInp->destRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00443 } else if (oprType == GET_OPR) {
00444 if (dataObjInfo->dataSize > 0) {
00445 dataOprInp->dataSize = dataObjInfo->dataSize;
00446 } else {
00447 dataOprInp->dataSize = dataObjInp->dataSize;
00448 }
00449 dataOprInp->srcL3descInx = L1desc[l1descInx].l3descInx;
00450 if (L1desc[l1descInx].remoteZoneHost == NULL)
00451 dataOprInp->srcRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00452 } else if (oprType == SAME_HOST_COPY_OPR) {
00453 int srcL1descInx = L1desc[l1descInx].srcL1descInx;
00454 int srcL3descInx = L1desc[srcL1descInx].l3descInx;
00455 dataOprInp->dataSize = L1desc[srcL1descInx].dataObjInfo->dataSize;
00456 dataOprInp->destL3descInx = L1desc[l1descInx].l3descInx;
00457 if (L1desc[l1descInx].remoteZoneHost == NULL)
00458 dataOprInp->destRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00459 dataOprInp->srcL3descInx = srcL3descInx;
00460 dataOprInp->srcRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00461 } else if (oprType == COPY_TO_REM_OPR) {
00462 int srcL1descInx = L1desc[l1descInx].srcL1descInx;
00463 int srcL3descInx = L1desc[srcL1descInx].l3descInx;
00464 dataOprInp->dataSize = L1desc[srcL1descInx].dataObjInfo->dataSize;
00465 dataOprInp->srcL3descInx = srcL3descInx;
00466 if (L1desc[srcL1descInx].remoteZoneHost == NULL) {
00467 dataOprInp->srcRescTypeInx =
00468 L1desc[srcL1descInx].dataObjInfo->rescInfo->rescTypeInx;
00469 }
00470 #if 0
00471 if (dataObjInfo->dataSize > 0) {
00472 dataOprInp->dataSize = dataObjInfo->dataSize;
00473 } else {
00474 dataOprInp->dataSize = dataObjInp->dataSize;
00475 }
00476 dataOprInp->srcL3descInx = L1desc[l1descInx].l3descInx;
00477 if (L1desc[l1descInx].remoteZoneHost == NULL)
00478 dataOprInp->srcRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00479 #endif
00480 } else if (oprType == COPY_TO_LOCAL_OPR) {
00481 int srcL1descInx = L1desc[l1descInx].srcL1descInx;
00482 dataOprInp->dataSize = L1desc[srcL1descInx].dataObjInfo->dataSize;
00483 dataOprInp->destL3descInx = L1desc[l1descInx].l3descInx;
00484 if (L1desc[l1descInx].remoteZoneHost == NULL)
00485 dataOprInp->destRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00486 }
00487 #if 0
00488 if (oprType == PUT_OPR && dataObjInp->dataSize > 0) {
00489 dataOprInp->dataSize = dataObjInp->dataSize;
00490 } else if (dataObjInfo->dataSize > 0) {
00491 dataOprInp->dataSize = dataObjInfo->dataSize;
00492 } else {
00493 dataOprInp->dataSize = dataObjInp->dataSize;
00494 }
00495 if (oprType == PUT_OPR || oprType == COPY_TO_LOCAL_OPR ||
00496 oprType == SAME_HOST_COPY_OPR) {
00497 dataOprInp->destL3descInx = L1desc[l1descInx].l3descInx;
00498 if (L1desc[l1descInx].remoteZoneHost == NULL)
00499 dataOprInp->destRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00500 } else if (oprType == GET_OPR || COPY_TO_REM_OPR) {
00501 dataOprInp->srcL3descInx = L1desc[l1descInx].l3descInx;
00502 if (L1desc[l1descInx].remoteZoneHost == NULL)
00503 dataOprInp->srcRescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00504 }
00505 #endif
00506 if (getValByKey (&dataObjInp->condInput, STREAMING_KW) != NULL) {
00507 addKeyVal (&dataOprInp->condInput, STREAMING_KW, "");
00508 }
00509
00510 if (getValByKey (&dataObjInp->condInput, NO_PARA_OP_KW) != NULL) {
00511 addKeyVal (&dataOprInp->condInput, NO_PARA_OP_KW, "");
00512 }
00513
00514 #ifdef RBUDP_TRANSFER
00515 if (getValByKey (&dataObjInp->condInput, RBUDP_TRANSFER_KW) != NULL) {
00516 if (dataObjInfo->rescInfo != NULL) {
00517
00518
00519
00520 std::string type;
00521 eirods::error err = eirods::get_resource_property< std::string >( dataObjInfo->rescInfo->rescName, "type", type );
00522 if( !err.ok() ) {
00523 eirods::log( PASS( err ) );
00524 } else {
00525 if( "unix file system" == type ) {
00526 addKeyVal (&dataOprInp->condInput, RBUDP_TRANSFER_KW, "");
00527 }
00528 }
00529 }
00530 }
00531
00532 if (getValByKey (&dataObjInp->condInput, VERY_VERBOSE_KW) != NULL) {
00533 addKeyVal (&dataOprInp->condInput, VERY_VERBOSE_KW, "");
00534 }
00535
00536 if ((tmpStr = getValByKey (&dataObjInp->condInput, RBUDP_SEND_RATE_KW)) !=
00537 NULL) {
00538 addKeyVal (&dataOprInp->condInput, RBUDP_SEND_RATE_KW, tmpStr);
00539 }
00540
00541 if ((tmpStr = getValByKey (&dataObjInp->condInput, RBUDP_PACK_SIZE_KW)) !=
00542 NULL) {
00543 addKeyVal (&dataOprInp->condInput, RBUDP_PACK_SIZE_KW, tmpStr);
00544 }
00545 #endif
00546
00547
00548 return (0);
00549 }
00550
00551 int
00552 initDataObjInfoForRepl (
00553 rsComm_t *rsComm,
00554 dataObjInfo_t *destDataObjInfo,
00555 dataObjInfo_t *srcDataObjInfo,
00556 rescInfo_t *destRescInfo,
00557 char *destRescGroupName)
00558 {
00559 memset (destDataObjInfo, 0, sizeof (dataObjInfo_t));
00560 *destDataObjInfo = *srcDataObjInfo;
00561 destDataObjInfo->filePath[0] = '\0';
00562 rstrcpy (destDataObjInfo->rescName, destRescInfo->rescName, NAME_LEN);
00563
00564
00565 rstrcpy (destDataObjInfo->rescHier, destRescInfo->rescName, MAX_NAME_LEN);
00566
00567
00568 destDataObjInfo->replNum = destDataObjInfo->dataId = 0;
00569 destDataObjInfo->rescInfo = destRescInfo;
00570 if (destRescGroupName != NULL && strlen (destRescGroupName) > 0) {
00571 rstrcpy (destDataObjInfo->rescGroupName, destRescGroupName,
00572 NAME_LEN);
00573 } else if (strlen (destDataObjInfo->rescGroupName) > 0) {
00574
00575
00576 rodsLog( LOG_NOTICE, "JMC - initDataObjInfoForRepl destDataObjInfo->rescGroupName > 0" );
00577
00578
00579
00580
00581 destDataObjInfo->rescGroupName[0] = '\0';
00582
00583 }
00584
00585 return (0);
00586 }
00587
00588 int
00589 convL3descInx (int l3descInx)
00590 {
00591 if (l3descInx <= 2 || FileDesc[l3descInx].inuseFlag == 0 ||
00592 FileDesc[l3descInx].rodsServerHost == NULL) {
00593 return l3descInx;
00594 }
00595
00596 if (FileDesc[l3descInx].rodsServerHost->localFlag == LOCAL_HOST) {
00597 return (l3descInx);
00598 } else {
00599 return (FileDesc[l3descInx].fd);
00600 }
00601 }
00602
00603 int
00604 initCollHandle ()
00605 {
00606 memset (CollHandle, 0, sizeof (collHandle_t) * NUM_COLL_HANDLE);
00607 return (0);
00608 }
00609
00610 int
00611 allocCollHandle ()
00612 {
00613 int i;
00614
00615 for (i = 0; i < NUM_COLL_HANDLE; i++) {
00616 if (CollHandle[i].inuseFlag <= FD_FREE) {
00617 CollHandle[i].inuseFlag = FD_INUSE;
00618 return (i);
00619 };
00620 }
00621
00622 rodsLog (LOG_NOTICE,
00623 "allocCollHandle: out of CollHandle");
00624
00625 return (SYS_OUT_OF_FILE_DESC);
00626 }
00627
00628 int
00629 freeCollHandle (int handleInx)
00630 {
00631 if (handleInx < 0 || handleInx >= NUM_COLL_HANDLE) {
00632 rodsLog (LOG_NOTICE,
00633 "freeCollHandle: handleInx %d out of range", handleInx);
00634 return (SYS_FILE_DESC_OUT_OF_RANGE);
00635 }
00636
00637
00638 #if 0
00639 clearCollHandle (&CollHandle[handleInx], 0);
00640 #else
00641 clearCollHandle (&CollHandle[handleInx], 1);
00642 #endif
00643 memset (&CollHandle[handleInx], 0, sizeof (collHandle_t));
00644
00645 return (0);
00646 }
00647
00648 int
00649 rsInitQueryHandle (queryHandle_t *queryHandle, rsComm_t *rsComm)
00650 {
00651 if (queryHandle == NULL || rsComm == NULL) {
00652 return (USER__NULL_INPUT_ERR);
00653 }
00654
00655 queryHandle->conn = rsComm;
00656 queryHandle->connType = RS_COMM;
00657 queryHandle->querySpecColl = (funcPtr) rsQuerySpecColl;
00658 queryHandle->genQuery = (funcPtr) rsGenQuery;
00659
00660 return (0);
00661 }
00662
00663 int
00664 allocAndSetL1descForZoneOpr (int remoteL1descInx, dataObjInp_t *dataObjInp,
00665 rodsServerHost_t *remoteZoneHost, openStat_t *openStat)
00666 {
00667 int l1descInx;
00668 dataObjInfo_t *dataObjInfo;
00669
00670 l1descInx = allocL1desc ();
00671 if (l1descInx < 0) return l1descInx;
00672 L1desc[l1descInx].remoteL1descInx = remoteL1descInx;
00673 L1desc[l1descInx].oprType = REMOTE_ZONE_OPR;
00674 L1desc[l1descInx].remoteZoneHost = remoteZoneHost;
00675 #if 0
00676 L1desc[l1descInx].dataObjInp = dataObjInp;
00677 #else
00678
00679 L1desc[l1descInx].dataObjInp = (dataObjInp_t*)malloc (sizeof (dataObjInp_t));
00680 replDataObjInp (dataObjInp, L1desc[l1descInx].dataObjInp);
00681 L1desc[l1descInx].dataObjInpReplFlag = 1;
00682 #endif
00683 dataObjInfo = L1desc[l1descInx].dataObjInfo =
00684 (dataObjInfo_t*)malloc (sizeof (dataObjInfo_t));
00685 bzero (dataObjInfo, sizeof (dataObjInfo_t));
00686 rstrcpy (dataObjInfo->objPath, dataObjInp->objPath, MAX_NAME_LEN);
00687
00688 if (openStat != NULL) {
00689 dataObjInfo->dataSize = openStat->dataSize;
00690 rstrcpy (dataObjInfo->dataMode, openStat->dataMode, SHORT_STR_LEN);
00691 rstrcpy (dataObjInfo->dataType, openStat->dataType, NAME_LEN);
00692 L1desc[l1descInx].l3descInx = openStat->l3descInx;
00693 L1desc[l1descInx].replStatus = openStat->replStatus;
00694 dataObjInfo->rescInfo = (rescInfo_t*)malloc (sizeof (rescInfo_t));
00695 bzero (dataObjInfo->rescInfo, sizeof (rescInfo_t));
00696 dataObjInfo->rescInfo->rescTypeInx = openStat->rescTypeInx;
00697 }
00698
00699 return l1descInx;
00700 }
00701