d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
080ef30b20
freebsd-nq/lib/libfetch/http.c

1132 lines
25 KiB
C
Raw Normal View History

Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
/*-
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
* Copyright (c) 2000 Dag-Erling Co<EFBFBD>dan Sm<EFBFBD>rgrav
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer
* in this position and unchanged.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
* derived from this software without specific prior written permission.
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
Add __FBSDID()s to libfetch
2001-09-30 21:36:09 +00:00
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
Reinsert the MIT copyright, which applies to the base64 code and was left out by accident during the rewrite.
2000-07-16 01:04:10 +00:00
/*
* The following copyright applies to the base64 code:
*
*-
* Copyright 1997 Massachusetts Institute of Technology
*
* Permission to use, copy, modify, and distribute this software and
* its documentation for any purpose and without fee is hereby
* granted, provided that both the above copyright notice and this
* permission notice appear in all copies, that both the above
* copyright notice and this permission notice appear in all
* supporting documentation, and that the name of M.I.T. not be used
* in advertising or publicity pertaining to distribution of the
* software without specific, written prior permission. M.I.T. makes
* no representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied
* warranty.
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
*
Reinsert the MIT copyright, which applies to the base64 code and was left out by accident during the rewrite.
2000-07-16 01:04:10 +00:00
* THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS
* ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
* SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
#include <sys/param.h>
IPv6 support.
2000-05-20 18:23:51 +00:00
#include <sys/socket.h>
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
#include <ctype.h>
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#include <err.h>
#include <errno.h>
Reorganize some of the http code and split it into more functions. Implement fetchStatHTTP(). Unbungle struct url, and add fetchFreeURL(). Document it.
2000-05-11 13:31:02 +00:00
#include <locale.h>
Use sizeof more consistently. Outline sanity checking of server port spec.
2000-05-07 20:01:55 +00:00
#include <netdb.h>
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
#include <stdarg.h>
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Reorganize some of the http code and split it into more functions. Implement fetchStatHTTP(). Unbungle struct url, and add fetchFreeURL(). Document it.
2000-05-11 13:31:02 +00:00
#include <time.h>
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
#include <unistd.h>
#include "fetch.h"
First of a series of cleanups to libfetch. Changed files, in alphabetical order: Makefile: Add common.c to SRCS. Make debugging easier by making 'CFLAGS += -DNDEBUG' conditional on DEBUG Don't declare struct {ftp,http}err in {ftp,http}err.c; use struct fetcherr instead. README: Remove the todo list, which is out of date anyway. common.c: (new file) Gather utility functions in this file. Merge the error reporting functions intp _fetch_errstring(), _fetch_seterr() and _fetch_syserr(). Set fetchLastErrCode and fetchLastErrText appropriately when fetchConnect fails. common.h: (new file) Gather internal prototypes and structures in this files. fetch.3: Undocument fetchFreeURL(). Document a few more known bugs. Document fetchLastErrCode and fetchLastErrText. fetch.c: Add descriptive comments to all functions that lacked them. Move fetchConnect() to common.c. Obviate the need for fetchFreeURL(), and remove it. fetch.h: Modify struct url_t so the document part is at the end. ftp.c: Remove code that is duplicated elsewhere. http.c: Remove code that is duplicated elsewhere. Prompted by: jkh
1998-11-05 19:48:17 +00:00
#include "common.h"
Add verbose flag, and support functions. Brucify the Makefile. Differentiate atime and mtime in fetch*Stat(). Fix a few pointer bugs. Tweak some error messages. Don't #include sys/param.h and stdio.h in fetch.h. Document that sys/param.h and stdio.h must be #included before fetch.h.
1998-12-16 10:24:55 +00:00
#include "httperr.h"
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/* Maximum number of redirects to follow */
#define MAX_REDIRECT 5
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/* Symbolic names for reply codes we care about */
#define HTTP_OK 200
#define HTTP_PARTIAL 206
#define HTTP_MOVED_PERM 301
#define HTTP_MOVED_TEMP 302
#define HTTP_SEE_OTHER 303
#define HTTP_NEED_AUTH 401
Properly handle being redirected to an FTP URL. Also fix a couple of not-so-minor bugs: - missing case for HTTP_SEE_OTHER - incorrect definition of HTTP_NEED_PROXY_AUTH PR: 20259 MFC after: 2 weeks
2001-12-04 01:12:51 +00:00
#define HTTP_NEED_PROXY_AUTH 407
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#define HTTP_PROTOCOL_ERROR 999
#define HTTP_REDIRECT(xyz) ((xyz) == HTTP_MOVED_PERM \
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
|| (xyz) == HTTP_MOVED_TEMP \
|| (xyz) == HTTP_SEE_OTHER)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
In verbose mode, display the full error message from the server, stripping it of HTML tags and comments. PR: bin/32989 MFC after: 1 week
2002-01-01 16:25:29 +00:00
#define HTTP_ERROR(xyz) ((xyz) > 400 && (xyz) < 599)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/*****************************************************************************
* I/O functions for decoding chunked streams
*/
Implement restart
2000-05-07 20:51:31 +00:00
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
struct httpio
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
{
Add comments to struct cookie.
2002-06-05 10:27:24 +00:00
conn_t *conn; /* connection */
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
int chunked; /* chunked mode */
Add comments to struct cookie.
2002-06-05 10:27:24 +00:00
char *buf; /* chunk buffer */
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
size_t bufsize; /* size of chunk buffer */
ssize_t buflen; /* amount of data currently in buffer */
int bufpos; /* current read offset in buffer */
Add comments to struct cookie.
2002-06-05 10:27:24 +00:00
int eof; /* end-of-file flag */
int error; /* error flag */
size_t chunksize; /* remaining size of current chunk */
#ifdef DEBUG -> #ifndef NDEBUG Pointed out by: ache
2000-07-16 23:18:44 +00:00
#ifndef NDEBUG
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
size_t total;
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#endif
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
};
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
/*
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
* Get next chunk header
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
*/
static int
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
_http_new_chunk(struct httpio *io)
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
char *p;
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (_fetch_getln(io->conn) == -1)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (io->conn->buflen < 2 || !ishexnumber(*io->conn->buf))
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
for (p = io->conn->buf; *p && !isspace(*p); ++p) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (*p == ';')
break;
if (!ishexnumber(*p))
return (-1);
if (isdigit(*p)) {
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
io->chunksize = io->chunksize * 16 +
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
*p - '0';
} else {
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
io->chunksize = io->chunksize * 16 +
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
10 + tolower(*p) - 'a';
}
}
#ifdef DEBUG -> #ifndef NDEBUG Pointed out by: ache
2000-07-16 23:18:44 +00:00
#ifndef NDEBUG
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (fetchDebug) {
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
io->total += io->chunksize;
if (io->chunksize == 0)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
fprintf(stderr, "_http_fillbuf(): "
"end of last chunk\n");
else
fprintf(stderr, "_http_fillbuf(): "
"new chunk: %lu (%lu)\n",
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
(unsigned long)io->chunksize, (unsigned long)io->total);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
}
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#endif
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
return (io->chunksize);
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
}
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
/*
* Grow the input buffer to at least len bytes
*/
static inline int
_http_growbuf(struct httpio *io, size_t len)
{
char *tmp;
if (io->bufsize >= len)
return (0);
if ((tmp = realloc(io->buf, len)) == NULL)
return (-1);
io->buf = tmp;
io->bufsize = len;
}
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
/*
* Fill the input buffer, do chunk decoding on the fly
*/
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
static int
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
_http_fillbuf(struct httpio *io, size_t len)
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
{
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (io->error)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (io->eof)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (0);
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
if (io->chunked == 0) {
if (_http_growbuf(io, len) == -1)
return (-1);
if ((io->buflen = _fetch_read(io->conn, io->buf, len)) == -1)
return (-1);
io->bufpos = 0;
return (io->buflen);
}
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (io->chunksize == 0) {
switch (_http_new_chunk(io)) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
case -1:
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
io->error = 1;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
case 0:
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
io->eof = 1;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (0);
}
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
if (len > io->chunksize)
len = io->chunksize;
if (_http_growbuf(io, len) == -1)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
if ((io->buflen = _fetch_read(io->conn, io->buf, len)) == -1)
return (-1);
io->chunksize -= io->buflen;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (io->chunksize == 0) {
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
char endl[2];
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
if (_fetch_read(io->conn, endl, 2) != 2 ||
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
endl[0] != '\r' || endl[1] != '\n')
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
}
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
io->bufpos = 0;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
return (io->buflen);
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
/*
* Read function
*/
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
static int
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
_http_readfn(void *v, char *buf, int len)
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
{
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
struct httpio *io = (struct httpio *)v;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
int l, pos;
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (io->error)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (io->eof)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (0);
for (pos = 0; len > 0; pos += l, len -= l) {
/* empty buffer */
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
if (!io->buf || io->bufpos == io->buflen)
if (_http_fillbuf(io, len) < 1)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
break;
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
l = io->buflen - io->bufpos;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (len < l)
l = len;
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
bcopy(io->buf + io->bufpos, buf + pos, l);
io->bufpos += l;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
}
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if (!pos && io->error)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
return (pos);
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
/*
* Write function
*/
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
static int
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
_http_writefn(void *v, const char *buf, int len)
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
{
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
struct httpio *io = (struct httpio *)v;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
return (_fetch_write(io->conn, buf, len));
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
/*
* Close function
*/
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
static int
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
_http_closefn(void *v)
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
{
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
struct httpio *io = (struct httpio *)v;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
int r;
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
r = _fetch_close(io->conn);
if (io->buf)
free(io->buf);
free(io);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (r);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
/*
* Wrap a file descriptor up
*/
static FILE *
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
_http_funopen(conn_t *conn, int chunked)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
struct httpio *io;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
FILE *f;
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
if ((io = calloc(1, sizeof *io)) == NULL) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
_fetch_syserr();
return (NULL);
}
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
io->conn = conn;
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
io->chunked = chunked;
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
f = funopen(io, _http_readfn, _http_writefn, NULL, _http_closefn);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (f == NULL) {
_fetch_syserr();
Rename struct cookie to struct httpio to avoid confusion (it's not an HTTP cookie) and increase symmetry with equivalent FTP code.
2002-06-05 10:31:01 +00:00
free(io);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (NULL);
}
return (f);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/*****************************************************************************
* Helper functions for talking to the server and parsing its replies
*/
/* Header types */
typedef enum {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
hdr_syserror = -2,
hdr_error = -1,
hdr_end = 0,
hdr_unknown = 1,
hdr_content_length,
hdr_content_range,
hdr_last_modified,
hdr_location,
hdr_transfer_encoding,
hdr_www_authenticate
Tons of type, style and warning fixes that have been rotting in my tree for ages - some of which wouldn't be necessary if gcc wasn't broken or TPTB were willing to do something (-fno-builtin) about it.
2001-10-18 08:29:26 +00:00
} hdr_t;
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/* Names of interesting headers */
static struct {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
hdr_t num;
const char *name;
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
} hdr_names[] = {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
{ hdr_content_length, "Content-Length" },
{ hdr_content_range, "Content-Range" },
{ hdr_last_modified, "Last-Modified" },
{ hdr_location, "Location" },
{ hdr_transfer_encoding, "Transfer-Encoding" },
{ hdr_www_authenticate, "WWW-Authenticate" },
{ hdr_unknown, NULL },
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
};
/*
* Send a formatted line; optionally echo to terminal
*/
static int
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn_t *conn, const char *fmt, ...)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
va_list ap;
size_t len;
char *msg;
int r;
va_start(ap, fmt);
len = vasprintf(&msg, fmt, ap);
va_end(ap);
if (msg == NULL) {
errno = ENOMEM;
_fetch_syserr();
return (-1);
}
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
r = _fetch_putln(conn, msg, len);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
free(msg);
if (r == -1) {
_fetch_syserr();
return (-1);
}
return (0);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
/*
* Get and parse status line
*/
static int
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_get_reply(conn_t *conn)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
char *p;
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (_fetch_getln(conn) == -1)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (-1);
/*
* A valid status line looks like "HTTP/m.n xyz reason" where m
* and n are the major and minor protocol version numbers and xyz
* is the reply code.
* Unfortunately, there are servers out there (NCSA 1.5.1, to name
* just one) that do not send a version number, so we can't rely
* on finding one, but if we do, insist on it being 1.0 or 1.1.
* We don't care about the reason phrase.
*/
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (strncmp(conn->buf, "HTTP", 4) != 0)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (HTTP_PROTOCOL_ERROR);
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
p = conn->buf + 4;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (*p == '/') {
if (p[1] != '1' || p[2] != '.' || (p[3] != '0' && p[3] != '1'))
return (HTTP_PROTOCOL_ERROR);
p += 4;
}
if (*p != ' ' || !isdigit(p[1]) || !isdigit(p[2]) || !isdigit(p[3]))
return (HTTP_PROTOCOL_ERROR);
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
conn->err = (p[1] - '0') * 100 + (p[2] - '0') * 10 + (p[3] - '0');
return (conn->err);
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
/*
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
* Check a header; if the type matches the given string, return a pointer
* to the beginning of the value.
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
*/
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
static const char *
_http_match(const char *str, const char *hdr)
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
while (*str && *hdr && tolower(*str++) == tolower(*hdr++))
/* nothing */;
if (*str || *hdr != ':')
return (NULL);
while (*hdr && isspace(*++hdr))
/* nothing */;
return (hdr);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
/*
* Get the next header and return the appropriate symbolic code.
*/
Tons of type, style and warning fixes that have been rotting in my tree for ages - some of which wouldn't be necessary if gcc wasn't broken or TPTB were willing to do something (-fno-builtin) about it.
2001-10-18 08:29:26 +00:00
static hdr_t
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_next_header(conn_t *conn, const char **p)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
int i;
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (_fetch_getln(conn) == -1)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (hdr_syserror);
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
while (conn->buflen && isspace(conn->buf[conn->buflen - 1]))
conn->buflen--;
conn->buf[conn->buflen] = '\0';
if (conn->buflen == 0)
return (hdr_end);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/*
* We could check for malformed headers but we don't really care.
* A valid header starts with a token immediately followed by a
* colon; a token is any sequence of non-control, non-whitespace
* characters except "()<>@,;:\\\"{}".
*/
for (i = 0; hdr_names[i].num != hdr_unknown; i++)
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if ((*p = _http_match(hdr_names[i].name, conn->buf)) != NULL)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (hdr_names[i].num);
return (hdr_unknown);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
/*
* Parse a last-modified header
*/
Ignore environment variables that are set but empty. Sort out the size / length confusion. Always try to report the *real* file size in the url_stat structure, no matter how much of it is actually being sent, and try to detect inconsistencies between sizes. Rearrange the request loop to avoid having to add meaningless code just to silence compiler warnings. Switch to a more sensible and consistent interface for the _http_parse*() functions.
2000-07-21 11:02:43 +00:00
static int
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
_http_parse_mtime(const char *p, time_t *mtime)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
char locale[64], *r;
struct tm tm;
strncpy(locale, setlocale(LC_TIME, NULL), sizeof locale);
setlocale(LC_TIME, "C");
r = strptime(p, "%a, %d %b %Y %H:%M:%S GMT", &tm);
/* XXX should add support for date-2 and date-3 */
setlocale(LC_TIME, locale);
if (r == NULL)
return (-1);
DEBUG(fprintf(stderr, "last modified: [%04d-%02d-%02d "
Remove VT100 escapes from debugging messages now that they're enabled by default. PR: 32988 MFC after: 3 days
2002-01-01 14:48:09 +00:00
"%02d:%02d:%02d]\n",
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec));
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
*mtime = timegm(&tm);
return (0);
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/*
* Parse a content-length header
*/
Ignore environment variables that are set but empty. Sort out the size / length confusion. Always try to report the *real* file size in the url_stat structure, no matter how much of it is actually being sent, and try to detect inconsistencies between sizes. Rearrange the request loop to avoid having to add meaningless code just to silence compiler warnings. Switch to a more sensible and consistent interface for the _http_parse*() functions.
2000-07-21 11:02:43 +00:00
static int
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
_http_parse_length(const char *p, off_t *length)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
off_t len;
for (len = 0; *p && isdigit(*p); ++p)
len = len * 10 + (*p - '0');
if (*p)
return (-1);
DEBUG(fprintf(stderr, "content length: [%lld]\n",
(long long)len));
*length = len;
return (0);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
/*
* Parse a content-range header
*/
Ignore environment variables that are set but empty. Sort out the size / length confusion. Always try to report the *real* file size in the url_stat structure, no matter how much of it is actually being sent, and try to detect inconsistencies between sizes. Rearrange the request loop to avoid having to add meaningless code just to silence compiler warnings. Switch to a more sensible and consistent interface for the _http_parse*() functions.
2000-07-21 11:02:43 +00:00
static int
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
_http_parse_range(const char *p, off_t *offset, off_t *length, off_t *size)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
off_t first, last, len;
if (strncasecmp(p, "bytes ", 6) != 0)
return (-1);
for (first = 0, p += 6; *p && isdigit(*p); ++p)
first = first * 10 + *p - '0';
if (*p != '-')
return (-1);
for (last = 0, ++p; *p && isdigit(*p); ++p)
last = last * 10 + *p - '0';
if (first > last || *p != '/')
return (-1);
for (len = 0, ++p; *p && isdigit(*p); ++p)
len = len * 10 + *p - '0';
if (*p || len < last - first + 1)
return (-1);
DEBUG(fprintf(stderr, "content range: [%lld-%lld/%lld]\n",
(long long)first, (long long)last, (long long)len));
*offset = first;
*length = last - first + 1;
*size = len;
return (0);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/*****************************************************************************
* Helper functions for authorization
*/
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
/*
* Base64 encoding
*/
Rework the authorization code. Only send absolute URI if connected to a proxy, since Apache doesn't always understand absolute URIs. Clean up some of the debugging output.
2000-07-11 18:12:41 +00:00
static char *
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
_http_base64(const char *src)
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
static const char base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
char *str, *dst;
size_t l;
int t, r;
l = strlen(src);
if ((str = malloc(((l + 2) / 3) * 4)) == NULL)
return (NULL);
dst = str;
r = 0;
while (l >= 3) {
t = (src[0] << 16) | (src[1] << 8) | src[2];
dst[0] = base64[(t >> 18) & 0x3f];
dst[1] = base64[(t >> 12) & 0x3f];
dst[2] = base64[(t >> 6) & 0x3f];
dst[3] = base64[(t >> 0) & 0x3f];
src += 3; l -= 3;
dst += 4; r += 4;
}
switch (l) {
case 2:
t = (src[0] << 16) | (src[1] << 8);
dst[0] = base64[(t >> 18) & 0x3f];
dst[1] = base64[(t >> 12) & 0x3f];
dst[2] = base64[(t >> 6) & 0x3f];
dst[3] = '=';
dst += 4;
r += 4;
break;
case 1:
t = src[0] << 16;
dst[0] = base64[(t >> 18) & 0x3f];
dst[1] = base64[(t >> 12) & 0x3f];
dst[2] = dst[3] = '=';
dst += 4;
r += 4;
break;
case 0:
break;
}
*dst = 0;
return (str);
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
}
/*
* Encode username and password
*/
Rework the authorization code. Only send absolute URI if connected to a proxy, since Apache doesn't always understand absolute URIs. Clean up some of the debugging output.
2000-07-11 18:12:41 +00:00
static int
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_basic_auth(conn_t *conn, const char *hdr, const char *usr, const char *pwd)
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
char *upw, *auth;
int r;
DEBUG(fprintf(stderr, "usr: [%s]\n", usr));
DEBUG(fprintf(stderr, "pwd: [%s]\n", pwd));
if (asprintf(&upw, "%s:%s", usr, pwd) == -1)
return (-1);
auth = _http_base64(upw);
free(upw);
if (auth == NULL)
return (-1);
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
r = _http_cmd(conn, "%s: Basic %s", hdr, auth);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
free(auth);
return (r);
Rework the authorization code. Only send absolute URI if connected to a proxy, since Apache doesn't always understand absolute URIs. Clean up some of the debugging output.
2000-07-11 18:12:41 +00:00
}
/*
* Send an authorization header
*/
static int
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_authorize(conn_t *conn, const char *hdr, const char *p)
Rework the authorization code. Only send absolute URI if connected to a proxy, since Apache doesn't always understand absolute URIs. Clean up some of the debugging output.
2000-07-11 18:12:41 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* basic authorization */
if (strncasecmp(p, "basic:", 6) == 0) {
char *user, *pwd, *str;
int r;
/* skip realm */
for (p += 6; *p && *p != ':'; ++p)
/* nothing */ ;
if (!*p || strchr(++p, ':') == NULL)
return (-1);
if ((str = strdup(p)) == NULL)
return (-1); /* XXX */
user = str;
pwd = strchr(str, ':');
*pwd++ = '\0';
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
r = _http_basic_auth(conn, hdr, user, pwd);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
free(str);
return (r);
}
return (-1);
Base64 code (and the MIT copyright) moved to http.c FTP STORe and APPEnd added. FTP proxy support added (untested).
1998-07-12 22:34:40 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/*****************************************************************************
* Helper functions for connecting to a server or proxy
*/
/*
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
* Connect to the correct HTTP server or proxy.
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
*/
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
static conn_t *
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
_http_connect(struct url *URL, struct url *purl, const char *flags)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
conn_t *conn;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
int verbose;
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
int af;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#ifdef INET6
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
af = AF_UNSPEC;
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#else
IPv6 support.
2000-05-20 18:23:51 +00:00
af = AF_INET;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
#endif
verbose = CHECK_FLAG('v');
if (CHECK_FLAG('4'))
af = AF_INET;
Rework proxy handling so that proxies can be specified as URLs. As a side effect, remove a lot of duplicate and now redundant code.
2000-10-12 22:10:26 +00:00
#ifdef INET6
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
else if (CHECK_FLAG('6'))
af = AF_INET6;
Rework proxy handling so that proxies can be specified as URLs. As a side effect, remove a lot of duplicate and now redundant code.
2000-10-12 22:10:26 +00:00
#endif
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (purl) {
URL = purl;
} else if (strcasecmp(URL->scheme, SCHEME_FTP) == 0) {
/* can't talk http to an ftp server */
/* XXX should set an error code */
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
return (NULL);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
}
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if ((conn = _fetch_connect(URL->host, URL->port, af, verbose)) == NULL)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* _fetch_connect() has already set an error code */
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
return (NULL);
return (conn);
Rework proxy handling so that proxies can be specified as URLs. As a side effect, remove a lot of duplicate and now redundant code.
2000-10-12 22:10:26 +00:00
}
static struct url *
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
_http_get_proxy(void)
Rework proxy handling so that proxies can be specified as URLs. As a side effect, remove a lot of duplicate and now redundant code.
2000-10-12 22:10:26 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
struct url *purl;
char *p;
if (((p = getenv("HTTP_PROXY")) || (p = getenv("http_proxy"))) &&
(purl = fetchParseURL(p))) {
if (!*purl->scheme)
strcpy(purl->scheme, SCHEME_HTTP);
if (!purl->port)
purl->port = _fetch_default_proxy_port(purl->scheme);
if (strcasecmp(purl->scheme, SCHEME_HTTP) == 0)
return (purl);
fetchFreeURL(purl);
}
return (NULL);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
}
In verbose mode, display the full error message from the server, stripping it of HTML tags and comments. PR: bin/32989 MFC after: 1 week
2002-01-01 16:25:29 +00:00
static void
_http_print_html(FILE *out, FILE *in)
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
size_t len;
char *line, *p, *q;
int comment, tag;
comment = tag = 0;
while ((line = fgetln(in, &len)) != NULL) {
while (len && isspace(line[len - 1]))
--len;
for (p = q = line; q < line + len; ++q) {
if (comment && *q == '-') {
if (q + 2 < line + len &&
strcmp(q, "-->") == 0) {
tag = comment = 0;
q += 2;
}
} else if (tag && !comment && *q == '>') {
p = q + 1;
tag = 0;
} else if (!tag && *q == '<') {
if (q > p)
fwrite(p, q - p, 1, out);
tag = 1;
if (q + 3 < line + len &&
strcmp(q, "<!--") == 0) {
comment = 1;
q += 3;
}
}
In verbose mode, display the full error message from the server, stripping it of HTML tags and comments. PR: bin/32989 MFC after: 1 week
2002-01-01 16:25:29 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (!tag && q > p)
fwrite(p, q - p, 1, out);
fputc('\n', out);
In verbose mode, display the full error message from the server, stripping it of HTML tags and comments. PR: bin/32989 MFC after: 1 week
2002-01-01 16:25:29 +00:00
}
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/*****************************************************************************
* Core
*/
/*
* Send a request and process the reply
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
*
* XXX This function is way too long, the do..while loop should be split
* XXX off into a separate function.
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
*/
Rework proxy handling so that proxies can be specified as URLs. As a side effect, remove a lot of duplicate and now redundant code.
2000-10-12 22:10:26 +00:00
FILE *
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
_http_request(struct url *URL, const char *op, struct url_stat *us,
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
struct url *purl, const char *flags)
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
{
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
conn_t *conn;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
struct url *url, *new;
int chunked, direct, need_auth, noredirect, verbose;
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
int i, n;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
off_t offset, clength, length, size;
time_t mtime;
const char *p;
FILE *f;
hdr_t h;
char *host;
IPv6 support.
2000-05-20 18:23:51 +00:00
#ifdef INET6
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
char hbuf[MAXHOSTNAMELEN + 1];
IPv6 support.
2000-05-20 18:23:51 +00:00
#endif
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
direct = CHECK_FLAG('d');
noredirect = CHECK_FLAG('A');
verbose = CHECK_FLAG('v');
if (direct && purl) {
fetchFreeURL(purl);
purl = NULL;
Properly handle being redirected to an FTP URL. Also fix a couple of not-so-minor bugs: - missing case for HTTP_SEE_OTHER - incorrect definition of HTTP_NEED_PROXY_AUTH PR: 20259 MFC after: 2 weeks
2001-12-04 01:12:51 +00:00
}
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* try the provided URL first */
url = URL;
/* if the A flag is set, we only get one try */
n = noredirect ? 1 : MAX_REDIRECT;
i = 0;
need_auth = 0;
do {
new = NULL;
chunked = 0;
offset = 0;
clength = -1;
length = -1;
size = -1;
mtime = 0;
/* check port */
if (!url->port)
url->port = _fetch_default_port(url->scheme);
/* were we redirected to an FTP URL? */
if (purl == NULL && strcmp(url->scheme, SCHEME_FTP) == 0) {
if (strcmp(op, "GET") == 0)
return (_ftp_request(url, "RETR", us, purl, flags));
else if (strcmp(op, "HEAD") == 0)
return (_ftp_request(url, "STAT", us, purl, flags));
}
/* connect to server or proxy */
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if ((conn = _http_connect(url, purl, flags)) == NULL)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
goto ouch;
host = url->host;
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#ifdef INET6
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (strchr(url->host, ':')) {
snprintf(hbuf, sizeof(hbuf), "[%s]", url->host);
host = hbuf;
}
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
#endif
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* send request */
if (verbose)
_fetch_info("requesting %s://%s:%d%s",
url->scheme, host, url->port, url->doc);
if (purl) {
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn, "%s %s://%s:%d%s HTTP/1.1",
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
op, url->scheme, host, url->port, url->doc);
} else {
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn, "%s %s HTTP/1.1",
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
op, url->doc);
}
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* virtual host */
if (url->port == _fetch_default_port(url->scheme))
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn, "Host: %s", host);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
else
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn, "Host: %s:%d", host, url->port);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* proxy authorization */
if (purl) {
if (*purl->user || *purl->pwd)
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_basic_auth(conn, "Proxy-Authorization",
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
purl->user, purl->pwd);
else if ((p = getenv("HTTP_PROXY_AUTH")) != NULL && *p != '\0')
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_authorize(conn, "Proxy-Authorization", p);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
}
/* server authorization */
if (need_auth || *url->user || *url->pwd) {
if (*url->user || *url->pwd)
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_basic_auth(conn, "Authorization", url->user, url->pwd);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
else if ((p = getenv("HTTP_AUTH")) != NULL && *p != '\0')
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_authorize(conn, "Authorization", p);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
else if (fetchAuthMethod && fetchAuthMethod(url) == 0) {
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_basic_auth(conn, "Authorization", url->user, url->pwd);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
} else {
_http_seterr(HTTP_NEED_AUTH);
goto ouch;
}
}
/* other headers */
if ((p = getenv("HTTP_USER_AGENT")) != NULL && *p != '\0')
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn, "User-Agent: %s", p);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
else
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn, "User-Agent: %s " _LIBFETCH_VER, getprogname());
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (url->offset)
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_cmd(conn, "Range: bytes=%lld-", (long long)url->offset);
_http_cmd(conn, "Connection: close");
_http_cmd(conn, "");
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* get reply */
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
switch (_http_get_reply(conn)) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
case HTTP_OK:
case HTTP_PARTIAL:
/* fine */
break;
case HTTP_MOVED_PERM:
case HTTP_MOVED_TEMP:
case HTTP_SEE_OTHER:
/*
* Not so fine, but we still have to read the headers to
* get the new location.
*/
break;
case HTTP_NEED_AUTH:
if (need_auth) {
/*
* We already sent out authorization code, so there's
* nothing more we can do.
*/
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_seterr(conn->err);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
goto ouch;
}
/* try again, but send the password this time */
if (verbose)
_fetch_info("server requires authorization");
break;
case HTTP_NEED_PROXY_AUTH:
/*
* If we're talking to a proxy, we already sent our proxy
* authorization code, so there's nothing more we can do.
*/
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_seterr(conn->err);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
goto ouch;
case HTTP_PROTOCOL_ERROR:
/* fall through */
case -1:
_fetch_syserr();
goto ouch;
default:
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_http_seterr(conn->err);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (!verbose)
goto ouch;
/* fall through so we can get the full error message */
}
/* get headers */
do {
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
switch ((h = _http_next_header(conn, &p))) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
case hdr_syserror:
_fetch_syserr();
goto ouch;
case hdr_error:
_http_seterr(HTTP_PROTOCOL_ERROR);
goto ouch;
case hdr_content_length:
_http_parse_length(p, &clength);
break;
case hdr_content_range:
_http_parse_range(p, &offset, &length, &size);
break;
case hdr_last_modified:
_http_parse_mtime(p, &mtime);
break;
case hdr_location:
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (!HTTP_REDIRECT(conn->err))
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
break;
if (new)
free(new);
if (verbose)
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_fetch_info("%d redirect to %s", conn->err, p);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (*p == '/')
/* absolute path */
new = fetchMakeURL(url->scheme, url->host, url->port, p,
url->user, url->pwd);
else
new = fetchParseURL(p);
if (new == NULL) {
/* XXX should set an error code */
DEBUG(fprintf(stderr, "failed to parse new URL\n"));
goto ouch;
}
if (!*new->user && !*new->pwd) {
strcpy(new->user, url->user);
strcpy(new->pwd, url->pwd);
}
new->offset = url->offset;
new->length = url->length;
break;
case hdr_transfer_encoding:
/* XXX weak test*/
chunked = (strcasecmp(p, "chunked") == 0);
break;
case hdr_www_authenticate:
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (conn->err != HTTP_NEED_AUTH)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
break;
/* if we were smarter, we'd check the method and realm */
break;
case hdr_end:
/* fall through */
case hdr_unknown:
/* ignore */
break;
}
} while (h > hdr_end);
/* we have a hit or an error */
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (conn->err == HTTP_OK || conn->err == HTTP_PARTIAL || HTTP_ERROR(conn->err))
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
break;
/* we need to provide authentication */
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (conn->err == HTTP_NEED_AUTH) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
need_auth = 1;
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_fetch_close(conn);
conn = NULL;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
continue;
}
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* all other cases: we got a redirect */
need_auth = 0;
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
_fetch_close(conn);
conn = NULL;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (!new) {
DEBUG(fprintf(stderr, "redirect with no new location\n"));
break;
}
if (url != URL)
fetchFreeURL(url);
url = new;
} while (++i < n);
/* we failed, or ran out of retries */
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (conn == NULL) {
_http_seterr(conn->err);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
goto ouch;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
}
DEBUG(fprintf(stderr, "offset %lld, length %lld,"
" size %lld, clength %lld\n",
(long long)offset, (long long)length,
(long long)size, (long long)clength));
/* check for inconsistencies */
if (clength != -1 && length != -1 && clength != length) {
_http_seterr(HTTP_PROTOCOL_ERROR);
In verbose mode, display the full error message from the server, stripping it of HTML tags and comments. PR: bin/32989 MFC after: 1 week
2002-01-01 16:25:29 +00:00
goto ouch;
Use sizeof more consistently. Outline sanity checking of server port spec.
2000-05-07 20:01:55 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
if (clength == -1)
clength = length;
if (clength != -1)
length = offset + clength;
if (length != -1 && size != -1 && length != size) {
_http_seterr(HTTP_PROTOCOL_ERROR);
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
goto ouch;
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
}
if (size == -1)
size = length;
/* fill in stats */
if (us) {
us->size = size;
us->atime = us->mtime = mtime;
}
/* too far? */
if (offset > URL->offset) {
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
_http_seterr(HTTP_PROTOCOL_ERROR);
goto ouch;
Add rudimentary support for an authentication callback function.
2001-05-26 19:37:15 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
/* report back real offset and size */
URL->offset = offset;
URL->length = clength;
/* wrap it up in a FILE */
Wrap everything in struct connection, and enforce timeouts everywhere (except for DNS operations). Always use funopen() for HTTP, to support both timeouts and SSL.
2002-06-05 12:19:08 +00:00
if ((f = _http_funopen(conn, chunked)) == NULL) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
_fetch_syserr();
goto ouch;
Add rudimentary support for an authentication callback function.
2001-05-26 19:37:15 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Fix a bug (misplaced continue) that caused redirects to fail. Lots of code moved around, but the acutal functional changes are small. Add support for site-internal redirects (where the Location: header gives a path instead of an absolute URI) Pointed out by: kuriyama
2000-07-13 09:13:58 +00:00
if (url != URL)
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
fetchFreeURL(url);
if (purl)
fetchFreeURL(purl);
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (HTTP_ERROR(conn->err)) {
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
_http_print_html(stderr, f);
fclose(f);
f = NULL;
}
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (f);
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
ouch:
if (url != URL)
fetchFreeURL(url);
if (purl)
fetchFreeURL(purl);
First step towards SSL support: wrap connections in a 'struct connection' which contains the socket descriptor, the input buffer and (yet unused) SSL state variables. This has the neat side effect of greatly improving reentrance (though we're not *quite* there yet) and opening the door to HTTP connection caching. This commit is inspired by email conversations with and patches from Henry Whincup <henry@techiebod.com> last fall.
2002-06-05 10:05:03 +00:00
if (conn != NULL)
_fetch_close(conn);
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (NULL);
Reorganize some of the http code and split it into more functions. Implement fetchStatHTTP(). Unbungle struct url, and add fetchFreeURL(). Document it.
2000-05-11 13:31:02 +00:00
}
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
Extensive rewrite of the HTTP code. The new code is significantly cleaner and more robust, and somewhat more efficient. It also handles authorization and redirects properly, and supports timeouts like the FTP code. Many thanks to Umemoto-san for his assistance with IPv6 support, both here and in other parts of libfetch.
2000-07-12 10:39:56 +00:00
/*****************************************************************************
* Entry points
Reorganize some of the http code and split it into more functions. Implement fetchStatHTTP(). Unbungle struct url, and add fetchFreeURL(). Document it.
2000-05-11 13:31:02 +00:00
*/
Introduce fetchXGet*(), which combine the functionalities of fetchGet*() and fetchStat*(). In most cases, either fetchGet*() or fetchXGet*() is a wrapper around the other; in all cases, calling fetchGet*() is identical to calling fetchXGet*() with the second argument set to NULL.
2000-07-17 21:25:00 +00:00
/*
* Retrieve and stat a file by HTTP
*/
FILE *
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
fetchXGetHTTP(struct url *URL, struct url_stat *us, const char *flags)
Introduce fetchXGet*(), which combine the functionalities of fetchGet*() and fetchStat*(). In most cases, either fetchGet*() or fetchXGet*() is a wrapper around the other; in all cases, calling fetchGet*() is identical to calling fetchXGet*() with the second argument set to NULL.
2000-07-17 21:25:00 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (_http_request(URL, "GET", us, _http_get_proxy(), flags));
Introduce fetchXGet*(), which combine the functionalities of fetchGet*() and fetchStat*(). In most cases, either fetchGet*() or fetchXGet*() is a wrapper around the other; in all cases, calling fetchGet*() is identical to calling fetchXGet*() with the second argument set to NULL.
2000-07-17 21:25:00 +00:00
}
Reorganize some of the http code and split it into more functions. Implement fetchStatHTTP(). Unbungle struct url, and add fetchFreeURL(). Document it.
2000-05-11 13:31:02 +00:00
/*
* Retrieve a file by HTTP
*/
FILE *
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
fetchGetHTTP(struct url *URL, const char *flags)
Reorganize some of the http code and split it into more functions. Implement fetchStatHTTP(). Unbungle struct url, and add fetchFreeURL(). Document it.
2000-05-11 13:31:02 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
return (fetchXGetHTTP(URL, NULL, flags));
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Introduce fetchXGet*(), which combine the functionalities of fetchGet*() and fetchStat*(). In most cases, either fetchGet*() or fetchXGet*() is a wrapper around the other; in all cases, calling fetchGet*() is identical to calling fetchXGet*() with the second argument set to NULL.
2000-07-17 21:25:00 +00:00
/*
* Store a file by HTTP
*/
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
FILE *
Tons of type, style and warning fixes that have been rotting in my tree for ages - some of which wouldn't be necessary if gcc wasn't broken or TPTB were willing to do something (-fno-builtin) about it.
2001-10-18 08:29:26 +00:00
fetchPutHTTP(struct url *URL __unused, const char *flags __unused)
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
warnx("fetchPutHTTP(): not implemented");
return (NULL);
Imported libfetch into the tree. It compiles, but there's still some work to do. I especially need help with the man page.
1998-07-09 16:52:44 +00:00
}
Second of a series of cleanups to libfetch. This commit introduces the following features: a) the fetchStat*() functions, which return meta-information for a document, such as size, modification time, etc. b) the use of the com_err(3) facilities to report errors. It also fixes a bunch of style bugs and a few logic bugs and somewhat improves the man page. Changed files, in alphabetical order: Makefile: Don't generate macros in {ftp,http}err.c. Generate category fields for the error message lists. Compile the error table. Install fetch_err.h along with fetch.h. common.c: Remove the _netdb_errstring() macro, and add FETCH_ERR_NETDB to the error code in the _netdb_seterr() macro. Add categories to the _netdb_errlist table. Report errors through the Common Error library. common.h: Add the DEBUG macros. Add prototype for fetchConnect(). Remove the prototype for _fetch_errstring(), which is local to common.c Add a categroy field to struct fetcherr, and define constants for error categories. Define macros for _{url,netdb,ftp,http}_seterr(). errors.et: (new file) List error categories. fetch.3: Document the fetchStat*() functions. Move the "unimplemented functionality" comments from NOTES to BUGS. Document that applications which use libfetch must also use libcom_err, and list existing error codes. Undocument fetchLastErr{Code,String}. Remove the (empty) DIAGNOSTICS section. Mention Eugene Skepner in the AUTHORS section. fetch.c: Move the DEBUG macros to common.c Add fetchStat() and fetchStatURL(). Generate error messages for URL parser errors, and fix a minor bug in the parser. Use 'struct url' instead of 'url_t'. Remove fetchLastErr{Code,String}. fetch.h: Use 'struct url' instead of 'url_t', and remove the typedef. Define struct url_stat (used by fetchStat()). Add prototypes for fetchStat*(). Remove the declarations for fetchLastErr{Code,String}. Include fetch_err.h. fetch_err.et: (new file) Error table for libfetch. file.c: Add fetchStatFile(). Use 'struct url' instead of 'url_t'. ftp.c: Add fetchStatFTP(). Use 'struct url' instead of 'url_t'. Don't use fetchLastErrCode. ftp.errors: Add categories to all error messages. http.c: Add fetchStatHTTP(). Use 'struct url' instead of 'url_t'. Don't use fetchLastErr{Code,Text}. http.errors: Add categories to all error messages. Prompted by: jkh and Eugene Skepner Numerous sugestions from: Garett Wollman and Eugene Skepner
1998-11-06 22:14:08 +00:00
/*
* Get an HTTP document's metadata
*/
int
Apply 'const' liberally. Fix some other minor glitches.
2001-04-24 00:06:21 +00:00
fetchStatHTTP(struct url *URL, struct url_stat *us, const char *flags)
Second of a series of cleanups to libfetch. This commit introduces the following features: a) the fetchStat*() functions, which return meta-information for a document, such as size, modification time, etc. b) the use of the com_err(3) facilities to report errors. It also fixes a bunch of style bugs and a few logic bugs and somewhat improves the man page. Changed files, in alphabetical order: Makefile: Don't generate macros in {ftp,http}err.c. Generate category fields for the error message lists. Compile the error table. Install fetch_err.h along with fetch.h. common.c: Remove the _netdb_errstring() macro, and add FETCH_ERR_NETDB to the error code in the _netdb_seterr() macro. Add categories to the _netdb_errlist table. Report errors through the Common Error library. common.h: Add the DEBUG macros. Add prototype for fetchConnect(). Remove the prototype for _fetch_errstring(), which is local to common.c Add a categroy field to struct fetcherr, and define constants for error categories. Define macros for _{url,netdb,ftp,http}_seterr(). errors.et: (new file) List error categories. fetch.3: Document the fetchStat*() functions. Move the "unimplemented functionality" comments from NOTES to BUGS. Document that applications which use libfetch must also use libcom_err, and list existing error codes. Undocument fetchLastErr{Code,String}. Remove the (empty) DIAGNOSTICS section. Mention Eugene Skepner in the AUTHORS section. fetch.c: Move the DEBUG macros to common.c Add fetchStat() and fetchStatURL(). Generate error messages for URL parser errors, and fix a minor bug in the parser. Use 'struct url' instead of 'url_t'. Remove fetchLastErr{Code,String}. fetch.h: Use 'struct url' instead of 'url_t', and remove the typedef. Define struct url_stat (used by fetchStat()). Add prototypes for fetchStat*(). Remove the declarations for fetchLastErr{Code,String}. Include fetch_err.h. fetch_err.et: (new file) Error table for libfetch. file.c: Add fetchStatFile(). Use 'struct url' instead of 'url_t'. ftp.c: Add fetchStatFTP(). Use 'struct url' instead of 'url_t'. Don't use fetchLastErrCode. ftp.errors: Add categories to all error messages. http.c: Add fetchStatHTTP(). Use 'struct url' instead of 'url_t'. Don't use fetchLastErr{Code,Text}. http.errors: Add categories to all error messages. Prompted by: jkh and Eugene Skepner Numerous sugestions from: Garett Wollman and Eugene Skepner
1998-11-06 22:14:08 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
FILE *f;
if ((f = _http_request(URL, "HEAD", us, _http_get_proxy(), flags)) == NULL)
return (-1);
fclose(f);
return (0);
Second of a series of cleanups to libfetch. This commit introduces the following features: a) the fetchStat*() functions, which return meta-information for a document, such as size, modification time, etc. b) the use of the com_err(3) facilities to report errors. It also fixes a bunch of style bugs and a few logic bugs and somewhat improves the man page. Changed files, in alphabetical order: Makefile: Don't generate macros in {ftp,http}err.c. Generate category fields for the error message lists. Compile the error table. Install fetch_err.h along with fetch.h. common.c: Remove the _netdb_errstring() macro, and add FETCH_ERR_NETDB to the error code in the _netdb_seterr() macro. Add categories to the _netdb_errlist table. Report errors through the Common Error library. common.h: Add the DEBUG macros. Add prototype for fetchConnect(). Remove the prototype for _fetch_errstring(), which is local to common.c Add a categroy field to struct fetcherr, and define constants for error categories. Define macros for _{url,netdb,ftp,http}_seterr(). errors.et: (new file) List error categories. fetch.3: Document the fetchStat*() functions. Move the "unimplemented functionality" comments from NOTES to BUGS. Document that applications which use libfetch must also use libcom_err, and list existing error codes. Undocument fetchLastErr{Code,String}. Remove the (empty) DIAGNOSTICS section. Mention Eugene Skepner in the AUTHORS section. fetch.c: Move the DEBUG macros to common.c Add fetchStat() and fetchStatURL(). Generate error messages for URL parser errors, and fix a minor bug in the parser. Use 'struct url' instead of 'url_t'. Remove fetchLastErr{Code,String}. fetch.h: Use 'struct url' instead of 'url_t', and remove the typedef. Define struct url_stat (used by fetchStat()). Add prototypes for fetchStat*(). Remove the declarations for fetchLastErr{Code,String}. Include fetch_err.h. fetch_err.et: (new file) Error table for libfetch. file.c: Add fetchStatFile(). Use 'struct url' instead of 'url_t'. ftp.c: Add fetchStatFTP(). Use 'struct url' instead of 'url_t'. Don't use fetchLastErrCode. ftp.errors: Add categories to all error messages. http.c: Add fetchStatHTTP(). Use 'struct url' instead of 'url_t'. Don't use fetchLastErr{Code,Text}. http.errors: Add categories to all error messages. Prompted by: jkh and Eugene Skepner Numerous sugestions from: Garett Wollman and Eugene Skepner
1998-11-06 22:14:08 +00:00
}
Implement and document file list retrieval.
1998-12-21 19:41:50 +00:00
/*
* List a directory
*/
struct url_ent *
Tons of type, style and warning fixes that have been rotting in my tree for ages - some of which wouldn't be necessary if gcc wasn't broken or TPTB were willing to do something (-fno-builtin) about it.
2001-10-18 08:29:26 +00:00
fetchListHTTP(struct url *url __unused, const char *flags __unused)
Implement and document file list retrieval.
1998-12-21 19:41:50 +00:00
{
Reindent, and add parentheses to return statements. Some functions in ftp.c and http.c now have exceedingly long lines due to deep nesting; this will be corrected by reorganizing the code in a later revision.
2002-02-05 22:13:51 +00:00
warnx("fetchListHTTP(): not implemented");
return (NULL);
Implement and document file list retrieval.
1998-12-21 19:41:50 +00:00
}
Reference in New Issue Copy Permalink