/* HTTP support.
- Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001
+ Copyright (C) 1995, 1996, 1997, 1998, 2000, 2001, 2002
Free Software Foundation, Inc.
This file is part of GNU Wget.
return statcode;
}
\f
+#define WMIN(x, y) ((x) > (y) ? (y) : (x))
+
+/* Send the contents of FILE_NAME to SOCK/SSL. Make sure that exactly
+ PROMISED_SIZE bytes are sent over the wire -- if the file is
+ longer, read only that much; if the file is shorter, pad it with
+ zeros. */
+
+static int
+post_file (int sock, void *ssl, const char *file_name, long promised_size)
+{
+ static char chunk[8192];
+ int written = 0;
+ int write_error;
+ FILE *fp;
+
+ /* Only one of SOCK and SSL may be active at the same time. */
+ assert (sock > -1 || ssl != NULL);
+ assert (sock == -1 || ssl == NULL);
+
+ DEBUGP (("[writing POST file %s ... ", file_name));
+
+ fp = fopen (file_name, "rb");
+ if (!fp)
+ goto pad;
+ while (written < promised_size)
+ {
+ long towrite;
+ int length = fread (chunk, 1, sizeof (chunk), fp);
+ if (length == 0)
+ break;
+ towrite = WMIN (promised_size - written, length);
+#ifdef HAVE_SSL
+ if (ssl)
+ write_error = ssl_iwrite (ssl, chunk, towrite);
+ else
+#endif
+ write_error = iwrite (sock, chunk, towrite);
+ if (write_error < 0)
+ {
+ fclose (fp);
+ return -1;
+ }
+ written += towrite;
+ }
+ fclose (fp);
+ pad:
+ if (written < promised_size)
+ {
+ DEBUGP (("padding ... "));
+ /* This highly unlikely case can happen only if the file has
+ shrunk while we weren't looking. To uphold the promise, pad
+ the remaining data with zeros. #### Should we abort
+ instead? */
+ memset (chunk, '\0', sizeof (chunk));
+ while (written < promised_size)
+ {
+ long towrite = WMIN (promised_size - written, sizeof (chunk));
+#ifdef HAVE_SSL
+ if (ssl)
+ write_error = ssl_iwrite (ssl, chunk, towrite);
+ else
+#endif
+ write_error = iwrite (sock, chunk, towrite);
+ if (write_error < 0)
+ return -1;
+ written += towrite;
+ }
+ }
+ assert (written == promised_size);
+ DEBUGP (("done]\n"));
+ return 0;
+}
+\f
/* Functions to be used as arguments to header_process(): */
struct http_process_range_closure {
char *all_headers;
char *port_maybe;
char *request_keep_alive;
- int sock, hcount, num_written, all_length, statcode;
+ int sock, hcount, all_length, statcode;
+ int write_error;
long contlen, contrange;
struct url *conn;
FILE *fp;
#ifdef HAVE_SSL
static SSL_CTX *ssl_ctx = NULL;
SSL *ssl = NULL;
-#endif /* HAVE_SSL */
+#endif
char *cookies = NULL;
/* Whether this connection will be kept alive after the HTTP request
"Host: symbolic-name:1234". */
int squares_around_host = 0;
+ /* Headers sent when using POST. */
+ char *post_content_type, *post_content_length;
+ long post_data_size;
+
#ifdef HAVE_SSL
/* initialize ssl_ctx on first run */
if (!ssl_ctx)
keep_alive = 0;
http_keep_alive_1 = http_keep_alive_2 = 0;
+ post_content_type = NULL;
+ post_content_length = NULL;
+
/* Initialize certain elements of struct http_stat. */
hs->len = 0L;
hs->contlen = -1;
DEBUGP (("Reusing fd %d.\n", sock));
}
- command = (*dt & HEAD_ONLY) ? "HEAD" : "GET";
+ if (*dt & HEAD_ONLY)
+ command = "HEAD";
+ else if (opt.post_file_name || opt.post_data)
+ command = "POST";
+ else
+ command = "GET";
referer = NULL;
if (hs->referer)
#endif
);
+ if (opt.post_data || opt.post_file_name)
+ {
+ post_content_type = "Content-Type: application/x-www-form-urlencoded\r\n";
+ if (opt.post_data)
+ post_data_size = strlen (opt.post_data);
+ else
+ {
+ post_data_size = file_size (opt.post_file_name);
+ if (post_data_size == -1)
+ {
+ logprintf (LOG_NOTQUIET, "POST data file missing: %s\n",
+ opt.post_file_name);
+ post_data_size = 0;
+ }
+ }
+ post_content_length = xmalloc (16 + numdigit (post_data_size) + 2 + 1);
+ sprintf (post_content_length,
+ "Content-Length: %ld\r\n", post_data_size);
+ }
+
if (proxy)
full_path = xstrdup (u->url);
else
+ (proxyauth ? strlen (proxyauth) : 0)
+ (range ? strlen (range) : 0)
+ strlen (pragma_h)
+ + (post_content_type
+ ? strlen (post_content_type) : 0)
+ + (post_content_length
+ ? strlen (post_content_length) : 0)
+ (opt.user_header ? strlen (opt.user_header) : 0)
+ 64);
/* Construct the request. */
User-Agent: %s\r\n\
Host: %s%s%s%s\r\n\
Accept: %s\r\n\
-%s%s%s%s%s%s%s%s\r\n",
+%s%s%s%s%s%s%s%s%s%s\r\n",
command, full_path,
useragent,
squares_around_host ? "[" : "", u->host, squares_around_host ? "]" : "",
wwwauth ? wwwauth : "",
proxyauth ? proxyauth : "",
range ? range : "",
- pragma_h,
+ pragma_h,
+ post_content_type ? post_content_type : "",
+ post_content_length ? post_content_length : "",
opt.user_header ? opt.user_header : "");
- DEBUGP (("---request begin---\n%s---request end---\n", request));
+ DEBUGP (("---request begin---\n%s", request));
/* Free the temporary memory. */
FREE_MAYBE (wwwauth);
/* Send the request to server. */
#ifdef HAVE_SSL
if (conn->scheme == SCHEME_HTTPS)
- num_written = ssl_iwrite (ssl, request, strlen (request));
+ write_error = ssl_iwrite (ssl, request, strlen (request));
else
-#endif /* HAVE_SSL */
- num_written = iwrite (sock, request, strlen (request));
+#endif
+ write_error = iwrite (sock, request, strlen (request));
+
+ if (write_error >= 0)
+ {
+ if (opt.post_data)
+ {
+ DEBUGP (("[POST data: %s]\n", opt.post_data));
+#ifdef HAVE_SSL
+ if (conn->scheme == SCHEME_HTTPS)
+ write_error = ssl_iwrite (ssl, opt.post_data, post_data_size);
+ else
+#endif
+ write_error = iwrite (sock, opt.post_data, post_data_size);
+ }
+ else if (opt.post_file_name)
+ {
+#ifdef HAVE_SSL
+ if (conn->scheme == SCHEME_HTTPS)
+ write_error = post_file (-1, ssl, opt.post_file_name,
+ post_data_size);
+ else
+#endif
+ write_error = post_file (sock, NULL, opt.post_file_name,
+ post_data_size);
+ }
+ }
+ DEBUGP (("---request end---\n"));
- if (num_written < 0)
+ if (write_error < 0)
{
logprintf (LOG_VERBOSE, _("Failed writing HTTP request: %s.\n"),
strerror (errno));
{ "no", required_argument, NULL, 'n' },
{ "output-document", required_argument, NULL, 'O' },
{ "output-file", required_argument, NULL, 'o' },
+ { "post-data", required_argument, NULL, 167 },
+ { "post-file", required_argument, NULL, 168 },
{ "progress", required_argument, NULL, 163 },
{ "proxy", required_argument, NULL, 'Y' },
{ "proxy-passwd", required_argument, NULL, 144 },
setval ("egdfile", optarg);
break;
#endif /* HAVE_SSL */
+ case 167:
+ setval ("postdata", optarg);
+ break;
+ case 168:
+ setval ("postfile", optarg);
+ break;
case 'A':
setval ("accept", optarg);
break;
res = -2;
goto out;
}
- if (opt.verbose)
+ if (progress)
progress_update (progress, sz, 0);
}
last_dltime = dltime;
}
- if (opt.verbose)
+ if (progress)
progress_update (progress, res, dltime);
*len += res;
}
res = -1;
out:
- if (opt.verbose)
+ if (progress)
progress_finish (progress, dltime);
if (elapsed)
*elapsed = dltime;
#define MAX_REDIRECTIONS 20
+#define SUSPEND_POST_DATA do { \
+ post_data_suspended = 1; \
+ saved_post_data = opt.post_data; \
+ saved_post_file_name = opt.post_file_name; \
+ opt.post_data = NULL; \
+ opt.post_file_name = NULL; \
+} while (0)
+
+#define RESTORE_POST_DATA do { \
+ if (post_data_suspended) \
+ { \
+ opt.post_data = saved_post_data; \
+ opt.post_file_name = saved_post_file_name; \
+ post_data_suspended = 0; \
+ } \
+} while (0)
+
/* Retrieve the given URL. Decides which loop to call -- HTTP, FTP,
FTP, proxy, etc. */
+/* #### This function should be rewritten so it doesn't return from
+ multiple points. */
+
uerr_t
retrieve_url (const char *origurl, char **file, char **newloc,
const char *refurl, int *dt)
char *local_file;
int redirection_count = 0;
+ int post_data_suspended = 0;
+ char *saved_post_data;
+ char *saved_post_file_name;
+
/* If dt is NULL, just ignore it. */
if (!dt)
dt = &dummy;
logprintf (LOG_NOTQUIET, _("Error parsing proxy URL %s: %s.\n"),
proxy, url_error (up_error_code));
xfree (url);
+ RESTORE_POST_DATA;
return PROXERR;
}
if (proxy_url->scheme != SCHEME_HTTP && proxy_url->scheme != u->scheme)
logprintf (LOG_NOTQUIET, _("Error in proxy URL %s: Must be HTTP.\n"), proxy);
url_free (proxy_url);
xfree (url);
+ RESTORE_POST_DATA;
return PROXERR;
}
}
url_free (u);
xfree (url);
xfree (mynewloc);
+ RESTORE_POST_DATA;
return result;
}
url_free (u);
xfree (url);
xfree (mynewloc);
+ RESTORE_POST_DATA;
return WRONGCODE;
}
url = mynewloc;
url_free (u);
u = newloc_parsed;
+
+ /* If we're being redirected from POST, we don't want to POST
+ again. Many requests answer POST with a redirection to an
+ index page; that redirection is clearly a GET. We "suspend"
+ POST data for the duration of the redirections, and restore
+ it when we're done. */
+ if (!post_data_suspended)
+ SUSPEND_POST_DATA;
+
goto redirected;
}
}
++global_download_count;
+ RESTORE_POST_DATA;
return result;
}
projects / wget / commitdiff