support.c

   1 /*
   2
   3     Ann Hell Ex Machina - Music Software
   4     Copyright (C) 2003/2007 Angel Ortega <angel@triptico.com>
   5
   6     support.c - Miscellaneous support functions
   7
   8     This program is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU General Public License
  10     as published by the Free Software Foundation; either version 2
  11     of the License, or (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21
  22     http://www.triptico.com
  23
  24 */
  25
  26 #include "config.h"
  27
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <sys/stat.h>
  33 #include <sys/types.h>
  34
  35 #include "ahxm.h"
  36 #include "sha1.h"
  37
  38 /*******************
  39         Data
  40 ********************/
  41
  42 static char **library_path = NULL;
  43 static int n_library_paths = 0;
  44
  45 static char located_file[2048];
  46
  47 /* global verbose flag */
  48 int verbose = 1;
  49
  50 /* global tracing flag */
  51 int trace = 0;
  52
  53 /* transparent converters */
  54 struct transconv {
  55         char *from;             /* extension from */
  56         char *to;               /* extension to */
  57         char *convcmd;          /* sprintf() format for converting command */
  58 };
  59
  60 static struct transconv *transconvs = NULL;
  61 static int n_transconvs = 0;
  62
  63 /*******************
  64         Code
  65 ********************/
  66
  67 /**
  68  * libpath_add - Adds a directory path to the search path
  69  * @path: the directory path
  70  * @strip: flag to strip the upper level
  71  *
  72  * Adds @path to the list of searchable paths for libpath_fopen(),
  73  * optionally stripping the upper level if @strip is set.
  74  * The last part of the path is stripped before being stored,
  75  * and duplication is avoided.
  76  */
  77 void libpath_add(char *path, int strip)
  78 {
  79         int n;
  80         char *ptr;
  81
  82         /* if path starts with ~, set it to $HOME */
  83         if (*path == '~') {
  84                 char *new;
  85                 char *home;
  86
  87                 if ((home = getenv("HOME")) == NULL)
  88                         return;
  89
  90                 if ((new = malloc(strlen(home) + strlen(path) + 2)) == NULL)
  91                         return;
  92
  93                 strcpy(new, home);
  94                 strcat(new, "/");
  95                 strcat(new, path + 1);
  96
  97                 path = new;
  98         }
  99         else {
 100                 /* just duplicate */
 101                 path = strdup(path);
 102         }
 103
 104         /* if no directory path remains, abort */
 105         if ((ptr = strrchr(path, '/')) == NULL) {
 106                 free(path);
 107                 return;
 108         }
 109
 110         /* strip the filename part */
 111         if (strip)
 112                 *ptr = '\0';
 113
 114         /* now try to find if that path is already stored */
 115         for (n = 0; n < n_library_paths; n++) {
 116                 if (strcmp(path, library_path[n]) == 0) {
 117                         /* found; free and return */
 118                         free(path);
 119                         return;
 120                 }
 121         }
 122
 123         /* add room for the new path */
 124         n_library_paths++;
 125         library_path = (char **) realloc(library_path, n_library_paths * sizeof(char *));
 126
 127         /* store */
 128         library_path[n_library_paths - 1] = path;
 129 }
 130
 131
 132 /**
 133  * libpath_fopen - Opens a file, optionally searching in a path list
 134  * @filename: the file name
 135  * @mode: the file mode
 136  *
 137  * Opens a file. If the file is found as is, it's opened;
 138  * otherwise, the full list of directory paths maintained by
 139  * libpath_add() is searched until it's found or the
 140  * end of the list is reached. Whenever a file
 141  * is successfully opened, its path is also stored.
 142  */
 143 FILE *libpath_fopen(char *filename, char *mode)
 144 {
 145         int n;
 146         FILE *f = NULL;
 147
 148         /* try first here */
 149         if ((f = fopen(filename, mode)) != NULL) {
 150                 strncpy(located_file, filename, sizeof(located_file));
 151                 located_file[sizeof(located_file) - 1] = '\0';
 152
 153                 libpath_add(filename, 1);
 154                 return f;
 155         }
 156
 157         /* couldn't open; try concatenating all stored paths */
 158         for (n = n_library_paths - 1; n >= 0; n--) {
 159                 snprintf(located_file, sizeof(located_file), "%s/%s",
 160                          library_path[n], filename);
 161                 located_file[sizeof(located_file) - 1] = '\0';
 162
 163                 if ((f = fopen(located_file, mode)) != NULL) {
 164                         libpath_add(located_file, 1);
 165                         break;
 166                 }
 167         }
 168
 169         return f;
 170 }
 171
 172
 173 /**
 174  * libpath_locate - Locates a file inside the path
 175  * @filename: the file to be located
 176  *
 177  * Locates a file inside the library path maintained by libpath_fopen()
 178  * and add_library_path(). If the file is found, a pointer to a static
 179  * buffer containing the real path of the file is returned, or
 180  * NULL otherwise.
 181  */
 182 char *libpath_locate(char *filename)
 183 {
 184         FILE *f;
 185
 186         if ((f = libpath_fopen(filename, "r")) == NULL)
 187                 return NULL;
 188
 189         fclose(f);
 190         return located_file;
 191 }
 192
 193
 194 /** transparent conversions **/
 195
 196 void transconv_add(char *from, char *to, char *convcmd)
 197 /* adds a converter */
 198 {
 199         struct transconv *t;
 200
 201         GROW(transconvs, n_transconvs, struct transconv);
 202
 203         t = &transconvs[n_transconvs++];
 204
 205         t->from = strdup(from);
 206         t->to = strdup(to);
 207         t->convcmd = strdup(convcmd);
 208 }
 209
 210
 211 static char *transconv_sha_file(char *file, char *ext)
 212 /* builds a unique cache file basename using a SHA1 hash */
 213 {
 214         static char c_file[64];
 215         unsigned char sha1[20];
 216         SHA_CTX c;
 217         int n;
 218
 219         SHA1_Init(&c);
 220         SHA1_Update(&c, file, strlen(file));
 221         SHA1_Update(&c, ext, strlen(ext));
 222         SHA1_Final(sha1, &c);
 223
 224         for (n = 0; n < sizeof(sha1); n++) {
 225                 char tmp[3];
 226
 227                 snprintf(tmp, sizeof(tmp), "%02x", sha1[n]);
 228                 c_file[n * 2] = tmp[0];
 229                 c_file[(n * 2) + 1] = tmp[1];
 230         }
 231
 232         c_file[n * 2] = '\0';
 233         return c_file;
 234 }
 235
 236
 237 static char *transconv_unique_file(char *file, char *ext, char *dir)
 238 /* builds a unique cache file name with complete path */
 239 {
 240         static char tmp[2048];
 241         char *c_path = NULL;
 242
 243         if ((c_path = getenv("TEMP")) == NULL)
 244                 if ((c_path = getenv("TMP")) == NULL)
 245                         c_path = "/tmp";
 246
 247         /* build the directory cache name */
 248         snprintf(tmp, sizeof(tmp), "%s/%s-%d", c_path, dir, getuid());
 249         tmp[sizeof(tmp) - 1] = '\0';
 250
 251         /* create the cache directory */
 252         mkdir(tmp, 0755);
 253
 254         strcat(tmp, "/");
 255         strcat(tmp, transconv_sha_file(file, ext));
 256         strcat(tmp, ext);
 257
 258         return tmp;
 259 }
 260
 261
 262 char *transconv_pipe(char *cmd, char *ext, char *dir)
 263 /* executes cmd as a pipe */
 264 {
 265         char *c_file = transconv_unique_file(cmd, ext, dir);
 266
 267         /* does the file already exist? */
 268         if (access(c_file, R_OK)) {
 269                 char tmp[2048];
 270
 271                 snprintf(tmp, sizeof(tmp), cmd, c_file);
 272                 tmp[sizeof(tmp) - 1] = '\0';
 273
 274                 if (verbose >= 2)
 275                         printf("Converting: %s\n", tmp);
 276
 277                 system(tmp);
 278         }
 279
 280         return c_file;
 281 }
 282
 283
 284 char *transconv(char *file, char *ext, char *dir)
 285 /* converts using the transparent converters and the cache, if needed */
 286 {
 287         char *this_ext;
 288         char *c_file;
 289         int n;
 290         struct transconv *t;
 291
 292         /* gets this file extension */
 293         if (file == NULL || (this_ext = strrchr(file, '.')) == NULL)
 294                 return NULL;
 295
 296         /* if it's already the desired type, do nothing */
 297         if (strcmp(ext, this_ext) == 0)
 298                 return file;
 299
 300         /* get a unique name */
 301         c_file = transconv_unique_file(file, ext, dir);
 302
 303         /* does the file already exist? */
 304         if (access(c_file, R_OK) == 0)
 305                 return c_file;
 306
 307         /* no; look for a suitable converter */
 308         for (n = 0, t = transconvs; n < n_transconvs; n++, t++) {
 309                 if (strcmp(t->from, ".*") == 0 ||
 310                     (strcmp(ext, t->to) == 0 && strcmp(this_ext, t->from) == 0)) {
 311                         char tmp[2048];
 312
 313                         /* found a converter! just do it */
 314                         snprintf(tmp, sizeof(tmp), t->convcmd, c_file, file);
 315                         tmp[sizeof(tmp) - 1] = '\0';
 316
 317                         if (verbose >= 2)
 318                                 printf("Executing: %s\n", tmp);
 319
 320                         if (system(tmp) == 0)
 321                                 break;
 322                         else
 323                                 unlink(c_file);
 324                 }
 325         }
 326
 327         return c_file;
 328 }