Merge commit 'ce2e858f5b3416c2d54f7f8c14e901f75c48b785'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 24 Jul 2014 00:08:14 +0000 (02:08 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 24 Jul 2014 00:08:14 +0000 (02:08 +0200)
* commit 'ce2e858f5b3416c2d54f7f8c14e901f75c48b785':
  http: K&R formatting cosmetics

Conflicts:
libavformat/http.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/http.c

   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
+ #include "config.h"
+ #if CONFIG_ZLIB
+ #include <zlib.h>
+ #endif /* CONFIG_ZLIB */
  #include "libavutil/avstring.h"
+ #include "libavutil/opt.h"
  #include "avformat.h"
+ #include "http.h"
+ #include "httpauth.h"
  #include "internal.h"
  #include "network.h"
- #include "http.h"
  #include "os_support.h"
- #include "httpauth.h"
  #include "url.h"
- #include "libavutil/opt.h"
- #if CONFIG_ZLIB
- #include <zlib.h>
- #endif
  
 -/* XXX: POST protocol is not completely implemented because avconv uses
 +/* XXX: POST protocol is not completely implemented because ffmpeg uses
-    only a subset of it. */
+  * only a subset of it. */
  
  /* The IO buffer size is unrelated to the max URL size in itself, but needs
   * to be large enough to fit the full request headers (including long
@@@ -96,29 -94,28 +98,30 @@@ typedef struct 
  #define D AV_OPT_FLAG_DECODING_PARAM
  #define E AV_OPT_FLAG_ENCODING_PARAM
  #define DEFAULT_USER_AGENT "Lavf/" AV_STRINGIFY(LIBAVFORMAT_VERSION)
  static const AVOption options[] = {
- {"seekable", "control seekability of connection", OFFSET(seekable), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, D },
- {"chunked_post", "use chunked transfer-encoding for posts", OFFSET(chunked_post), AV_OPT_TYPE_INT, {.i64 = 1}, 0, 1, E },
- {"headers", "set custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
- {"content_type", "set a specific content type for the POST messages", OFFSET(content_type), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
- {"user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = DEFAULT_USER_AGENT}, 0, 0, D },
- {"user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = DEFAULT_USER_AGENT}, 0, 0, D },
- {"multiple_requests", "use persistent connections", OFFSET(multiple_requests), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D|E },
- {"post_data", "set custom HTTP post data", OFFSET(post_data), AV_OPT_TYPE_BINARY, .flags = D|E },
- {"mime_type", "export the MIME type", OFFSET(mime_type), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY  },
- {"cookies", "set cookies to be sent in applicable future requests, use newline delimited Set-Cookie HTTP field value syntax", OFFSET(cookies), AV_OPT_TYPE_STRING, {0}, 0, 0, D },
- {"icy", "request ICY metadata", OFFSET(icy), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, D },
- {"icy_metadata_headers", "return ICY metadata headers", OFFSET(icy_metadata_headers), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
- {"icy_metadata_packet", "return current ICY metadata packet", OFFSET(icy_metadata_packet), AV_OPT_TYPE_STRING, {0}, 0, 0, AV_OPT_FLAG_EXPORT },
- {"auth_type", "HTTP authentication type", OFFSET(auth_state.auth_type), AV_OPT_TYPE_INT, {.i64 = HTTP_AUTH_NONE}, HTTP_AUTH_NONE, HTTP_AUTH_BASIC, D|E, "auth_type" },
- {"none", "No auth method set, autodetect", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_NONE}, 0, 0, D|E, "auth_type" },
- {"basic", "HTTP basic authentication", 0, AV_OPT_TYPE_CONST, {.i64 = HTTP_AUTH_BASIC}, 0, 0, D|E, "auth_type" },
- {"send_expect_100", "Force sending an Expect: 100-continue header for POST", OFFSET(send_expect_100), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, E },
- {"location", "The actual location of the data received", OFFSET(location), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
- {"offset", "initial byte offset", OFFSET(off), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, D },
- {"end_offset", "try to limit the request to bytes preceding this offset", OFFSET(end_off), AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, D },
- {"method", "Override the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E, },
- {NULL}
++    { "seekable", "control seekability of connection", OFFSET(seekable), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, D },
+     { "chunked_post", "use chunked transfer-encoding for posts", OFFSET(chunked_post), AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, E },
+     { "headers", "set custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D | E },
+     { "content_type", "set a specific content type for the POST messages", OFFSET(content_type), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D | E },
+     { "user_agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, { .str = DEFAULT_USER_AGENT }, 0, 0, D },
 -    { "user-agent", "override User-Agent header, for compatibility with ffmpeg", OFFSET(user_agent), AV_OPT_TYPE_STRING, { .str = DEFAULT_USER_AGENT }, 0, 0, D },
++    { "user-agent", "override User-Agent header", OFFSET(user_agent), AV_OPT_TYPE_STRING, { .str = DEFAULT_USER_AGENT }, 0, 0, D },
+     { "multiple_requests", "use persistent connections", OFFSET(multiple_requests), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, D | E },
+     { "post_data", "set custom HTTP post data", OFFSET(post_data), AV_OPT_TYPE_BINARY, .flags = D | E },
+     { "mime_type", "export the MIME type", OFFSET(mime_type), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_EXPORT | AV_OPT_FLAG_READONLY },
++    { "cookies", "set cookies to be sent in applicable future requests, use newline delimited Set-Cookie HTTP field value syntax", OFFSET(cookies), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D },
+     { "icy", "request ICY metadata", OFFSET(icy), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, D },
+     { "icy_metadata_headers", "return ICY metadata headers", OFFSET(icy_metadata_headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_EXPORT },
+     { "icy_metadata_packet", "return current ICY metadata packet", OFFSET(icy_metadata_packet), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_EXPORT },
+     { "auth_type", "HTTP authentication type", OFFSET(auth_state.auth_type), AV_OPT_TYPE_INT, { .i64 = HTTP_AUTH_NONE }, HTTP_AUTH_NONE, HTTP_AUTH_BASIC, D | E, "auth_type"},
+     { "none", "No auth method set, autodetect", 0, AV_OPT_TYPE_CONST, { .i64 = HTTP_AUTH_NONE }, 0, 0, D | E, "auth_type"},
+     { "basic", "HTTP basic authentication", 0, AV_OPT_TYPE_CONST, { .i64 = HTTP_AUTH_BASIC }, 0, 0, D | E, "auth_type"},
+     { "send_expect_100", "Force sending an Expect: 100-continue header for POST", OFFSET(send_expect_100), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, E },
+     { "location", "The actual location of the data received", OFFSET(location), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D | E },
+     { "offset", "initial byte offset", OFFSET(off), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, D },
+     { "end_offset", "try to limit the request to bytes preceding this offset", OFFSET(end_off), AV_OPT_TYPE_INT64, { .i64 = 0 }, 0, INT64_MAX, D },
+     { "method", "Override the HTTP method", OFFSET(method), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
+     { NULL }
  };
  
  static int http_connect(URLContext *h, const char *path, const char *local_path,
@@@ -212,10 -213,12 +217,11 @@@ redo
          } else
              goto fail;
      }
-     if ((s->http_code == 301 || s->http_code == 302 || s->http_code == 303 || s->http_code == 307)
-         && location_changed == 1) {
+     if ((s->http_code == 301 || s->http_code == 302 ||
+          s->http_code == 303 || s->http_code == 307) &&
+         location_changed == 1) {
          /* url moved, get next */
 -        ffurl_close(s->hd);
 -        s->hd = NULL;
 +        ffurl_closep(&s->hd);
          if (redirects++ >= MAX_REDIRECTS)
              return AVERROR(EIO);
          /* Restart the authentication process with the new target, which
          goto redo;
      }
      return 0;
-  fail:
+ fail:
      if (s->hd)
 -        ffurl_close(s->hd);
 -    s->hd = NULL;
 +        ffurl_closep(&s->hd);
      return AVERROR(EIO);
  }
  
@@@ -356,13 -360,12 +365,13 @@@ static void parse_content_range(URLCont
      const char *slash;
  
      if (!strncmp(p, "bytes ", 6)) {
-         p += 6;
+         p     += 6;
          s->off = strtoll(p, NULL, 10);
          if ((slash = strchr(p, '/')) && strlen(slash) > 0)
-             s->filesize = strtoll(slash+1, NULL, 10);
+             s->filesize = strtoll(slash + 1, NULL, 10);
      }
 -    h->is_streamed = 0; /* we _can_ in fact seek */
 +    if (s->seekable == -1 && (!s->is_akamai || s->filesize != 2147483647))
 +        h->is_streamed = 0; /* we _can_ in fact seek */
  }
  
  static int parse_content_encoding(URLContext *h, const char *p)
