miniffs.c 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
  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. miniffs_seterror(MINIFFS_FILE_NOT_FOUND);
  27. goto free_and_exit;
  28. }
  29. ret->offset = 0;
  30. miniffs_seterror(MINIFFS_NOERROR);
  31. goto exit;
  32. free_and_exit:
  33. free(ret);
  34. ret = NULL;
  35. exit:
  36. return ret;
  37. }
  38. int miniffs_close(file_t *file)
  39. {
  40. /* Let's poison the struct */
  41. file->private_data = NULL;
  42. file->offset = 0;
  43. file->fent = NULL;
  44. free(file);
  45. miniffs_seterror(MINIFFS_NOERROR);
  46. }
  47. void *miniffs_map(file_t *file)
  48. {
  49. miniffs_t *fs = (miniffs_t *)file->private_data;
  50. miniffs_seterror(MINIFFS_NOERROR);
  51. return miniffs_getfileaddr(fs, file->fent);
  52. }
  53. uint8_t miniffs_read(file_t *file)
  54. {
  55. miniffs_t *fs = (miniffs_t *) file->private_data;
  56. uint8_t *filePtr = miniffs_getfileaddr(fs, file->fent);
  57. uint8_t ret = filePtr[file->offset];
  58. file->offset++;
  59. if (file->offset >= file->fent->size)
  60. {
  61. miniffs_seterror(MINIFFS_END_OF_FILE);
  62. file->offset = file->fent->size - 1;
  63. }
  64. else
  65. {
  66. miniffs_seterror(MINIFFS_NOERROR);
  67. }
  68. return ret;
  69. }
  70. int miniffs_read_blocks(void *ptr, size_t size, size_t nmemb, file_t *file)
  71. {
  72. int i;
  73. miniffs_t *fs = (miniffs_t *) file->private_data;
  74. uint8_t *filePtr = miniffs_getfileaddr(fs, file->fent);
  75. size_t fileOffset = file->offset;
  76. size_t bufferOffset = 0;
  77. int blockCount = 0;
  78. for(i = 0; i < nmemb; i++)
  79. {
  80. if (file->fent->size > (fileOffset + size))
  81. {
  82. memcpy(ptr + bufferOffset, &filePtr[fileOffset], size);
  83. bufferOffset += size;
  84. fileOffset += size;
  85. blockCount++;
  86. }
  87. }
  88. file->offset = fileOffset;
  89. miniffs_seterror(MINIFFS_NOERROR);
  90. return blockCount;
  91. }
  92. int miniffs_seek(file_t *file, size_t offset, int whence)
  93. {
  94. switch(whence)
  95. {
  96. default:
  97. miniffs_seterror(MINIFFS_INVALID_PARAMS);
  98. return -1;
  99. case MFFS_SEEK_SET:
  100. file->offset = offset;
  101. break;
  102. case MFFS_SEEK_CUR:
  103. file->offset += offset;
  104. break;
  105. case MFFS_SEEK_END:
  106. file->offset = file->fent->size - offset;
  107. break;
  108. }
  109. miniffs_seterror(MINIFFS_NOERROR);
  110. }
  111. size_t miniffs_tell(file_t *file)
  112. {
  113. miniffs_seterror(MINIFFS_NOERROR);
  114. return file->offset;
  115. }
  116. miniffs_error_t miniffs_geterror()
  117. {
  118. return last_error;
  119. }
  120. /* Private API */
  121. bool miniffs_isvalidfs(miniffs_t *fs)
  122. {
  123. return (fs->header->magic == MINIFFS_MAGIC) &&
  124. (fs->header->fs_version_major == MINIFFS_VERSION_MAJOR) &&
  125. (fs->header->fs_version_minor == MINIFFS_VERSION_MINOR) &&
  126. (fs->header->fs_filename_len == MINIFFS_FILENAME_LENGTH) &&
  127. (fs->header->fs_extention_len == MINIFFS_EXTENSION_LENGTH);
  128. }
  129. static void make_fullname(char *name, char *ext, char *out)
  130. {
  131. uint8_t nameLen = strnlen(name, MINIFFS_FILENAME_LENGTH);
  132. uint8_t extLen = strnlen(ext, MINIFFS_EXTENSION_LENGTH);
  133. memcpy(out, name, nameLen);
  134. memcpy(out + nameLen, ".", 1);
  135. memcpy(out + nameLen + 1, ext, extLen);
  136. }
  137. fileentry_t *miniffs_findfile(miniffs_t *fs, const char *filename)
  138. {
  139. int i;
  140. char entryFullName[MINIFFS_FULLNAME_LENGTH];
  141. uint8_t filenameLength = strlen(filename);
  142. fileentry_t *ret = NULL;
  143. if (filenameLength > MINIFFS_FULLNAME_LENGTH)
  144. {
  145. miniffs_seterror(MINIFFS_INVALID_NAME);
  146. goto exit;
  147. }
  148. for(i = 0; i < fs->header->entry_count; i++)
  149. {
  150. fileentry_t *cur = &fs->header->fent[i];
  151. make_fullname(cur->name, cur->ext, entryFullName);
  152. if (memcmp(filename, entryFullName, filenameLength) == 0)
  153. {
  154. /* File found! */
  155. ret = cur;
  156. break;
  157. }
  158. }
  159. exit:
  160. return ret;
  161. }
  162. void miniffs_seterror(miniffs_error_t err)
  163. {
  164. last_error = err;
  165. }