src/misc/scan_scripts.c

   1 /* libquvi
   2  * Copyright (C) 2012,2013  Toni Gundogdu <legatvs@gmail.com>
   3  *
   4  * This file is part of libquvi <http://quvi.sourceforge.net/>.
   5  *
   6  * This library is free software: you can redistribute it and/or
   7  * modify it under the terms of the GNU Affero General Public
   8  * License as published by the Free Software Foundation, either
   9  * version 3 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU Affero General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Affero General
  17  * Public License along with this library.  If not, see
  18  * <http://www.gnu.org/licenses/>.
  19  */
  20
  21 #include "config.h"
  22
  23 #include <string.h>
  24 #include <glib.h>
  25
  26 #include "quvi.h"
  27 /* -- */
  28 #include "_quvi_s.h"
  29 #include "_quvi_media_s.h"
  30 #include "_quvi_subtitle_export_s.h"
  31 #include "_quvi_subtitle_s.h"
  32 #include "_quvi_playlist_s.h"
  33 #include "_quvi_script_s.h"
  34 /* -- */
  35 #include "misc/script_free.h"
  36 #include "misc/subtitle_export.h"
  37 #include "misc/subtitle.h"
  38 #include "misc/playlist.h"
  39 #include "misc/media.h"
  40 #include "misc/re.h"
  41 #include "lua/exec.h"
  42
  43 /* Return path to script file. */
  44 static GString *_get_fpath(const gchar *path, const gchar *fname)
  45 {
  46   GString *r;
  47   gchar *s;
  48
  49   s = g_build_filename(path, fname, NULL);
  50   r = g_string_new(s);
  51
  52   g_free(s);
  53   s = NULL;
  54
  55   return (r);
  56 }
  57
  58 /* Return SHA1 for script file. */
  59 static GString *_file_sha1(const GString *c)
  60 {
  61   GString *r = g_string_new(NULL);
  62   if (c != NULL)
  63     {
  64       gchar *s = g_compute_checksum_for_string(G_CHECKSUM_SHA1, c->str, -1);
  65       g_string_assign(r, s);
  66       g_free(s);
  67       s = NULL;
  68     }
  69   return (r);
  70 }
  71
  72 /* Return file contents in a GString. */
  73 static GString *_contents(GString *fpath)
  74 {
  75   gchar *c = NULL;
  76   g_file_get_contents(fpath->str, &c, NULL, NULL);
  77   if (c != NULL)
  78     {
  79       GString *s = g_string_new(c);
  80       g_free(c);
  81       c = NULL;
  82       return (s);
  83     }
  84   return (NULL);
  85 }
  86
  87 static gboolean excl_scripts_dir;
  88 static const gchar *scripts_dir;
  89 static const gchar *show_dir;
  90 const gchar *show_script;
  91
  92 typedef QuviError (*exec_script_ident_callback)(gpointer, GSList*);
  93 typedef gpointer (*new_ident_callback)(_quvi_t, const gchar*);
  94 typedef void (*free_ident_callback)(gpointer);
  95
  96 /* Parses the values returned by the ident function. */
  97 static void _chk_script_ident(_quvi_t q, _quvi_script_t qs, gboolean *ok,
  98                               new_ident_callback cb_new,
  99                               exec_script_ident_callback cb_exec,
 100                               free_ident_callback cb_free)
 101 {
 102   static const gchar URL[] = "http://foo";
 103
 104   QuviError r;
 105   gpointer p;
 106   GSList *s;
 107
 108   s = g_slist_prepend(NULL, qs);
 109   p = cb_new(q, URL);
 110   r = cb_exec(p, s);
 111
 112   g_slist_free(s);
 113   cb_free(p);
 114
 115   /* Script ident function should return "no support". If anything else
 116    * is returned, there's something wrong with the script. */
 117   if (r == QUVI_ERROR_NO_SUPPORT)
 118     *ok = TRUE;
 119   else
 120     {
 121       g_critical("[%s] %s", __func__, q->status.errmsg->str);
 122       *ok = FALSE;
 123     }
 124 }
 125
 126 /* Check if a pattern matches in a string. */
 127 static gboolean _chk(const gchar *s, const gchar *p)
 128 {
 129   const gboolean r = m_match(s, p);
 130   if (show_script != NULL && strlen(show_script) >0)
 131     {
 132       if (r == FALSE)
 133         {
 134           g_message("[%s] libquvi: nothing matched the pattern `%s'",
 135                     __func__, p);
 136         }
 137     }
 138   return (r);
 139 }
 140
 141 /* New script */
 142 static gpointer _script_new(const gchar *fpath, const gchar *fname, GString *c)
 143 {
 144   _quvi_script_t qs = g_new0(struct _quvi_script_s, 1);
 145   qs->export.format = g_string_new(NULL);
 146   qs->domains = g_string_new(NULL);
 147   qs->fpath = g_string_new(fpath);
 148   qs->fname = g_string_new(fname);
 149   qs->sha1 = _file_sha1(c);
 150   g_string_free(c, TRUE);
 151   return (qs);
 152 }
 153
 154 /* New media script. */
 155 static gpointer _new_media_script(_quvi_t q, const gchar *path,
 156                                   const gchar *fname)
 157 {
 158   _quvi_script_t qs;
 159   GString *fpath;
 160   GString *c;
 161
 162   fpath = _get_fpath(path, fname);
 163   c = _contents(fpath);
 164   qs = NULL;
 165
 166   if (c != NULL)
 167     {
 168       gboolean OK =
 169         (_chk(c->str, "^\\-\\-\\s+libquvi\\-scripts") == TRUE
 170          && _chk(c->str, "^function ident") == TRUE
 171          && _chk(c->str, "^function parse") == TRUE);
 172
 173       if (OK == TRUE)
 174         {
 175           qs = _script_new(fpath->str, fname, c);
 176
 177           _chk_script_ident(q, qs, &OK, m_media_new,
 178                             l_exec_media_script_ident,
 179                             (free_ident_callback) m_media_free);
 180         }
 181
 182       if (OK == FALSE)
 183         {
 184           m_script_free(qs, NULL);
 185           qs = NULL;
 186         }
 187     }
 188   g_string_free(fpath, TRUE);
 189   return (qs);
 190 }
 191
 192 /* New subtitle export script. */
 193 static gpointer
 194 _new_subtitle_export_script(_quvi_t q, const gchar *path, const gchar *fname)
 195 {
 196   _quvi_script_t qs;
 197   GString *fpath;
 198   GString *c;
 199
 200   fpath = _get_fpath(path, fname);
 201   c = _contents(fpath);
 202   qs = NULL;
 203
 204   if (c != NULL)
 205     {
 206       gboolean OK =
 207         (_chk(c->str, "^\\-\\-\\s+libquvi\\-scripts") == TRUE
 208          && _chk(c->str, "^function ident") == TRUE
 209          && _chk(c->str, "^function export") == TRUE);
 210
 211       if (OK == TRUE)
 212         {
 213           qs = _script_new(fpath->str, fname, c);
 214
 215           _chk_script_ident(q, qs, &OK, m_subtitle_export_new,
 216                             l_exec_subtitle_export_script_ident,
 217                             (free_ident_callback) m_subtitle_export_free);
 218         }
 219
 220       if (OK == FALSE)
 221         {
 222           m_script_free(qs, NULL);
 223           qs = NULL;
 224         }
 225     }
 226   g_string_free(fpath, TRUE);
 227   return (qs);
 228 }
 229
 230 /* New subtitle script. */
 231 static gpointer _new_subtitle_script(_quvi_t q, const gchar *path,
 232                                      const gchar *fname)
 233 {
 234   _quvi_script_t qs;
 235   GString *fpath;
 236   GString *c;
 237
 238   fpath = _get_fpath(path, fname);
 239   c = _contents(fpath);
 240   qs = NULL;
 241
 242   if (c != NULL)
 243     {
 244       gboolean OK =
 245         (_chk(c->str, "^\\-\\-\\s+libquvi\\-scripts") == TRUE
 246          && _chk(c->str, "^function ident") == TRUE
 247          && _chk(c->str, "^function parse") == TRUE);
 248
 249       if (OK == TRUE)
 250         {
 251           qs = _script_new(fpath->str, fname, c);
 252
 253           _chk_script_ident(q, qs, &OK, m_subtitle_new,
 254                             l_exec_subtitle_script_ident,
 255                             (free_ident_callback) m_subtitle_free);
 256         }
 257
 258       if (OK == FALSE)
 259         {
 260           m_script_free(qs, NULL);
 261           qs = NULL;
 262         }
 263     }
 264   g_string_free(fpath, TRUE);
 265   return (qs);
 266 }
 267
 268 /* New playlist script. */
 269 static gpointer _new_playlist_script(_quvi_t q, const gchar *path,
 270                                      const gchar *fname)
 271 {
 272   _quvi_script_t qs;
 273   GString *fpath;
 274   GString *c;
 275
 276   fpath = _get_fpath(path, fname);
 277   c = _contents(fpath);
 278   qs = NULL;
 279
 280   if (c != NULL)
 281     {
 282       gboolean OK =
 283         (_chk(c->str, "^\\-\\-\\s+libquvi\\-scripts") == TRUE
 284          && _chk(c->str, "^function ident") == TRUE
 285          && _chk(c->str, "^function parse") == TRUE);
 286
 287       if (OK == TRUE)
 288         {
 289           qs = _script_new(fpath->str, fname, c);
 290
 291           _chk_script_ident(q, qs, &OK, m_playlist_new,
 292                             l_exec_playlist_script_ident,
 293                             (free_ident_callback) m_playlist_free);
 294         }
 295
 296       if (OK == FALSE)
 297         {
 298           m_script_free(qs, NULL);
 299           qs = NULL;
 300         }
 301     }
 302   g_string_free(fpath, TRUE);
 303   return (qs);
 304 }
 305
 306 /* New scan script. */
 307 static gpointer _new_scan_script(_quvi_t q, const gchar *path,
 308                                  const gchar *fname)
 309 {
 310   _quvi_script_t qs;
 311   GString *fpath;
 312   GString *c;
 313
 314   fpath = _get_fpath(path, fname);
 315   c = _contents(fpath);
 316   qs = NULL;
 317
 318   if (c != NULL)
 319     {
 320       gboolean OK =
 321         (_chk(c->str, "^\\-\\-\\s+libquvi\\-scripts") == TRUE
 322          && _chk(c->str, "^function parse") == TRUE);
 323
 324       if (OK == TRUE)
 325         qs = _script_new(fpath->str, fname, c);
 326
 327       if (OK == FALSE)
 328         {
 329           m_script_free(qs, NULL);
 330           qs = NULL;
 331         }
 332     }
 333   g_string_free(fpath, TRUE);
 334   return (qs);
 335 }
 336
 337 /* New utility script. */
 338 static gpointer _new_util_script(_quvi_t q, const gchar *path,
 339                                  const gchar *fname)
 340 {
 341   _quvi_script_t qs;
 342   GString *fpath;
 343   GString *c;
 344
 345   fpath = _get_fpath(path, fname);
 346   c = _contents(fpath);
 347   qs = NULL;
 348
 349   if (c != NULL)
 350     {
 351       const gboolean OK =
 352         (_chk(c->str, "^\\-\\-\\s+libquvi\\-scripts") == TRUE);
 353
 354       if (OK == TRUE)
 355         qs = _script_new(fpath->str, fname, c);
 356
 357       if (OK == FALSE)
 358         {
 359           m_script_free(qs, NULL);
 360           qs = NULL;
 361         }
 362     }
 363   g_string_free(fpath, TRUE);
 364   return (qs);
 365 }
 366
 367 /* Check for duplicate script. */
 368 static gboolean _chkdup_script(_quvi_t q, gpointer script, GSList *l)
 369 {
 370   _quvi_script_t a, b;
 371   GSList *curr;
 372
 373   a = (_quvi_script_t) script;
 374   curr = l;
 375
 376   while (curr != NULL)
 377     {
 378       b = (_quvi_script_t) curr->data;
 379
 380       if (g_string_equal(a->sha1, b->sha1) == TRUE)
 381         return (TRUE);
 382
 383       curr = g_slist_next(curr);
 384     }
 385   return (FALSE);
 386 }
 387
 388 /* Include '*.lua' files only. */
 389 static gint _lua_files_only(const gchar *fpath)
 390 {
 391   const gchar *ext = strrchr(fpath, '.');
 392   return (fpath[0] != '.' && ext != NULL && strcmp(ext, ".lua") == 0);
 393 }
 394
 395 typedef gpointer (*new_script_callback)(_quvi_t, const gchar*, const gchar*);
 396 typedef gboolean (*chkdup_script_callback)(_quvi_t, gpointer, GSList*);
 397 typedef void (*free_script_callback)(gpointer, gpointer);
 398
 399 static gboolean _glob_scripts_dir(_quvi_t q, const gchar *path, GSList **dst,
 400                                   new_script_callback cb_new,
 401                                   free_script_callback cb_free,
 402                                   chkdup_script_callback cb_chkdup)
 403 {
 404   const gchar *fname;
 405   GDir *dir;
 406
 407   if (show_dir != NULL && strlen(show_dir) >0)
 408     g_message("[%s] libquvi: %s", __func__, path);
 409
 410   dir = g_dir_open(path, 0, NULL);
 411   if (dir == NULL)
 412     return (FALSE);
 413
 414   while ( (fname = g_dir_read_name(dir)) != NULL)
 415     {
 416       if (_lua_files_only(fname) != 0)
 417         {
 418           gpointer s = cb_new(q, path, fname);
 419           if (s == NULL)
 420             {
 421               /* Either file read failed or this is not a valid
 422                * libquvi-script. */
 423               if (show_script != NULL && strlen(show_script) >0)
 424                 {
 425                   g_message("[%s] libquvi: rejected: %s [INVALID]",
 426                             __func__, fname);
 427                 }
 428             }
 429           else
 430             {
 431               /* Valid libquvi-script file. */
 432               const gboolean r = cb_chkdup(q, s, *dst);
 433
 434               if (r == FALSE)
 435                 *dst = g_slist_prepend(*dst, s);
 436               else
 437                 {
 438                   cb_free(s, NULL);
 439                   s = NULL;
 440                 }
 441
 442               if (show_script != NULL && strlen(show_script) >0)
 443                 {
 444                   g_message("[%s] libquvi: %s: %s [%s]",
 445                             __func__,
 446                             (r == FALSE) ? "accepted" : "rejected",
 447                             fname,
 448                             (r == FALSE) ? "OK" : "DUPLICATE");
 449                 }
 450             }
 451         }
 452     }
 453   g_dir_close(dir);
 454   dir = NULL;
 455
 456   if (*dst != NULL)
 457     *dst = g_slist_reverse(*dst);
 458
 459   return (*dst != NULL);
 460 }
 461
 462 typedef enum
 463 {
 464   GLOB_SUBTITLE_EXPORT_SCRIPTS,
 465   GLOB_SUBTITLE_SCRIPTS,
 466   GLOB_PLAYLIST_SCRIPTS,
 467   GLOB_MEDIA_SCRIPTS,
 468   GLOB_SCAN_SCRIPTS,
 469   GLOB_UTIL_SCRIPTS,
 470   _GLOB_COUNT
 471 } GlobType;
 472
 473 static const gchar *glob_dir[_GLOB_COUNT] =
 474 {
 475   "subtitle/export/",
 476   "subtitle/",
 477   "playlist/",
 478   "media/",
 479   "scan/",
 480   "util/"
 481 };
 482
 483 static gboolean _glob_scripts(_quvi_t q, const GlobType t)
 484 {
 485   chkdup_script_callback cb_chkdup;
 486   free_script_callback cb_free;
 487   new_script_callback cb_new;
 488   GSList **dst;
 489   gchar *path;
 490
 491   switch (t)
 492     {
 493     case GLOB_SUBTITLE_EXPORT_SCRIPTS:
 494       cb_new = _new_subtitle_export_script;
 495       dst = &q->scripts.subtitle_export;
 496       break;
 497     case GLOB_SUBTITLE_SCRIPTS:
 498       cb_new = _new_subtitle_script;
 499       dst = &q->scripts.subtitle;
 500       break;
 501     case GLOB_PLAYLIST_SCRIPTS:
 502       cb_new = _new_playlist_script;
 503       dst = &q->scripts.playlist;
 504       break;
 505     case GLOB_MEDIA_SCRIPTS:
 506       cb_new = _new_media_script;
 507       dst = &q->scripts.media;
 508       break;
 509     case GLOB_SCAN_SCRIPTS:
 510       cb_new = _new_scan_script;
 511       dst = &q->scripts.scan;
 512       break;
 513     case GLOB_UTIL_SCRIPTS:
 514       cb_new = _new_util_script;
 515       dst = &q->scripts.util;
 516       break;
 517     default:
 518       g_error("%s: %d: invalid mode", __func__, __LINE__);
 519     }
 520
 521   cb_chkdup = _chkdup_script;
 522   cb_free = m_script_free;
 523
 524   {
 525     /* LIBQUVI_SCRIPTS_DIR */
 526
 527     if (scripts_dir != NULL && strlen(scripts_dir) >0)
 528       {
 529         gchar **r;
 530         gint i;
 531
 532         r = g_strsplit(scripts_dir, G_SEARCHPATH_SEPARATOR_S, 0);
 533         for (i=0; r[i] != NULL; ++i)
 534           {
 535             path = g_build_path(G_DIR_SEPARATOR_S, r[i], glob_dir[t], NULL);
 536             _glob_scripts_dir(q, path, dst, cb_new, cb_free, cb_chkdup);
 537
 538             g_free(path);
 539             path = NULL;
 540           }
 541         g_strfreev(r);
 542
 543         if (excl_scripts_dir == TRUE)
 544           return ((*dst != NULL) ? TRUE:FALSE);
 545       }
 546   }
 547
 548   {
 549     /* Current working directory. */
 550
 551     gchar *cwd = g_get_current_dir();
 552     path = g_build_path(G_DIR_SEPARATOR_S, cwd, glob_dir[t], NULL);
 553     g_free(cwd);
 554
 555     _glob_scripts_dir(q, path, dst, cb_new, cb_free, cb_chkdup);
 556     g_free(path);
 557   }
 558
 559 #ifdef SCRIPTSDIR
 560   {
 561     /* SCRIPTSDIR from config.h */
 562
 563     path = g_build_path(G_DIR_SEPARATOR_S,
 564                         SCRIPTSDIR, VERSION_MM, glob_dir[t], NULL);
 565
 566     _glob_scripts_dir(q, path, dst, cb_new, cb_free, cb_chkdup);
 567     g_free(path);
 568
 569     /* SCRIPTSDIR: Without the VERSION_MM. */
 570
 571     path = g_build_path(G_DIR_SEPARATOR_S, SCRIPTSDIR, glob_dir[t], NULL);
 572     _glob_scripts_dir(q, path, dst, cb_new, cb_free, cb_chkdup);
 573     g_free(path);
 574   }
 575 #endif /* SCRIPTSDIR */
 576
 577   return ((*dst != NULL) ? TRUE:FALSE);
 578 }
 579
 580 static gboolean _dir_exists(const gchar *path)
 581 {
 582   GDir *dir = g_dir_open(path, 0, NULL);
 583
 584   if (dir == NULL)
 585     return (FALSE);
 586
 587   g_dir_close(dir);
 588   dir = NULL;
 589
 590   return (TRUE);
 591 }
 592
 593 extern void l_modify_pkgpath(_quvi_t, const gchar*);
 594
 595 #define Q_COMMON_DIR "common"
 596
 597 /*
 598  * Check for the "common" directory, if found, append the path to the
 599  * Lua's package.path setting.  We're not interested in the contents of
 600  * this directory at this stage.
 601  */
 602 static void _chk_common_scripts(_quvi_t q)
 603 {
 604   gchar *path = NULL;
 605
 606   {
 607     /* LIBQUVI_SCRIPTS_DIR */
 608
 609     if (scripts_dir != NULL && strlen(scripts_dir) >0)
 610       {
 611         gchar **r;
 612         gint i;
 613
 614         r = g_strsplit(scripts_dir, G_SEARCHPATH_SEPARATOR_S, 0);
 615         for (i=0; r[i] != NULL; ++i)
 616           {
 617             path = g_build_path(G_DIR_SEPARATOR_S,
 618                                 scripts_dir, Q_COMMON_DIR, NULL);
 619
 620             if (_dir_exists(path) == TRUE)
 621               l_modify_pkgpath(q, path);
 622
 623             g_free(path);
 624             path = NULL;
 625           }
 626         g_strfreev(r);
 627         r = NULL;
 628
 629         if (excl_scripts_dir == TRUE)
 630           return;
 631       }
 632   }
 633
 634   {
 635     /* Current working directory. */
 636
 637     gchar *cwd = g_get_current_dir();
 638     path = g_build_path(G_DIR_SEPARATOR_S, cwd, Q_COMMON_DIR, NULL);
 639
 640     if (_dir_exists(path) == TRUE)
 641       l_modify_pkgpath(q, path);
 642
 643     g_free(path);
 644     path = NULL;
 645
 646     g_free(cwd);
 647     cwd = NULL;
 648   }
 649
 650 #ifdef SCRIPTSDIR
 651   {
 652     /* SCRIPTSDIR from config.h */
 653
 654     path = g_build_path(G_DIR_SEPARATOR_S,
 655                         SCRIPTSDIR, VERSION_MM, Q_COMMON_DIR, NULL);
 656
 657     if (_dir_exists(path) == TRUE)
 658       l_modify_pkgpath(q, path);
 659
 660     g_free(path);
 661
 662     /* SCRIPTSDIR: Without the VERSION_MM. */
 663
 664     path = g_build_path(G_DIR_SEPARATOR_S, SCRIPTSDIR, Q_COMMON_DIR, NULL);
 665
 666     if (_dir_exists(path) == TRUE)
 667       l_modify_pkgpath(q, path);
 668
 669     g_free(path);
 670     path = NULL;
 671   }
 672 #endif /* SCRIPTSDIR */
 673 }
 674
 675 #undef Q_COMMON_DIR
 676
 677 QuviError m_scan_scripts(_quvi_t q)
 678 {
 679   QuviError r, e;
 680   GlobType t;
 681
 682   {
 683     const gchar *s = g_getenv("LIBQUVI_EXCLUSIVE_SCRIPTS_DIR");
 684
 685     excl_scripts_dir = (s != NULL && strlen(s) >0)
 686                        ? TRUE
 687                        : FALSE;
 688   }
 689
 690   scripts_dir = g_getenv("LIBQUVI_SCRIPTS_DIR");
 691   show_script = g_getenv("LIBQUVI_SHOW_SCRIPT");
 692   show_dir = g_getenv("LIBQUVI_SHOW_DIR");
 693
 694   _chk_common_scripts(q);
 695
 696   e = QUVI_ERROR_CALLBACK_ABORTED+1;
 697   r = QUVI_OK;
 698   t = -1;
 699
 700   while (++t <_GLOB_COUNT && r ==QUVI_OK)
 701     {
 702       r = (_glob_scripts(q,t) == TRUE)  ? QUVI_OK : e;
 703       ++e;
 704     }
 705   return (r);
 706 }
 707
 708 /* vim: set ts=2 sw=2 tw=72 expandtab: */