miniffs.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251
  1. /******************************************************************************
  2. * MiniFFS : Mini Flat File System
  3. * miniffs.c: Shared code for all platforms.
  4. *
  5. * Copyright (c) 2008-2022 986-Studio. All rights reserved.
  6. *
  7. ******************************************************************************/
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #define __miniffs_internal
  11. #include <miniffs.h>
  12. static miniffs_error_t last_error = MINIFFS_NOERROR;
  13. /* Public API */
  14. file_t *miniffs_open(miniffs_t *fs, const char *filename)
  15. {
  16. file_t *ret = (file_t *)calloc(1, sizeof(file_t));
  17. if (ret == NULL)
  18. {
  19. miniffs_seterror(MINIFFS_ALLOCATION_ERROR);
  20. goto exit;
  21. }
  22. ret->private_data = fs;
  23. ret->fent = miniffs_findfile(fs, filename);
  24. if (!ret->fent)
  25. {
  26. if (miniffs_geterror() != MINIFFS_INVALID_NAME)
  27. {
  28. miniffs_seterror(MINIFFS_FILE_NOT_FOUND);
  29. }
  30. goto free_and_exit;
  31. }
  32. ret->offset = 0;
  33. miniffs_seterror(MINIFFS_NOERROR);
  34. goto exit;
  35. free_and_exit:
  36. free(ret);
  37. ret = NULL;
  38. exit:
  39. return ret;
  40. }
  41. int miniffs_close(file_t *file)
  42. {
  43. /* Let's poison the struct */
  44. file->private_data = NULL;
  45. file->offset = 0;
  46. file->fent = NULL;
  47. free(file);
  48. miniffs_seterror(MINIFFS_NOERROR);
  49. }
  50. void *miniffs_map(file_t *file)
  51. {
  52. miniffs_t *fs = (miniffs_t *)file->private_data;
  53. miniffs_seterror(MINIFFS_NOERROR);
  54. return miniffs_getfileaddr(fs, file->fent);
  55. }
  56. uint8_t miniffs_read(file_t *file)
  57. {
  58. miniffs_t *fs = (miniffs_t *) file->private_data;
  59. uint8_t *filePtr = miniffs_getfileaddr(fs, file->fent);
  60. uint8_t ret = filePtr[file->offset];
  61. file->offset++;
  62. if (file->offset >= file->fent->size)
  63. {
  64. miniffs_seterror(MINIFFS_END_OF_FILE);
  65. file->offset = file->fent->size - 1;
  66. }
  67. else
  68. {
  69. miniffs_seterror(MINIFFS_NOERROR);
  70. }
  71. return ret;
  72. }
  73. int miniffs_write(file_t *file, char value)
  74. {
  75. miniffs_t *fs = (miniffs_t *) file->private_data;
  76. uint8_t *filePtr = miniffs_getfileaddr(fs, file->fent);
  77. filePtr[file->offset] = value;
  78. file->offset++;
  79. if (file->offset >= file->fent->size)
  80. {
  81. miniffs_seterror(MINIFFS_END_OF_FILE);
  82. file->offset = file->fent->size - 1;
  83. }
  84. else
  85. {
  86. miniffs_seterror(MINIFFS_NOERROR);
  87. }
  88. return 0;
  89. }
  90. int miniffs_read_blocks(void *ptr, size_t size, size_t nmemb, file_t *file)
  91. {
  92. int i;
  93. miniffs_t *fs = (miniffs_t *) file->private_data;
  94. uint8_t *filePtr = miniffs_getfileaddr(fs, file->fent);
  95. size_t fileOffset = file->offset;
  96. size_t bufferOffset = 0;
  97. int blockCount = 0;
  98. for(i = 0; i < nmemb; i++)
  99. {
  100. if (file->fent->size >= (fileOffset + size))
  101. {
  102. memcpy(ptr + bufferOffset, &filePtr[fileOffset], size);
  103. bufferOffset += size;
  104. fileOffset += size;
  105. blockCount++;
  106. }
  107. }
  108. file->offset = fileOffset;
  109. miniffs_seterror(MINIFFS_NOERROR);
  110. return blockCount;
  111. }
  112. int miniffs_seek(file_t *file, size_t offset, int whence)
  113. {
  114. bool noError = true;
  115. switch(whence) {
  116. default:
  117. miniffs_seterror(MINIFFS_INVALID_PARAMS);
  118. return -1;
  119. case MFFS_SEEK_SET:
  120. file->offset = offset;
  121. break;
  122. case MFFS_SEEK_CUR:
  123. file->offset += offset;
  124. break;
  125. case MFFS_SEEK_END:
  126. if (file->fent->size <= offset)
  127. {
  128. /* Negative boundary check */
  129. noError = false;
  130. miniffs_seterror(MINIFFS_SEEK_OUT_OF_BOUNDARIES);
  131. file->offset = 0;
  132. }
  133. else
  134. {
  135. file->offset = file->fent->size - 1 - offset;
  136. }
  137. break;
  138. }
  139. if (file->offset >= file->fent->size)
  140. {
  141. /* Positive Boundary check */
  142. noError = false;
  143. miniffs_seterror(MINIFFS_SEEK_OUT_OF_BOUNDARIES);
  144. file->offset = file->fent->size - 1;
  145. }
  146. if (noError)
  147. {
  148. miniffs_seterror(MINIFFS_NOERROR);
  149. }
  150. }
  151. size_t miniffs_tell(file_t *file)
  152. {
  153. miniffs_seterror(MINIFFS_NOERROR);
  154. return file->offset;
  155. }
  156. miniffs_error_t miniffs_geterror()
  157. {
  158. return last_error;
  159. }
  160. /* Private API */
  161. bool miniffs_isvalidfs(miniffs_t *fs)
  162. {
  163. return (fs->header->magic == MINIFFS_MAGIC) &&
  164. (fs->header->fs_version_major == MINIFFS_VERSION_MAJOR) &&
  165. (fs->header->fs_version_minor == MINIFFS_VERSION_MINOR) &&
  166. (fs->header->fs_filename_len == MINIFFS_FILENAME_LENGTH) &&
  167. (fs->header->fs_extention_len == MINIFFS_EXTENSION_LENGTH);
  168. }
  169. static void make_fullname(char *name, char *ext, char *out)
  170. {
  171. uint8_t nameLen = strnlen(name, MINIFFS_FILENAME_LENGTH);
  172. uint8_t extLen = strnlen(ext, MINIFFS_EXTENSION_LENGTH);
  173. memcpy(out, name, nameLen);
  174. memcpy(out + nameLen, ".", 1);
  175. memcpy(out + nameLen + 1, ext, extLen);
  176. }
  177. fileentry_t *miniffs_findfile(miniffs_t *fs, const char *filename)
  178. {
  179. int i;
  180. char entryFullName[MINIFFS_FULLNAME_LENGTH];
  181. uint8_t filenameLength = strlen(filename);
  182. fileentry_t *ret = NULL;
  183. if (filenameLength > MINIFFS_FULLNAME_LENGTH)
  184. {
  185. miniffs_seterror(MINIFFS_INVALID_NAME);
  186. goto exit;
  187. }
  188. for(i = 0; i < fs->header->entry_count; i++)
  189. {
  190. fileentry_t *cur = &fs->header->fent[i];
  191. make_fullname(cur->name, cur->ext, entryFullName);
  192. if (memcmp(filename, entryFullName, filenameLength) == 0)
  193. {
  194. /* File found! */
  195. ret = cur;
  196. break;
  197. }
  198. }
  199. exit:
  200. return ret;
  201. }
  202. void miniffs_seterror(miniffs_error_t err)
  203. {
  204. last_error = err;
  205. }
  206. char *miniffs_getversion()
  207. {
  208. return VERSION;
  209. }