[pcsx_rearmed.git] / deps / libretro-common / formats / m3u / m3u_file.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (m3u_file.c).
 * ---------------------------------------------------------------------------------------
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <retro_miscellaneous.h>

#include <string/stdstring.h>
#include <lists/string_list.h>
#include <file/file_path.h>
#include <streams/file_stream.h>
#include <array/rbuf.h>

#include <formats/m3u_file.h>

/* We parse the following types of entry label:
 * - '#LABEL:<label>' non-standard, but used by
 *   some cores
 * - '#EXTINF:<runtime>,<label>' standard extended
 *   M3U directive
 * - '<content path>|<label>' non-standard, but
 *   used by some cores
 * All other comments/directives are ignored */
#define M3U_FILE_COMMENT            '#'
#define M3U_FILE_NONSTD_LABEL       "#LABEL:"
#define M3U_FILE_EXTSTD_LABEL       "#EXTINF:"
#define M3U_FILE_EXTSTD_LABEL_TOKEN ','
#define M3U_FILE_RETRO_LABEL_TOKEN  '|'

/* Holds all internal M3U file data
 * > Note the awkward name: 'content_m3u_file'
 *   If we used just 'm3u_file' here, it would
 *   lead to conflicts elsewhere... */
struct content_m3u_file
{
   char *path;
   m3u_file_entry_t *entries;
};

/* File Initialisation / De-Initialisation */

/* Reads M3U file contents from disk
 * - Does nothing if file does not exist 
 * - Returns false in the event of an error */
static bool m3u_file_load(m3u_file_t *m3u_file)
{
   const char *file_ext      = NULL;
   int64_t file_len          = 0;
   uint8_t *file_buf         = NULL;
   struct string_list *lines = NULL;
   bool success              = false;
   size_t i;
   char entry_path[PATH_MAX_LENGTH];
   char entry_label[PATH_MAX_LENGTH];

   entry_path[0]  = '\0';
   entry_label[0] = '\0';

   if (!m3u_file)
      goto end;

   /* Check whether file exists
    * > If path is empty, then an error
    *   has occurred... */
   if (string_is_empty(m3u_file->path))
      goto end;

   /* > File must have the correct extension */
   file_ext = path_get_extension(m3u_file->path);

   if (string_is_empty(file_ext) ||
       !string_is_equal_noncase(file_ext, M3U_FILE_EXT))
      goto end;

   /* > If file does not exist, no action
    *   is required */
   if (!path_is_valid(m3u_file->path))
   {
      success = true;
      goto end;
   }

   /* Read file from disk */
   if (filestream_read_file(m3u_file->path, (void**)&file_buf, &file_len) >= 0)
   {
      /* Split file into lines */
      if (file_len > 0)
         lines = string_split((const char*)file_buf, "\n");

      /* File buffer no longer required */
      if (file_buf)
      {
         free(file_buf);
         file_buf = NULL;
      }
   }
   /* File IO error... */
   else
      goto end;

   /* If file was empty, no action is required */
   if (!lines)
   {
      success = true;
      goto end;
   }

   /* Parse lines of file */
   for (i = 0; i < lines->size; i++)
   {
      const char *line = lines->elems[i].data;

      if (string_is_empty(line))
         continue;

      /* Determine line 'type' */

      /* > '#LABEL:' */
      if (string_starts_with_size(line, M3U_FILE_NONSTD_LABEL,
            STRLEN_CONST(M3U_FILE_NONSTD_LABEL)))
      {
         /* Label is the string to the right
          * of '#LABEL:' */
         const char *label = line + STRLEN_CONST(M3U_FILE_NONSTD_LABEL);

         if (!string_is_empty(label))
         {
            strlcpy(
                  entry_label, line + STRLEN_CONST(M3U_FILE_NONSTD_LABEL),
                  sizeof(entry_label));
            string_trim_whitespace(entry_label);
         }
      }
      /* > '#EXTINF:' */
      else if (string_starts_with_size(line, M3U_FILE_EXTSTD_LABEL,
            STRLEN_CONST(M3U_FILE_EXTSTD_LABEL)))
      {
         /* Label is the string to the right
          * of the first comma */
         const char* label_ptr = strchr(
               line + STRLEN_CONST(M3U_FILE_EXTSTD_LABEL),
               M3U_FILE_EXTSTD_LABEL_TOKEN);

         if (!string_is_empty(label_ptr))
         {
            label_ptr++;
            if (!string_is_empty(label_ptr))
            {
               strlcpy(entry_label, label_ptr, sizeof(entry_label));
               string_trim_whitespace(entry_label);
            }
         }
      }
      /* > Ignore other comments/directives */
      else if (line[0] == M3U_FILE_COMMENT)
         continue;
      /* > An actual 'content' line */
      else
      {
         /* This is normally a file name/path, but may
          * have the format <content path>|<label> */
         const char *token_ptr = strchr(line, M3U_FILE_RETRO_LABEL_TOKEN);

         if (token_ptr)
         {
            size_t len = (size_t)(1 + token_ptr - line);

            /* Get entry_path segment */
            if (len > 0)
            {
               memset(entry_path, 0, sizeof(entry_path));
               strlcpy(
                     entry_path, line,
                     ((len < PATH_MAX_LENGTH ?
                           len : PATH_MAX_LENGTH) * sizeof(char)));
               string_trim_whitespace(entry_path);
            }

            /* Get entry_label segment */
            token_ptr++;
            if (*token_ptr != '\0')
            {
               strlcpy(entry_label, token_ptr, sizeof(entry_label));
               string_trim_whitespace(entry_label);
            }
         }
         else
         {
            /* Just a normal file name/path */
            strlcpy(entry_path, line, sizeof(entry_path));
            string_trim_whitespace(entry_path);
         }

         /* Add entry to file
          * > Note: The only way that m3u_file_add_entry()
          *   can fail here is if we run out of memory.
          *   This is a critical error, and m3u_file must
          *   be considered invalid in this case */
         if (!string_is_empty(entry_path) &&
             !m3u_file_add_entry(m3u_file, entry_path, entry_label))
            goto end;

         /* Reset entry_path/entry_label */
         entry_path[0]  = '\0';
         entry_label[0] = '\0';
      }
   }

   success = true;

end:
   /* Clean up */
   if (lines)
   {
      string_list_free(lines);
      lines = NULL;
   }

   if (file_buf)
   {
      free(file_buf);
      file_buf = NULL;
   }

   return success;
}

