/* Copyright 1997 Acorn Computers Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/***************************************************/
/* File : URLveneer.c */
/* */
/* Purpose: Veneer to the URL_Fetcher module SWIs. */
/* */
/* Author : A.D.Hodgkinson */
/* */
/* History: 17-Aug-97: Created from Fetch.c. */
/***************************************************/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "swis.h"
#include "wimp.h"
#include "event.h"
#include "svcprint.h"
#include "Global.h"
#include "Utils.h"
#include "URLutils.h"
#include "URLveneer.h"
/*************************************************/
/* url_register() */
/* */
/* Registers a requirement to fetch a URL with */
/* the URL module. */
/* */
/* Parameters: Flags (must be 0 at present); */
/* */
/* Pointer to int into which the */
/* session handle is placed. May be */
/* NULL. */
/*************************************************/
_kernel_oserror * url_register(unsigned int flags, unsigned int * handle)
{
_kernel_oserror * e;
unsigned int h;
/* If there's a pointer to put the handle into, set it to zero initially */
if (handle) *handle = 0;
e = _swix(URL_Register,
_IN(0) | _OUT(1),
flags,
&h);
/* If the call didn't return an error, store the session handle */
if ((!e) && (handle)) *handle = h;
#ifdef TRACE
if (tl & (1u<<6))
{
if (!e) Printf("url_register: Registered ID %d\n",*handle);
else Printf("url_register: Exitting with error\n");
}
#endif
return e;
}
/*************************************************/
/* url_deregister() */
/* */
/* Deregisters a requirement to fetch a URL with */
/* the URL module. */
/* */
/* Parameters: Flags (must be 0 at present); */
/* */
/* The session handle. */
/*************************************************/
_kernel_oserror * url_deregister(unsigned int flags, unsigned int handle)
{
#ifdef TRACE
if (tl & (1u<<6)) Printf("url_deregister: Deregistering ID %d\n",handle);
#endif
/* Abort any current action */
url_stop(flags,handle);
/* Deregister the session */
return _swix(URL_Deregister,
_INR(0,1),
flags,
handle);
}
/*************************************************/
/* url_stop() */
/* */
/* Interrupts a fetch if one is going on. */
/* */
/* Parameters: Flags (must be 0 at present); */
/* */
/* The session handle. */
/*************************************************/
_kernel_oserror * url_stop(unsigned int flags, unsigned int handle)
{
#ifdef TRACE
if (tl & (1u<<6)) Printf("url_stop: Stop with ID %d\n",handle);
#endif
return _swix(URL_Stop,
_INR(0,1),
flags,
handle);
}
/*************************************************/
/* url_get_url() */
/* */
/* Starts fetching data from a URL. */
/* */
/* Parameters: Flags - if URL_GetURL_AgentGiven */
/* (see URLveneer.h) is set, this */
/* function works out the agent */
/* string so you don't need to pass */
/* it in externally; */
/* */
/* The session handle; */
/* */
/* The fetch method, as in html_get */
/* in FetchHTML.c; */
/* */
/* Pointer to URL to fetch; */
/* */
/* Pointer to a pointer to any extra */
/* data to send for POST etc. (this */
/* allows such data to be stored in */
/* a flex block - you'd pass the */
/* pointer to the flex anchor); */
/* */
/* Pointer to an int into which a */
/* status flag is placed (this may */
/* be NULL); */
/* */
/* The fetch mode: */
/* */
/* 0: Get data only, */
/* 1: Get header only, */
/* 2: Get both. */
/*************************************************/
_kernel_oserror * url_get_url(unsigned int flags, unsigned int handle, int method, char * url,
char ** extradata, unsigned int * status, int mode)
{
char agent[Limits_UserAgent];
_kernel_oserror * e = NULL;
int s;
agent[0] = '\0';
#ifdef TRACE
if (tl & (1u<<6)) Printf("url_get_url: Called with ID %d\n",handle);
#endif
/* If a pointer to the int in which status information can be written */
/* is not NULL, set the current status to 0 */
if (status) *status = 0;
/* Only proceed if we have a URL, and it's not an internal one */
if (url && strncmp(url, Internal_URL, strlen(Internal_URL)))
{
#ifdef DUMP_HEADERS
{
FILE * file;
file = fopen("<Wimp$ScrapDir>.Headers", "ab");
if (!extradata || !*extradata || !**extradata) fprintf(file, "Fetch URL '%s'; sending standard header\r\n\r\n", url);
else
{
fprintf(file, "Fetch URL '%s'; sending standard header plus:\r\n\r\n%s\r\n", url, *extradata);
if ((*extradata)[strlen(*extradata) - 1] != '\n') fprintf(file, "\r\n");
}
fclose(file);
}
#endif
/* We may need to work out the user agent string */
if (flags & URL_GetURL_AgentGiven)
{
utils_build_user_agent_string(choices.clone, agent, sizeof(agent));
}
/* Now call the SWI - it can take a while to complete, */
/* so turn the hourglass on. */
_swix(Hourglass_Start, _IN(0), 50);
e = _swix(URL_GetURL,
_INR(0,6) | _OUT(0),
flags,
handle,
method,
url,
*extradata,
mode,
agent,
&s);
_swix(Hourglass_Off, 0);
/* If the GetURL call didn't return an error, write the new status */
if (status && !e) *status = s;
}
#ifdef TRACE
if (tl & (1u<<6))
{
if (!e) Printf("url_get_url: Successful\n");
else Printf("url_get_url: Exitting with error\n");
}
#endif
return e;
}
/*************************************************/
/* url_read_data() */
/* */
/* Asks the URL module to copy some of the data */
/* it has fetched over into a buffer. */
/* */
/* Parameters: Flags (must be 0 at present); */
/* */
/* The session handle; */
/* */
/* Pointer to buffer into which the */
/* data is transferred, or NULL to */
/* just get a Pending state; */
/* */
/* The size of the buffer; */
/* */
/* Pointer to an int, into which a */
/* status word is placed; */
/* */
/* Pointer to int, into which the */
/* number of bytes read (and put in */
/* the bufrer) is placed; */
/* */
/* Pointer to int, into which the */
/* number of bytes that are still to */
/* be fetched s placed. */
/*************************************************/
_kernel_oserror * url_read_data(unsigned int flags, unsigned int handle, void * buffer,
int size, int * status, int * read, int * pending)
{
_kernel_oserror * e;
int s, r, p = 0;
#ifdef TRACE
if (tl & (1u<<6)) Printf("url_read_data: Called with ID %d\n",handle);
#endif
/* Ensure all returned data is set to a sensible default to start with */
if (status) * status = 0;
if (read) * read = 0;
if (pending) * pending = 0;
/* Call the URL module */
e = _swix(URL_ReadData,
_INR(0,3) | _OUT(0) | _OUTR(4,5),
flags,
handle,
buffer,
size,
&s,
&r,
&p);
#ifdef TRACE
if (tl & (1u<<6)) Printf("url_read_data: Status %p, error %p returned\n",s,e);
#endif
/* In the absence of any errors, fill in the relevant returned data */
if (!e)
{
if (status) *status = s;
if (read) *read = r;
if (pending) *pending = p;
}
#ifdef TRACE
if (tl & (1u<<6))
{
if (!e) Printf("url_read_data: Successful\n");
else Printf("url_read_data: Exitting with error\n");
}
#endif
return e;
}
/*************************************************/
/* url_status() */
/* */
/* Returns the status of a fetch. */
/* */
/* Parameters: Flags (must be 0 at present); */
/* */
/* The session handle; */
/* */
/* Pointer to an int, into which a */
/* status word is placed; */
/* */
/* Pointer to an int, into which the */
/* server's response is placed; */
/* */
/* Pointer to an int, into which the */
/* number of bytes transferred so */
/* far is placed. */
/*************************************************/
_kernel_oserror * url_status(unsigned int flags, unsigned int handle,
int * status, int * response, int * bytes)
{
_kernel_oserror * e;
int s, r, b;
#ifdef TRACE
if (tl & (1u<<6)) Printf("url_status: Called with ID %d\n",handle);
#endif
/* Set returned data to zero to begin with */
if (status) *status = 0;
if (response) *response = 0;
if (bytes) *bytes = 0;
e = _swix(URL_Status,
_INR(0,1) | _OUT(0) | _OUTR(2,3),
flags,
handle,
&s,
&r,
&b);
/* In the absence of an error, fill in the returned data */
if (!e)
{
if (status) *status = s;
if (response) *response = r;
if (bytes) *bytes = b;
}
#ifdef TRACE
if (tl & (1u<<6))
{
if (!e) Printf("url_status: Successful\n");
else Printf("url_status: Exitting with error\n");
}
#endif
return e;
}
/*************************************************/
/* url_set_proxy() */
/* */
/* Instructs the URL module to fetch through a */
/* proxy (or not). */
/* */
/* Parameters: Flags (must be 0 at present); */
/* */
/* The session handle; */
/* */
/* Pointer to the base URL of the */
/* proxy server, e.g. for a local */
/* proxy, "http://127.0.0.1/"; */
/* */
/* Pointer to a string holding the */
/* protocol to use, e.g. "http:" or */
/* "ftp:"; */
/* */
/* 1 to disable proxying, 0 to */
/* enable it with the above data. */
/*************************************************/
_kernel_oserror * url_set_proxy(int flags, unsigned int session, char * baseurl,
char * protocol, int noproxy)
{
return _swix(URL_SetProxy,
_INR(0,4),
flags,
session,
baseurl,
protocol,
noproxy);
}