lib/quvi.c

   1 /* quvi
   2  * Copyright (C) 2009,2010  Toni Gundogdu <legatvs@gmail.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301  USA
  18  */
  19
  20 #include "config.h"
  21
  22 #include <assert.h>
  23 #include <string.h>
  24
  25 #include <curl/curl.h>
  26
  27 #include "quvi/quvi.h"
  28 #include "internal.h"
  29 #include "lua_wrap.h"
  30 #include "util.h"
  31 #include "curl_wrap.h"
  32
  33 #define is_invarg(p) \
  34     do { if (p == NULL) return (QUVI_INVARG); } while (0)
  35
  36 #define is_badhandle(h) \
  37     do { if (h == NULL) return (QUVI_BADHANDLE); } while (0)
  38
  39 /* quvi_init */
  40
  41 QUVIcode quvi_init(quvi_t * dst)
  42 {
  43   _quvi_t quvi;
  44
  45   is_invarg(dst);
  46   *dst = 0;
  47
  48   quvi = calloc(1, sizeof(*quvi));
  49   if (!quvi)
  50     return (QUVI_MEM);
  51
  52   *dst = (quvi_t) quvi;
  53
  54   curl_global_init(CURL_GLOBAL_ALL);
  55
  56   quvi->curl = curl_easy_init();
  57   if (!quvi->curl)
  58     {
  59       _free(quvi);
  60       return (QUVI_CURLINIT);
  61     }
  62
  63   /* Set library defaults. */
  64   quvi_setopt(quvi, QUVIOPT_FORMAT, "default");
  65   quvi_setopt(quvi, QUVIOPT_CATEGORY, QUVIPROTO_HTTP);
  66
  67   curl_easy_setopt(quvi->curl, CURLOPT_USERAGENT, "Mozilla/5.0");
  68   curl_easy_setopt(quvi->curl, CURLOPT_FOLLOWLOCATION, 1L);
  69   curl_easy_setopt(quvi->curl, CURLOPT_NOBODY, 0L);
  70
  71   return (init_lua(quvi));
  72 }
  73
  74 /* quvi_close */
  75
  76 void quvi_close(quvi_t * handle)
  77 {
  78   _quvi_t *quvi;
  79
  80   quvi = (_quvi_t *) handle;
  81
  82   if (quvi && *quvi)
  83     {
  84
  85       free_lua(quvi);
  86       assert((*quvi)->util_scripts == NULL);
  87       assert((*quvi)->website_scripts == NULL);
  88
  89       _free((*quvi)->format);
  90       assert((*quvi)->format == NULL);
  91
  92       _free((*quvi)->errmsg);
  93       assert((*quvi)->errmsg == NULL);
  94
  95       curl_easy_cleanup((*quvi)->curl);
  96       (*quvi)->curl = NULL;
  97
  98       _free(*quvi);
  99       assert((*quvi) == NULL);
 100
 101       curl_global_cleanup();
 102     }
 103 }
 104
 105 /* quvi_supported */
 106
 107 QUVIcode quvi_supported(quvi_t quvi, char *url)
 108 {
 109   _quvi_video_t video;
 110   QUVIcode rc;
 111
 112   is_invarg(url);
 113   is_badhandle(quvi);
 114
 115   video = calloc(1, sizeof(*video));
 116   if (!video)
 117     return (QUVI_MEM);
 118
 119   video->quvi = quvi;
 120
 121   freprintf(&video->page_link, "%s", url);
 122
 123   rc = find_host_script(video);
 124
 125   quvi_parse_close((quvi_video_t) & video);
 126
 127   return (rc);
 128 }
 129
 130 /* quvi_parse */
 131
 132 QUVIcode quvi_parse(quvi_t quvi, char *url, quvi_video_t * dst)
 133 {
 134   _quvi_video_t video;
 135   QUVIcode rc;
 136
 137   is_invarg(dst);
 138   *dst = 0;
 139   is_invarg(url);
 140   is_badhandle(quvi);
 141
 142   video = calloc(1, sizeof(*video));
 143   if (!video)
 144     return (QUVI_MEM);
 145
 146   *dst = video;
 147   video->quvi = quvi;
 148
 149   freprintf(&video->page_link, "%s", url);
 150
 151   if (!video->quvi->no_shortened)
 152     {
 153       rc = is_shortened_url(video);
 154       if (rc != QUVI_OK)
 155         return (rc);
 156     }
 157
 158   while (1)
 159     {
 160       rc = find_host_script_and_parse(video);
 161       if (rc != QUVI_OK)
 162         return (rc);
 163       else
 164         {
 165           if (strlen(video->redirect))      /* Found a redirect. */
 166             {
 167               freprintf(&video->page_link, "%s", video->redirect);
 168               continue;
 169             }
 170           else
 171             break;
 172         }
 173     }
 174
 175 #ifdef HAVE_ICONV               /* Convert character set encoding to utf8. */
 176   if (video->charset)
 177     to_utf8(video);
 178 #endif
 179   assert(video->title != NULL); /* must be set in the lua script */
 180
 181   video->title = from_html_entities(video->title);
 182
 183   if (!video->quvi->no_verify)
 184     {
 185       llst_node_t curr = video->link;
 186       while (curr)
 187         {
 188           rc = query_file_length(video->quvi, curr);
 189           if (rc != QUVI_OK)
 190             break;
 191           curr = curr->next;
 192         }
 193     }
 194
 195   /* set current video link to first link in the list. */
 196   video->curr = video->link;
 197
 198   return (rc);
 199 }
 200
 201 /* quvi_parse_close */
 202
 203 void quvi_parse_close(quvi_video_t * handle)
 204 {
 205   _quvi_video_t *video;
 206
 207   video = (_quvi_video_t *) handle;
 208
 209   if (video && *video)
 210     {
 211       llst_node_t curr = (*video)->link;
 212
 213       while (curr)
 214         {
 215           _quvi_video_link_t l = (_quvi_video_link_t) curr->data;
 216           _free(l->url);
 217           _free(l->suffix);
 218           _free(l->content_type);
 219           curr = curr->next;
 220         }
 221       llst_free(&(*video)->link);
 222
 223       _free((*video)->id);
 224       _free((*video)->title);
 225       _free((*video)->charset);
 226       _free((*video)->page_link);
 227       _free((*video)->host_id);
 228       _free((*video)->redirect);
 229       _free((*video)->starttime);
 230
 231       _free(*video);
 232     }
 233 }
 234
 235 static QUVIcode _setopt(_quvi_t quvi, QUVIoption opt, va_list arg)
 236 {
 237
 238 #define _sets(opt) \
 239     do { \
 240         _free(opt); \
 241         asprintf(&opt, "%s", va_arg(arg,char *)); \
 242     } while(0); break
 243
 244 #define _setn(opt) \
 245     do { opt = va_arg(arg,long); } while(0); break
 246
 247   switch (opt)
 248     {
 249     case QUVIOPT_FORMAT:
 250       _sets(quvi->format);
 251     case QUVIOPT_NOVERIFY:
 252       _setn(quvi->no_verify);
 253     case QUVIOPT_STATUSFUNCTION:
 254       quvi->status_func = va_arg(arg, quvi_callback_status);
 255       break;
 256     case QUVIOPT_WRITEFUNCTION:
 257       quvi->write_func = va_arg(arg, quvi_callback_write);
 258       break;
 259     case QUVIOPT_NOSHORTENED:
 260       _setn(quvi->no_shortened);
 261     case QUVIOPT_CATEGORY:
 262       _setn(quvi->category);
 263     default:
 264       return (QUVI_INVARG);
 265     }
 266 #undef _sets
 267 #undef _setn
 268   return (QUVI_OK);
 269 }
 270
 271 /* quvi_setopt */
 272
 273 QUVIcode quvi_setopt(quvi_t quvi, QUVIoption opt, ...)
 274 {
 275   va_list arg;
 276   QUVIcode rc;
 277
 278   is_badhandle(quvi);
 279
 280   va_start(arg, opt);
 281   rc = _setopt(quvi, opt, arg);
 282   va_end(arg);
 283
 284   return (rc);
 285 }
 286
 287 static const char empty[] = "";
 288
 289 static QUVIcode _getprop(_quvi_video_t video, QUVIproperty prop, ...)
 290 {
 291   _quvi_video_link_t qvl;
 292   QUVIcode rc;
 293   va_list arg;
 294   double *dp;
 295   char **sp;
 296   long *lp;
 297   int type;
 298
 299   qvl = (_quvi_video_link_t) video->curr->data;
 300   assert(qvl != 0);
 301
 302   rc = QUVI_OK;
 303   dp = 0;
 304   sp = 0;
 305   lp = 0;
 306
 307   va_start(arg, prop);
 308   type = QUVIPROPERTY_TYPEMASK & (int)prop;
 309
 310 #define _initv(var,type) \
 311     do { \
 312         if ( !(var = va_arg(arg,type)) ) \
 313             rc = QUVI_INVARG; \
 314     } while (0); break
 315
 316   switch (type)
 317     {
 318     case QUVIPROPERTY_DOUBLE:
 319       _initv(dp, double *);
 320     case QUVIPROPERTY_STRING:
 321       _initv(sp, char **);
 322     case QUVIPROPERTY_LONG:
 323       _initv(lp, long *);
 324     default:
 325       rc = QUVI_INVARG;
 326     }
 327   va_end(arg);
 328
 329   if (rc != QUVI_OK)
 330     return rc;
 331
 332 #define _sets(with) \
 333     do { *sp = with ? with:(char*)empty; } while(0); break
 334
 335 #define _setn(var,with) \
 336     do { *var = with; } while(0); break
 337
 338   switch (prop)
 339     {
 340     case QUVIPROP_HOSTID:
 341       _sets(video->host_id);
 342     case QUVIPROP_PAGEURL:
 343       _sets(video->page_link);
 344     case QUVIPROP_PAGETITLE:
 345       _sets(video->title);
 346     case QUVIPROP_VIDEOID:
 347       _sets(video->id);
 348     case QUVIPROP_VIDEOURL:
 349       _sets(qvl->url);
 350     case QUVIPROP_VIDEOFILELENGTH:
 351       _setn(dp, qvl->length);
 352     case QUVIPROP_VIDEOFILECONTENTTYPE:
 353       _sets(qvl->content_type);
 354     case QUVIPROP_VIDEOFILESUFFIX:
 355       _sets(qvl->suffix);
 356     case QUVIPROP_HTTPCODE:
 357       _setn(lp, video->quvi->httpcode);
 358     case QUVIPROP_VIDEOFORMAT:
 359       _sets(video->quvi->format);
 360     case QUVIPROP_STARTTIME:
 361       _sets(video->starttime);
 362     default:
 363       rc = QUVI_INVARG;
 364     }
 365
 366   return (rc);
 367 }
 368
 369 static QUVIcode _getinfo(_quvi_t quvi, QUVIinfo info, ...)
 370 {
 371   QUVIcode rc;
 372   va_list arg;
 373   double *dp;
 374   char **sp;
 375   void **vp;
 376   long *lp;
 377   int type;
 378
 379   rc = QUVI_OK;
 380   dp = 0;
 381   sp = 0;
 382   vp = 0;
 383   lp = 0;
 384
 385   va_start(arg, info);
 386   type = QUVIINFO_TYPEMASK & (int)info;
 387
 388   switch (type)
 389     {
 390     case QUVIINFO_DOUBLE:
 391       _initv(dp, double *);
 392     case QUVIINFO_STRING:
 393       _initv(sp, char **);
 394     case QUVIINFO_LONG:
 395       _initv(lp, long *);
 396     case QUVIINFO_VOID:
 397       _initv(vp, void **);
 398     default:
 399       rc = QUVI_INVARG;
 400     }
 401   va_end(arg);
 402
 403   if (rc != QUVI_OK)
 404     return rc;
 405
 406 #define _setv(with) \
 407     do  { *vp = with ? with:NULL; } while(0); break
 408
 409   switch (info)
 410     {
 411     case QUVIINFO_CURL:
 412       _setv(quvi->curl);
 413     case QUVIINFO_CURLCODE:
 414       _setn(lp, quvi->curlcode);
 415     case QUVIINFO_HTTPCODE:
 416       _setn(lp, quvi->httpcode);
 417     default:
 418       rc = QUVI_INVARG;
 419     }
 420
 421   return (rc);
 422 }
 423
 424 #undef _setv
 425 #undef _setn
 426 #undef _sets
 427 #undef _initv
 428
 429 /* quvi_getinfo */
 430
 431 QUVIcode quvi_getinfo(quvi_t quvi, QUVIinfo info, ...)
 432 {
 433   va_list arg;
 434   void *p;
 435
 436   is_badhandle(quvi);
 437
 438   va_start(arg, info);
 439   p = va_arg(arg, void *);
 440   va_end(arg);
 441
 442   return (_getinfo(quvi, info, p));
 443 }
 444
 445 /* quvi_getprop */
 446
 447 QUVIcode quvi_getprop(quvi_video_t video, QUVIproperty prop, ...)
 448 {
 449   va_list arg;
 450   void *p;
 451
 452   is_badhandle(video);
 453
 454   va_start(arg, prop);
 455   p = va_arg(arg, void *);
 456   va_end(arg);
 457
 458   return (_getprop(video, prop, p));
 459 }
 460
 461 /* quvi_next_videolink */
 462
 463 QUVIcode quvi_next_videolink(quvi_video_t handle)
 464 {
 465   _quvi_video_t video;
 466
 467   is_badhandle(handle);
 468
 469   video = (_quvi_video_t) handle;
 470
 471   /* start from the first */
 472   if (!video->curr)
 473     {
 474       video->curr = video->link;
 475       return (QUVI_OK);
 476     }
 477
 478   /* move to the next */
 479   video->curr = video->curr->next;
 480   if (!video->curr)
 481     {
 482       video->curr = video->link;  /* reset */
 483       return (QUVI_LAST);
 484     }
 485
 486   return (QUVI_OK);
 487 }
 488
 489 static llst_node_t curr_host = NULL;
 490
 491 /* quvi_next_supported_website */
 492
 493 QUVIcode
 494 quvi_next_supported_website(quvi_t handle, char **domain,
 495                             char **formats)
 496 {
 497   struct lua_ident_s ident;
 498   _quvi_t quvi;
 499   QUVIcode rc;
 500
 501   is_badhandle(handle);
 502   quvi = (_quvi_t) handle;
 503
 504   is_invarg(domain);
 505   is_invarg(formats);
 506
 507   if (!quvi->website_scripts)
 508     return (QUVI_NOLUAWEBSITE);
 509
 510   if (!curr_host)
 511     curr_host = quvi->website_scripts;
 512   else
 513     {
 514       curr_host = curr_host->next;
 515       if (!curr_host)
 516         return (QUVI_LAST);
 517     }
 518
 519   ident.quvi = quvi;
 520   ident.url = NULL;
 521   ident.domain = NULL;
 522   ident.formats = NULL;
 523
 524   rc = run_ident_func(&ident, curr_host);
 525
 526   if (rc == QUVI_NOSUPPORT)
 527     {
 528       /* The website scripts return QUVI_NOSUPPORT in all cases. This is
 529        * because of the undefined URL that we pass to them above (ident.url
 530        * = NULL). We are only interested in the `domain' and `formats'
 531        * information anyway, so this is OK. */
 532       if (ident.categories & quvi->category)
 533         {
 534           *domain = ident.domain;
 535           *formats = ident.formats;
 536           rc = QUVI_OK;
 537         }
 538       else
 539         {
 540           _free(ident.domain);
 541           _free(ident.formats);
 542           rc = quvi_next_supported_website(handle, domain, formats);
 543         }
 544     }
 545
 546   return (rc);
 547 }
 548
 549 /* quvi_next_host, NOTE: deprecated. */
 550
 551 QUVIcode quvi_next_host(char **domain, char **formats)
 552 {
 553   *domain = *formats = NULL;
 554   return (QUVI_LAST);
 555 }
 556
 557 #undef is_badhandle
 558 #undef is_invarg
 559
 560 /* quvi_strerror */
 561
 562 char *quvi_strerror(quvi_t handle, QUVIcode code)
 563 {
 564   static const char *errormsgs[] =
 565   {
 566     "no error",
 567     "memory allocation failed",
 568     "bad handle argument to function",
 569     "invalid argument to function",
 570     "curl initialization failed",
 571     "end of list iteration",
 572     "aborted by callback",
 573     "lua initilization failed",
 574     "lua website scripts not found",
 575     "lua util scripts not found",
 576     "invalid error code (internal _INTERNAL_QUVI_LAST)"
 577   };
 578
 579   _quvi_t quvi = (_quvi_t) handle;
 580
 581   if (quvi)
 582     {
 583       if (code > _INTERNAL_QUVI_LAST)
 584         return (quvi->errmsg);
 585     }
 586   else
 587     {
 588       if (code > _INTERNAL_QUVI_LAST)
 589         code = _INTERNAL_QUVI_LAST;
 590     }
 591
 592   return ((char *)errormsgs[code]);
 593 }
 594
 595 /* quvi_version */
 596
 597 char *quvi_version(QUVIversion type)
 598 {
 599   static const char version[] = PACKAGE_VERSION;
 600   static const char version_long[] =
 601 #ifdef GIT_DESCRIBE
 602     GIT_DESCRIBE
 603 #else
 604     PACKAGE_VERSION
 605 #endif
 606 #ifdef BUILD_DATE
 607     " built on " BUILD_DATE
 608 #endif
 609     " for " CANONICAL_TARGET " ("
 610 #ifdef HAVE_ICONV
 611     "i"
 612 #endif
 613 #ifdef ENABLE_BROKEN
 614     "b"
 615 #endif
 616 #ifdef ENABLE_NSFW
 617     "n"
 618 #endif
 619     ")";
 620
 621   if (type == QUVI_VERSION_LONG)
 622     return ((char *)version_long);
 623   return ((char *)version);
 624 }
 625
 626 /* quvi_free */
 627
 628 void quvi_free(void *ptr)
 629 {
 630   if (ptr != NULL)
 631     free(ptr);
 632 }
 633
 634 /* vim: set ts=2 sw=2 tw=72 expandtab: */