@@@ -480,30 -483,10 +489,30 @@@ static int process_line(URLContext *h, 
          } else if (!av_strcasecmp(tag, "Connection")) {
              if (!strcmp(p, "close"))
                  s->willclose = 1;
-         } else if (!av_strcasecmp (tag, "Server")) {
-             if (!av_strcasecmp (p, "AkamaiGHost")) {
++        } else if (!av_strcasecmp(tag, "Server")) {
++            if (!av_strcasecmp(p, "AkamaiGHost")) {
 +                s->is_akamai = 1;
-             } else if (!av_strncasecmp (p, "MediaGateway", 12)) {
++            } else if (!av_strncasecmp(p, "MediaGateway", 12)) {
 +                s->is_mediagateway = 1;
 +            }
-         } else if (!av_strcasecmp (tag, "Content-Type")) {
+         } else if (!av_strcasecmp(tag, "Content-Type")) {
              av_free(s->mime_type);
              s->mime_type = av_strdup(p);
-         } else if (!av_strcasecmp (tag, "Set-Cookie")) {
++        } else if (!av_strcasecmp(tag, "Set-Cookie")) {
 +            if (!s->cookies) {
 +                if (!(s->cookies = av_strdup(p)))
 +                    return AVERROR(ENOMEM);
 +            } else {
 +                char *tmp = s->cookies;
 +                size_t str_size = strlen(tmp) + strlen(p) + 2;
 +                if (!(s->cookies = av_malloc(str_size))) {
 +                    s->cookies = tmp;
 +                    return AVERROR(ENOMEM);
 +                }
 +                snprintf(s->cookies, str_size, "%s\n%s", tmp, p);
 +                av_free(tmp);
 +            }
-         } else if (!av_strcasecmp (tag, "Icy-MetaInt")) {
+         } else if (!av_strcasecmp(tag, "Icy-MetaInt")) {
              s->icy_metaint = strtoll(p, NULL, 10);
          } else if (!av_strncasecmp(tag, "Icy-", 4)) {
              if ((ret = parse_icy(s, tag, p)) < 0)
@@@ -740,18 -618,9 +747,17 @@@ static int http_connect(URLContext *h, 
      if (!has_header(s->headers, "\r\nContent-Type: ") && s->content_type)
          len += av_strlcatf(headers + len, sizeof(headers) - len,
                             "Content-Type: %s\r\n", s->content_type);
-     if (!has_header(s->headers, "\r\nIcy-MetaData: ") && s->icy) {
 +    if (!has_header(s->headers, "\r\nCookie: ") && s->cookies) {
 +        char *cookies = NULL;
 +        if (!get_cookies(s, &cookies, path, hoststr) && cookies) {
 +            len += av_strlcatf(headers + len, sizeof(headers) - len,
 +                               "Cookie: %s\r\n", cookies);
 +            av_free(cookies);
 +        }
 +    }
+     if (!has_header(s->headers, "\r\nIcy-MetaData: ") && s->icy)
          len += av_strlcatf(headers + len, sizeof(headers) - len,
                             "Icy-MetaData: %d\r\n", 1);
-     }
  
      /* now add in custom headers */
      if (s->headers)
  
      if (s->post_data)
          if ((err = ffurl_write(s->hd, s->post_data, s->post_datalen)) < 0)
 -            return err;
 +            goto done;
  
      /* init input buffer */
-     s->buf_ptr = s->buffer;
-     s->buf_end = s->buffer;
-     s->line_count = 0;
-     s->off = 0;
-     s->icy_data_read = 0;
-     s->filesize = -1;
-     s->willclose = 0;
+     s->buf_ptr          = s->buffer;
+     s->buf_end          = s->buffer;
+     s->line_count       = 0;
+     s->off              = 0;
+     s->icy_data_read    = 0;
+     s->filesize         = -1;
+     s->willclose        = 0;
      s->end_chunked_post = 0;
-     s->end_header = 0;
+     s->end_header       = 0;
      if (post && !s->post_data && !send_expect_100) {
          /* Pretend that it did work. We didn't read any header yet, since
           * we've still to send the POST data, but the code calling this
      /* wait for header */
      err = http_read_header(h, new_location);
      if (err < 0)
 -        return err;
 +        goto done;
  
 -    return (off == s->off) ? 0 : -1;
 +    err = (off == s->off) ? 0 : -1;
 +done:
 +    av_freep(&authstr);
 +    av_freep(&proxyauthstr);
 +    return err;
  }
  
  static int http_buf_read(URLContext *h, uint8_t *buf, int size)
  {
      HTTPContext *s = h->priv_data;
@@@ -1024,15 -890,14 +1031,14 @@@ static int http_close(URLContext *h
  #if CONFIG_ZLIB
      inflateEnd(&s->inflate_stream);
      av_freep(&s->inflate_buffer);
- #endif
+ #endif /* CONFIG_ZLIB */
  
-     if (!s->end_chunked_post) {
+     if (!s->end_chunked_post)
          /* Close the write direction by sending the end of chunked encoding. */
          ret = http_shutdown(h, h->flags);
-     }
  
      if (s->hd)
 -        ffurl_close(s->hd);
 +        ffurl_closep(&s->hd);
      av_dict_free(&s->chained_options);
      return ret;
  }