00001
00002
00003
00004
00005
00006 #include "fileDriver.h"
00007 #include "fileDriverTable.h"
00008
00009 int
00010 fileCreate (fileDriverType_t myType, rsComm_t *rsComm, char *fileName,
00011 int mode, rodsLong_t mySize)
00012 {
00013 int fileInx;
00014 int fd;
00015
00016 if ((fileInx = fileIndexLookup (myType)) < 0) {
00017 return (fileInx);
00018 }
00019
00020 fd = FileDriverTable[fileInx].fileCreate (rsComm, fileName, mode, mySize);
00021 return (fd);
00022 }
00023
00024 int
00025 fileOpen (fileDriverType_t myType, rsComm_t *rsComm, char *fileName, int flags, int mode)
00026 {
00027 int fileInx;
00028 int fd;
00029
00030 if ((fileInx = fileIndexLookup (myType)) < 0) {
00031 return (fileInx);
00032 }
00033
00034 fd = FileDriverTable[fileInx].fileOpen (rsComm, fileName, flags, mode);
00035 return (fd);
00036 }
00037
00038 int
00039 fileRead (fileDriverType_t myType, rsComm_t *rsComm, int fd, void *buf,
00040 int len)
00041 {
00042 int fileInx;
00043 int status;
00044
00045 if ((fileInx = fileIndexLookup (myType)) < 0) {
00046 return (fileInx);
00047 }
00048
00049 status = FileDriverTable[fileInx].fileRead (rsComm, fd, buf, len);
00050 return (status);
00051 }
00052
00053 int
00054 fileWrite (fileDriverType_t myType, rsComm_t *rsComm, int fd, void *buf,
00055 int len)
00056 {
00057 int fileInx;
00058 int status;
00059
00060 if ((fileInx = fileIndexLookup (myType)) < 0) {
00061 return (fileInx);
00062 }
00063
00064 status = FileDriverTable[fileInx].fileWrite (rsComm, fd, buf, len);
00065 return (status);
00066 }
00067
00068 int
00069 fileClose (fileDriverType_t myType, rsComm_t *rsComm, int fd)
00070 {
00071 int fileInx;
00072 int status;
00073
00074 if ((fileInx = fileIndexLookup (myType)) < 0) {
00075 return (fileInx);
00076 }
00077
00078 status = FileDriverTable[fileInx].fileClose (rsComm, fd);
00079 return (status);
00080 }
00081
00082 int
00083 fileUnlink (fileDriverType_t myType, rsComm_t *rsComm, char *filename)
00084 {
00085 int fileInx;
00086 int status;
00087
00088 if ((fileInx = fileIndexLookup (myType)) < 0) {
00089 return (fileInx);
00090 }
00091
00092 status = FileDriverTable[fileInx].fileUnlink (rsComm, filename);
00093 return (status);
00094 }
00095
00096 int
00097 fileStat (fileDriverType_t myType, rsComm_t *rsComm, char *filename,
00098 struct stat *statbuf)
00099 {
00100 int fileInx;
00101 int status;
00102
00103 if ((fileInx = fileIndexLookup (myType)) < 0) {
00104 return (fileInx);
00105 }
00106
00107 status = FileDriverTable[fileInx].fileStat (rsComm, filename, statbuf);
00108 return (status);
00109 }
00110
00111 int
00112 fileFstat (fileDriverType_t myType, rsComm_t *rsComm, int fd,
00113 struct stat *statbuf)
00114 {
00115 int fileInx;
00116 int status;
00117
00118 if ((fileInx = fileIndexLookup (myType)) < 0) {
00119 return (fileInx);
00120 }
00121
00122 status = FileDriverTable[fileInx].fileFstat (rsComm, fd, statbuf);
00123 return (status);
00124 }
00125
00126 rodsLong_t
00127 fileLseek (fileDriverType_t myType, rsComm_t *rsComm, int fd,
00128 rodsLong_t offset, int whence)
00129 {
00130 int fileInx;
00131 rodsLong_t status;
00132
00133 if ((fileInx = fileIndexLookup (myType)) < 0) {
00134 return (fileInx);
00135 }
00136
00137 status = FileDriverTable[fileInx].fileLseek (rsComm, fd, offset, whence);
00138 return (status);
00139 }
00140
00141 int
00142 fileFsync (fileDriverType_t myType, rsComm_t *rsComm, int fd)
00143 {
00144 int fileInx;
00145 int status;
00146
00147 if ((fileInx = fileIndexLookup (myType)) < 0) {
00148 return (fileInx);
00149 }
00150
00151 status = FileDriverTable[fileInx].fileFsync (rsComm, fd);
00152 return (status);
00153 }
00154
00155 int
00156 fileMkdir (fileDriverType_t myType, rsComm_t *rsComm, char *filename, int mode)
00157 {
00158 int fileInx;
00159 int status;
00160
00161 if ((fileInx = fileIndexLookup (myType)) < 0) {
00162 return (fileInx);
00163 }
00164
00165 status = FileDriverTable[fileInx].fileMkdir (rsComm, filename, mode);
00166 return (status);
00167 }
00168
00169 int
00170 fileChmod (fileDriverType_t myType, rsComm_t *rsComm, char *filename, int mode)
00171 {
00172 int fileInx;
00173 int status;
00174
00175 if ((fileInx = fileIndexLookup (myType)) < 0) {
00176 return (fileInx);
00177 }
00178
00179 status = FileDriverTable[fileInx].fileChmod (rsComm, filename, mode);
00180 return (status);
00181 }
00182
00183 int
00184 fileRmdir (fileDriverType_t myType, rsComm_t *rsComm, char *filename)
00185 {
00186 int fileInx;
00187 int status;
00188
00189 if ((fileInx = fileIndexLookup (myType)) < 0) {
00190 return (fileInx);
00191 }
00192
00193 status = FileDriverTable[fileInx].fileRmdir (rsComm, filename);
00194 return (status);
00195 }
00196
00197 int
00198 fileOpendir (fileDriverType_t myType, rsComm_t *rsComm, char *filename,
00199 void **outDirPtr)
00200 {
00201 int fileInx;
00202 int status;
00203
00204 if ((fileInx = fileIndexLookup (myType)) < 0) {
00205 return (fileInx);
00206 }
00207
00208 status = FileDriverTable[fileInx].fileOpendir (rsComm, filename,
00209 outDirPtr);
00210
00211 return (status);
00212 }
00213
00214 int
00215 fileClosedir (fileDriverType_t myType, rsComm_t *rsComm, void *dirPtr)
00216 {
00217 int fileInx;
00218 int status;
00219
00220 if ((fileInx = fileIndexLookup (myType)) < 0) {
00221 return (fileInx);
00222 }
00223
00224 status = FileDriverTable[fileInx].fileClosedir (rsComm, dirPtr);
00225
00226 return (status);
00227 }
00228
00229 int
00230 fileReaddir (fileDriverType_t myType, rsComm_t *rsComm, void *dirPtr,
00231 struct dirent *direntPtr)
00232 {
00233 int fileInx;
00234 int status;
00235
00236 if ((fileInx = fileIndexLookup (myType)) < 0) {
00237 return (fileInx);
00238 }
00239
00240 bzero (direntPtr, sizeof (struct dirent));
00241
00242 status = FileDriverTable[fileInx].fileReaddir (rsComm, dirPtr, direntPtr);
00243
00244 return (status);
00245 }
00246
00247 int
00248 fileStage (fileDriverType_t myType, rsComm_t *rsComm, char *path, int flag)
00249 {
00250 int fileInx;
00251 int status;
00252
00253 if ((fileInx = fileIndexLookup (myType)) < 0) {
00254 return (fileInx);
00255 }
00256
00257 status = FileDriverTable[fileInx].fileStage (rsComm, path, flag);
00258
00259 return (status);
00260 }
00261
00262 int
00263 fileRename (fileDriverType_t myType, rsComm_t *rsComm, char *oldFileName,
00264 char *newFileName)
00265 {
00266 int fileInx;
00267 int status;
00268
00269 if ((fileInx = fileIndexLookup (myType)) < 0) {
00270 return (fileInx);
00271 }
00272
00273 status = FileDriverTable[fileInx].fileRename (rsComm, oldFileName,
00274 newFileName);
00275
00276 return (status);
00277 }
00278
00279 rodsLong_t
00280 fileGetFsFreeSpace (fileDriverType_t myType, rsComm_t *rsComm,
00281 char *path, int flag)
00282 {
00283 int fileInx;
00284 rodsLong_t status;
00285
00286 if ((fileInx = fileIndexLookup (myType)) < 0) {
00287 return (fileInx);
00288 }
00289
00290 status = FileDriverTable[fileInx].fileGetFsFreeSpace (rsComm, path, flag);
00291
00292 return (status);
00293 }
00294
00295 int
00296 fileTruncate (fileDriverType_t myType, rsComm_t *rsComm, char *path,
00297 rodsLong_t dataSize)
00298 {
00299 int fileInx;
00300 rodsLong_t status;
00301
00302 if ((fileInx = fileIndexLookup (myType)) < 0) {
00303 return (fileInx);
00304 }
00305
00306 status = FileDriverTable[fileInx].fileTruncate (rsComm, path, dataSize);
00307
00308 return (status);
00309 }
00310
00311 int
00312 fileIndexLookup (fileDriverType_t myType)
00313 {
00314 int i;
00315
00316 for (i = 0; i < NumFileDriver; i++) {
00317 if (myType == FileDriverTable[i].driverType)
00318 return (i);
00319 }
00320 rodsLog (LOG_NOTICE, "fileIndexLookup error for type %d", myType);
00321
00322 return (FILE_INDEX_LOOKUP_ERR);
00323 }
00324
00325 int
00326 fileStageToCache (fileDriverType_t myType, rsComm_t *rsComm,
00327 fileDriverType_t cacheFileType, int mode, int flags,
00328 char *filename, char *cacheFilename, rodsLong_t dataSize,
00329 keyValPair_t *condInput)
00330 {
00331 int fileInx;
00332 int status;
00333
00334 if ((fileInx = fileIndexLookup (myType)) < 0) {
00335 return (fileInx);
00336 }
00337
00338 status = FileDriverTable[fileInx].fileStageToCache (rsComm, cacheFileType,
00339 mode, flags, filename, cacheFilename, dataSize, condInput);
00340
00341 return (status);
00342 }
00343
00344 int
00345 fileSyncToArch (fileDriverType_t myType, rsComm_t *rsComm,
00346 fileDriverType_t cacheFileType, int mode, int flags,
00347 char *filename, char *cacheFilename, rodsLong_t dataSize,
00348 keyValPair_t *condInput)
00349 {
00350 int fileInx;
00351 int status;
00352
00353 if ((fileInx = fileIndexLookup (myType)) < 0) {
00354 return (fileInx);
00355 }
00356
00357 status = FileDriverTable[fileInx].fileSyncToArch (rsComm, cacheFileType,
00358 mode, flags, filename, cacheFilename, dataSize, condInput);
00359
00360 return (status);
00361 }
00362