/* Creates and initialises an M3U file
 * - If 'path' refers to an existing file,
 *   contents is parsed
 * - If path does not exist, an empty M3U file
 *   is created
 * - Returned m3u_file_t object must be free'd using
 *   m3u_file_free()
 * - Returns NULL in the event of an error */
m3u_file_t *m3u_file_init(const char *path)
{
   m3u_file_t *m3u_file = NULL;
   char m3u_path[PATH_MAX_LENGTH];

   m3u_path[0] = '\0';

   /* Sanity check */
   if (string_is_empty(path))
      return NULL;

   /* Get 'real' file path */
   strlcpy(m3u_path, path, sizeof(m3u_path));
   path_resolve_realpath(m3u_path, sizeof(m3u_path), false);

   if (string_is_empty(m3u_path))
      return NULL;

   /* Create m3u_file_t object */
   m3u_file = (m3u_file_t*)malloc(sizeof(*m3u_file));

   if (!m3u_file)
      return NULL;

   /* Initialise members */
   m3u_file->path    = NULL;
   m3u_file->entries = NULL;

   /* Copy file path */
   m3u_file->path    = strdup(m3u_path);

   /* Read existing file contents from
    * disk, if required */
   if (!m3u_file_load(m3u_file))
   {
      m3u_file_free(m3u_file);
      return NULL;
   }

   return m3u_file;
}

/* Frees specified M3U file entry */
static void m3u_file_free_entry(m3u_file_entry_t *entry)
{
   if (!entry)
      return;

   if (entry->path)
      free(entry->path);

   if (entry->full_path)
      free(entry->full_path);

   if (entry->label)
      free(entry->label);

   entry->path      = NULL;
   entry->full_path = NULL;
   entry->label     = NULL;
}

/* Frees specified M3U file */
void m3u_file_free(m3u_file_t *m3u_file)
{
   size_t i;

   if (!m3u_file)
      return;

   if (m3u_file->path)
      free(m3u_file->path);

   m3u_file->path = NULL;

   /* Free entries */
   if (m3u_file->entries)
   {
      for (i = 0; i < RBUF_LEN(m3u_file->entries); i++)
      {
         m3u_file_entry_t *entry = &m3u_file->entries[i];
         m3u_file_free_entry(entry);
      }

      RBUF_FREE(m3u_file->entries);
   }

   free(m3u_file);
}

