00001
00002
00003
00004
00005
00006 #include "dataObjGet.h"
00007 #include "rodsLog.h"
00008 #include "dataGet.h"
00009 #include "fileGet.h"
00010 #include "dataObjOpen.h"
00011 #include "rsGlobalExtern.h"
00012 #include "rcGlobalExtern.h"
00013 #include "rsApiHandler.h"
00014 #include "objMetaOpr.h"
00015 #include "physPath.h"
00016 #include "specColl.h"
00017 #include "subStructFileGet.h"
00018 #include "getRemoteZoneResc.h"
00019
00020 int
00021 rsDataObjGet (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00022 portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf)
00023 {
00024 int status;
00025 int remoteFlag;
00026 rodsServerHost_t *rodsServerHost;
00027 specCollCache_t *specCollCache = NULL;
00028
00029 resolveLinkedPath (rsComm, dataObjInp->objPath, &specCollCache,
00030 &dataObjInp->condInput);
00031 remoteFlag = getAndConnRemoteZone (rsComm, dataObjInp, &rodsServerHost,
00032 REMOTE_OPEN);
00033
00034 if (remoteFlag < 0) {
00035 return (remoteFlag);
00036 } else if (remoteFlag == LOCAL_HOST) {
00037 status = _rsDataObjGet (rsComm, dataObjInp, portalOprOut,
00038 dataObjOutBBuf, BRANCH_MSG);
00039 } else {
00040 int l1descInx;
00041 status = _rcDataObjGet (rodsServerHost->conn, dataObjInp, portalOprOut,
00042 dataObjOutBBuf);
00043
00044 if (status < 0) {
00045 return (status);
00046 }
00047 if (status == 0 ||
00048 (dataObjOutBBuf != NULL && dataObjOutBBuf->len > 0)) {
00049
00050 return status;
00051 } else {
00052
00053
00054
00055
00056 l1descInx = allocAndSetL1descForZoneOpr (
00057 (*portalOprOut)->l1descInx, dataObjInp, rodsServerHost, NULL);
00058 if (l1descInx < 0) return l1descInx;
00059 (*portalOprOut)->l1descInx = l1descInx;
00060 return status;
00061 }
00062 }
00063
00064 return (status);
00065 }
00066
00067 int
00068 _rsDataObjGet (rsComm_t *rsComm, dataObjInp_t *dataObjInp,
00069 portalOprOut_t **portalOprOut, bytesBuf_t *dataObjOutBBuf, int handlerFlag)
00070 {
00071 int status;
00072 dataObjInfo_t *dataObjInfo;
00073 int l1descInx;
00074 char *chksumStr = NULL;
00075 int retval;
00076 openedDataObjInp_t dataObjCloseInp;
00077
00078
00079
00080 addKeyVal (&dataObjInp->condInput, PHYOPEN_BY_SIZE_KW, "");
00081 l1descInx = _rsDataObjOpen (rsComm, dataObjInp);
00082
00083 if (l1descInx < 0)
00084 return l1descInx;
00085
00086 L1desc[l1descInx].oprType = GET_OPR;
00087
00088 dataObjInfo = L1desc[l1descInx].dataObjInfo;
00089
00090 if (getStructFileType (dataObjInfo->specColl) >= 0 &&
00091 L1desc[l1descInx].l3descInx > 0) {
00092
00093 *portalOprOut = (portalOprOut_t *) malloc (sizeof (portalOprOut_t));
00094 bzero (*portalOprOut, sizeof (portalOprOut_t));
00095 (*portalOprOut)->l1descInx = l1descInx;
00096 return l1descInx;
00097 }
00098
00099 if (getValByKey (&dataObjInp->condInput, VERIFY_CHKSUM_KW) != NULL) {
00100 if (strlen (dataObjInfo->chksum) > 0) {
00101
00102 chksumStr = strdup (dataObjInfo->chksum);
00103 } else {
00104
00105 status = dataObjChksumAndReg (rsComm, dataObjInfo, &chksumStr);
00106 if (status < 0) {
00107 return status;
00108 }
00109 rstrcpy (dataObjInfo->chksum, chksumStr, NAME_LEN);
00110 }
00111 }
00112
00113 if (L1desc[l1descInx].l3descInx <= 2) {
00114
00115 status = l3DataGetSingleBuf (rsComm, l1descInx, dataObjOutBBuf,
00116 portalOprOut);
00117 if (status >= 0) {
00118 int status2;
00119
00120
00121 status2 = applyRuleForPostProcForRead(rsComm, dataObjOutBBuf,
00122 dataObjInp->objPath);
00123 if (status2 >= 0) {
00124 status = 0;
00125 } else {
00126 status = status2;
00127 }
00128
00129
00130 if (chksumStr != NULL) {
00131 rstrcpy ((*portalOprOut)->chksum, chksumStr, NAME_LEN);
00132 free (chksumStr);
00133 }
00134 }
00135 return (status);
00136 }
00137
00138
00139 status = preProcParaGet (rsComm, l1descInx, portalOprOut);
00140
00141 if (status < 0) {
00142 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
00143 dataObjCloseInp.l1descInx = l1descInx;
00144 rsDataObjClose (rsComm, &dataObjCloseInp);
00145 if (chksumStr != NULL) {
00146 free (chksumStr);
00147 }
00148 return (status);
00149 }
00150
00151 status = l1descInx;
00152 if (chksumStr != NULL) {
00153 rstrcpy ((*portalOprOut)->chksum, chksumStr, NAME_LEN);
00154 free (chksumStr);
00155 }
00156
00157
00158
00159 retval = sendAndRecvBranchMsg (rsComm, rsComm->apiInx, status,
00160 (void *) *portalOprOut, dataObjOutBBuf);
00161
00162 if (retval < 0) {
00163 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
00164 dataObjCloseInp.l1descInx = l1descInx;
00165 rsDataObjClose (rsComm, &dataObjCloseInp);
00166 }
00167
00168 if (handlerFlag & INTERNAL_SVR_CALL) {
00169
00170 return (retval);
00171 } else {
00172
00173 return (SYS_NO_HANDLER_REPLY_MSG);
00174 }
00175 }
00176
00177
00178
00179
00180 int
00181 preProcParaGet (rsComm_t *rsComm, int l1descInx, portalOprOut_t **portalOprOut)
00182 {
00183 int l3descInx;
00184 int status;
00185 dataOprInp_t dataOprInp;
00186
00187 l3descInx = L1desc[l1descInx].l3descInx;
00188
00189 initDataOprInp (&dataOprInp, l1descInx, GET_OPR);
00190
00191 if (L1desc[l1descInx].dataObjInfo != NULL &&
00192 L1desc[l1descInx].dataObjInfo->rescInfo != NULL) {
00193 addKeyVal (&dataOprInp.condInput, RESC_NAME_KW,
00194 L1desc[l1descInx].dataObjInfo->rescInfo->rescName);
00195 }
00196 if (L1desc[l1descInx].remoteZoneHost != NULL) {
00197 status = remoteDataGet (rsComm, &dataOprInp, portalOprOut,
00198 L1desc[l1descInx].remoteZoneHost);
00199 } else {
00200 status = rsDataGet (rsComm, &dataOprInp, portalOprOut);
00201 }
00202
00203 if (status >= 0) {
00204 (*portalOprOut)->l1descInx = l1descInx;
00205 }
00206 clearKeyVal (&dataOprInp.condInput);
00207 return (status);
00208 }
00209
00210 int
00211 l3DataGetSingleBuf (rsComm_t *rsComm, int l1descInx,
00212 bytesBuf_t *dataObjOutBBuf, portalOprOut_t **portalOprOut)
00213 {
00214 int status = 0;
00215 int bytesRead;
00216 openedDataObjInp_t dataObjCloseInp;
00217 dataObjInfo_t *dataObjInfo;
00218
00219
00220
00221 *portalOprOut = (portalOprOut_t*)malloc (sizeof (portalOprOut_t));
00222 memset (*portalOprOut, 0, sizeof (portalOprOut_t));
00223
00224 dataObjInfo = L1desc[l1descInx].dataObjInfo;
00225
00226 if (dataObjInfo->dataSize > 0) {
00227 dataObjOutBBuf->buf = malloc (dataObjInfo->dataSize);
00228 bytesRead = l3FileGetSingleBuf (rsComm, l1descInx, dataObjOutBBuf);
00229 } else {
00230 bytesRead = 0;
00231 }
00232
00233 #if 0
00234 if (bytesRead != dataObjInfo->dataSize) {
00235 free (dataObjOutBBuf->buf);
00236 memset (dataObjOutBBuf, 0, sizeof (bytesBuf_t));
00237 if (bytesRead >= 0) {
00238 rodsLog (LOG_NOTICE,
00239 "l3DataGetSingleBuf:Bytes toread %d don't match read %d",
00240 dataObjInfo->dataSize, bytesRead);
00241 bytesRead = SYS_COPY_LEN_ERR - errno;
00242 }
00243 }
00244 #endif
00245
00246 memset (&dataObjCloseInp, 0, sizeof (dataObjCloseInp));
00247 dataObjCloseInp.l1descInx = l1descInx;
00248 status = rsDataObjClose (rsComm, &dataObjCloseInp);
00249 if (status < 0) {
00250 rodsLog (LOG_NOTICE,
00251 "l3DataGetSingleBuf: rsDataObjClose of %d error, status = %d",
00252 l1descInx, status);
00253 }
00254
00255 if (bytesRead < 0)
00256 return (bytesRead);
00257 else
00258 return status;
00259 }
00260
00261
00262
00263
00264
00265
00266 int
00267 l3FileGetSingleBuf (rsComm_t *rsComm, int l1descInx,
00268 bytesBuf_t *dataObjOutBBuf)
00269 {
00270 dataObjInfo_t *dataObjInfo;
00271 int rescTypeInx;
00272 fileOpenInp_t fileGetInp;
00273 int bytesRead;
00274 dataObjInp_t *dataObjInp;
00275
00276 dataObjInfo = L1desc[l1descInx].dataObjInfo;
00277
00278
00279 if (getStructFileType (dataObjInfo->specColl) >= 0) {
00280 subFile_t subFile;
00281 memset (&subFile, 0, sizeof (subFile));
00282 rstrcpy (subFile.subFilePath, dataObjInfo->subPath,
00283 MAX_NAME_LEN);
00284 rstrcpy (subFile.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
00285 NAME_LEN);
00286 subFile.specColl = dataObjInfo->specColl;
00287 subFile.mode = getFileMode (L1desc[l1descInx].dataObjInp);
00288 subFile.flags = O_RDONLY;
00289 subFile.offset = dataObjInfo->dataSize;
00290 bytesRead = rsSubStructFileGet (rsComm, &subFile, dataObjOutBBuf);
00291 return (bytesRead);
00292 }
00293
00294 rescTypeInx = dataObjInfo->rescInfo->rescTypeInx;
00295
00296 switch (RescTypeDef[rescTypeInx].rescCat) {
00297 case FILE_CAT:
00298 memset (&fileGetInp, 0, sizeof (fileGetInp));
00299 dataObjInp = L1desc[l1descInx].dataObjInp;
00300 fileGetInp.fileType = (fileDriverType_t)RescTypeDef[rescTypeInx].driverType;
00301 rstrcpy (fileGetInp.addr.hostAddr, dataObjInfo->rescInfo->rescLoc,
00302 NAME_LEN);
00303 rstrcpy (fileGetInp.fileName, dataObjInfo->filePath, MAX_NAME_LEN);
00304 fileGetInp.mode = getFileMode (dataObjInp);
00305 fileGetInp.flags = O_RDONLY;
00306 fileGetInp.dataSize = dataObjInfo->dataSize;
00307
00308 bytesRead = rsFileGet (rsComm, &fileGetInp, dataObjOutBBuf);
00309 break;
00310 default:
00311 rodsLog (LOG_NOTICE,
00312 "l3Open: rescCat type %d is not recognized",
00313 RescTypeDef[rescTypeInx].rescCat);
00314 bytesRead = SYS_INVALID_RESC_TYPE;
00315 break;
00316 }
00317 return (bytesRead);
00318 }
00319