00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "rodsClient.h"
00016 #include "msoDriversMS.h"
00017 #include <strings.h>
00018
00019 int
00020 connectToRemoteiRODS(char * inStr, rcComm_t **rcComm)
00021 {
00022 int i, port;
00023 rErrMsg_t errMsg;
00024 char *t, *s;
00025 char *host = NULL;
00026 char *user = NULL;
00027 char *zone = NULL;
00028 char *pass = NULL;
00029 char *str;
00030
00031
00032
00033
00034
00035
00036 str = strdup(inStr);
00037 if ((t = strstr(str, "/")) == NULL){
00038 free(str);
00039 return(USER_INPUT_FORMAT_ERR);
00040 }
00041 else
00042 *t = '\0';
00043 if ((t = strstr(str, ":")) == NULL) {
00044 free(str);
00045 return(USER_INPUT_FORMAT_ERR);
00046 }
00047 s = t+1;
00048 port = -1;
00049 host = s;
00050 while ((t = strstr(s, ":")) != NULL) {
00051 *t = '\0';
00052 s = t+1;
00053 if (port == -1 && user == NULL && isdigit(*s))
00054 port = atoi(s);
00055 else if (user == NULL)
00056 user = s;
00057 else if (pass == NULL){
00058 pass = s;
00059 break;
00060 }
00061 }
00062
00063
00064 if (user == NULL)
00065 strcpy(user, ANONYMOUS_USER);
00066 if ((t = strstr(user, "@")) != NULL) {
00067 *t = '\0';
00068 zone = t+1;
00069 }
00070 if (port == -1)
00071 port = 1247;
00072 if (pass != NULL) {
00073
00074 t++;
00075 }
00076
00077 printf("MM: host=%s,port=%i,user=%s\n",host, port, user);
00078
00079 *rcComm = rcConnect (host, port, user, zone, 0, &errMsg);
00080 if (*rcComm == NULL) {
00081 free( str );
00082 return(REMOTE_IRODS_CONNECT_ERR);
00083 }
00084 i = clientLogin(*rcComm);
00085 if (i != 0) {
00086 rcDisconnect(*rcComm);
00087 }
00088 free( str );
00089 return(i);
00090
00091
00092 }
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131 int
00132 msiobjget_irods(msParam_t* inRequestPath, msParam_t* inFileMode,
00133 msParam_t* inFileFlags, msParam_t* inCacheFilename,
00134 ruleExecInfo_t* rei )
00135 {
00136
00137 char *locStr;
00138 int mode, flags;
00139 char *cacheFilename;
00140 char *str, *t;
00141 int status, bytesRead, bytesWritten;
00142 int destFd, i;
00143 rsComm_t *rsComm;
00144 rcComm_t *rcComm = NULL;
00145
00146 dataObjInp_t dataObjInp;
00147 int objFD;
00148 openedDataObjInp_t dataObjReadInp;
00149 openedDataObjInp_t dataObjCloseInp;
00150 bytesBuf_t readBuf;
00151
00152
00153
00154 RE_TEST_MACRO( " Calling msiobjget_irods" );
00155
00156
00157 if (inRequestPath == NULL ||
00158 strcmp(inRequestPath->type , STR_MS_T) != 0 ||
00159 inRequestPath->inOutStruct == NULL)
00160 return(USER_PARAM_TYPE_ERR);
00161
00162 if (inFileMode == NULL ||
00163 strcmp(inFileMode->type , STR_MS_T) != 0 ||
00164 inFileMode->inOutStruct == NULL)
00165 return(USER_PARAM_TYPE_ERR);
00166
00167 if (inFileFlags == NULL ||
00168 strcmp(inFileFlags->type , STR_MS_T) != 0 ||
00169 inFileFlags->inOutStruct == NULL)
00170 return(USER_PARAM_TYPE_ERR);
00171
00172 if (inCacheFilename == NULL ||
00173 strcmp(inCacheFilename->type , STR_MS_T) != 0 ||
00174 inCacheFilename->inOutStruct == NULL)
00175 return(USER_PARAM_TYPE_ERR);
00176
00177
00178 str = strdup((char *) inRequestPath->inOutStruct);
00179 if ((t = strstr(str, ":")) != NULL) {
00180 locStr = t+1;
00181 if ((t = strstr(locStr,"/"))!= NULL)
00182 locStr = t;
00183 else {
00184 free(str);
00185 return(USER_INPUT_FORMAT_ERR);
00186 }
00187 }
00188
00189 else {
00190 free(str);
00191 return(USER_INPUT_FORMAT_ERR);
00192 }
00193
00194
00195 cacheFilename = (char *) inCacheFilename->inOutStruct;
00196 mode = atoi((char *) inFileMode->inOutStruct);
00197 flags = atoi((char *) inFileFlags->inOutStruct);
00198 rsComm = rei->rsComm;
00199
00200
00201
00202 i = connectToRemoteiRODS((char *) inRequestPath->inOutStruct, &rcComm);
00203 if (i < 0) {
00204 printf("msiputobj_irods: error connecting to remote iRODS: %s:%i\n",
00205 (char *) inRequestPath->inOutStruct,i);
00206 free(str);
00207 return(i);
00208 }
00209
00210
00211 bzero (&dataObjInp, sizeof (dataObjInp));
00212 bzero (&dataObjReadInp, sizeof (dataObjReadInp));
00213 bzero (&dataObjCloseInp, sizeof (dataObjCloseInp));
00214 bzero (&readBuf, sizeof (readBuf));
00215
00216 dataObjInp.openFlags = O_RDONLY;
00217 rstrcpy(dataObjInp.objPath, locStr, MAX_NAME_LEN);
00218 free(str);
00219
00220 objFD = rcDataObjOpen (rcComm, &dataObjInp);
00221 if (objFD < 0) {
00222 printf("msigetobj_irods: Unable to open file %s:%i\n", dataObjInp.objPath,objFD);
00223 rcDisconnect(rcComm);
00224 return(objFD);
00225 }
00226
00227 destFd = open (cacheFilename, O_WRONLY | O_CREAT | O_TRUNC, mode);
00228 if (destFd < 0) {
00229 status = UNIX_FILE_OPEN_ERR - errno;
00230 printf (
00231 "msigetobj_irods: open error for cacheFilename %s, status = %d",
00232 cacheFilename, status);
00233 rcDisconnect(rcComm);
00234 return status;
00235 }
00236
00237 dataObjReadInp.l1descInx = objFD;
00238 dataObjCloseInp.l1descInx = objFD;
00239
00240 readBuf.len = MAX_SZ_FOR_SINGLE_BUF;
00241 readBuf.buf = (char *)malloc(readBuf.len);
00242 dataObjReadInp.len = readBuf.len;
00243
00244 while ((bytesRead = rcDataObjRead (rcComm, &dataObjReadInp, &readBuf)) > 0) {
00245 bytesWritten = write (destFd, readBuf.buf, bytesRead);
00246 if (bytesWritten != bytesRead ) {
00247 free(readBuf.buf);
00248 close (destFd);
00249 rcDataObjClose (rcComm, &dataObjCloseInp);
00250 rcDisconnect(rcComm);
00251 printf(
00252 "msigetobj_irods: In Cache File %s bytesWritten %d != returned objLen %i\n",
00253 cacheFilename, bytesWritten, bytesRead);
00254 return SYS_COPY_LEN_ERR;
00255 }
00256 }
00257 free(readBuf.buf);
00258 close (destFd);
00259 i = rcDataObjClose (rcComm, &dataObjCloseInp);
00260 rcDisconnect(rcComm);
00261 return(i);
00262
00263 }
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300
00301
00302
00303
00304
00305 int
00306 msiobjput_irods(msParam_t* inMSOPath, msParam_t* inCacheFilename,
00307 msParam_t* inFileSize, ruleExecInfo_t* rei )
00308 {
00309
00310 char *reqStr;
00311 char *str, *t;
00312 char *cacheFilename;
00313 rodsLong_t dataSize;
00314 int status, i;
00315 int srcFd;
00316 char *myBuf;
00317 int bytesRead;
00318 openedDataObjInp_t dataObjWriteInp;
00319 int bytesWritten;
00320 openedDataObjInp_t dataObjCloseInp;
00321 dataObjInp_t dataObjInp;
00322 int outDesc;
00323 bytesBuf_t writeBuf;
00324 int writeBufLen;
00325 rsComm_t *rsComm;
00326 rcComm_t *rcComm = NULL;
00327
00328
00329 RE_TEST_MACRO( " Calling msiobjput_irods" );
00330
00331
00332 if (inMSOPath == NULL ||
00333 strcmp(inMSOPath->type , STR_MS_T) != 0 ||
00334 inMSOPath->inOutStruct == NULL)
00335 return(USER_PARAM_TYPE_ERR);
00336
00337 if (inCacheFilename == NULL ||
00338 strcmp(inCacheFilename->type , STR_MS_T) != 0 ||
00339 inCacheFilename->inOutStruct == NULL)
00340 return(USER_PARAM_TYPE_ERR);
00341
00342 if (inFileSize == NULL ||
00343 strcmp(inFileSize->type , STR_MS_T) != 0 ||
00344 inFileSize->inOutStruct == NULL)
00345 return(USER_PARAM_TYPE_ERR);
00346
00347
00348
00349 str = strdup((char *) inMSOPath->inOutStruct);
00350 if ((t = strstr(str, ":")) != NULL) {
00351 reqStr = t+1;
00352 if ((t = strstr(reqStr,"/"))!= NULL)
00353 reqStr = t;
00354 else {
00355 free(str);
00356 return(USER_INPUT_FORMAT_ERR);
00357 }
00358 }
00359 else {
00360 free(str);
00361 return(USER_INPUT_FORMAT_ERR);
00362 }
00363
00364 cacheFilename = (char *) inCacheFilename->inOutStruct;
00365 dataSize = atol((char *) inFileSize->inOutStruct);
00366 rsComm = rei->rsComm;
00367
00368 i = connectToRemoteiRODS((char *) inMSOPath->inOutStruct, &rcComm);
00369 if (i < 0) {
00370 printf("msiputobj_irods: error connecting to remote iRODS: %s:%i\n",
00371 (char *) inMSOPath->inOutStruct,i);
00372 free(str);
00373 return(i);
00374 }
00375
00376
00377 srcFd = open (cacheFilename, O_RDONLY, 0);
00378 if (srcFd < 0) {
00379 status = UNIX_FILE_OPEN_ERR - errno;
00380 printf ("msiputobj_irods: open error for %s, status = %d\n",
00381 cacheFilename, status);
00382 free(str);
00383 rcDisconnect(rcComm);
00384 return status;
00385 }
00386
00387 bzero (&dataObjInp, sizeof(dataObjInp_t));
00388 bzero(&dataObjWriteInp, sizeof (dataObjWriteInp));
00389 bzero(&dataObjCloseInp, sizeof (dataObjCloseInp));
00390
00391 rstrcpy(dataObjInp.objPath, reqStr, MAX_NAME_LEN);
00392 addKeyVal (&dataObjInp.condInput, FORCE_FLAG_KW, "");
00393 free(str);
00394
00395 outDesc = rcDataObjCreate (rcComm, &dataObjInp);
00396 if (outDesc < 0) {
00397 printf ("msiputobj_irods: Unable to open file %s:%i\n", dataObjInp.objPath,outDesc);
00398 rcDisconnect(rcComm);
00399 close(srcFd);
00400 return(outDesc);
00401 }
00402
00403 dataObjWriteInp.l1descInx = outDesc;
00404 dataObjCloseInp.l1descInx = outDesc;
00405
00406 if (dataSize > MAX_SZ_FOR_SINGLE_BUF)
00407 writeBufLen = MAX_SZ_FOR_SINGLE_BUF;
00408 else
00409 writeBufLen = dataSize;
00410
00411 myBuf = (char *) malloc (writeBufLen);
00412 writeBuf.buf = myBuf;
00413
00414 while ( (bytesRead = read(srcFd, (void *) myBuf, writeBufLen)) > 0) {
00415 writeBuf.len = bytesRead;
00416 dataObjWriteInp.len = bytesRead;
00417 bytesWritten = rcDataObjWrite(rcComm, &dataObjWriteInp, &writeBuf);
00418 if (bytesWritten != bytesRead) {
00419 free(myBuf);
00420 close (srcFd);
00421 rcDataObjClose (rcComm, &dataObjCloseInp);
00422 rcDisconnect(rcComm);
00423 printf ("msiputobj_irods: Write Error: bytesRead %d != bytesWritten %d\n",
00424 bytesRead, bytesWritten);
00425 return SYS_COPY_LEN_ERR;
00426 }
00427 }
00428 free(myBuf);
00429 close (srcFd);
00430 i = rcDataObjClose (rcComm, &dataObjCloseInp);
00431 rcDisconnect(rcComm);
00432
00433 return(i);
00434 }
00435