pal_fileSystem.c

00001 /*
00002  * 2.c
00003  *
00004  *  Created on: 22 Jan 2017
00005  *      Author: alonof01
00006  */
00007 
00008 #include "pal.h"
00009 #include "pal_fileSystem.h"
00010 #include "pal_plat_fileSystem.h"
00011 
00012 PAL_PRIVATE char* g_RootFolder[PAL_FS_PARTITION_LAST] = { NULL , NULL };      //!< global var that holds the  root folder
00013 PAL_PRIVATE bool g_RootFolderIsSet[PAL_FS_PARTITION_LAST] = { false, false };    //!< global var that holds the state root folder
00014 
00015 
00016 void pal_fsCleanup()
00017 {
00018     if (NULL != g_RootFolder[PAL_FS_PARTITION_PRIMARY])
00019     {
00020         free(g_RootFolder[PAL_FS_PARTITION_PRIMARY]);
00021         g_RootFolder[PAL_FS_PARTITION_PRIMARY] = NULL;
00022     }
00023 
00024     if (NULL != g_RootFolder[PAL_FS_PARTITION_SECONDARY])
00025     {
00026         free(g_RootFolder[PAL_FS_PARTITION_SECONDARY]);
00027         g_RootFolder[PAL_FS_PARTITION_SECONDARY] = NULL;
00028     }
00029 
00030     g_RootFolder[PAL_FS_PARTITION_SECONDARY] = NULL;
00031     g_RootFolderIsSet[PAL_FS_PARTITION_PRIMARY] = false;
00032     g_RootFolderIsSet[PAL_FS_PARTITION_SECONDARY] = false;
00033 }
00034 
00035 
00036 
00037 palStatus_t pal_fsMkDir(const char *pathName)
00038 {
00039     palStatus_t ret = PAL_SUCCESS;
00040     if (pathName == NULL)
00041     {
00042         ret = PAL_ERR_FS_INVALID_FILE_NAME;
00043     }
00044     else if (pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR)
00045     {
00046         ret = PAL_ERR_FS_FILENAME_LENGTH;
00047     }
00048     else
00049     {
00050         ret = pal_plat_fsMkdir(pathName);
00051         if ((PAL_SUCCESS != ret) && (PAL_ERR_FS_NAME_ALREADY_EXIST != ret))
00052         {
00053             PAL_LOG(ERR, "Failed to create folder, was the storage properly initialized?");
00054         }
00055     }
00056     return ret;
00057 }
00058 
00059 
00060 
00061 palStatus_t pal_fsRmDir(const char *pathName)
00062 {
00063     palStatus_t ret = PAL_SUCCESS;
00064     if (pathName == NULL)
00065     {
00066         ret = PAL_ERR_FS_INVALID_FILE_NAME;
00067     }
00068     else if (pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR)
00069     {
00070         ret = PAL_ERR_FS_FILENAME_LENGTH;
00071     }
00072     else
00073     {
00074         ret = pal_plat_fsRmdir(pathName);
00075     }
00076     return ret;
00077 }
00078 
00079 palStatus_t pal_fsFopen(const char *pathName, pal_fsFileMode_t mode, palFileDescriptor_t *fd)
00080 {
00081     palStatus_t ret = PAL_SUCCESS;
00082     if (fd == NULL)
00083     {
00084         return PAL_ERR_FS_INVALID_ARGUMENT;
00085     }
00086     if (pathName == NULL)
00087     {
00088         ret = PAL_ERR_FS_INVALID_FILE_NAME;
00089     }
00090     else if (pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FULL_FILE_NAME)
00091     {
00092         ret = PAL_ERR_FS_FILENAME_LENGTH;
00093     }
00094     else if (!((mode > PAL_FS_FLAG_KEEP_FIRST) && (mode < PAL_FS_FLAG_KEEP_LAST)))
00095     {
00096         ret = PAL_ERR_FS_INVALID_OPEN_FLAGS;
00097     }
00098     else
00099     {
00100         ret = pal_plat_fsFopen(pathName,  mode, fd);
00101     }
00102     if (ret != PAL_SUCCESS)
00103     {
00104         PAL_LOG(ERR, "Failed to open/create file, was the storage properly initialized?");
00105         *fd = 0;
00106     }
00107     return ret;
00108 }
00109 
00110 
00111 palStatus_t pal_fsFclose(palFileDescriptor_t *fd)
00112 {
00113     palStatus_t ret = PAL_SUCCESS;
00114     if (fd == NULL)
00115     {
00116         return PAL_ERR_FS_INVALID_ARGUMENT;
00117     }
00118     if (*fd == 0)
00119     {
00120         ret = PAL_ERR_FS_BAD_FD;
00121     }
00122     else
00123     {
00124         ret = pal_plat_fsFclose(fd);
00125         *fd = 0;
00126     }
00127     return ret;
00128 }
00129 
00130 
00131 palStatus_t pal_fsFread(palFileDescriptor_t *fd, void * buffer, size_t numOfBytes, size_t *numberOfBytesRead)
00132 {
00133     palStatus_t ret = PAL_SUCCESS;
00134     *numberOfBytesRead = 0;
00135     if (*fd == 0)
00136     {
00137         ret = PAL_ERR_FS_BAD_FD;
00138     }
00139 
00140     else if (buffer == NULL)
00141     {
00142         ret = PAL_ERR_FS_BUFFER_ERROR;
00143     }
00144     else
00145     {
00146         ret = pal_plat_fsFread(fd, buffer, numOfBytes, numberOfBytesRead);
00147     }
00148     return ret;
00149 }
00150 
00151 
00152 palStatus_t pal_fsFwrite(palFileDescriptor_t *fd, const void * buffer, size_t numOfBytes, size_t *numberOfBytesWritten)
00153 {
00154     palStatus_t ret = PAL_SUCCESS;
00155     *numberOfBytesWritten = 0;
00156     if (*fd == 0)
00157     {
00158         ret = PAL_ERR_FS_BAD_FD;
00159     }
00160     else if (numOfBytes == 0)
00161     {
00162         ret = PAL_ERR_FS_LENGTH_ERROR;
00163     }
00164     else if (buffer == NULL)
00165     {
00166         ret = PAL_ERR_FS_BUFFER_ERROR;
00167     }
00168     else
00169     {
00170         ret = pal_plat_fsFwrite(fd, buffer, numOfBytes, numberOfBytesWritten);
00171     }
00172     return ret;
00173 }
00174 
00175 
00176 palStatus_t pal_fsFseek(palFileDescriptor_t *fd, int32_t offset, pal_fsOffset_t whence)
00177 {
00178     palStatus_t ret = PAL_SUCCESS;
00179     if (*fd == 0)
00180     {
00181         ret = PAL_ERR_FS_BAD_FD;
00182     }
00183     else if (!((whence < PAL_FS_OFFSET_KEEP_LAST) && (whence > PAL_FS_OFFSET_KEEP_FIRST)))
00184     {
00185         ret = PAL_ERR_FS_OFFSET_ERROR;
00186     }
00187     else
00188     {
00189         ret = pal_plat_fsFseek(fd, offset, whence);
00190     }
00191     return ret;
00192 }
00193 
00194 
00195 palStatus_t pal_fsFtell(palFileDescriptor_t *fd, int32_t *pos)
00196 {
00197     palStatus_t ret = PAL_SUCCESS;
00198     if (*fd == 0)
00199     {
00200         ret = PAL_ERR_FS_BAD_FD;
00201     }
00202     else
00203     {
00204         ret = pal_plat_fsFtell(fd, pos);
00205     }
00206     return ret;
00207 }
00208 
00209 palStatus_t pal_fsUnlink(const char *pathName)
00210 {
00211     palStatus_t ret = PAL_SUCCESS;
00212     if (pathName == NULL)
00213     {
00214         ret = PAL_ERR_FS_INVALID_FILE_NAME;
00215     }
00216     else if (pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FULL_FILE_NAME)
00217     {
00218         ret = PAL_ERR_FS_FILENAME_LENGTH;
00219     }
00220     else
00221     {
00222         ret = pal_plat_fsUnlink(pathName);
00223     }
00224     return ret;
00225 }
00226 
00227 
00228 
00229 palStatus_t pal_fsRmFiles(const char *pathName)
00230 {
00231     palStatus_t ret = PAL_SUCCESS;
00232     if (pathName == NULL)
00233     {
00234         ret = PAL_ERR_FS_INVALID_FILE_NAME;
00235     }
00236     else if (pal_plat_fsSizeCheck(pathName) >= PAL_MAX_FOLDER_DEPTH_CHAR)
00237     {
00238         ret = PAL_ERR_FS_FILENAME_LENGTH;
00239     }
00240     else
00241     {
00242         ret = pal_plat_fsRmFiles(pathName);
00243     }
00244     return ret;
00245 }
00246 
00247 
00248 palStatus_t pal_fsCpFolder(const char *pathNameSrc,  char *pathNameDest)
00249 {
00250     palStatus_t ret = PAL_SUCCESS;
00251     if ((pathNameSrc == NULL) || ((pathNameDest == NULL)))
00252     {
00253         ret = PAL_ERR_FS_INVALID_FILE_NAME;
00254     }
00255     else if ((pal_plat_fsSizeCheck(pathNameSrc) >= PAL_MAX_FOLDER_DEPTH_CHAR) || (pal_plat_fsSizeCheck(pathNameDest) >= PAL_MAX_FOLDER_DEPTH_CHAR))
00256     {
00257         ret = PAL_ERR_FS_FILENAME_LENGTH;
00258     }
00259     else
00260     {
00261         ret = pal_plat_fsCpFolder(pathNameSrc, pathNameDest);
00262     }
00263     return ret;
00264 }
00265 
00266 
00267 
00268 palStatus_t pal_fsSetMountPoint(pal_fsStorageID_t dataID, const char *path)
00269 {
00270     palStatus_t ret = PAL_SUCCESS;
00271     if ((dataID >= PAL_FS_PARTITION_LAST) || (NULL == path))
00272     {
00273         ret = PAL_ERR_FS_INVALID_FILE_NAME;
00274     }
00275     else if (pal_plat_fsSizeCheck(path) >= PAL_MAX_FOLDER_DEPTH_CHAR)
00276     {
00277         ret = PAL_ERR_FS_FILENAME_LENGTH;
00278     }
00279     else
00280     {
00281             if (g_RootFolderIsSet[dataID])
00282             {
00283                 ret = PAL_ERR_FS_ERROR;
00284             }
00285             else
00286             {
00287                 if (NULL == g_RootFolder[dataID])
00288                 {
00289                     g_RootFolder[dataID] = (char*)malloc(PAL_MAX_FOLDER_DEPTH_CHAR);
00290                     if (NULL == g_RootFolder[dataID])
00291                     {
00292                         return PAL_ERR_NO_MEMORY ;
00293                     }
00294                     g_RootFolder[dataID][0] = NULLPTR;
00295                 }
00296                 strncat( g_RootFolder[dataID], path, PAL_MAX_FOLDER_DEPTH_CHAR - pal_plat_fsSizeCheck(g_RootFolder[dataID]));// same buffer is used for active backup root dirs using indexing
00297                 g_RootFolderIsSet[dataID] = true;
00298             }
00299     }
00300     return ret;
00301 }
00302 
00303 palStatus_t pal_fsGetMountPoint(pal_fsStorageID_t dataID, size_t length, char *path)
00304 {
00305     palStatus_t ret = PAL_SUCCESS;
00306 
00307     if (dataID >= PAL_FS_PARTITION_LAST)
00308     {
00309         return  PAL_ERR_INVALID_ARGUMENT ;
00310     }
00311     if (length < PAL_MAX_FOLDER_DEPTH_CHAR)
00312     {
00313         return PAL_ERR_FS_LENGTH_ERROR;
00314     }
00315 
00316     if (path)
00317     {
00318         if (false == g_RootFolderIsSet[dataID])
00319         {
00320             strncpy(path, pal_plat_fsGetDefaultRootFolder(dataID), length);
00321         }
00322         else 
00323         {
00324             strncpy(path, g_RootFolder[dataID], length); // same buffer is used for active backup root dirs using indexing
00325         }
00326         
00327     }
00328     else
00329     {
00330         ret = PAL_ERR_FS_BUFFER_ERROR;
00331     }
00332     return ret;
00333 }
00334 
00335 
00336 palStatus_t pal_fsFormat(pal_fsStorageID_t dataID)
00337 {
00338     palStatus_t ret = PAL_SUCCESS;
00339     int32_t opCode = (int32_t)dataID;
00340     if ((opCode < PAL_FS_PARTITION_PRIMARY) || (opCode >= PAL_FS_PARTITION_LAST))
00341     {
00342         ret = PAL_ERR_INVALID_ARGUMENT ;
00343     }
00344     else
00345     {
00346         ret = pal_plat_fsFormat(dataID);
00347     }
00348     return ret;
00349 }
00350 
00351 
00352 
00353 
00354 bool pal_fsIsPrivatePartition(pal_fsStorageID_t dataID)
00355 {
00356     bool isPrivate;
00357     if (PAL_FS_PARTITION_PRIMARY == dataID)
00358     {
00359         isPrivate = PAL_PRIMARY_PARTITION_PRIVATE;
00360     }
00361     else
00362     {
00363         isPrivate = PAL_SECONDARY_PARTITION_PRIVATE;
00364     }
00365     return isPrivate;
00366 }