/* Getters */

/* Returns M3U file path */
char *m3u_file_get_path(m3u_file_t *m3u_file)
{
   if (!m3u_file)
      return NULL;

   return m3u_file->path;
}

/* Returns number of entries in M3U file */
size_t m3u_file_get_size(m3u_file_t *m3u_file)
{
   if (!m3u_file)
      return 0;

   return RBUF_LEN(m3u_file->entries);
}

/* Fetches specified M3U file entry
 * - Returns false if 'idx' is invalid, or internal
 *   entry is NULL */
bool m3u_file_get_entry(
      m3u_file_t *m3u_file, size_t idx, m3u_file_entry_t **entry)
{
   if (!m3u_file ||
       !entry ||
       (idx >= RBUF_LEN(m3u_file->entries)))
      return false;

   *entry = &m3u_file->entries[idx];

   if (!*entry)
      return false;

   return true;
}

/* Setters */

/* Adds specified entry to the M3U file
 * - Returns false if path is invalid, or
 *   memory could not be allocated for the
 *   entry */
bool m3u_file_add_entry(
      m3u_file_t *m3u_file, const char *path, const char *label)
{
   m3u_file_entry_t *entry = NULL;
   size_t num_entries;
   char full_path[PATH_MAX_LENGTH];

   full_path[0] = '\0';

   if (!m3u_file || string_is_empty(path))
      return false;

   /* Get current number of file entries */
   num_entries = RBUF_LEN(m3u_file->entries);

   /* Attempt to allocate memory for new entry */
   if (!RBUF_TRYFIT(m3u_file->entries, num_entries + 1))
      return false;

   /* Allocation successful - increment array size */
   RBUF_RESIZE(m3u_file->entries, num_entries + 1);

   /* Fetch entry at end of list, and zero-initialise
    * members */
   entry = &m3u_file->entries[num_entries];
   memset(entry, 0, sizeof(*entry));

   /* Copy path and label */
   entry->path = strdup(path);

   if (!string_is_empty(label))
      entry->label = strdup(label);

   /* Populate 'full_path' field */
   if (path_is_absolute(path))
   {
      strlcpy(full_path, path, sizeof(full_path));
      path_resolve_realpath(full_path, sizeof(full_path), false);
   }
   else
      fill_pathname_resolve_relative(
            full_path, m3u_file->path, path,
            sizeof(full_path));

   /* Handle unforeseen errors... */
   if (string_is_empty(full_path))
   {
      m3u_file_free_entry(entry);
      return false;
   }

   entry->full_path = strdup(full_path);

   return true;
}

/* Removes all entries in M3U file */
void m3u_file_clear(m3u_file_t *m3u_file)
{
   size_t i;

   if (!m3u_file)
      return;

   if (m3u_file->entries)
   {
      for (i = 0; i < RBUF_LEN(m3u_file->entries); i++)
      {
         m3u_file_entry_t *entry = &m3u_file->entries[i];
         m3u_file_free_entry(entry);
      }

      RBUF_FREE(m3u_file->entries);
   }
}

/* Saving */

/* Saves M3U file to disk
 * - Setting 'label_type' to M3U_FILE_LABEL_NONE
 *   just outputs entry paths - this the most
 *   common format supported by most cores
 * - Returns false in the event of an error */
