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