libretro/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch.git synced 2024-11-23 16:09:47 +00:00
Code Issues Actions 23 Packages Projects Releases Wiki Activity
f2c3ae1e28
RetroArch/http_lib.c

538 lines
13 KiB
C
Raw Blame History

/*
* Http put/get mini lib
* written by L. Demailly
* (c) 1998 Laurent Demailly - http://www.demailly.com/~dl/
* (c) 1996 Observatoire de Paris - Meudon - France
* see LICENSE for terms, conditions and DISCLAIMER OF ALL WARRANTIES
*
* $Id: http_lib.c,v 3.5 1998/09/23 06:19:15 dl Exp $
*
* Description : Use http protocol, connects to server to echange data
*
* $Log: http_lib.c,v $
* Revision 3.5 1998/09/23 06:19:15 dl
* portability and http 1.x (1.1 and later) compatibility
*
* Revision 3.4 1998/09/23 05:44:27 dl
* added support for HTTP/1.x answers
*
* Revision 3.3 1996/04/25 19:07:22 dl
* using intermediate variable for htons (port) so it does not yell
* on freebsd (thx pp for report)
*
* Revision 3.2 1996/04/24 13:56:08 dl
* added proxy support through http_proxy_server & http_proxy_port
* some httpd *needs* cr+lf so provide them
* simplification + cleanup
*
* Revision 3.1 1996/04/18 13:53:13 dl
* http-tiny release 1.0
*
*
*/
#define VERBOSE
/* http_lib - Http data exchanges mini library.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#ifdef _WIN32
#include <direct.h>
#else
#include <unistd.h>
#endif
#include "netplay_compat.h"
#include "http_lib.h"
#define SERVER_DEFAULT "adonis"
/* pointer to a mallocated string containing server name or NULL */
char *http_server=NULL ;
/* server port number */
int http_port=5757;
/* pointer to proxy server name or NULL */
char *http_proxy_server=NULL;
/* proxy server port number or 0 */
int http_proxy_port=0;
/* user agent id string */
static const char *http_user_agent="adlib/3 ($Date: 1998/09/23 06:19:15 $)";
/*
* read a line from file descriptor
* returns the number of bytes read. negative if a read error occured
* before the end of line or the max.
* cariage returns (CR) are ignored.
*/
/*
* fd - file descriptor to read from
* buffer - placeholder for data
* max - max number of bytes to read
*/
static int http_read_line (int fd, char *buffer, int max)
{
/* not efficient on long lines (multiple unbuffered 1 char reads) */
int n=0;
while (n<max)
{
if (read(fd,buffer,1) != 1)
{
n= -n;
break;
}
n++;
if (*buffer == '\015')
continue; /* ignore CR */
if (*buffer == '\012')
break; /* LF is the separator */
buffer++;
}
*buffer=0;
return n;
}
/*
* read data from file descriptor
* retries reading until the number of bytes requested is read.
* returns the number of bytes read. negative if a read error (EOF) occured
* before the requested length.
*/
/*
* fd - file descriptor to read from
* buffer - placeholder for data
* max - max number of bytes to read
*/
static int http_read_buffer (int fd, char *buffer, int length)
{
int n,r;
for (n = 0; n < length; n += r)
{
r = read(fd,buffer,length-n);
if (r <= 0)
return -n;
buffer += r;
}
return n;
}
typedef enum
{
CLOSE, /* Close the socket after the query (for put) */
KEEP_OPEN /* Keep it open */
} querymode;
#ifndef OSK
static http_retcode http_query(const char *command, const char *url,
const char *additional_header, querymode mode,
const char* data, int length, int *pfd);
#endif
/* beware that filename+type+rest of header must not exceed MAXBUF */
/* so we limit filename to 256 and type to 64 chars in put & get */
#define MAXBUF 512
/*
* Pseudo general http query
*
* send a command and additional headers to the http server.
* optionally through the proxy (if http_proxy_server and http_proxy_port are
* set).
*
* Limitations: the url is truncated to first 256 chars and
* the server name to 128 in case of proxy request.
*/
/*
command - command to send
url - url / filename queried
additional_header - additional header
mode - type of query
data - Data to send after header. If NULL, not data is sent
length - size of data
pfd - pointer to variable where to set file descriptor value
*/
static http_retcode http_query(const char *command, const char *url, const char *additional_header, querymode mode,
const char *data, int length, int *pfd)
{
int s;
struct hostent *hp;
struct sockaddr_in server;
char header[MAXBUF];
int hlg;
http_retcode ret;
int proxy=(http_proxy_server != NULL && http_proxy_port != 0);
int port = proxy ? http_proxy_port : http_port ;
if (pfd) *pfd=-1;
/* get host info by name :*/
if ((hp = gethostbyname( proxy ? http_proxy_server
: ( http_server ? http_server
: SERVER_DEFAULT )
)))
{
memset((char *) &server,0, sizeof(server));
memmove((char *) &server.sin_addr, hp->h_addr, hp->h_length);
server.sin_family = hp->h_addrtype;
server.sin_port = (unsigned short) htons( port );
}
else
return ERRHOST;
/* create socket */
if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0)
return ERRSOCK;
setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, 0, 0);
/* connect to server */
if (connect(s, (struct sockaddr*)&server, sizeof(server)) < 0)
ret=ERRCONN;
else
{
if (pfd) *pfd=s;
/* create header */
if (proxy)
{
sprintf(header,
"%s http://%.128s:%d/%.256s HTTP/1.0\015\012User-Agent: %s\015\012Host: %s\015\012%s\015\012",
command,
http_server,
http_port,
url,
http_user_agent,
http_server,
additional_header
);
}
else
{
sprintf(header,
"%s /%.256s HTTP/1.0\015\012User-Agent: %s\015\012Host: %s\015\012%s\015\012",
command,
url,
http_user_agent,
http_server,
additional_header
);
}
hlg=strlen(header);
/* send header */
if (write(s,header,hlg) != hlg)
ret= ERRWRHD;
/* send data */
else if (length && data && (write(s,data,length) != length) )
ret= ERRWRDT;
else
{
/* read result & check */
int linelen=http_read_line(s,header,MAXBUF-1);
#ifdef VERBOSE
fputs(header,stderr);
putc('\n',stderr);
#endif
if (linelen<=0)
ret=ERRRDHD;
else if (sscanf(header,"HTTP/1.%*d %03d",(int*)&ret) != 1)
ret=ERRPAHD;
else if (mode == KEEP_OPEN)
return ret;
}
}
/* close socket */
close(s);
return ret;
}
/*
* Put data on the server
*
* This function sends data to the http data server.
* The data will be stored under the ressource name filename.
* returns a negative error code or a positive code from the server
*
* limitations: filename is truncated to first 256 characters
* and type to 64.
*/
/*
filename - name of the ressource to create
data - pointer to the data to send
length - length of the data to send
overwrite - flag to request to overwrite the ressource if it
was already existing.
type - type of the data, if NULL default type is used.
*/
http_retcode http_put(const char *filename, const char *data, int length, int overwrite, const char *type)
{
char header[MAXBUF];
if (type)
sprintf(header,"Content-length: %d\015\012Content-type: %.64s\015\012%s",
length,
type ,
overwrite ? "Control: overwrite=1\015\012" : ""
);
else
sprintf(header,"Content-length: %d\015\012%s",length,
overwrite ? "Control: overwrite=1\015\012" : ""
);
return http_query("PUT",filename,header,CLOSE, data, length, NULL);
}
/*
* Get data from the server
*
* This function gets data from the http data server.
* The data is read from the ressource named filename.
* Address of new new allocated memory block is filled in pdata
* whose length is returned via plength.
*
* returns a negative error code or a positive code from the server
*
*
* limitations: filename is truncated to first 256 characters
*/
/*
filename - name of the ressource to read
pdata - address of a pointer variable which will be set
to point toward allocated memory containing read data.
plength - address of integer variable which will be set to
length of the read data.
typebuf - allocated buffer where the read data type is returned.
If NULL, the type is not returned.
*/
http_retcode http_get(const char *filename, char **pdata, int *plength, char *typebuf)
{
http_retcode ret;
char header[MAXBUF];
char *pc;
int fd;
int n,length=-1;
if (!pdata)
return ERRNULL;
*pdata = NULL;
if (plength)
*plength = 0;
if (typebuf)
*typebuf = '\0';
ret = http_query("GET",filename,"",KEEP_OPEN, NULL, 0, &fd);
if (ret == 200)
{
while (1)
{
n=http_read_line(fd,header,MAXBUF-1);
#ifdef VERBOSE
fputs(header,stderr);
putc('\n',stderr);
#endif
if (n<=0)
{
close(fd);
return ERRRDHD;
}
/* empty line ? (=> end of header) */
if ( n>0 && (*header) == '\0')
break;
/* try to parse some keywords : */
/* convert to lower case 'till a : is found or end of string */
for (pc=header; (*pc != ':' && *pc) ; pc++)
*pc=tolower(*pc);
sscanf(header,"content-length: %d",&length);
if (typebuf)
sscanf(header,"content-type: %s",typebuf);
}
if (length<=0)
{
close(fd);
return ERRNOLG;
}
if (plength)
*plength=length;
if (!(*pdata=(char*)malloc(length)))
{
close(fd);
return ERRMEM;
}
n=http_read_buffer(fd,*pdata,length);
close(fd);
if (n != length)
ret=ERRRDDT;
}
else if (ret>=0)
close(fd);
return ret;
}
/*
* Request the header
*
* This function outputs the header of thehttp data server.
* The header is from the ressource named filename.
* The length and type of data is eventually returned (like for http_get(3))
*
* returns a negative error code or a positive code from the server
*
* limitations: filename is truncated to first 256 characters
*/
/*
* filename - name of the ressource to read
* plength - address of integer variable which will be set to
* length of the data.
* typebuf - allocated buffer where the data type is returned.
* If NULL, the type is not returned.
*/
http_retcode http_head(const char *filename, int *plength, char *typebuf)
{
/* mostly copied from http_get : */
http_retcode ret;
char header[MAXBUF];
char *pc;
int fd;
int n,length=-1;
if (plength)
*plength=0;
if (typebuf)
*typebuf='\0';
ret=http_query("HEAD",filename,"",KEEP_OPEN, NULL, 0, &fd);
if (ret == 200)
{
while (1)
{
n=http_read_line(fd,header,MAXBUF-1);
#ifdef VERBOSE
fputs(header,stderr);
putc('\n',stderr);
#endif
if (n<=0)
{
close(fd);
return ERRRDHD;
}
/* empty line ? (=> end of header) */
if (n > 0 && (*header) == '\0')
break;
/* try to parse some keywords : */
/* convert to lower case 'till a : is found or end of string */
for (pc=header; (*pc != ':' && *pc) ; pc++)
*pc=tolower(*pc);
sscanf(header,"content-length: %d",&length);
if (typebuf)
sscanf(header,"content-type: %s",typebuf);
}
if (plength)
*plength=length;
close(fd);
}
else if (ret>=0)
close(fd);
return ret;
}
/*
* Delete data on the server
*
* This function request a DELETE on the http data server.
*
* returns a negative error code or a positive code from the server
*
* limitations: filename is truncated to first 256 characters
*/
/*
* filename - name of the ressource to create
*/
http_retcode http_delete(const char *filename)
{
return http_query("DELETE",filename,"",CLOSE, NULL, 0, NULL);
}
/* parses an url : setting the http_server and http_port global variables
* and returning the filename to pass to http_get/put/...
* returns a negative error code or 0 if sucessfully parsed.
*/
/* url - writeable copy of an url
* pfilename - address of a pointer that will be filled with allocated filename
* the pointer must be equal to NULL before calling or it will be
* automatically freed (free(3))
*/
http_retcode http_parse_url(char *url, char **pfilename)
{
char *pc,c;
http_port=80;
if (http_server)
{
free(http_server);
http_server=NULL;
}
if (*pfilename)
{
free(*pfilename);
*pfilename=NULL;
}
if (strncasecmp("http://",url,7))
{
#ifdef VERBOSE
fprintf(stderr,"invalid url (must start with 'http://')\n");
#endif
return ERRURLH;
}
url+=7;
for (pc = url, c = *pc; (c && c != ':' && c != '/');)
c=*pc++;
*(pc-1) = 0;
if (c == ':')
{
if (sscanf(pc,"%d",&http_port) != 1)
{
#ifdef VERBOSE
fprintf(stderr,"invalid port in url\n");
#endif
return ERRURLP;
}
for (pc++; (*pc && *pc != '/') ; pc++) ;
if (*pc)
pc++;
}
http_server=strdup(url);
*pfilename= strdup ( c ? pc : "") ;
#ifdef VERBOSE
fprintf(stderr,"host=(%s), port=%d, filename=(%s)\n",
http_server,http_port,*pfilename);
#endif
return OK0;
}
Reference in New Issue View Git Blame Copy Permalink