bool m3u_file_save(
      m3u_file_t *m3u_file, enum m3u_file_label_type label_type)
{
   RFILE *file = NULL;
   size_t i;
   char base_dir[PATH_MAX_LENGTH];

   base_dir[0] = '\0';

   if (!m3u_file || !m3u_file->entries)
      return false;

   /* This should never happen */
   if (string_is_empty(m3u_file->path))
      return false;

   /* Get M3U file base directory */
   if (find_last_slash(m3u_file->path))
   {
      strlcpy(base_dir, m3u_file->path, sizeof(base_dir));
      path_basedir(base_dir);
   }

   /* Open file for writing */
   file = filestream_open(
         m3u_file->path,
         RETRO_VFS_FILE_ACCESS_WRITE,
         RETRO_VFS_FILE_ACCESS_HINT_NONE);

   if (!file)
      return false;

   /* Loop over entries */
   for (i = 0; i < RBUF_LEN(m3u_file->entries); i++)
   {
      m3u_file_entry_t *entry = &m3u_file->entries[i];
      char entry_path[PATH_MAX_LENGTH];

      entry_path[0] = '\0';

      if (!entry || string_is_empty(entry->full_path))
         continue;

      /* When writing M3U files, entry paths are
       * always relative */
      if (string_is_empty(base_dir))
         strlcpy(
               entry_path, entry->full_path,
               sizeof(entry_path));
      else
         path_relative_to(
               entry_path, entry->full_path, base_dir,
               sizeof(entry_path));

      if (string_is_empty(entry_path))
         continue;

      /* Check if we need to write a label */
      if (!string_is_empty(entry->label))
      {
         switch (label_type)
         {
            case M3U_FILE_LABEL_NONSTD:
               filestream_printf(
                     file, "%s%s\n%s\n",
                     M3U_FILE_NONSTD_LABEL, entry->label,
                     entry_path);
               break;
            case M3U_FILE_LABEL_EXTSTD:
               filestream_printf(
                     file, "%s%c%s\n%s\n",
                     M3U_FILE_EXTSTD_LABEL, M3U_FILE_EXTSTD_LABEL_TOKEN, entry->label,
                     entry_path);
               break;
            case M3U_FILE_LABEL_RETRO:
               filestream_printf(
                     file, "%s%c%s\n",
                     entry_path, M3U_FILE_RETRO_LABEL_TOKEN, entry->label);
               break;
            case M3U_FILE_LABEL_NONE:
            default:
               filestream_printf(
                     file, "%s\n", entry_path);
               break;
         }
      }
      /* No label - just write entry path */
      else
         filestream_printf(
               file, "%s\n", entry_path);
   }

   /* Close file */
   filestream_close(file);

   return true;
}

/* Utilities */

/* Internal qsort function */
static int m3u_file_qsort_func(
      const m3u_file_entry_t *a, const m3u_file_entry_t *b)
{
   if (!a || !b)
      return 0;

   if (string_is_empty(a->full_path) || string_is_empty(b->full_path))
      return 0;

   return strcasecmp(a->full_path, b->full_path);
}

/* Sorts M3U file entries in alphabetical order */
void m3u_file_qsort(m3u_file_t *m3u_file)
{
   size_t num_entries;

   if (!m3u_file)
      return;

   num_entries = RBUF_LEN(m3u_file->entries);

   if (num_entries < 2)
      return;

   qsort(
         m3u_file->entries, num_entries,
         sizeof(m3u_file_entry_t),
         (int (*)(const void *, const void *))m3u_file_qsort_func);
}

/* Returns true if specified path corresponds
 * to an M3U file (simple convenience function) */
