00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014 #include "msoDriversMS.h"
00015 #include <strings.h>
00016
00017 extern int rsDataObjWrite (rsComm_t *rsComm,
00018 openedDataObjInp_t *dataObjWriteInp,
00019 bytesBuf_t *dataObjWriteInpBBuf);
00020 extern int rsDataObjRead (rsComm_t *rsComm,
00021 openedDataObjInp_t *dataObjReadInp,
00022 bytesBuf_t *dataObjReadOutBBuf);
00023 extern int rsDataObjOpen (rsComm_t *rsComm, dataObjInp_t *dataObjInp);
00024 extern int rsDataObjClose (rsComm_t *rsComm, openedDataObjInp_t *dataObjCloseInp);
00025 extern int rsDataObjCreate (rsComm_t *rsComm, dataObjInp_t *dataObjInp);
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065 int
00066 msiobjget_slink(msParam_t* inRequestPath, msParam_t* inFileMode,
00067 msParam_t* inFileFlags, msParam_t* inCacheFilename,
00068 ruleExecInfo_t* rei )
00069 {
00070
00071 char *locStr;
00072 int mode, flags;
00073 char *cacheFilename;
00074 char *str, *t;
00075 int status, bytesRead, bytesWritten;
00076 int destFd, i;
00077 rsComm_t *rsComm;
00078
00079 dataObjInp_t dataObjInp;
00080 int objFD;
00081 openedDataObjInp_t dataObjReadInp;
00082 openedDataObjInp_t dataObjCloseInp;
00083 bytesBuf_t readBuf;
00084
00085
00086 RE_TEST_MACRO( " Calling msiobjget_slink" );
00087
00088
00089 if (inRequestPath == NULL ||
00090 strcmp(inRequestPath->type , STR_MS_T) != 0 ||
00091 inRequestPath->inOutStruct == NULL)
00092 return(USER_PARAM_TYPE_ERR);
00093
00094 if (inFileMode == NULL ||
00095 strcmp(inFileMode->type , STR_MS_T) != 0 ||
00096 inFileMode->inOutStruct == NULL)
00097 return(USER_PARAM_TYPE_ERR);
00098
00099 if (inFileFlags == NULL ||
00100 strcmp(inFileFlags->type , STR_MS_T) != 0 ||
00101 inFileFlags->inOutStruct == NULL)
00102 return(USER_PARAM_TYPE_ERR);
00103
00104 if (inCacheFilename == NULL ||
00105 strcmp(inCacheFilename->type , STR_MS_T) != 0 ||
00106 inCacheFilename->inOutStruct == NULL)
00107 return(USER_PARAM_TYPE_ERR);
00108
00109
00110 str = strdup((char *) inRequestPath->inOutStruct);
00111 if ((t = strstr(str, ":")) != NULL)
00112 locStr = t+1;
00113 else {
00114 free(str);
00115 return(USER_INPUT_FORMAT_ERR);
00116 }
00117
00118
00119 cacheFilename = (char *) inCacheFilename->inOutStruct;
00120 mode = atoi((char *) inFileMode->inOutStruct);
00121 flags = atoi((char *) inFileFlags->inOutStruct);
00122 rsComm = rei->rsComm;
00123
00124
00125 bzero (&dataObjInp, sizeof (dataObjInp));
00126 bzero (&dataObjReadInp, sizeof (dataObjReadInp));
00127 bzero (&dataObjCloseInp, sizeof (dataObjCloseInp));
00128 bzero (&readBuf, sizeof (readBuf));
00129
00130 dataObjInp.openFlags = O_RDONLY;
00131 rstrcpy(dataObjInp.objPath, locStr, MAX_NAME_LEN);
00132 free(str);
00133
00134 objFD = rsDataObjOpen (rsComm, &dataObjInp);
00135 if (objFD < 0) {
00136 printf("msigetobj_slink: Unable to open file %s:%i\n", dataObjInp.objPath,objFD);
00137 return(objFD);
00138 }
00139
00140 destFd = open (cacheFilename, O_WRONLY | O_CREAT | O_TRUNC, mode);
00141 if (destFd < 0) {
00142 status = UNIX_FILE_OPEN_ERR - errno;
00143 printf (
00144 "msigetobj_slink: open error for cacheFilename %s, status = %d",
00145 cacheFilename, status);
00146 return status;
00147 }
00148
00149 dataObjReadInp.l1descInx = objFD;
00150 dataObjCloseInp.l1descInx = objFD;
00151
00152 readBuf.len = MAX_SZ_FOR_SINGLE_BUF;
00153 readBuf.buf = (char *)malloc(readBuf.len);
00154 dataObjReadInp.len = readBuf.len;
00155
00156 while ((bytesRead = rsDataObjRead (rsComm, &dataObjReadInp, &readBuf)) > 0) {
00157 bytesWritten = write (destFd, readBuf.buf, bytesRead);
00158 if (bytesWritten != bytesRead ) {
00159 free(readBuf.buf);
00160 close (destFd);
00161 rsDataObjClose (rsComm, &dataObjCloseInp);
00162 printf(
00163 "msigetobj_slink: In Cache File %s bytesWritten %d != returned objLen %i\n",
00164 cacheFilename, bytesWritten, bytesRead);
00165 return SYS_COPY_LEN_ERR;
00166 }
00167 }
00168 free(readBuf.buf);
00169 close (destFd);
00170 i = rsDataObjClose (rsComm, &dataObjCloseInp);
00171
00172 return(i);
00173
00174 }
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216 int
00217 msiobjput_slink(msParam_t* inMSOPath, msParam_t* inCacheFilename,
00218 msParam_t* inFileSize, ruleExecInfo_t* rei )
00219 {
00220
00221 char *reqStr;
00222 char *str, *t;
00223 char *cacheFilename;
00224 rodsLong_t dataSize;
00225 int status, i;
00226 int srcFd;
00227 char *myBuf;
00228 int bytesRead;
00229 openedDataObjInp_t dataObjWriteInp;
00230 int bytesWritten;
00231 openedDataObjInp_t dataObjCloseInp;
00232 dataObjInp_t dataObjInp;
00233 int outDesc;
00234 bytesBuf_t writeBuf;
00235 int writeBufLen;
00236 rsComm_t *rsComm;
00237
00238 RE_TEST_MACRO( " Calling msiobjput_slink" );
00239
00240
00241 if (inMSOPath == NULL ||
00242 strcmp(inMSOPath->type , STR_MS_T) != 0 ||
00243 inMSOPath->inOutStruct == NULL)
00244 return(USER_PARAM_TYPE_ERR);
00245
00246 if (inCacheFilename == NULL ||
00247 strcmp(inCacheFilename->type , STR_MS_T) != 0 ||
00248 inCacheFilename->inOutStruct == NULL)
00249 return(USER_PARAM_TYPE_ERR);
00250
00251 if (inFileSize == NULL ||
00252 strcmp(inFileSize->type , STR_MS_T) != 0 ||
00253 inFileSize->inOutStruct == NULL)
00254 return(USER_PARAM_TYPE_ERR);
00255
00256
00257
00258 str = strdup((char *) inMSOPath->inOutStruct);
00259 if ((t = strstr(str, ":")) != NULL)
00260 reqStr = t+1;
00261 else {
00262 free(str);
00263 return(USER_INPUT_FORMAT_ERR);
00264 }
00265
00266 cacheFilename = (char *) inCacheFilename->inOutStruct;
00267 dataSize = atol((char *) inFileSize->inOutStruct);
00268 rsComm = rei->rsComm;
00269
00270
00271 srcFd = open (cacheFilename, O_RDONLY, 0);
00272 if (srcFd < 0) {
00273 status = UNIX_FILE_OPEN_ERR - errno;
00274 printf ("msiputobj_slink: open error for %s, status = %d\n",
00275 cacheFilename, status);
00276 free(str);
00277 return status;
00278 }
00279
00280 bzero (&dataObjInp, sizeof(dataObjInp_t));
00281 bzero(&dataObjWriteInp, sizeof (dataObjWriteInp));
00282 bzero(&dataObjCloseInp, sizeof (dataObjCloseInp));
00283
00284 rstrcpy(dataObjInp.objPath, reqStr, MAX_NAME_LEN);
00285 addKeyVal (&dataObjInp.condInput, FORCE_FLAG_KW, "");
00286 free(str);
00287
00288 outDesc = rsDataObjCreate (rsComm, &dataObjInp);
00289 if (outDesc < 0) {
00290 printf ("msiputobj_slink: Unable to open file %s:%i\n", dataObjInp.objPath,outDesc);
00291 close( srcFd );
00292 return(outDesc);
00293 }
00294
00295 dataObjWriteInp.l1descInx = outDesc;
00296 dataObjCloseInp.l1descInx = outDesc;
00297
00298 if (dataSize > MAX_SZ_FOR_SINGLE_BUF)
00299 writeBufLen = MAX_SZ_FOR_SINGLE_BUF;
00300 else
00301 writeBufLen = dataSize;
00302
00303 myBuf = (char *) malloc (writeBufLen);
00304 writeBuf.buf = myBuf;
00305
00306 while ( (bytesRead = read(srcFd, (void *) myBuf, writeBufLen)) > 0) {
00307 writeBuf.len = bytesRead;
00308 dataObjWriteInp.len = bytesRead;
00309 bytesWritten = rsDataObjWrite(rsComm, &dataObjWriteInp, &writeBuf);
00310 if (bytesWritten != bytesRead) {
00311 free(myBuf);
00312 close (srcFd);
00313 rsDataObjClose (rsComm, &dataObjCloseInp);
00314 printf ("msiputobj_slink: Write Error: bytesRead %d != bytesWritten %d\n",
00315 bytesRead, bytesWritten);
00316 return SYS_COPY_LEN_ERR;
00317 }
00318 }
00319 free(myBuf);
00320 close (srcFd);
00321 i = rsDataObjClose (rsComm, &dataObjCloseInp);
00322
00323 return(i);
00324 }
00325