← Back to branch summary

~ubuntu-branches/ubuntu/saucy/libquvi/saucy-proposed

« back to all changes in this revision

Viewing changes to lib/curl_wrap.c

  • Committer: Bazaar Package Importer
  • Author(s): Alejandro Garrido Mota
  • Date: 2011-04-25 01:07:41 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20110425010741-nalzd12y180qs082
Tags: 0.2.15-1
http://bugs.debian.org/622253
http://bugs.debian.org/615554
* New upstream release (Closes: #622253). 
* Update d/watch to sf.net
* Update homepage field to quvi.sourceforge.net (Closes: #615554) 
* d/rules: Add dh_auto_test before NO_INTERNET=1 in override_dh_auto_test 
* Update Standards-Version field to 3.9.2 
* Add symbol (d/libquvi0.symbols) file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/curl_wrap.c
38
38
  return malloc(size);
39
39
}
40
40
 
41
 
struct mem_s {
 
41
struct mem_s
 
42
{
42
43
  size_t size;
43
44
  char *p;
44
45
};
45
46
 
46
47
size_t
47
 
quvi_write_callback_default(void *p, size_t size, size_t nmemb, void *data)
 
48
quvi_write_callback_default(void *p, size_t size, size_t nmemb,
 
49
                            void *data)
48
50
{
49
51
  struct mem_s *m = (struct mem_s *)data;
50
52
  const size_t rsize = size * nmemb;
51
53
  void *tmp = _realloc(m->p, m->size + rsize + 1);
52
 
  if (tmp) {
53
 
    m->p = (char *)tmp;
54
 
    memcpy(&(m->p[m->size]), p, rsize);
55
 
    m->size += rsize;
56
 
    m->p[m->size] = '\0';
57
 
  }
 
54
  if (tmp)
 
55
    {
 
56
      m->p = (char *)tmp;
 
57
      memcpy(&(m->p[m->size]), p, rsize);
 
58
      m->size += rsize;
 
59
      m->p[m->size] = '\0';
 
60
    }
58
61
  return (rsize);
59
62
}
60
63
 
62
65
extern char *lua_get_field_s(lua_State *, const char *);
63
66
 
64
67
QUVIcode
65
 
fetch_to_mem(_quvi_video_t video, const char *url, lua_State * l, char **dst)
 
68
fetch_to_mem(_quvi_media_t video, const char *url, lua_State * l,
 
69
             char **dst)
66
70
{
67
71
  char *fetch_type, *arbitrary_cookie, *user_agent;
68
72
  QUVIstatusType fetch_type_n;
69
73
  long respcode, conncode;
70
74
  CURLcode curlcode;
71
75
  struct mem_s mem;
72
 
  _quvi_t quvi;
73
76
  QUVIcode rc;
74
77
 
75
78
  if (!video)
76
79
    return (QUVI_BADHANDLE);
77
80
 
78
 
  quvi = video->quvi;
79
 
 
80
 
  if (!quvi)
81
 
    return (QUVI_BADHANDLE);
82
 
 
83
81
  if (!dst)
84
82
    return (QUVI_INVARG);
85
83
 
91
89
 
92
90
  /* Additional settings from LUA table */
93
91
 
94
 
  if (lua_istable(l, 2)) {
95
 
    fetch_type = lua_get_field_s(l, "fetch_type");
96
 
    if (fetch_type) {
97
 
      if (strcmp(fetch_type, "config") == 0)
98
 
        fetch_type_n = QUVISTATUSTYPE_CONFIG;
99
 
      else if (strcmp(fetch_type, "playlist") == 0)
100
 
        fetch_type_n = QUVISTATUSTYPE_PLAYLIST;
101
 
    }
102
 
    arbitrary_cookie = lua_get_field_s(l, "arbitrary_cookie");
103
 
    user_agent = lua_get_field_s(l, "user_agent");
104
 
  }
105
 
 
106
 
  if (quvi->status_func) {
107
 
    if (quvi->status_func(makelong(QUVISTATUS_FETCH, fetch_type_n),
108
 
                          (void *)url) != QUVI_OK) {
109
 
      return (QUVI_ABORTEDBYCALLBACK);
110
 
    }
111
 
  }
112
 
 
113
 
  csetopt(CURLOPT_URL, url);
114
 
  csetopt(CURLOPT_ENCODING, "");
 
92
  if (lua_istable(l, 2))
 
93
    {
 
94
      fetch_type = lua_get_field_s(l, "fetch_type");
 
95
      if (fetch_type)
 
96
        {
 
97
          if (strcmp(fetch_type, "config") == 0)
 
98
            fetch_type_n = QUVISTATUSTYPE_CONFIG;
 
99
          else if (strcmp(fetch_type, "playlist") == 0)
 
100
            fetch_type_n = QUVISTATUSTYPE_PLAYLIST;
 
101
        }
 
102
      arbitrary_cookie = lua_get_field_s(l, "arbitrary_cookie");
 
103
      user_agent = lua_get_field_s(l, "user_agent");
 
104
    }
 
105
 
 
106
  if (video->quvi->status_func)
 
107
    {
 
108
      if (video->quvi->
 
109
          status_func(makelong(QUVISTATUS_FETCH, fetch_type_n),
 
110
                      (void *)url) != QUVI_OK)
 
111
        {
 
112
          return (QUVI_ABORTEDBYCALLBACK);
 
113
        }
 
114
    }
 
115
 
 
116
  curl_easy_setopt(video->quvi->curl, CURLOPT_URL, url);
 
117
  curl_easy_setopt(video->quvi->curl, CURLOPT_ENCODING, "");
115
118
 
116
119
  memset(&mem, 0, sizeof(mem));
117
 
 
118
 
  csetopt(CURLOPT_WRITEDATA, &mem);
119
 
 
120
 
  if (quvi->write_func)
121
 
    csetopt(CURLOPT_WRITEFUNCTION, (curl_write_callback) quvi->write_func);
122
 
  else
123
 
    csetopt(CURLOPT_WRITEFUNCTION, quvi_write_callback_default);
 
120
  curl_easy_setopt(video->quvi->curl, CURLOPT_WRITEDATA, &mem);
 
121
 
 
122
  curl_easy_setopt(video->quvi->curl, CURLOPT_WRITEFUNCTION,
 
123
                   video->quvi->write_func
 
124
                   ? (curl_write_callback) video->quvi->write_func
 
125
                   : (curl_write_callback) quvi_write_callback_default);
124
126
 
125
127
  if (arbitrary_cookie != NULL && *arbitrary_cookie != '\0')
126
 
    csetopt(CURLOPT_COOKIE, arbitrary_cookie);
 
128
    {
 
129
      curl_easy_setopt(video->quvi->curl, CURLOPT_COOKIE,
 
130
                       arbitrary_cookie);
 
131
    }
127
132
 
128
133
  if (user_agent != NULL && *user_agent != '\0')
129
 
    csetopt(CURLOPT_USERAGENT, user_agent);
 
134
    {
 
135
      curl_easy_setopt(video->quvi->curl, CURLOPT_USERAGENT, user_agent);
 
136
    }
130
137
 
131
 
  curlcode = curl_easy_perform(quvi->curl);
 
138
  curlcode = curl_easy_perform(video->quvi->curl);
132
139
  respcode = 0;
133
140
  conncode = 0;
134
141
  rc = QUVI_OK;
135
142
 
136
 
  curl_easy_getinfo(quvi->curl, CURLINFO_RESPONSE_CODE, &respcode);
137
 
 
138
 
  curl_easy_getinfo(quvi->curl, CURLINFO_HTTP_CONNECTCODE, &conncode);
139
 
 
140
 
  if (curlcode == CURLE_OK && respcode == 200) {
141
 
 
142
 
    if (quvi->status_func) {
143
 
 
144
 
      if (quvi->status_func(makelong(QUVISTATUS_FETCH, QUVISTATUSTYPE_DONE),
145
 
                            0) != QUVI_OK) {
146
 
        rc = QUVI_ABORTEDBYCALLBACK;
147
 
      }
148
 
 
149
 
    }
150
 
 
151
 
  }
152
 
 
153
 
  else {
154
 
 
155
 
    if (curlcode == CURLE_OK) {
156
 
      seterr("server response code %ld (conncode=%ld)", respcode, conncode);
157
 
    }
158
 
 
159
 
    else {
160
 
      seterr("%s (curlcode=%d, conncode=%ld)",
161
 
             curl_easy_strerror(curlcode), curlcode, conncode);
162
 
    }
163
 
 
164
 
    rc = QUVI_CURL;
165
 
  }
166
 
 
167
 
  if (mem.p) {
168
 
    *dst = mem.p;
169
 
    if (rc == QUVI_OK && !video->charset)       /* charset */
170
 
      run_lua_charset_func(video, mem.p);
171
 
  }
 
143
  curl_easy_getinfo(video->quvi->curl, CURLINFO_RESPONSE_CODE,
 
144
                    &respcode);
 
145
  curl_easy_getinfo(video->quvi->curl, CURLINFO_HTTP_CONNECTCODE,
 
146
                    &conncode);
 
147
 
 
148
  if (curlcode == CURLE_OK && respcode == 200)
 
149
    {
 
150
      if (video->quvi->status_func)
 
151
        {
 
152
          if (video->quvi->status_func(makelong(QUVISTATUS_FETCH,
 
153
                                                QUVISTATUSTYPE_DONE),
 
154
                                       0) != QUVI_OK)
 
155
            {
 
156
              rc = QUVI_ABORTEDBYCALLBACK;
 
157
            }
 
158
        }
 
159
    }
 
160
  else
 
161
    {
 
162
      if (curlcode == CURLE_OK)
 
163
        {
 
164
          freprintf(&video->quvi->errmsg,
 
165
                    "server response code %ld (conncode=%ld)", respcode,
 
166
                    conncode);
 
167
        }
 
168
      else
 
169
        {
 
170
          freprintf(&video->quvi->errmsg,
 
171
                    "%s (curlcode=%d, conncode=%ld)",
 
172
                    curl_easy_strerror(curlcode), curlcode, conncode);
 
173
        }
 
174
 
 
175
      rc = QUVI_CURL;
 
176
    }
 
177
 
 
178
  if (mem.p)
 
179
    {
 
180
      *dst = mem.p;
 
181
      if (rc == QUVI_OK && !video->charset)       /* charset */
 
182
        run_lua_charset_func(video, mem.p);
 
183
    }
172
184
 
173
185
  video->quvi->httpcode = respcode;
174
186
  video->quvi->curlcode = curlcode;
205
217
  if (strcmp(strncpy(buf, qvl->url, strlen(scheme)), scheme) != 0)
206
218
    return (QUVI_OK);           /* Skip video URL verification discreetly. */
207
219
 
208
 
  if (quvi->status_func) {
209
 
    if (quvi->status_func(makelong(QUVISTATUS_VERIFY, 0), 0) != QUVI_OK) {
210
 
      return (QUVI_ABORTEDBYCALLBACK);
 
220
  if (quvi->status_func)
 
221
    {
 
222
      if (quvi->status_func(makelong(QUVISTATUS_VERIFY, 0), 0) != QUVI_OK)
 
223
        {
 
224
          return (QUVI_ABORTEDBYCALLBACK);
 
225
        }
211
226
    }
212
 
  }
213
227
 
214
 
  csetopt(CURLOPT_URL, qvl->url);
215
 
  csetopt(CURLOPT_NOBODY, 1L);  /* get -> head */
 
228
  curl_easy_setopt(quvi->curl, CURLOPT_URL, qvl->url);
 
229
  curl_easy_setopt(quvi->curl, CURLOPT_NOBODY, 1L);     /* get -> head */
216
230
 
217
231
  memset(&mem, 0, sizeof(mem));
218
 
  csetopt(CURLOPT_WRITEDATA, &mem);
 
232
  curl_easy_setopt(quvi->curl, CURLOPT_WRITEDATA, &mem);
219
233
 
220
 
  if (quvi->write_func)
221
 
    csetopt(CURLOPT_WRITEFUNCTION, (curl_write_callback) quvi->write_func);
222
 
  else
223
 
    csetopt(CURLOPT_WRITEFUNCTION, quvi_write_callback_default);
 
234
  curl_easy_setopt(quvi->curl, CURLOPT_WRITEFUNCTION, (quvi->write_func)
 
235
                   ? (curl_write_callback) quvi->write_func
 
236
                   : (curl_write_callback) quvi_write_callback_default);
224
237
 
225
238
  curlcode = curl_easy_perform(quvi->curl);
226
239
 
227
 
  csetopt(CURLOPT_HTTPGET, 1L); /* reset: head -> get */
 
240
  curl_easy_setopt(quvi->curl, CURLOPT_HTTPGET, 1L);    /* reset: head -> get */
228
241
 
229
242
  respcode = 0;
230
243
  conncode = 0;
231
244
  rc = QUVI_OK;
232
245
 
233
246
  curl_easy_getinfo(quvi->curl, CURLINFO_RESPONSE_CODE, &respcode);
234
 
 
235
247
  curl_easy_getinfo(quvi->curl, CURLINFO_HTTP_CONNECTCODE, &conncode);
236
248
 
237
 
  if (curlcode == CURLE_OK) {
238
 
 
239
 
    if (respcode == 200 || respcode == 206) {
240
 
 
241
 
      const char *ct;
242
 
 
243
 
      curl_easy_getinfo(quvi->curl, CURLINFO_CONTENT_TYPE, &ct);
244
 
 
245
 
      _free(qvl->content_type);
246
 
      asprintf(&qvl->content_type, "%s", ct);
247
 
 
248
 
      curl_easy_getinfo(quvi->curl,
249
 
                        CURLINFO_CONTENT_LENGTH_DOWNLOAD, &qvl->length);
250
 
 
251
 
      if (quvi->status_func) {
252
 
        if (quvi->status_func(makelong(QUVISTATUS_VERIFY, QUVISTATUSTYPE_DONE),
253
 
                              0) != QUVI_OK) {
254
 
          rc = QUVI_ABORTEDBYCALLBACK;
255
 
        }
256
 
      }
257
 
 
258
 
      if (rc == QUVI_OK) {
259
 
        /* Content-Type -> suffix. */
260
 
        rc = run_lua_suffix_func(quvi, qvl);
261
 
      }
262
 
    } else {
263
 
      seterr("server response code %ld (conncode=%ld)", respcode, conncode);
 
249
  if (curlcode == CURLE_OK)
 
250
    {
 
251
      if (respcode == 200 || respcode == 206)
 
252
        {
 
253
          const char *ct;
 
254
 
 
255
          curl_easy_getinfo(quvi->curl, CURLINFO_CONTENT_TYPE, &ct);
 
256
 
 
257
          _free(qvl->content_type);
 
258
          asprintf(&qvl->content_type, "%s", ct);
 
259
 
 
260
          curl_easy_getinfo(quvi->curl,
 
261
                            CURLINFO_CONTENT_LENGTH_DOWNLOAD, &qvl->length);
 
262
 
 
263
          if (quvi->status_func)
 
264
            {
 
265
              if (quvi->status_func(makelong
 
266
                                    (QUVISTATUS_VERIFY, QUVISTATUSTYPE_DONE),
 
267
                                    0) != QUVI_OK)
 
268
                {
 
269
                  rc = QUVI_ABORTEDBYCALLBACK;
 
270
                }
 
271
            }
 
272
 
 
273
          if (rc == QUVI_OK)
 
274
            {
 
275
              /* Content-Type -> suffix. */
 
276
              rc = run_lua_suffix_func(quvi, qvl);
 
277
            }
 
278
        }
 
279
      else
 
280
        {
 
281
          freprintf(&quvi->errmsg,
 
282
                    "server response code %ld (conncode=%ld)", respcode,
 
283
                    conncode);
 
284
          rc = QUVI_CURL;
 
285
        }
 
286
    }
 
287
  else
 
288
    {
 
289
      freprintf(&quvi->errmsg, "%s (curlcode=%d, conncode=%ld)",
 
290
                curl_easy_strerror(curlcode), curlcode, conncode);
264
291
      rc = QUVI_CURL;
265
292
    }
266
 
  } else {
267
 
    seterr("%s (curlcode=%d, conncode=%ld)",
268
 
           curl_easy_strerror(curlcode), curlcode, conncode);
269
 
    rc = QUVI_CURL;
270
 
  }
271
293
 
272
294
  quvi->httpcode = respcode;
273
295
  quvi->curlcode = curlcode;
282
304
 * Check if URL is a shortened URL (e.g. dai.ly, goo.gl, etc.) and
283
305
 * replace the (shortened) video page URL with the redirect URL.
284
306
 */
285
 
QUVIcode is_shortened_url(_quvi_video_t video)
 
307
QUVIcode is_shortened_url(_quvi_media_t video)
286
308
{
287
309
  long respcode, conncode;
288
310
  CURLcode curlcode;
289
311
  struct mem_s mem;
290
 
  _quvi_t quvi;
291
312
  QUVIcode rc;
292
313
 
293
314
  assert(video != NULL);
294
 
  quvi = video->quvi;
295
 
  assert(quvi != NULL);
296
 
 
297
 
  if (quvi->status_func) {
298
 
 
299
 
    const QUVIcode r = quvi->status_func(makelong(QUVISTATUS_SHORTENED, 0), 0);
300
 
 
301
 
    if (r != QUVI_OK)
302
 
      return (QUVI_ABORTEDBYCALLBACK);
303
 
 
304
 
  }
 
315
 
 
316
  if (video->quvi->status_func)
 
317
    {
 
318
      if (video->quvi->status_func(QUVISTATUS_SHORTENED, 0) != QUVI_OK)
 
319
        return (QUVI_ABORTEDBYCALLBACK);
 
320
    }
305
321
 
306
322
  memset(&mem, 0, sizeof(mem));
307
 
 
308
 
  csetopt(CURLOPT_WRITEDATA, &mem);
309
 
 
310
 
  if (quvi->write_func)
311
 
    csetopt(CURLOPT_WRITEFUNCTION, (curl_write_callback) quvi->write_func);
312
 
  else
313
 
    csetopt(CURLOPT_WRITEFUNCTION, quvi_write_callback_default);
314
 
 
315
 
  csetopt(CURLOPT_URL, video->page_link);
316
 
  csetopt(CURLOPT_FOLLOWLOCATION, 0L);
317
 
  csetopt(CURLOPT_NOBODY, 1L);  /* get -> head */
318
 
 
319
 
  curlcode = curl_easy_perform(quvi->curl);
320
 
 
321
 
  csetopt(CURLOPT_FOLLOWLOCATION, 1L);  /* reset */
322
 
  csetopt(CURLOPT_HTTPGET, 1L); /* reset: head -> get */
 
323
  curl_easy_setopt(video->quvi->curl, CURLOPT_WRITEDATA, &mem);
 
324
 
 
325
  curl_easy_setopt(video->quvi->curl, CURLOPT_WRITEFUNCTION,
 
326
                   (video->quvi->write_func)
 
327
                   ? (curl_write_callback) video->quvi->write_func
 
328
                   : (curl_write_callback) quvi_write_callback_default);
 
329
 
 
330
  curl_easy_setopt(video->quvi->curl, CURLOPT_URL, video->page_link);
 
331
  curl_easy_setopt(video->quvi->curl, CURLOPT_FOLLOWLOCATION, 0L);
 
332
  curl_easy_setopt(video->quvi->curl, CURLOPT_NOBODY, 1L);      /* get -> head */
 
333
 
 
334
  curlcode = curl_easy_perform(video->quvi->curl);
 
335
 
 
336
  curl_easy_setopt(video->quvi->curl, CURLOPT_FOLLOWLOCATION, 1L);      /* reset */
 
337
 
 
338
  curl_easy_setopt(video->quvi->curl, CURLOPT_HTTPGET, 1L);     /* reset: head -> get */
323
339
 
324
340
  respcode = 0;
325
341
  conncode = 0;
326
342
  rc = QUVI_OK;
327
343
 
328
 
  curl_easy_getinfo(quvi->curl, CURLINFO_RESPONSE_CODE, &respcode);
329
 
  curl_easy_getinfo(quvi->curl, CURLINFO_HTTP_CONNECTCODE, &conncode);
330
 
 
331
 
  if (curlcode == CURLE_OK) {
332
 
 
333
 
    if (respcode >= 301 && respcode <= 303) {
334
 
 
335
 
      /* A redirect. */
336
 
 
337
 
      char *url = NULL;
338
 
 
339
 
      curl_easy_getinfo(quvi->curl, CURLINFO_REDIRECT_URL, &url);
340
 
      setvid(video->page_link, "%s", url);
341
 
 
342
 
      rc = QUVI_OK;
343
 
 
344
 
    }
345
 
    /* respcode >= 301 && respcode <= 303 */
346
 
    else {
347
 
      /* Most likely not a shortened URL redirect. Let it pass. */
348
 
      rc = QUVI_OK;
349
 
    }
350
 
 
351
 
    if (quvi->status_func) {
352
 
 
353
 
      rc = quvi->status_func(makelong
354
 
                             (QUVISTATUS_SHORTENED, QUVISTATUSTYPE_DONE), 0);
355
 
 
356
 
    }
357
 
 
358
 
  } else {
359
 
 
360
 
    seterr("%s (curlcode=%d, conncode=%ld)",
361
 
           curl_easy_strerror(curlcode), curlcode, conncode);
362
 
 
363
 
    rc = QUVI_CURL;
364
 
  }
 
344
  curl_easy_getinfo(video->quvi->curl, CURLINFO_RESPONSE_CODE,
 
345
                    &respcode);
 
346
  curl_easy_getinfo(video->quvi->curl, CURLINFO_HTTP_CONNECTCODE,
 
347
                    &conncode);
 
348
 
 
349
  if (curlcode == CURLE_OK)
 
350
    {
 
351
      if (respcode >= 301 && respcode <= 303)
 
352
        {
 
353
          /* A redirect. */
 
354
 
 
355
          char *url = NULL;
 
356
 
 
357
          curl_easy_getinfo(video->quvi->curl, CURLINFO_REDIRECT_URL, &url);
 
358
          freprintf(&video->page_link, "%s", url);
 
359
 
 
360
          rc = QUVI_OK;
 
361
        }
 
362
      /* respcode >= 301 && respcode <= 303 */
 
363
      else
 
364
        {
 
365
          /* Most likely not a shortened URL redirect. Let it pass. */
 
366
          rc = QUVI_OK;
 
367
        }
 
368
 
 
369
      if (video->quvi->status_func)
 
370
        {
 
371
          const long param =
 
372
            makelong(QUVISTATUS_SHORTENED, QUVISTATUSTYPE_DONE);
 
373
 
 
374
          rc = video->quvi->status_func(param, 0);
 
375
        }
 
376
    }
 
377
  else
 
378
    {
 
379
      freprintf(&video->quvi->errmsg, "%s (curlcode=%d, conncode=%ld)",
 
380
                curl_easy_strerror(curlcode), curlcode, conncode);
 
381
 
 
382
      rc = QUVI_CURL;
 
383
    }
365
384
 
366
385
  if (mem.p)
367
386
    _free(mem.p);
368
387
 
369
 
  quvi->httpcode = respcode;
370
 
  quvi->curlcode = curlcode;
 
388
  video->quvi->httpcode = respcode;
 
389
  video->quvi->curlcode = curlcode;
371
390
 
372
391
  return (rc);
373
392
}
 
393
 
 
394
/* vim: set ts=2 sw=2 tw=72 expandtab: */