lib/util.c

   1 /*
   2 * Copyright (C) 2009,2010 Toni Gundogdu.
   3 *
   4 * This program is free software: you can redistribute it and/or modify
   5 * it under the terms of the GNU General Public License as published by
   6 * the Free Software Foundation, either version 3 of the License, or
   7 * (at your option) any later version.
   8 *
   9 * This program 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
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16 */
  17
  18 #include "config.h"
  19
  20 #include <string.h>
  21 #include <errno.h>
  22 #include <stdarg.h>
  23 #include <assert.h>
  24
  25 #include <curl/curl.h>
  26
  27 #ifdef HAVE_ICONV
  28 #include <iconv.h>
  29 #endif
  30
  31 #include "quvi/quvi.h"
  32 #include "internal.h"
  33 #include "curl_wrap.h"
  34 #include "util.h"
  35
  36 #ifdef HAVE_ICONV
  37 QUVIcode to_utf8(_quvi_video_t video)
  38 {
  39   static const char to[] = "UTF-8";
  40   size_t insize, avail, iconv_code;
  41   char inbuf[1024], outbuf[1024];
  42   ICONV_CONST char *inptr;
  43   char *from, *wptr;
  44   iconv_t cd;
  45   _quvi_t quvi;
  46
  47   assert(video != 0);
  48   assert(video->quvi != 0);
  49   assert(video->title != 0);
  50   assert(video->charset != 0);
  51
  52   quvi = video->quvi;
  53   wptr = outbuf;
  54   inptr = inbuf;
  55   avail = sizeof(outbuf);
  56   insize = strlen(video->title);
  57
  58   if (insize >= sizeof(inbuf))
  59     insize = sizeof(inbuf);
  60
  61   memset(wptr, 0, sizeof(outbuf));
  62
  63   snprintf(inbuf, sizeof(inbuf), "%s", video->title);
  64
  65   /* Try with TRANSLIT first. */
  66   asprintf(&from, "%s//TRANSLIT", video->charset);
  67   cd = iconv_open(to, from);
  68
  69   /* If that fails, then without TRANSLIT. */
  70   if (cd == (iconv_t) - 1) {
  71     _free(from);
  72     asprintf(&from, "%s", video->charset);
  73     cd = iconv_open(to, from);
  74   }
  75
  76   if (cd == (iconv_t) - 1) {
  77     if (errno == EINVAL)
  78       seterr("conversion from %s to %s unavailable", from, to);
  79     else {
  80 #ifdef HAVE_STRERROR
  81       seterr("iconv_open: %s", strerror(errno));
  82 #else
  83       perror("iconv_open");
  84 #endif
  85     }
  86
  87     _free(from);
  88
  89     return (QUVI_ICONV);
  90   }
  91
  92   iconv_code = iconv(cd, &inptr, &insize, &wptr, &avail);
  93   iconv_close(cd);
  94   cd = 0;
  95
  96   if (iconv_code == (size_t) - 1) {
  97     seterr("converting characters from '%s' to '%s' failed", from, to);
  98     _free(from);
  99     return (QUVI_ICONV);
 100   } else
 101     setvid(video->title, "%s", outbuf);
 102
 103   _free(from);
 104
 105   return (QUVI_OK);
 106 }
 107 #endif
 108
 109 char *unescape(_quvi_t quvi, char *s)
 110 {
 111   char *tmp, *ret;
 112
 113   assert(quvi != 0);
 114   assert(quvi->curl != 0);
 115
 116   tmp = curl_easy_unescape(quvi->curl, s, 0, NULL);
 117   assert(tmp != 0);
 118   ret = strdup(tmp);
 119   curl_free(tmp);
 120
 121   free(s);
 122
 123   return (ret);
 124 }
 125
 126 char *from_html_entities(char *src)
 127 {
 128   struct lookup_s {
 129     const char *from;
 130     const char *to;
 131   };
 132
 133   static const struct lookup_s conv[] = {
 134     {"&quot;", "\""},
 135     {"&#34;", "\""},
 136     {"&amp;", "&"},
 137     {"&#38;", "&"},
 138     {"&apos;", "'"},
 139     {"&#39;", "'"},
 140     {"&lt;", "<"},
 141     {"&#60;", "<"},
 142     {"&gt;", ">"},
 143     {"&#62;", ">"},
 144     {0, 0}
 145   };
 146
 147   int i;
 148
 149   for (i = 0; conv[i].from; ++i)
 150     src = strepl(src, conv[i].from, conv[i].to);
 151
 152   return (src);
 153 }
 154
 155 static int new_video_link(_quvi_video_link_t * dst)
 156 {
 157   struct _quvi_video_link_s *qvl;
 158
 159   qvl = calloc(1, sizeof(*qvl));
 160   if (!qvl)
 161     return (QUVI_MEM);
 162
 163   *dst = qvl;
 164
 165   return (QUVI_OK);
 166 }
 167
 168 int add_video_link(llst_node_t * lst, const char *fmt, ...)
 169 {
 170   _quvi_video_link_t qvl;
 171   va_list args;
 172   int rc;
 173
 174   rc = new_video_link(&qvl);
 175   if (rc != QUVI_OK)
 176     return (rc);
 177
 178   va_start(args, fmt);
 179   vasprintf((char **)&qvl->url, fmt, args);
 180   va_end(args);
 181
 182   if (!qvl->url) {
 183     _free(qvl);
 184     return (QUVI_MEM);
 185   }
 186
 187   return (llst_add(lst, qvl));
 188 }