600 lines
16 KiB
C
600 lines
16 KiB
C
|
#include "config.h"
|
||
|
#include "mpg123.h"
|
||
|
#include "mpg123app.h"
|
||
|
#include "httpget.h"
|
||
|
#include "debug.h"
|
||
|
#include "resolver.h"
|
||
|
#include "compat.h"
|
||
|
#include <errno.h>
|
||
|
|
||
|
#if defined (WANT_WIN32_SOCKETS)
|
||
|
#ifdef DEBUG
|
||
|
#define msgme(x) win32_net_msg(x,__FILE__,__LINE__)
|
||
|
#define msgme1 win32_net_msg(1,__FILE__,__LINE__)
|
||
|
#define msgme_sock_err(x) if ((x)==SOCKET_ERROR) {msgme1;}
|
||
|
#else
|
||
|
#define msgme(x) x
|
||
|
#define msgme1 do{} while(0)
|
||
|
#define msgme_sock_err(x) x
|
||
|
#endif
|
||
|
struct ws_local
|
||
|
{
|
||
|
int inited;
|
||
|
SOCKET local_socket; /*stores last connet in win32_net_open_connection*/
|
||
|
WSADATA wsadata;
|
||
|
};
|
||
|
|
||
|
static struct ws_local ws;
|
||
|
#ifdef DEBUG
|
||
|
static void win32_net_msg (const int err, const char * const filedata, const int linedata)
|
||
|
{
|
||
|
char *errbuff;
|
||
|
int lc_err;
|
||
|
if (err)
|
||
|
{
|
||
|
lc_err = WSAGetLastError();
|
||
|
FormatMessage(
|
||
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
||
|
NULL,
|
||
|
lc_err,
|
||
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||
|
(LPTSTR) &errbuff,
|
||
|
0,
|
||
|
NULL );
|
||
|
fprintf(stderr, "[%s:%d] [WSA2: %d] %s", filedata, linedata, lc_err, errbuff);
|
||
|
LocalFree (errbuff);
|
||
|
}
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
void win32_net_init (void)
|
||
|
{
|
||
|
ws.inited = 1;
|
||
|
switch ((WSAStartup(MAKEWORD(2,2), &ws.wsadata)))
|
||
|
{
|
||
|
case WSASYSNOTREADY: debug("WSAStartup failed with WSASYSNOTREADY"); break;
|
||
|
case WSAVERNOTSUPPORTED: debug("WSAStartup failed with WSAVERNOTSUPPORTED"); break;
|
||
|
case WSAEINPROGRESS: debug("WSAStartup failed with WSAEINPROGRESS"); break;
|
||
|
case WSAEPROCLIM: debug("WSAStartup failed with WSAEPROCLIM"); break;
|
||
|
case WSAEFAULT: debug("WSAStartup failed with WSAEFAULT"); break;
|
||
|
default:
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void win32_net_deinit (void)
|
||
|
{
|
||
|
debug("Begin winsock cleanup");
|
||
|
if (ws.inited)
|
||
|
{
|
||
|
if (ws.inited >= 2 && ws.local_socket != SOCKET_ERROR)
|
||
|
{
|
||
|
debug1("ws.local_socket = %"SIZE_P"", (size_p)ws.local_socket);
|
||
|
msgme_sock_err(shutdown(ws.local_socket, SD_BOTH));
|
||
|
win32_net_close(ws.local_socket);
|
||
|
}
|
||
|
WSACleanup();
|
||
|
ws.inited = 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void win32_net_close (int sock)
|
||
|
{
|
||
|
msgme_sock_err(closesocket(ws.local_socket));
|
||
|
}
|
||
|
|
||
|
static void win32_net_nonblock(int sock)
|
||
|
{
|
||
|
u_long mode = 1;
|
||
|
msgme_sock_err(ioctlsocket(ws.local_socket, FIONBIO, &mode));
|
||
|
}
|
||
|
|
||
|
static void win32_net_block(int sock)
|
||
|
{
|
||
|
u_long mode = 0;
|
||
|
msgme_sock_err(ioctlsocket(ws.local_socket, FIONBIO, &mode));
|
||
|
}
|
||
|
|
||
|
ssize_t win32_net_read (int fildes, void *buf, size_t nbyte)
|
||
|
{
|
||
|
debug1("Attempting to read %"SIZE_P" bytes from network.", (size_p)nbyte);
|
||
|
ssize_t ret;
|
||
|
msgme_sock_err(ret = (ssize_t) recv(ws.local_socket, buf, nbyte, 0));
|
||
|
debug1("Read %"SSIZE_P" bytes from network.", (ssize_p)ret);
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
static int get_sock_ch (int sock)
|
||
|
{
|
||
|
char c;
|
||
|
int ret;
|
||
|
msgme_sock_err(ret = recv (ws.local_socket, &c, 1, 0));
|
||
|
if (ret == 1)
|
||
|
return (((int) c)&0xff);
|
||
|
return -1;
|
||
|
}
|
||
|
/* Addapted from from newlib*/
|
||
|
char *win32_net_fgets(char *s, int n, int stream)
|
||
|
{
|
||
|
char c = 0;
|
||
|
char *buf;
|
||
|
buf = s;
|
||
|
debug1("Pseudo net fgets attempts to read %d bytes from network.", n - 1);
|
||
|
while (--n > 0 && (c = get_sock_ch (stream)) != -1)
|
||
|
{
|
||
|
*s++ = c;
|
||
|
if (c == '\n' || c == '\r')
|
||
|
break;
|
||
|
}
|
||
|
debug1("Pseudo net fgets got %"SIZE_P" bytes.", (size_p)(s - buf));
|
||
|
if (c == -1 && s == buf)
|
||
|
{
|
||
|
debug("Pseudo net fgets met a premature end.");
|
||
|
return NULL;
|
||
|
}
|
||
|
*s = 0;
|
||
|
return buf;
|
||
|
}
|
||
|
|
||
|
ssize_t win32_net_write (int fildes, const void *buf, size_t nbyte)
|
||
|
{
|
||
|
debug1("Attempting to write %"SIZE_P" bytes to network.", (size_p)nbyte);
|
||
|
ssize_t ret;
|
||
|
msgme_sock_err((ret = (ssize_t) send(ws.local_socket, buf, nbyte, 0)));
|
||
|
debug1("wrote %"SSIZE_P" bytes to network.", (ssize_t)ret);
|
||
|
|
||
|
return ret;
|
||
|
}
|
||
|
|
||
|
off_t win32_net_lseek (int a, off_t b, int c)
|
||
|
{
|
||
|
debug("lseek on a socket called!");
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
void win32_net_replace (mpg123_handle *fr)
|
||
|
{
|
||
|
debug("win32_net_replace ran");
|
||
|
mpg123_replace_reader(fr, win32_net_read, win32_net_lseek);
|
||
|
}
|
||
|
|
||
|
static int win32_net_timeout_connect(int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen)
|
||
|
{
|
||
|
debug("win32_net_timeout_connect ran");
|
||
|
if(param.timeout > 0)
|
||
|
{
|
||
|
int err;
|
||
|
win32_net_nonblock(ws.local_socket);
|
||
|
err = connect(ws.local_socket, serv_addr, addrlen);
|
||
|
if(err != SOCKET_ERROR)
|
||
|
{
|
||
|
debug("immediately successful");
|
||
|
win32_net_block(ws.local_socket);
|
||
|
return 0;
|
||
|
}
|
||
|
else if(WSAGetLastError() == WSAEWOULDBLOCK) /*WSAEINPROGRESS would not work here for some reason*/
|
||
|
{
|
||
|
struct timeval tv;
|
||
|
fd_set fds;
|
||
|
tv.tv_sec = param.timeout;
|
||
|
tv.tv_usec = 0;
|
||
|
|
||
|
debug("in progress, waiting...");
|
||
|
|
||
|
FD_ZERO(&fds);
|
||
|
FD_SET(ws.local_socket, &fds);
|
||
|
err = select(ws.local_socket+1, NULL, &fds, NULL, &tv);
|
||
|
if(err != SOCKET_ERROR)
|
||
|
{
|
||
|
socklen_t len = sizeof(err);
|
||
|
if((getsockopt(ws.local_socket, SOL_SOCKET, SO_ERROR, (char *)&err, &len) != SOCKET_ERROR)
|
||
|
&& (err == 0) )
|
||
|
{
|
||
|
debug("non-blocking connect has been successful");
|
||
|
win32_net_block(ws.local_socket);
|
||
|
return 0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
//error1("connection error: %s", msgme(err));
|
||
|
return -1;
|
||
|
}
|
||
|
}
|
||
|
else if(err == 0)
|
||
|
{
|
||
|
error("connection timed out");
|
||
|
return -1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/*error1("error from select(): %s", strerror(errno));*/
|
||
|
debug("error from select():");
|
||
|
msgme1;
|
||
|
return -1;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/*error1("connection failed: %s", strerror(errno));*/
|
||
|
debug("connection failed: ");
|
||
|
msgme1;
|
||
|
return err;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if(connect(ws.local_socket, serv_addr, addrlen) == SOCKET_ERROR)
|
||
|
{
|
||
|
/*error1("connecton failed: %s", strerror(errno));*/
|
||
|
debug("connecton failed");
|
||
|
msgme1;
|
||
|
return -1;
|
||
|
}
|
||
|
else {
|
||
|
debug("win32_net_timeout_connect succeed");
|
||
|
return 0; /* _good_ */
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static int win32_net_open_connection(mpg123_string *host, mpg123_string *port)
|
||
|
{
|
||
|
struct addrinfo hints;
|
||
|
struct addrinfo *addr, *addrlist;
|
||
|
SOCKET addrcount;
|
||
|
ws.local_socket = SOCKET_ERROR;
|
||
|
|
||
|
if(param.verbose>1) fprintf(stderr, "Note: Attempting new-style connection to %s\n", host->p);
|
||
|
memset(&hints, 0, sizeof(struct addrinfo));
|
||
|
hints.ai_family = AF_UNSPEC; /* We accept both IPv4 and IPv6 ... and perhaps IPv8;-) */
|
||
|
hints.ai_socktype = SOCK_STREAM;
|
||
|
hints.ai_protocol = IPPROTO_TCP;
|
||
|
|
||
|
debug2("Atempt resolve/connect to %s:%s", host->p, port->p);
|
||
|
msgme(addrcount = getaddrinfo(host->p, port->p, &hints, &addrlist));
|
||
|
|
||
|
if(addrcount == INVALID_SOCKET)
|
||
|
{
|
||
|
error3("Resolving %s:%s: %s", host->p, port->p, gai_strerror(addrcount));
|
||
|
return -1;
|
||
|
}
|
||
|
|
||
|
addr = addrlist;
|
||
|
while(addr != NULL)
|
||
|
{
|
||
|
ws.local_socket = socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
|
||
|
if (ws.local_socket == INVALID_SOCKET)
|
||
|
{
|
||
|
msgme1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
if(win32_net_timeout_connect(ws.local_socket, addr->ai_addr, addr->ai_addrlen) == 0)
|
||
|
break;
|
||
|
debug("win32_net_timeout_connect error, closing socket");
|
||
|
win32_net_close(ws.local_socket);
|
||
|
ws.local_socket=SOCKET_ERROR;
|
||
|
}
|
||
|
addr=addr->ai_next;
|
||
|
}
|
||
|
if(ws.local_socket == SOCKET_ERROR) {error2("Cannot resolve/connect to %s:%s!", host->p, port->p);}
|
||
|
else
|
||
|
{
|
||
|
ws.inited = 2;
|
||
|
}
|
||
|
|
||
|
freeaddrinfo(addrlist);
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
static size_t win32_net_readstring (mpg123_string *string, size_t maxlen, FILE *f)
|
||
|
{
|
||
|
debug2("Attempting readstring on %d for %"SIZE_P" bytes", f ? fileno(f) : -1, (size_p)maxlen);
|
||
|
int err;
|
||
|
string->fill = 0;
|
||
|
while(maxlen == 0 || string->fill < maxlen)
|
||
|
{
|
||
|
if(string->size-string->fill < 1)
|
||
|
if(!mpg123_grow_string(string, string->fill+4096))
|
||
|
{
|
||
|
error("Cannot allocate memory for reading.");
|
||
|
string->fill = 0;
|
||
|
return 0;
|
||
|
}
|
||
|
err = win32_net_read(0,string->p+string->fill,1); /*fd is ignored */
|
||
|
/* Whoa... reading one byte at a time... one could ensure the line break in another way, but more work. */
|
||
|
if( err == 1)
|
||
|
{
|
||
|
string->fill++;
|
||
|
if(string->p[string->fill-1] == '\n') break;
|
||
|
}
|
||
|
else if(errno != EINTR)
|
||
|
{
|
||
|
error("Error reading from socket or unexpected EOF.");
|
||
|
string->fill = 0;
|
||
|
/* bail out to prevent endless loop */
|
||
|
return 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if(!mpg123_grow_string(string, string->fill+1))
|
||
|
{
|
||
|
string->fill=0;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
string->p[string->fill] = 0;
|
||
|
string->fill++;
|
||
|
}
|
||
|
return string->fill;
|
||
|
}
|
||
|
|
||
|
static int win32_net_writestring (int fd, mpg123_string *string)
|
||
|
{
|
||
|
size_t result, bytes;
|
||
|
char *ptr = string->p;
|
||
|
bytes = string->fill ? string->fill-1 : 0;
|
||
|
|
||
|
while(bytes)
|
||
|
{
|
||
|
result = win32_net_write(ws.local_socket, ptr, bytes);
|
||
|
if(result < 0 && WSAGetLastError() != WSAEINTR)
|
||
|
{
|
||
|
perror ("writing http string");
|
||
|
return FALSE;
|
||
|
}
|
||
|
else if(result == 0)
|
||
|
{
|
||
|
error("write: socket closed unexpectedly");
|
||
|
return FALSE;
|
||
|
}
|
||
|
ptr += result;
|
||
|
bytes -= result;
|
||
|
}
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
static int win32_net_resolve_redirect(mpg123_string *response, mpg123_string *request_url, mpg123_string *purl)
|
||
|
{
|
||
|
debug1("request_url:%s", request_url->p);
|
||
|
/* initialized with full old url */
|
||
|
if(!mpg123_copy_string(request_url, purl)) return FALSE;
|
||
|
|
||
|
/* We may strip it down to a prefix ot totally. */
|
||
|
if(strncasecmp(response->p, "Location: http://", 17))
|
||
|
{ /* OK, only partial strip, need prefix for relative path. */
|
||
|
char* ptmp = NULL;
|
||
|
/* though it's not RFC (?), accept relative URIs as wget does */
|
||
|
fprintf(stderr, "NOTE: no complete URL in redirect, constructing one\n");
|
||
|
/* not absolute uri, could still be server-absolute */
|
||
|
/* I prepend a part of the request... out of the request */
|
||
|
if(response->p[10] == '/')
|
||
|
{
|
||
|
/* only prepend http://server/ */
|
||
|
/* I null the first / after http:// */
|
||
|
ptmp = strchr(purl->p+7,'/');
|
||
|
if(ptmp != NULL){ purl->fill = ptmp-purl->p+1; purl->p[purl->fill-1] = 0; }
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* prepend http://server/path/ */
|
||
|
/* now we want the last / */
|
||
|
ptmp = strrchr(purl->p+7, '/');
|
||
|
if(ptmp != NULL){ purl->fill = ptmp-purl->p+2; purl->p[purl->fill-1] = 0; }
|
||
|
}
|
||
|
}
|
||
|
else purl->fill = 0;
|
||
|
|
||
|
debug1("prefix=%s", purl->fill ? purl->p : "");
|
||
|
if(!mpg123_add_string(purl, response->p+10)) return FALSE;
|
||
|
|
||
|
debug1(" purl: %s", purl->p);
|
||
|
debug1("old request_url: %s", request_url->p);
|
||
|
|
||
|
return TRUE;
|
||
|
}
|
||
|
|
||
|
int win32_net_http_open(char* url, struct httpdata *hd)
|
||
|
{
|
||
|
mpg123_string purl, host, port, path;
|
||
|
mpg123_string request, response, request_url;
|
||
|
mpg123_string httpauth1;
|
||
|
ws.local_socket = SOCKET_ERROR;
|
||
|
int oom = 0;
|
||
|
int relocate, numrelocs = 0;
|
||
|
int got_location = FALSE;
|
||
|
/*
|
||
|
workaround for http://www.global24music.com/rautemusik/files/extreme/isdn.pls
|
||
|
this site's apache gives me a relocation to the same place when I give the port in Host request field
|
||
|
for the record: Apache/2.0.51 (Fedora)
|
||
|
*/
|
||
|
int try_without_port = 0;
|
||
|
mpg123_init_string(&purl);
|
||
|
mpg123_init_string(&host);
|
||
|
mpg123_init_string(&port);
|
||
|
mpg123_init_string(&path);
|
||
|
mpg123_init_string(&request);
|
||
|
mpg123_init_string(&response);
|
||
|
mpg123_init_string(&request_url);
|
||
|
mpg123_init_string(&httpauth1);
|
||
|
|
||
|
/* Get initial info for proxy server. Once. */
|
||
|
if(hd->proxystate == PROXY_UNKNOWN && !proxy_init(hd)) goto exit;
|
||
|
|
||
|
if(!translate_url(url, &purl)){ oom=1; goto exit; }
|
||
|
|
||
|
/* Don't confuse the different auth strings... */
|
||
|
if(!split_url(&purl, &httpauth1, NULL, NULL, NULL) ){ oom=1; goto exit; }
|
||
|
|
||
|
/* "GET http://" 11
|
||
|
* " HTTP/1.0\r\nUser-Agent: <PACKAGE_NAME>/<PACKAGE_VERSION>\r\n"
|
||
|
* 26 + PACKAGE_NAME + PACKAGE_VERSION
|
||
|
* accept header + accept_length()
|
||
|
* "Authorization: Basic \r\n" 23
|
||
|
* "\r\n" 2
|
||
|
* ... plus the other predefined header lines
|
||
|
*/
|
||
|
/* Just use this estimate as first guess to reduce malloc calls in string library. */
|
||
|
{
|
||
|
size_t length_estimate = 62 + strlen(PACKAGE_NAME) + strlen(PACKAGE_VERSION)
|
||
|
+ accept_length() + strlen(CONN_HEAD) + strlen(icy_yes) + purl.fill;
|
||
|
if( !mpg123_grow_string(&request, length_estimate)
|
||
|
|| !mpg123_grow_string(&response,4096) )
|
||
|
{
|
||
|
oom=1; goto exit;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
do
|
||
|
{
|
||
|
/* Storing the request url, with http:// prepended if needed. */
|
||
|
/* used to be url here... seemed wrong to me (when loop advanced...) */
|
||
|
if(strncasecmp(purl.p, "http://", 7) != 0) mpg123_set_string(&request_url, "http://");
|
||
|
else mpg123_set_string(&request_url, "");
|
||
|
|
||
|
mpg123_add_string(&request_url, purl.p);
|
||
|
|
||
|
if (hd->proxystate >= PROXY_HOST)
|
||
|
{
|
||
|
/* We will connect to proxy, full URL goes into the request. */
|
||
|
if( !mpg123_copy_string(&hd->proxyhost, &host)
|
||
|
|| !mpg123_copy_string(&hd->proxyport, &port)
|
||
|
|| !mpg123_set_string(&request, "GET ")
|
||
|
|| !mpg123_add_string(&request, request_url.p) )
|
||
|
{
|
||
|
oom=1; goto exit;
|
||
|
}
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
/* We will connect to the host from the URL and only the path goes into the request. */
|
||
|
if(!split_url(&purl, NULL, &host, &port, &path)){ oom=1; goto exit; }
|
||
|
if( !mpg123_set_string(&request, "GET ")
|
||
|
|| !mpg123_add_string(&request, path.p) )
|
||
|
{
|
||
|
oom=1; goto exit;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if(!fill_request(&request, &host, &port, &httpauth1, &try_without_port)){ oom=1; goto exit; }
|
||
|
|
||
|
httpauth1.fill = 0; /* We use the auth data from the URL only once. */
|
||
|
debug2("attempting to open_connection to %s:%s", host.p, port.p);
|
||
|
win32_net_open_connection(&host, &port);
|
||
|
if(ws.local_socket == SOCKET_ERROR)
|
||
|
{
|
||
|
error1("Unable to establish connection to %s", host.fill ? host.p : "");
|
||
|
goto exit;
|
||
|
}
|
||
|
debug("win32_net_open_connection succeed");
|
||
|
#define http_failure win32_net_close(ws.local_socket); ws.local_socket=SOCKET_ERROR; goto exit;
|
||
|
|
||
|
if(param.verbose > 2) fprintf(stderr, "HTTP request:\n%s\n",request.p);
|
||
|
if(!win32_net_writestring(ws.local_socket, &request)){ http_failure; }
|
||
|
debug("Skipping fdopen for WSA sockets");
|
||
|
relocate = FALSE;
|
||
|
/* Arbitrary length limit here... */
|
||
|
#define safe_readstring \
|
||
|
win32_net_readstring(&response, SIZE_MAX/16, NULL); \
|
||
|
if(response.fill > SIZE_MAX/16) /* > because of appended zero. */ \
|
||
|
{ \
|
||
|
error("HTTP response line exceeds max. length"); \
|
||
|
http_failure; \
|
||
|
} \
|
||
|
else if(response.fill == 0) \
|
||
|
{ \
|
||
|
error("readstring failed"); \
|
||
|
http_failure; \
|
||
|
} \
|
||
|
if(param.verbose > 2) fprintf(stderr, "HTTP in: %s", response.p);
|
||
|
safe_readstring;
|
||
|
|
||
|
{
|
||
|
char *sptr;
|
||
|
if((sptr = strchr(response.p, ' ')))
|
||
|
{
|
||
|
if(response.fill > sptr-response.p+2)
|
||
|
switch (sptr[1])
|
||
|
{
|
||
|
case '3':
|
||
|
relocate = TRUE;
|
||
|
case '2':
|
||
|
break;
|
||
|
default:
|
||
|
fprintf (stderr, "HTTP request failed: %s", sptr+1); /* '\n' is included */
|
||
|
http_failure;
|
||
|
}
|
||
|
else{ error("Too short response,"); http_failure; }
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/* If we are relocated, we need to look out for a Location header. */
|
||
|
got_location = FALSE;
|
||
|
|
||
|
do
|
||
|
{
|
||
|
safe_readstring; /* Think about that: Should we really error out when we get nothing? Could be that the server forgot the trailing empty line... */
|
||
|
if (!strncasecmp(response.p, "Location: ", 10))
|
||
|
{ /* It is a redirection! */
|
||
|
if(!win32_net_resolve_redirect(&response, &request_url, &purl)){ oom=1, http_failure; }
|
||
|
|
||
|
if(!strcmp(purl.p, request_url.p))
|
||
|
{
|
||
|
warning("relocated to very same place! trying request again without host port");
|
||
|
try_without_port = 1;
|
||
|
}
|
||
|
got_location = TRUE;
|
||
|
}
|
||
|
else
|
||
|
{ /* We got a header line (or the closing empty line). */
|
||
|
char *tmp;
|
||
|
debug1("searching for header values... %s", response.p);
|
||
|
/* Not sure if I want to bail out on error here. */
|
||
|
/* Also: What text encoding are these strings in? Doesn't need to be plain ASCII... */
|
||
|
get_header_string(&response, "content-type", &hd->content_type);
|
||
|
get_header_string(&response, "icy-name", &hd->icy_name);
|
||
|
get_header_string(&response, "icy-url", &hd->icy_url);
|
||
|
|
||
|
/* watch out for icy-metaint */
|
||
|
if((tmp = get_header_val("icy-metaint", &response)))
|
||
|
{
|
||
|
hd->icy_interval = (off_t) atol(tmp); /* atoll ? */
|
||
|
debug1("got icy-metaint %li", (long int)hd->icy_interval);
|
||
|
}
|
||
|
}
|
||
|
} while(response.p[0] != '\r' && response.p[0] != '\n');
|
||
|
} while(relocate && got_location && purl.fill && numrelocs++ < HTTP_MAX_RELOCATIONS);
|
||
|
if(relocate)
|
||
|
{
|
||
|
if(!got_location)
|
||
|
error("Server meant to redirect but failed to provide a location!");
|
||
|
else
|
||
|
error1("Too many HTTP relocations (%i).", numrelocs);
|
||
|
|
||
|
http_failure;
|
||
|
}
|
||
|
|
||
|
exit: /* The end as well as the exception handling point... */
|
||
|
if(oom) error("Apparently, I ran out of memory or had some bad input data...");
|
||
|
|
||
|
mpg123_free_string(&purl);
|
||
|
mpg123_free_string(&host);
|
||
|
mpg123_free_string(&port);
|
||
|
mpg123_free_string(&path);
|
||
|
mpg123_free_string(&request);
|
||
|
mpg123_free_string(&response);
|
||
|
mpg123_free_string(&request_url);
|
||
|
mpg123_free_string(&httpauth1);
|
||
|
if (ws.local_socket == SOCKET_ERROR || oom)
|
||
|
return -1;
|
||
|
else
|
||
|
return 1;
|
||
|
}
|
||
|
#else
|
||
|
int win32_net_http_open(char* url, struct httpdata *hd)
|
||
|
{
|
||
|
return -1;
|
||
|
}
|
||
|
#endif /*WANT_WIN32_SOCKETS */
|