bool m3u_file_is_m3u(const char *path)
{
   const char *file_ext = NULL;
   int32_t file_size;

   if (string_is_empty(path))
      return false;

   /* Check file extension */
   file_ext = path_get_extension(path);

   if (string_is_empty(file_ext))
      return false;

   if (!string_is_equal_noncase(file_ext, M3U_FILE_EXT))
      return false;

   /* Ensure file exists */
   if (!path_is_valid(path))
      return false;

   /* Ensure we have non-zero file size */
   file_size = path_get_size(path);

   if (file_size <= 0)
      return false;

   return true;
}
Commit	Line	Data
3719602c PC	1	/* Copyright (C) 2010-2020 The RetroArch team
	2	*
	3	* ---------------------------------------------------------------------------------------
	4	* The following license statement only applies to this file (m3u_file.c).
	5	* ---------------------------------------------------------------------------------------
	6	*
	7	* Permission is hereby granted, free of charge,
	8	* to any person obtaining a copy of this software and associated documentation files (the "Software"),
	9	* to deal in the Software without restriction, including without limitation the rights to
	10	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
	11	* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	16	* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	18	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	19	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	21	*/
	22
	23	#include <retro_miscellaneous.h>
	24
	25	#include <string/stdstring.h>
	26	#include <lists/string_list.h>
	27	#include <file/file_path.h>
	28	#include <streams/file_stream.h>
	29	#include <array/rbuf.h>
	30
	31	#include <formats/m3u_file.h>
	32
	33	/* We parse the following types of entry label:
	34	* - '#LABEL:<label>' non-standard, but used by
	35	* some cores
	36	* - '#EXTINF:<runtime>,<label>' standard extended
	37	* M3U directive
	38	* - '<content path>\|<label>' non-standard, but
	39	* used by some cores
	40	* All other comments/directives are ignored */
	41	#define M3U_FILE_COMMENT '#'
	42	#define M3U_FILE_NONSTD_LABEL "#LABEL:"
	43	#define M3U_FILE_EXTSTD_LABEL "#EXTINF:"
	44	#define M3U_FILE_EXTSTD_LABEL_TOKEN ','
	45	#define M3U_FILE_RETRO_LABEL_TOKEN '\|'
	46
	47	/* Holds all internal M3U file data
	48	* > Note the awkward name: 'content_m3u_file'
	49	* If we used just 'm3u_file' here, it would
	50	* lead to conflicts elsewhere... */
	51	struct content_m3u_file
	52	{
	53	char *path;
	54	m3u_file_entry_t *entries;
	55	};
	56
	57	/* File Initialisation / De-Initialisation */
	58
	59	/* Reads M3U file contents from disk
	60	* - Does nothing if file does not exist
	61	* - Returns false in the event of an error */
	62	static bool m3u_file_load(m3u_file_t *m3u_file)
	63	{
	64	const char *file_ext = NULL;
65	int64_t file_len = 0;
66	uint8_t *file_buf = NULL;
67	struct string_list *lines = NULL;
68	bool success = false;
69	size_t i;
70	char entry_path[PATH_MAX_LENGTH];
71	char entry_label[PATH_MAX_LENGTH];
72
73	entry_path[0] = '\0';
74	entry_label[0] = '\0';
75
76	if (!m3u_file)
77	goto end;
78
79	/* Check whether file exists
80	* > If path is empty, then an error
81	* has occurred... */
82	if (string_is_empty(m3u_file->path))
83	goto end;
84
85	/* > File must have the correct extension */
86	file_ext = path_get_extension(m3u_file->path);
87
88	if (string_is_empty(file_ext) \|\|
89	!string_is_equal_noncase(file_ext, M3U_FILE_EXT))
90	goto end;
91
92	/* > If file does not exist, no action
93	* is required */
94	if (!path_is_valid(m3u_file->path))
95	{
96	success = true;
97	goto end;
98	}
99
100	/* Read file from disk */
101	if (filestream_read_file(m3u_file->path, (void**)&file_buf, &file_len) >= 0)
102	{
103	/* Split file into lines */
104	if (file_len > 0)
105	lines = string_split((const char*)file_buf, "\n");
106
107	/* File buffer no longer required */
108	if (file_buf)
109	{
110	free(file_buf);
111	file_buf = NULL;
112	}
113	}
114	/* File IO error... */
115	else
116	goto end;
117
118	/* If file was empty, no action is required */
119	if (!lines)
120	{
121	success = true;
122	goto end;
123	}
124
125	/* Parse lines of file */
126	for (i = 0; i < lines->size; i++)
127	{
128	const char *line = lines->elems[i].data;
129
130	if (string_is_empty(line))
131	continue;
132
133	/* Determine line 'type' */
134
135	/* > '#LABEL:' */
136	if (string_starts_with_size(line, M3U_FILE_NONSTD_LABEL,
137	STRLEN_CONST(M3U_FILE_NONSTD_LABEL)))
138	{
139	/* Label is the string to the right
140	* of '#LABEL:' */
141	const char *label = line + STRLEN_CONST(M3U_FILE_NONSTD_LABEL);
142
143	if (!string_is_empty(label))
144	{
145	strlcpy(
146	entry_label, line + STRLEN_CONST(M3U_FILE_NONSTD_LABEL),
147	sizeof(entry_label));
148	string_trim_whitespace(entry_label);
149	}
150	}
151	/* > '#EXTINF:' */
152	else if (string_starts_with_size(line, M3U_FILE_EXTSTD_LABEL,
153	STRLEN_CONST(M3U_FILE_EXTSTD_LABEL)))
154	{
155	/* Label is the string to the right
156	* of the first comma */
157	const char* label_ptr = strchr(
158	line + STRLEN_CONST(M3U_FILE_EXTSTD_LABEL),
159	M3U_FILE_EXTSTD_LABEL_TOKEN);
160
161	if (!string_is_empty(label_ptr))
162	{
163	label_ptr++;
164	if (!string_is_empty(label_ptr))
165	{
166	strlcpy(entry_label, label_ptr, sizeof(entry_label));
167	string_trim_whitespace(entry_label);
168	}
169	}
170	}
171	/* > Ignore other comments/directives */
172	else if (line[0] == M3U_FILE_COMMENT)
173	continue;
174	/* > An actual 'content' line */
175	else
176	{
177	/* This is normally a file name/path, but may
178	* have the format <content path>\|<label> */
179	const char *token_ptr = strchr(line, M3U_FILE_RETRO_LABEL_TOKEN);
180
181	if (token_ptr)
182	{
183	size_t len = (size_t)(1 + token_ptr - line);
184
185	/* Get entry_path segment */
186	if (len > 0)
187	{
188	memset(entry_path, 0, sizeof(entry_path));
189	strlcpy(
190	entry_path, line,
191	((len < PATH_MAX_LENGTH ?
192	len : PATH_MAX_LENGTH) * sizeof(char)));
193	string_trim_whitespace(entry_path);
194	}
195
196	/* Get entry_label segment */
197	token_ptr++;
198	if (*token_ptr != '\0')
199	{
200	strlcpy(entry_label, token_ptr, sizeof(entry_label));
201	string_trim_whitespace(entry_label);
202	}
203	}
204	else
205	{
206	/* Just a normal file name/path */
207	strlcpy(entry_path, line, sizeof(entry_path));
208	string_trim_whitespace(entry_path);
209	}
210
211	/* Add entry to file
212	* > Note: The only way that m3u_file_add_entry()
213	* can fail here is if we run out of memory.
214	* This is a critical error, and m3u_file must
215	* be considered invalid in this case */
216	if (!string_is_empty(entry_path) &&
217	!m3u_file_add_entry(m3u_file, entry_path, entry_label))
218	goto end;
219
220	/* Reset entry_path/entry_label */
221	entry_path[0] = '\0';
222	entry_label[0] = '\0';
223	}
224	}
225
226	success = true;
227
228	end:
229	/* Clean up */
230	if (lines)
231	{
232	string_list_free(lines);
233	lines = NULL;
234	}
235
236	if (file_buf)
237	{
238	free(file_buf);
239	file_buf = NULL;
240	}
241
242	return success;
243	}
244
245	/* Creates and initialises an M3U file
246	* - If 'path' refers to an existing file,
247	* contents is parsed
248	* - If path does not exist, an empty M3U file
249	* is created
250	* - Returned m3u_file_t object must be free'd using
251	* m3u_file_free()
252	* - Returns NULL in the event of an error */
253	m3u_file_t m3u_file_init(const char path)
254	{
255	m3u_file_t *m3u_file = NULL;
256	char m3u_path[PATH_MAX_LENGTH];
257
258	m3u_path[0] = '\0';
259
260	/* Sanity check */
261	if (string_is_empty(path))
262	return NULL;
263
264	/* Get 'real' file path */
265	strlcpy(m3u_path, path, sizeof(m3u_path));
266	path_resolve_realpath(m3u_path, sizeof(m3u_path), false);
267
268	if (string_is_empty(m3u_path))
269	return NULL;
270
271	/* Create m3u_file_t object */
272	m3u_file = (m3u_file_t)malloc(sizeof(m3u_file));
273
274	if (!m3u_file)
275	return NULL;
276
277	/* Initialise members */
278	m3u_file->path = NULL;
279	m3u_file->entries = NULL;
280
281	/* Copy file path */
282	m3u_file->path = strdup(m3u_path);
283
284	/* Read existing file contents from
285	* disk, if required */
286	if (!m3u_file_load(m3u_file))
287	{
288	m3u_file_free(m3u_file);
289	return NULL;
290	}
291
292	return m3u_file;
293	}
294
295	/* Frees specified M3U file entry */
296	static void m3u_file_free_entry(m3u_file_entry_t *entry)
297	{
298	if (!entry)
299	return;
300
301	if (entry->path)
302	free(entry->path);
303
304	if (entry->full_path)
305	free(entry->full_path);
306
307	if (entry->label)
308	free(entry->label);
309
310	entry->path = NULL;
311	entry->full_path = NULL;
312	entry->label = NULL;
313	}
314
315	/* Frees specified M3U file */
316	void m3u_file_free(m3u_file_t *m3u_file)
317	{
318	size_t i;
319
320	if (!m3u_file)
321	return;
322
323	if (m3u_file->path)
324	free(m3u_file->path);
325
326	m3u_file->path = NULL;
327
328	/* Free entries */
329	if (m3u_file->entries)
330	{
331	for (i = 0; i < RBUF_LEN(m3u_file->entries); i++)
332	{
333	m3u_file_entry_t *entry = &m3u_file->entries[i];
334	m3u_file_free_entry(entry);
335	}
336
337	RBUF_FREE(m3u_file->entries);
338	}
339
340	free(m3u_file);
341	}
342
343	/* Getters */
344
345	/* Returns M3U file path */
346	char m3u_file_get_path(m3u_file_t m3u_file)
347	{
348	if (!m3u_file)
349	return NULL;
350
351	return m3u_file->path;
352	}
353
354	/* Returns number of entries in M3U file */
355	size_t m3u_file_get_size(m3u_file_t *m3u_file)
356	{
357	if (!m3u_file)
358	return 0;
359
360	return RBUF_LEN(m3u_file->entries);
361	}
362
363	/* Fetches specified M3U file entry
364	* - Returns false if 'idx' is invalid, or internal
365	* entry is NULL */
366	bool m3u_file_get_entry(
367	m3u_file_t m3u_file, size_t idx, m3u_file_entry_t *entry)
368	{
369	if (!m3u_file \|\|
370	!entry \|\|
371	(idx >= RBUF_LEN(m3u_file->entries)))
372	return false;
373
374	*entry = &m3u_file->entries[idx];
375
376	if (!*entry)
377	return false;
378
379	return true;
380	}
381
382	/* Setters */
383
384	/* Adds specified entry to the M3U file
385	* - Returns false if path is invalid, or
386	* memory could not be allocated for the
387	* entry */
388	bool m3u_file_add_entry(
389	m3u_file_t m3u_file, const char path, const char *label)
390	{
391	m3u_file_entry_t *entry = NULL;
392	size_t num_entries;
393	char full_path[PATH_MAX_LENGTH];
394
395	full_path[0] = '\0';
396
397	if (!m3u_file \|\| string_is_empty(path))
398	return false;
399
400	/* Get current number of file entries */
401	num_entries = RBUF_LEN(m3u_file->entries);
402
403	/* Attempt to allocate memory for new entry */
404	if (!RBUF_TRYFIT(m3u_file->entries, num_entries + 1))
405	return false;
406
407	/* Allocation successful - increment array size */
408	RBUF_RESIZE(m3u_file->entries, num_entries + 1);
409
410	/* Fetch entry at end of list, and zero-initialise
411	* members */
412	entry = &m3u_file->entries[num_entries];
413	memset(entry, 0, sizeof(*entry));
414
415	/* Copy path and label */
416	entry->path = strdup(path);
417
418	if (!string_is_empty(label))
419	entry->label = strdup(label);
420
421	/* Populate 'full_path' field */
422	if (path_is_absolute(path))
423	{
424	strlcpy(full_path, path, sizeof(full_path));
425	path_resolve_realpath(full_path, sizeof(full_path), false);
426	}
427	else
428	fill_pathname_resolve_relative(
429	full_path, m3u_file->path, path,
430	sizeof(full_path));
431
432	/* Handle unforeseen errors... */
433	if (string_is_empty(full_path))
434	{
435	m3u_file_free_entry(entry);
436	return false;
437	}
438
439	entry->full_path = strdup(full_path);
440
441	return true;
442	}
443
444	/* Removes all entries in M3U file */
445	void m3u_file_clear(m3u_file_t *m3u_file)
446	{
447	size_t i;
448
449	if (!m3u_file)
450	return;
451
452	if (m3u_file->entries)
453	{
454	for (i = 0; i < RBUF_LEN(m3u_file->entries); i++)
455	{
456	m3u_file_entry_t *entry = &m3u_file->entries[i];
457	m3u_file_free_entry(entry);
458	}
459
460	RBUF_FREE(m3u_file->entries);
461	}
462	}
463
464	/* Saving */
465
466	/* Saves M3U file to disk
467	* - Setting 'label_type' to M3U_FILE_LABEL_NONE
468	* just outputs entry paths - this the most
469	* common format supported by most cores
470	* - Returns false in the event of an error */
471	bool m3u_file_save(
472	m3u_file_t *m3u_file, enum m3u_file_label_type label_type)
473	{
474	RFILE *file = NULL;
475	size_t i;
476	char base_dir[PATH_MAX_LENGTH];
477
478	base_dir[0] = '\0';
479
480	if (!m3u_file \|\| !m3u_file->entries)
481	return false;
482
483	/* This should never happen */
484	if (string_is_empty(m3u_file->path))
485	return false;
486
487	/* Get M3U file base directory */
488	if (find_last_slash(m3u_file->path))
489	{
490	strlcpy(base_dir, m3u_file->path, sizeof(base_dir));
491	path_basedir(base_dir);
492	}
493
494	/* Open file for writing */
495	file = filestream_open(
496	m3u_file->path,
497	RETRO_VFS_FILE_ACCESS_WRITE,
498	RETRO_VFS_FILE_ACCESS_HINT_NONE);
499
500	if (!file)
501	return false;
502
503	/* Loop over entries */
504	for (i = 0; i < RBUF_LEN(m3u_file->entries); i++)
505	{
506	m3u_file_entry_t *entry = &m3u_file->entries[i];
507	char entry_path[PATH_MAX_LENGTH];
508
509	entry_path[0] = '\0';
510
511	if (!entry \|\| string_is_empty(entry->full_path))
512	continue;
513
514	/* When writing M3U files, entry paths are
515	* always relative */
516	if (string_is_empty(base_dir))
517	strlcpy(
518	entry_path, entry->full_path,
519	sizeof(entry_path));
520	else
521	path_relative_to(
522	entry_path, entry->full_path, base_dir,
523	sizeof(entry_path));
524
525	if (string_is_empty(entry_path))
526	continue;
527
528	/* Check if we need to write a label */
529	if (!string_is_empty(entry->label))
530	{
531	switch (label_type)
532	{
533	case M3U_FILE_LABEL_NONSTD:
534	filestream_printf(
535	file, "%s%s\n%s\n",
536	M3U_FILE_NONSTD_LABEL, entry->label,
537	entry_path);
538	break;
539	case M3U_FILE_LABEL_EXTSTD:
540	filestream_printf(
541	file, "%s%c%s\n%s\n",
542	M3U_FILE_EXTSTD_LABEL, M3U_FILE_EXTSTD_LABEL_TOKEN, entry->label,
543	entry_path);
544	break;
545	case M3U_FILE_LABEL_RETRO:
546	filestream_printf(
547	file, "%s%c%s\n",
548	entry_path, M3U_FILE_RETRO_LABEL_TOKEN, entry->label);
549	break;
550	case M3U_FILE_LABEL_NONE:
551	default:
552	filestream_printf(
553	file, "%s\n", entry_path);
554	break;
555	}
556	}
557	/* No label - just write entry path */
558	else
559	filestream_printf(
560	file, "%s\n", entry_path);
561	}
562
563	/* Close file */
564	filestream_close(file);
565
566	return true;
567	}
568
569	/* Utilities */
570
571	/* Internal qsort function */
572	static int m3u_file_qsort_func(
573	const m3u_file_entry_t a, const m3u_file_entry_t b)
574	{
575	if (!a \|\| !b)
576	return 0;
577
578	if (string_is_empty(a->full_path) \|\| string_is_empty(b->full_path))
579	return 0;
580
581	return strcasecmp(a->full_path, b->full_path);
582	}
583
584	/* Sorts M3U file entries in alphabetical order */
585	void m3u_file_qsort(m3u_file_t *m3u_file)
586	{
587	size_t num_entries;
588
589	if (!m3u_file)
590	return;
591
592	num_entries = RBUF_LEN(m3u_file->entries);
593
594	if (num_entries < 2)
595	return;
596
597	qsort(
598	m3u_file->entries, num_entries,
599	sizeof(m3u_file_entry_t),
600	(int ()(const void , const void *))m3u_file_qsort_func);
601	}
602
603	/* Returns true if specified path corresponds
604	* to an M3U file (simple convenience function) */
605	bool m3u_file_is_m3u(const char *path)
606	{
607	const char *file_ext = NULL;
608	int32_t file_size;
609
610	if (string_is_empty(path))
611	return false;
612
613	/* Check file extension */
614	file_ext = path_get_extension(path);
615
616	if (string_is_empty(file_ext))
617	return false;
618
619	if (!string_is_equal_noncase(file_ext, M3U_FILE_EXT))
620	return false;
621
622	/* Ensure file exists */
623	if (!path_is_valid(path))
624	return false;
625
626	/* Ensure we have non-zero file size */
627	file_size = path_get_size(path);
628
629	if (file_size <= 0)
630	return false;
631
632	return true;
633	}