Merge pull request #1730 from FluidSynth/issue-1728

derselbst · web-flow · commit 685e54cdc449 · 2025-12-23T15:57:14.000+01:00
Fix a heap-based use after free during synth destruction
diff --git a/src/sfloader/fluid_defsfont.c b/src/sfloader/fluid_defsfont.c
@@ -22,7 +22,6 @@
 
 
 #include "fluid_defsfont.h"
-#include "fluid_sfont.h"
 #include "fluid_sys.h"
 #include "fluid_synth.h"
 #include "fluid_samplecache.h"
@@ -468,10 +467,10 @@ int fluid_defsfont_load(fluid_defsfont_t *defsfont, const fluid_file_callbacks_t
         return FLUID_FAILED;
     }
 
-    defsfont->fcbs = fcbs;
+    defsfont->fcbs = *fcbs;
 
     /* The actual loading is done in the sfont and sffile files */
-    sfdata = fluid_sffile_open(file, fcbs);
+    sfdata = fluid_sffile_open(file, &defsfont->fcbs);
 
     if(sfdata == NULL)
     {
@@ -2246,7 +2245,7 @@ static int load_preset_samples(fluid_defsfont_t *defsfont, fluid_preset_t *prese
                      * for a preset */
                     if(sffile == NULL)
                     {
-                        sffile = fluid_sffile_open(defsfont->filename, defsfont->fcbs);
+                        sffile = fluid_sffile_open(defsfont->filename, &defsfont->fcbs);
 
                         if(sffile == NULL)
                         {
diff --git a/src/sfloader/fluid_defsfont.h b/src/sfloader/fluid_defsfont.h
@@ -30,6 +30,7 @@
 #include "fluid_list.h"
 #include "fluid_mod.h"
 #include "fluid_gen.h"
+#include "fluid_sfont.h"
 
 
 
@@ -105,7 +106,7 @@ int fluid_zone_inside_range(fluid_zone_range_t *zone_range, int key, int vel);
  */
 struct _fluid_defsfont_t
 {
-    const fluid_file_callbacks_t *fcbs; /* the file callbacks used to load this Soundfont */
+    fluid_file_callbacks_t fcbs; /* the file callbacks used to load this Soundfont */
     char *filename;           /* the filename of this soundfont */
     unsigned int samplepos;   /* the position in the file at which the sample data starts */
     unsigned int samplesize;  /* the size of the sample data in bytes */
diff --git a/src/sfloader/fluid_dls.cpp b/src/sfloader/fluid_dls.cpp
@@ -374,7 +374,7 @@ struct fluid_dls_font
 {
     fluid_synth_t *synth;
     fluid_sfont_t *sfont;
-    const fluid_file_callbacks_t *fcbs;
+    const fluid_file_callbacks_t fcbs;
     uint32_t output_sample_rate; // only used for cdl eval
     std::string filename;
 
@@ -384,7 +384,7 @@ struct fluid_dls_font
         {
             if(file != nullptr)
             {
-                fcbs->fclose(file);
+                fcbs.fclose(file);
                 file = nullptr;
             }
         } };
@@ -477,7 +477,7 @@ struct fluid_dls_font
     // utilities
     void fseek(fluid_long_long_t pos, int whence)
     {
-        if(fcbs->fseek(file, pos, whence) != FLUID_OK)
+        if(fcbs.fseek(file, pos, whence) != FLUID_OK)
         {
             throw std::runtime_error{ "Failed to seek" };
         }
@@ -589,30 +589,30 @@ static void delete_fluid_dls_font(fluid_dls_font *dlsfont) noexcept
 #define READCHUNK_RAW(sf, var)                                                  \
     do                                                                          \
     {                                                                           \
-        if ((sf)->fcbs->fread(var, 8, (sf)->file) == FLUID_FAILED)              \
+        if ((sf)->fcbs.fread(var, 8, (sf)->file) == FLUID_FAILED)              \
             throw std::runtime_error{ "Failed when reading chunk" };            \
         ((RIFFChunk *)(var))->size = FLUID_LE32TOH(((RIFFChunk *)(var))->size); \
     } while (0)
 
 #define READID(sf, var)                                                  \
     do                                                                   \
     {                                                                    \
-        if ((sf)->fcbs->fread(var, 4, (sf)->file) == FLUID_FAILED)       \
+        if ((sf)->fcbs.fread(var, 4, (sf)->file) == FLUID_FAILED)       \
             throw std::runtime_error{ "Failed when reading FOURCC ID" }; \
     } while (0)
 
 #define READ8(sf, var)                                              \
     do                                                              \
     {                                                               \
-        if ((sf)->fcbs->fread(&var, 1, (sf)->file) == FLUID_FAILED) \
+        if ((sf)->fcbs.fread(&var, 1, (sf)->file) == FLUID_FAILED) \
             throw std::runtime_error{ "Failed when reading byte" }; \
     } while (0)
 
 #define READ16(sf, var)                                               \
     do                                                                \
     {                                                                 \
         uint16_t _temp;                                               \
-        if ((sf)->fcbs->fread(&_temp, 2, (sf)->file) == FLUID_FAILED) \
+        if ((sf)->fcbs.fread(&_temp, 2, (sf)->file) == FLUID_FAILED) \
             throw std::runtime_error{ "Failed when reading word" };   \
         (var) = FLUID_LE16TOH(_temp);                                 \
     } while (0)
@@ -621,7 +621,7 @@ static void delete_fluid_dls_font(fluid_dls_font *dlsfont) noexcept
     do                                                                \
     {                                                                 \
         uint32_t _temp;                                               \
-        if ((sf)->fcbs->fread(&_temp, 4, (sf)->file) == FLUID_FAILED) \
+        if ((sf)->fcbs.fread(&_temp, 4, (sf)->file) == FLUID_FAILED) \
             throw std::runtime_error{ "Failed when reading dword" };  \
         (var) = FLUID_LE32TOH(_temp);                                 \
     } while (0)
@@ -758,7 +758,7 @@ inline std::string fluid_dls_font::read_name_from_info_entries(fluid_long_long_t
             std::string name;
             name.resize(chunk.size);
 
-            if(fcbs->fread(name.data(), chunk.size, file) != FLUID_OK)
+            if(fcbs.fread(name.data(), chunk.size, file) != FLUID_OK)
             {
                 throw std::runtime_error{ "Failed when reading INAM chunk" };
             }
@@ -815,7 +815,7 @@ inline static void READGUID(fluid_dls_font *sf, DLSID &id)
     READ16(sf, id.Data2);
     READ16(sf, id.Data3);
 
-    if(sf->fcbs->fread(id.Data4, 8, sf->file) == FLUID_FAILED)
+    if(sf->fcbs.fread(id.Data4, 8, sf->file) == FLUID_FAILED)
     {
         throw std::runtime_error{ "Failed when reading GUID" };
     }
@@ -1456,34 +1456,33 @@ void convert_dls_connectionblock_to_art(fluid_dls_articulation &art,
 // Parse the DLS structure
 fluid_dls_font::fluid_dls_font(fluid_synth_t *synth,
                                fluid_sfont_t *sfont,
-                               const fluid_file_callbacks_t *fcbs,
+                               const fluid_file_callbacks_t *fcbs_in,
                                const char *filename,
                                uint32_t output_sample_rate,
                                bool try_mlock)
-    : synth(synth), sfont(sfont), fcbs(fcbs), output_sample_rate(output_sample_rate), filename(filename)
+    : synth(synth), sfont(sfont), fcbs(*fcbs_in), output_sample_rate(output_sample_rate), filename(filename)
 {
     // Get basic file information
 
-    file = fcbs->fopen(filename); // NOLINT(cppcoreguidelines-prefer-member-initializer)
-
+    file = fcbs.fopen(filename); // NOLINT(cppcoreguidelines-prefer-member-initializer)
     if(file == nullptr)
     {
         throw std::runtime_error{ string_format("Unable to open file '%s'", filename) };
     }
 
-    if(fcbs->fseek(file, 0L, SEEK_END) == FLUID_FAILED)
+    if(fcbs.fseek(file, 0L, SEEK_END) == FLUID_FAILED)
     {
         throw std::runtime_error{ "Seek to end of file failed" };
     }
 
-    filesize = fcbs->ftell(file);
+    filesize = fcbs.ftell(file);
 
     if(filesize == FLUID_FAILED)
     {
         throw std::runtime_error{ "Get end of file position failed" };
     }
 
-    if(fcbs->fseek(file, 0, SEEK_SET) == FLUID_FAILED)
+    if(fcbs.fseek(file, 0, SEEK_SET) == FLUID_FAILED)
     {
         throw std::runtime_error{ "Rewind to start of file failed" };
     }
@@ -1947,7 +1946,7 @@ inline bool fluid_dls_font::execute_cdls(fluid_long_long_t offset, int size)
         return stack[--sp];
     };
 
-    if(fcbs->fseek(file, offset, SEEK_SET) != FLUID_OK)
+    if(fcbs.fseek(file, offset, SEEK_SET) != FLUID_OK)
     {
         throw std::runtime_error{ "Failed to seek to CDL operations" };
     }
@@ -2247,9 +2246,9 @@ inline void fluid_dls_font::parse_wave(fluid_long_long_t offset, fluid_dls_sampl
             {
                 uint32_t c = remaining > sizeof(buffer) ? sizeof(buffer) : remaining;
 
-                if(fcbs->fread(buffer, c, file) != FLUID_OK)
+                if(fcbs.fread(buffer, c, file) != FLUID_OK)
                 {
-                    FLUID_LOG(FLUID_ERR, "fcbs->fread failed when reading DLS data chunk");
+                    FLUID_LOG(FLUID_ERR, "fcbs::fread failed when reading DLS data chunk");
                     throw std::exception{};
                 }
 
@@ -2750,7 +2749,7 @@ inline void fluid_dls_font::parse_pgal(fluid_long_long_t offset, int size)
 
     drum_note_aliasing.emplace();
 
-    if(fcbs->fread(drum_note_aliasing->data(), 128, file) != FLUID_OK)
+    if(fcbs.fread(drum_note_aliasing->data(), 128, file) != FLUID_OK)
     {
         throw std::runtime_error{ "Failed to read drum note aliasing table" };
     }
@@ -2844,7 +2843,7 @@ static sf_count_t sfvio_seek(sf_count_t offset, int whence, void *user_data) noe
 
     newpos = std::clamp(newpos, 0LL, data->size);
 
-    if(data->font->fcbs->fseek(data->font->file, data->offset + newpos, SEEK_SET) == FLUID_OK)
+    if(data->font->fcbs.fseek(data->font->file, data->offset + newpos, SEEK_SET) == FLUID_OK)
     {
         data->pos = newpos;
     }
@@ -2872,7 +2871,7 @@ static sf_count_t sfvio_read(void *buffer, sf_count_t count, void *user_data) no
         return 0;
     }
 
-    if(data->font->fcbs->fread(buffer, count, data->font->file) != FLUID_OK)
+    if(data->font->fcbs.fread(buffer, count, data->font->file) != FLUID_OK)
     {
         return 0;
     }
diff --git a/src/synth/fluid_synth.c b/src/synth/fluid_synth.c
@@ -1220,16 +1220,6 @@ delete_fluid_synth(fluid_synth_t *synth)
 
     delete_fluid_list(synth->sfont);
 
-    /* delete all the SoundFont loaders */
-
-    for(list = synth->loaders; list; list = fluid_list_next(list))
-    {
-        loader = (fluid_sfloader_t *) fluid_list_get(list);
-        fluid_sfloader_delete(loader);
-    }
-
-    delete_fluid_list(synth->loaders);
-
     /* wait for and delete all the lazy sfont unloading timers */
 
     for(list = synth->fonts_to_be_unloaded; list; list = fluid_list_next(list))
@@ -1243,6 +1233,16 @@ delete_fluid_synth(fluid_synth_t *synth)
 
     delete_fluid_list(synth->fonts_to_be_unloaded);
 
+    /* delete all the SoundFont loaders */
+
+    for(list = synth->loaders; list; list = fluid_list_next(list))
+    {
+        loader = (fluid_sfloader_t *) fluid_list_get(list);
+        fluid_sfloader_delete(loader);
+    }
+
+    delete_fluid_list(synth->loaders);
+
     if(synth->channel != NULL)
     {
         for(i = 0; i < synth->midi_channels; i++)

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@`
`22`	`22`
`23`	`23`
`24`	`24`	`#include "fluid_defsfont.h"`
`25`		`-#include "fluid_sfont.h"`
`26`	`25`	`#include "fluid_sys.h"`
`27`	`26`	`#include "fluid_synth.h"`
`28`	`27`	`#include "fluid_samplecache.h"`
`@@ -468,10 +467,10 @@ int fluid_defsfont_load(fluid_defsfont_t *defsfont, const fluid_file_callbacks_t`
`468`	`467`	`return FLUID_FAILED;`
`469`	`468`	`}`
`470`	`469`
`471`		`- defsfont->fcbs = fcbs;`
	`470`	`+ defsfont->fcbs = *fcbs;`
`472`	`471`
`473`	`472`	`/* The actual loading is done in the sfont and sffile files */`
`474`		`- sfdata = fluid_sffile_open(file, fcbs);`
	`473`	`+ sfdata = fluid_sffile_open(file, &defsfont->fcbs);`
`475`	`474`
`476`	`475`	`if(sfdata == NULL)`
`477`	`476`	`{`
`@@ -2246,7 +2245,7 @@ static int load_preset_samples(fluid_defsfont_t defsfont, fluid_preset_t prese`
`2246`	`2245`	`* for a preset */`
`2247`	`2246`	`if(sffile == NULL)`
`2248`	`2247`	`{`
`2249`		`- sffile = fluid_sffile_open(defsfont->filename, defsfont->fcbs);`
	`2248`	`+ sffile = fluid_sffile_open(defsfont->filename, &defsfont->fcbs);`
`2250`	`2249`
`2251`	`2250`	`if(sffile == NULL)`
`2252`	`2251`	`{`
Original file line number	Diff line number	Diff line change
`@@ -374,7 +374,7 @@ struct fluid_dls_font`
`374`	`374`	`{`
`375`	`375`	`fluid_synth_t *synth;`
`376`	`376`	`fluid_sfont_t *sfont;`
`377`		`- const fluid_file_callbacks_t *fcbs;`
	`377`	`+ const fluid_file_callbacks_t fcbs;`
`378`	`378`	`uint32_t output_sample_rate; // only used for cdl eval`
`379`	`379`	`std::string filename;`
`380`	`380`
`@@ -384,7 +384,7 @@ struct fluid_dls_font`
`384`	`384`	`{`
`385`	`385`	`if(file != nullptr)`
`386`	`386`	`{`
`387`		`- fcbs->fclose(file);`
	`387`	`+ fcbs.fclose(file);`
`388`	`388`	`file = nullptr;`
`389`	`389`	`}`
`390`	`390`	`} };`
`@@ -477,7 +477,7 @@ struct fluid_dls_font`
`477`	`477`	`// utilities`
`478`	`478`	`void fseek(fluid_long_long_t pos, int whence)`
`479`	`479`	`{`
`480`		`- if(fcbs->fseek(file, pos, whence) != FLUID_OK)`
	`480`	`+ if(fcbs.fseek(file, pos, whence) != FLUID_OK)`
`481`	`481`	`{`
`482`	`482`	`throw std::runtime_error{ "Failed to seek" };`
`483`	`483`	`}`
`@@ -589,30 +589,30 @@ static void delete_fluid_dls_font(fluid_dls_font *dlsfont) noexcept`
`589`	`589`	`#define READCHUNK_RAW(sf, var) \`
`590`	`590`	`do \`
`591`	`591`	`{ \`
`592`		`- if ((sf)->fcbs->fread(var, 8, (sf)->file) == FLUID_FAILED) \`
	`592`	`+ if ((sf)->fcbs.fread(var, 8, (sf)->file) == FLUID_FAILED) \`
`593`	`593`	`throw std::runtime_error{ "Failed when reading chunk" }; \`
`594`	`594`	`((RIFFChunk )(var))->size = FLUID_LE32TOH(((RIFFChunk )(var))->size); \`
`595`	`595`	`} while (0)`
`596`	`596`
`597`	`597`	`#define READID(sf, var) \`
`598`	`598`	`do \`
`599`	`599`	`{ \`
`600`		`- if ((sf)->fcbs->fread(var, 4, (sf)->file) == FLUID_FAILED) \`
	`600`	`+ if ((sf)->fcbs.fread(var, 4, (sf)->file) == FLUID_FAILED) \`
`601`	`601`	`throw std::runtime_error{ "Failed when reading FOURCC ID" }; \`
`602`	`602`	`} while (0)`
`603`	`603`
`604`	`604`	`#define READ8(sf, var) \`
`605`	`605`	`do \`
`606`	`606`	`{ \`
`607`		`- if ((sf)->fcbs->fread(&var, 1, (sf)->file) == FLUID_FAILED) \`
	`607`	`+ if ((sf)->fcbs.fread(&var, 1, (sf)->file) == FLUID_FAILED) \`
`608`	`608`	`throw std::runtime_error{ "Failed when reading byte" }; \`
`609`	`609`	`} while (0)`
`610`	`610`
`611`	`611`	`#define READ16(sf, var) \`
`612`	`612`	`do \`
`613`	`613`	`{ \`
`614`	`614`	`uint16_t _temp; \`
`615`		`- if ((sf)->fcbs->fread(&_temp, 2, (sf)->file) == FLUID_FAILED) \`
	`615`	`+ if ((sf)->fcbs.fread(&_temp, 2, (sf)->file) == FLUID_FAILED) \`
`616`	`616`	`throw std::runtime_error{ "Failed when reading word" }; \`
`617`	`617`	`(var) = FLUID_LE16TOH(_temp); \`
`618`	`618`	`} while (0)`
`@@ -621,7 +621,7 @@ static void delete_fluid_dls_font(fluid_dls_font *dlsfont) noexcept`
`621`	`621`	`do \`
`622`	`622`	`{ \`
`623`	`623`	`uint32_t _temp; \`
`624`		`- if ((sf)->fcbs->fread(&_temp, 4, (sf)->file) == FLUID_FAILED) \`
	`624`	`+ if ((sf)->fcbs.fread(&_temp, 4, (sf)->file) == FLUID_FAILED) \`
`625`	`625`	`throw std::runtime_error{ "Failed when reading dword" }; \`
`626`	`626`	`(var) = FLUID_LE32TOH(_temp); \`
`627`	`627`	`} while (0)`
`@@ -758,7 +758,7 @@ inline std::string fluid_dls_font::read_name_from_info_entries(fluid_long_long_t`
`758`	`758`	`std::string name;`
`759`	`759`	`name.resize(chunk.size);`
`760`	`760`
`761`		`- if(fcbs->fread(name.data(), chunk.size, file) != FLUID_OK)`
	`761`	`+ if(fcbs.fread(name.data(), chunk.size, file) != FLUID_OK)`
`762`	`762`	`{`
`763`	`763`	`throw std::runtime_error{ "Failed when reading INAM chunk" };`
`764`	`764`	`}`
`@@ -815,7 +815,7 @@ inline static void READGUID(fluid_dls_font *sf, DLSID &id)`
`815`	`815`	`READ16(sf, id.Data2);`
`816`	`816`	`READ16(sf, id.Data3);`
`817`	`817`
`818`		`- if(sf->fcbs->fread(id.Data4, 8, sf->file) == FLUID_FAILED)`
	`818`	`+ if(sf->fcbs.fread(id.Data4, 8, sf->file) == FLUID_FAILED)`
`819`	`819`	`{`
`820`	`820`	`throw std::runtime_error{ "Failed when reading GUID" };`
`821`	`821`	`}`
`@@ -1456,34 +1456,33 @@ void convert_dls_connectionblock_to_art(fluid_dls_articulation &art,`
`1456`	`1456`	`// Parse the DLS structure`
`1457`	`1457`	`fluid_dls_font::fluid_dls_font(fluid_synth_t *synth,`
`1458`	`1458`	`fluid_sfont_t *sfont,`
`1459`		`- const fluid_file_callbacks_t *fcbs,`
	`1459`	`+ const fluid_file_callbacks_t *fcbs_in,`
`1460`	`1460`	`const char *filename,`
`1461`	`1461`	`uint32_t output_sample_rate,`
`1462`	`1462`	`bool try_mlock)`
`1463`		`- : synth(synth), sfont(sfont), fcbs(fcbs), output_sample_rate(output_sample_rate), filename(filename)`
	`1463`	`+ : synth(synth), sfont(sfont), fcbs(*fcbs_in), output_sample_rate(output_sample_rate), filename(filename)`
`1464`	`1464`	`{`
`1465`	`1465`	`// Get basic file information`
`1466`	`1466`
`1467`		`- file = fcbs->fopen(filename); // NOLINT(cppcoreguidelines-prefer-member-initializer)`
`1468`		`-`
	`1467`	`+ file = fcbs.fopen(filename); // NOLINT(cppcoreguidelines-prefer-member-initializer)`
`1469`	`1468`	`if(file == nullptr)`
`1470`	`1469`	`{`
`1471`	`1470`	`throw std::runtime_error{ string_format("Unable to open file '%s'", filename) };`
`1472`	`1471`	`}`
`1473`	`1472`
`1474`		`- if(fcbs->fseek(file, 0L, SEEK_END) == FLUID_FAILED)`
	`1473`	`+ if(fcbs.fseek(file, 0L, SEEK_END) == FLUID_FAILED)`
`1475`	`1474`	`{`
`1476`	`1475`	`throw std::runtime_error{ "Seek to end of file failed" };`
`1477`	`1476`	`}`
`1478`	`1477`
`1479`		`- filesize = fcbs->ftell(file);`
	`1478`	`+ filesize = fcbs.ftell(file);`
`1480`	`1479`
`1481`	`1480`	`if(filesize == FLUID_FAILED)`
`1482`	`1481`	`{`
`1483`	`1482`	`throw std::runtime_error{ "Get end of file position failed" };`
`1484`	`1483`	`}`
`1485`	`1484`
`1486`		`- if(fcbs->fseek(file, 0, SEEK_SET) == FLUID_FAILED)`
	`1485`	`+ if(fcbs.fseek(file, 0, SEEK_SET) == FLUID_FAILED)`
`1487`	`1486`	`{`
`1488`	`1487`	`throw std::runtime_error{ "Rewind to start of file failed" };`
`1489`	`1488`	`}`
`@@ -1947,7 +1946,7 @@ inline bool fluid_dls_font::execute_cdls(fluid_long_long_t offset, int size)`
`1947`	`1946`	`return stack[--sp];`
`1948`	`1947`	`};`
`1949`	`1948`
`1950`		`- if(fcbs->fseek(file, offset, SEEK_SET) != FLUID_OK)`
	`1949`	`+ if(fcbs.fseek(file, offset, SEEK_SET) != FLUID_OK)`
`1951`	`1950`	`{`
`1952`	`1951`	`throw std::runtime_error{ "Failed to seek to CDL operations" };`
`1953`	`1952`	`}`
`@@ -2247,9 +2246,9 @@ inline void fluid_dls_font::parse_wave(fluid_long_long_t offset, fluid_dls_sampl`
`2247`	`2246`	`{`
`2248`	`2247`	`uint32_t c = remaining > sizeof(buffer) ? sizeof(buffer) : remaining;`
`2249`	`2248`
`2250`		`- if(fcbs->fread(buffer, c, file) != FLUID_OK)`
	`2249`	`+ if(fcbs.fread(buffer, c, file) != FLUID_OK)`
`2251`	`2250`	`{`
`2252`		`- FLUID_LOG(FLUID_ERR, "fcbs->fread failed when reading DLS data chunk");`
	`2251`	`+ FLUID_LOG(FLUID_ERR, "fcbs::fread failed when reading DLS data chunk");`
`2253`	`2252`	`throw std::exception{};`
`2254`	`2253`	`}`
`2255`	`2254`
`@@ -2750,7 +2749,7 @@ inline void fluid_dls_font::parse_pgal(fluid_long_long_t offset, int size)`
`2750`	`2749`
`2751`	`2750`	`drum_note_aliasing.emplace();`
`2752`	`2751`
`2753`		`- if(fcbs->fread(drum_note_aliasing->data(), 128, file) != FLUID_OK)`
	`2752`	`+ if(fcbs.fread(drum_note_aliasing->data(), 128, file) != FLUID_OK)`
`2754`	`2753`	`{`
`2755`	`2754`	`throw std::runtime_error{ "Failed to read drum note aliasing table" };`
`2756`	`2755`	`}`
`@@ -2844,7 +2843,7 @@ static sf_count_t sfvio_seek(sf_count_t offset, int whence, void *user_data) noe`
`2844`	`2843`
`2845`	`2844`	`newpos = std::clamp(newpos, 0LL, data->size);`
`2846`	`2845`
`2847`		`- if(data->font->fcbs->fseek(data->font->file, data->offset + newpos, SEEK_SET) == FLUID_OK)`
	`2846`	`+ if(data->font->fcbs.fseek(data->font->file, data->offset + newpos, SEEK_SET) == FLUID_OK)`
`2848`	`2847`	`{`
`2849`	`2848`	`data->pos = newpos;`
`2850`	`2849`	`}`
`@@ -2872,7 +2871,7 @@ static sf_count_t sfvio_read(void buffer, sf_count_t count, void user_data) no`
`2872`	`2871`	`return 0;`
`2873`	`2872`	`}`
`2874`	`2873`
`2875`		`- if(data->font->fcbs->fread(buffer, count, data->font->file) != FLUID_OK)`
	`2874`	`+ if(data->font->fcbs.fread(buffer, count, data->font->file) != FLUID_OK)`
`2876`	`2875`	`{`
`2877`	`2876`	`return 0;`
`2878`	`2877`	`}`