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