void*
xmlNanoHTTPMethodRedir(const char *URL, const char *method, const char *input,
char **contentType, char **redir,
const char *headers, int ilen ) {
xmlNanoHTTPCtxtPtr ctxt;
char *bp, *p;
int blen, ret;
int nbRedirects = 0;
char *redirURL = NULL;
#ifdef DEBUG_HTTP
int xmt_bytes;
#endif
if (URL == NULL) return(NULL);
if (method == NULL) method = "GET";
xmlNanoHTTPInit();
retry:
if (redirURL == NULL)
ctxt = xmlNanoHTTPNewCtxt(URL);
else {
ctxt = xmlNanoHTTPNewCtxt(redirURL);
ctxt->location = xmlMemStrdup(redirURL);
}
if ( ctxt == NULL ) {
return ( NULL );
}
if ((ctxt->protocol == NULL) || (strcmp(ctxt->protocol, "http"))) {
__xmlIOErr(XML_FROM_HTTP, XML_HTTP_URL_SYNTAX, "Not a valid HTTP URI");
xmlNanoHTTPFreeCtxt(ctxt);
if (redirURL != NULL) xmlFree(redirURL);
return(NULL);
}
if (ctxt->hostname == NULL) {
__xmlIOErr(XML_FROM_HTTP, XML_HTTP_UNKNOWN_HOST,
"Failed to identify host in URI");
xmlNanoHTTPFreeCtxt(ctxt);
if (redirURL != NULL) xmlFree(redirURL);
return(NULL);
}
if (proxy) {
blen = strlen(ctxt->hostname) * 2 + 16;
ret = xmlNanoHTTPConnectHost(proxy, proxyPort);
}
else {
blen = strlen(ctxt->hostname);
ret = xmlNanoHTTPConnectHost(ctxt->hostname, ctxt->port);
}
if (ret < 0) {
xmlNanoHTTPFreeCtxt(ctxt);
if (redirURL != NULL) xmlFree(redirURL);
return(NULL);
}
ctxt->fd = ret;
if (input == NULL)
ilen = 0;
else
blen += 36;
if (headers != NULL)
blen += strlen(headers) + 2;
if (contentType && *contentType)
/* reserve for string plus 'Content-Type: \r\n" */
blen += strlen(*contentType) + 16;
if (ctxt->query != NULL)
/* 1 for '?' */
blen += strlen(ctxt->query) + 1;
blen += strlen(method) + strlen(ctxt->path) + 24;
#ifdef HAVE_ZLIB_H
/* reserve for possible 'Accept-Encoding: gzip' string */
blen += 23;
#endif
if (ctxt->port != 80) {
/* reserve space for ':xxxxx', incl. potential proxy */
if (proxy)
blen += 12;
else
blen += 6;
}
bp = (char*)xmlMallocAtomic(blen);
if ( bp == NULL ) {
xmlNanoHTTPFreeCtxt( ctxt );
xmlHTTPErrMemory("allocating header buffer");
return ( NULL );
}
p = bp;
if (proxy) {
if (ctxt->port != 80) {
p += snprintf( p, blen - (p - bp), "%s http://%s:%d%s",
method, ctxt->hostname,
ctxt->port, ctxt->path );
}
else
p += snprintf( p, blen - (p - bp), "%s http://%s%s", method,
ctxt->hostname, ctxt->path);
}
else
p += snprintf( p, blen - (p - bp), "%s %s", method, ctxt->path);
if (ctxt->query != NULL)
p += snprintf( p, blen - (p - bp), "?%s", ctxt->query);
if (ctxt->port == 80) {
p += snprintf( p, blen - (p - bp), " HTTP/1.0\r\nHost: %s\r\n",
ctxt->hostname);
} else {
p += snprintf( p, blen - (p - bp), " HTTP/1.0\r\nHost: %s:%d\r\n",
ctxt->hostname, ctxt->port);
}
#ifdef HAVE_ZLIB_H
p += snprintf(p, blen - (p - bp), "Accept-Encoding: gzip\r\n");
#endif
if (contentType != NULL && *contentType)
p += snprintf(p, blen - (p - bp), "Content-Type: %s\r\n", *contentType);
if (headers != NULL)
p += snprintf( p, blen - (p - bp), "%s", headers );
if (input != NULL)
snprintf(p, blen - (p - bp), "Content-Length: %d\r\n\r\n", ilen );
else
snprintf(p, blen - (p - bp), "\r\n");
#ifdef DEBUG_HTTP
xmlGenericError(xmlGenericErrorContext,
"-> %s%s", proxy? "(Proxy) " : "", bp);
if ((blen -= strlen(bp)+1) < 0)
xmlGenericError(xmlGenericErrorContext,
"ERROR: overflowed buffer by %d bytes\n", -blen);
#endif
ctxt->outptr = ctxt->out = bp;
ctxt->state = XML_NANO_HTTP_WRITE;
blen = strlen( ctxt->out );
#ifdef DEBUG_HTTP
xmt_bytes = xmlNanoHTTPSend(ctxt, ctxt->out, blen );
if ( xmt_bytes != blen )
xmlGenericError( xmlGenericErrorContext,
"xmlNanoHTTPMethodRedir: Only %d of %d %s %s\n",
xmt_bytes, blen,
"bytes of HTTP headers sent to host",
ctxt->hostname );
#else
xmlNanoHTTPSend(ctxt, ctxt->out, blen );
#endif
if ( input != NULL ) {
#ifdef DEBUG_HTTP
xmt_bytes = xmlNanoHTTPSend( ctxt, input, ilen );
if ( xmt_bytes != ilen )
xmlGenericError( xmlGenericErrorContext,
"xmlNanoHTTPMethodRedir: Only %d of %d %s %s\n",
xmt_bytes, ilen,
"bytes of HTTP content sent to host",
ctxt->hostname );
#else
xmlNanoHTTPSend( ctxt, input, ilen );
#endif
}
ctxt->state = XML_NANO_HTTP_READ;
while ((p = xmlNanoHTTPReadLine(ctxt)) != NULL) {
if (*p == 0) {
ctxt->content = ctxt->inrptr;
xmlFree(p);
break;
}
xmlNanoHTTPScanAnswer(ctxt, p);
#ifdef DEBUG_HTTP
xmlGenericError(xmlGenericErrorContext, "<- %s\n", p);
#endif
xmlFree(p);
}
if ((ctxt->location != NULL) && (ctxt->returnValue >= 300) &&
(ctxt->returnValue < 400)) {
#ifdef DEBUG_HTTP
xmlGenericError(xmlGenericErrorContext,
"\nRedirect to: %s\n", ctxt->location);
#endif
while ( xmlNanoHTTPRecv(ctxt) > 0 ) ;
if (nbRedirects < XML_NANO_HTTP_MAX_REDIR) {
nbRedirects++;
if (redirURL != NULL)
xmlFree(redirURL);
redirURL = xmlMemStrdup(ctxt->location);
xmlNanoHTTPFreeCtxt(ctxt);
goto retry;
}
xmlNanoHTTPFreeCtxt(ctxt);
if (redirURL != NULL) xmlFree(redirURL);
#ifdef DEBUG_HTTP
xmlGenericError(xmlGenericErrorContext,
"xmlNanoHTTPMethodRedir: Too many redirects, aborting ...\n");
#endif
return(NULL);
}
if (contentType != NULL) {
if (ctxt->contentType != NULL)
*contentType = xmlMemStrdup(ctxt->contentType);
else
*contentType = NULL;
}
if ((redir != NULL) && (redirURL != NULL)) {
*redir = redirURL;
} else {
if (redirURL != NULL)
xmlFree(redirURL);
if (redir != NULL)
*redir = NULL;
}
#ifdef DEBUG_HTTP
if (ctxt->contentType != NULL)
xmlGenericError(xmlGenericErrorContext,
"\nCode %d, content-type '%s'\n\n",
ctxt->returnValue, ctxt->contentType);
else
xmlGenericError(xmlGenericErrorContext,
"\nCode %d, no content-type\n\n",
ctxt->returnValue);
#endif
return((void *) ctxt);
}
int
xmlNanoFTPUpdateURL(void *ctx, const char *URL) {
xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
const char *cur = URL;
char buf[4096];
int indx = 0;
int port = 0;
if (URL == NULL)
return(-1);
if (ctxt == NULL)
return(-1);
if (ctxt->protocol == NULL)
return(-1);
if (ctxt->hostname == NULL)
return(-1);
buf[indx] = 0;
while (*cur != 0) {
if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
buf[indx] = 0;
if (strcmp(ctxt->protocol, buf))
return(-1);
indx = 0;
cur += 3;
break;
}
buf[indx++] = *cur++;
}
if (*cur == 0)
return(-1);
buf[indx] = 0;
while (1) {
if (cur[0] == ':') {
buf[indx] = 0;
if (strcmp(ctxt->hostname, buf))
return(-1);
indx = 0;
cur += 1;
while ((*cur >= '0') && (*cur <= '9')) {
port *= 10;
port += *cur - '0';
cur++;
}
if (port != ctxt->port)
return(-1);
while ((cur[0] != '/') && (*cur != 0))
cur++;
break;
}
if ((*cur == '/') || (*cur == 0)) {
buf[indx] = 0;
if (strcmp(ctxt->hostname, buf))
return(-1);
indx = 0;
break;
}
buf[indx++] = *cur++;
}
if (ctxt->path != NULL) {
xmlFree(ctxt->path);
ctxt->path = NULL;
}
if (*cur == 0)
ctxt->path = xmlMemStrdup("/");
else {
indx = 0;
buf[indx] = 0;
while (*cur != 0)
buf[indx++] = *cur++;
buf[indx] = 0;
ctxt->path = xmlMemStrdup(buf);
}
return(0);
}
static void
xmlNanoFTPScanURL(void *ctx, const char *URL) {
xmlNanoFTPCtxtPtr ctxt = (xmlNanoFTPCtxtPtr) ctx;
const char *cur = URL;
char buf[4096];
int indx = 0;
int port = 0;
if (ctxt->protocol != NULL) {
xmlFree(ctxt->protocol);
ctxt->protocol = NULL;
}
if (ctxt->hostname != NULL) {
xmlFree(ctxt->hostname);
ctxt->hostname = NULL;
}
if (ctxt->path != NULL) {
xmlFree(ctxt->path);
ctxt->path = NULL;
}
if (URL == NULL) return;
buf[indx] = 0;
while (*cur != 0) {
if ((cur[0] == ':') && (cur[1] == '/') && (cur[2] == '/')) {
buf[indx] = 0;
ctxt->protocol = xmlMemStrdup(buf);
indx = 0;
cur += 3;
break;
}
buf[indx++] = *cur++;
}
if (*cur == 0) return;
buf[indx] = 0;
/* allow user@ and user:pass@ forms */
{
const char *p = strchr(cur, '@');
if(p) {
while(1) {
if(cur[0] == ':' || cur[0] == '@') break;
buf[indx++] = *cur++;
}
buf[indx] = 0;
ctxt->user = xmlMemStrdup(buf);
indx = 0;
if(cur[0] == ':') {
cur++;
while(1) {
if(cur[0] == '@') break;
buf[indx++] = *cur++;
}
buf[indx] = 0;
ctxt->passwd = xmlMemStrdup(buf);
indx = 0;
}
cur = p+1;
}
}
while (1) {
if (cur[0] == ':') {
buf[indx] = 0;
ctxt->hostname = xmlMemStrdup(buf);
indx = 0;
cur += 1;
while ((*cur >= '0') && (*cur <= '9')) {
port *= 10;
port += *cur - '0';
cur++;
}
if (port != 0) ctxt->port = port;
while ((cur[0] != '/') && (*cur != 0))
cur++;
break;
}
if ((*cur == '/') || (*cur == 0)) {
buf[indx] = 0;
ctxt->hostname = xmlMemStrdup(buf);
indx = 0;
break;
}
buf[indx++] = *cur++;
}
if (*cur == 0)
ctxt->path = xmlMemStrdup("/");
else {
indx = 0;
buf[indx] = 0;
while (*cur != 0)
buf[indx++] = *cur++;
buf[indx] = 0;
ctxt->path = xmlMemStrdup(buf);
}
}
/**
* breakPointAdd:
* @url: Non-null, non-empty file name that has been loaded by
* debugger
* @lineNumber: @lineNumber >= 0 and is available in url specified and
* points to an xml element
* @templateName: The template name of breakPoint or NULL
* @modeName : The mode of breakpoint or NULL
* @type: Valid BreakPointTypeEnum
*
* Add break point at file and line number specified
*
* Returns 1 if successful,
* 0 otherwise
*/
int
breakPointAdd(const xmlChar * url, long lineNumber,
const xmlChar * templateName,
const xmlChar * modeName,
BreakPointTypeEnum type)
{
int result = 0, breakPointType = type;
xmlHashTablePtr breakPointHash = NULL; /* hash of breakPoints */
breakPointPtr breakPtr;
if (!breakList) {
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
xsltGenericError(xsltGenericErrorContext,
"Error: Breakpoints structures not initialized\n");
#endif
return result;
}
if (!url || (lineNumber == -1)) {
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
xsltGenericError(xsltGenericErrorContext,
"Error: Invalid url or line number to breakPointAdd\n");
#endif
return result;
}
/* if breakpoint already exists then don;t add it */
if (breakPointIsPresent(url, lineNumber)) {
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
xsltGenericError(xsltGenericErrorContext,
"Warning: Breakpoint at file %s: line %d exists\n",
url, lineNumber);
#endif
return result;
}
breakPtr = breakPointItemNew();
if (breakPtr) {
breakPtr->url = (xmlChar *) xmlMemStrdup((char *) url);
breakPtr->lineNo = lineNumber;
if (templateName)
breakPtr->templateName =
xmlStrdup( templateName);
else
breakPtr->templateName = NULL;
if (modeName)
breakPtr->modeName =
xmlStrdup(modeName);
else
breakPtr->modeName = NULL;
breakPtr->type = BreakPointTypeEnum(breakPointType);
/* add new breakPoint to the right hash table */
breakPointHash = breakPointGetLineNoHash(lineNumber);
if (breakPointHash) {
result = lineNoItemAdd(breakPointHash, breakPtr);
} else {
/* Grow breakList size */
int lineIndex;
int newEntries = breakList->count;
xmlHashTablePtr hash;
result = 1;
if ((lineNumber < breakList->count) && breakList->count) {
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
xsltGenericError(xsltGenericErrorContext,
"Error: Unable to find breakpoint line hash at %d\n",
lineNumber);
#endif
} else {
if (breakList->count + newEntries < lineNumber)
newEntries = lineNumber - breakList->count + 1;
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
/*
* xsltGenericError(xsltGenericErrorContext,
* "Size of line list was %d adding %d entries\n",
* breakList->count, newEntries);
*/
#endif
lineIndex = 0;
while ((lineIndex < newEntries) && result) {
hash = lineNoItemNew();
if (hash) {
result = result && arrayListAdd(breakList, hash);
} else {
result = 0;
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
xsltGenericError(xsltGenericErrorContext,
"Error: Unable to create hash table breakPoint list: memory error\n");
#endif
return result;
}
lineIndex++;
}
/* find the newly added hashtable of breakpoints */
breakPointHash = breakPointGetLineNoHash(lineNumber);
if (breakPointHash) {
result = lineNoItemAdd(breakPointHash, breakPtr);
} else {
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
xsltGenericError(xsltGenericErrorContext,
"Error: Unable to create new breakPoint:interal error\n");
#endif
return result;
}
}
}
} else {
#ifdef WITH_XSLDBG_DEBUG_BREAKPOINTS
xsltGenericError(xsltGenericErrorContext,
"Error: Unable to create new breakPoint: memory error\n");
#endif
}
if (result && (optionsGetIntOption(OPTIONS_GDB) > 1) &&
(xsldbgValidateBreakpoints != BREAKPOINTS_BEING_VALIDATED)){
breakPointPrint(breakPtr);
xsldbgGenericErrorFunc("\n");
}
return result;
}
static void
xmlNanoHTTPScanAnswer(xmlNanoHTTPCtxtPtr ctxt, const char *line) {
const char *cur = line;
if (line == NULL) return;
if (!strncmp(line, "HTTP/", 5)) {
int version = 0;
int ret = 0;
cur += 5;
while ((*cur >= '0') && (*cur <= '9')) {
version *= 10;
version += *cur - '0';
cur++;
}
if (*cur == '.') {
cur++;
if ((*cur >= '0') && (*cur <= '9')) {
version *= 10;
version += *cur - '0';
cur++;
}
while ((*cur >= '0') && (*cur <= '9'))
cur++;
} else
version *= 10;
if ((*cur != ' ') && (*cur != '\t')) return;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if ((*cur < '0') || (*cur > '9')) return;
while ((*cur >= '0') && (*cur <= '9')) {
ret *= 10;
ret += *cur - '0';
cur++;
}
if ((*cur != 0) && (*cur != ' ') && (*cur != '\t')) return;
ctxt->returnValue = ret;
ctxt->version = version;
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Content-Type:", 13)) {
const xmlChar *charset, *last, *mime;
cur += 13;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->contentType != NULL)
xmlFree(ctxt->contentType);
ctxt->contentType = xmlMemStrdup(cur);
mime = (const xmlChar *) cur;
last = mime;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->mimeType != NULL)
xmlFree(ctxt->mimeType);
ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
if (charset != NULL) {
charset += 8;
last = charset;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->encoding != NULL)
xmlFree(ctxt->encoding);
ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"ContentType:", 12)) {
const xmlChar *charset, *last, *mime;
cur += 12;
if (ctxt->contentType != NULL) return;
while ((*cur == ' ') || (*cur == '\t')) cur++;
ctxt->contentType = xmlMemStrdup(cur);
mime = (const xmlChar *) cur;
last = mime;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->mimeType != NULL)
xmlFree(ctxt->mimeType);
ctxt->mimeType = (char *) xmlStrndup(mime, last - mime);
charset = xmlStrstr(BAD_CAST ctxt->contentType, BAD_CAST "charset=");
if (charset != NULL) {
charset += 8;
last = charset;
while ((*last != 0) && (*last != ' ') && (*last != '\t') &&
(*last != ';') && (*last != ','))
last++;
if (ctxt->encoding != NULL)
xmlFree(ctxt->encoding);
ctxt->encoding = (char *) xmlStrndup(charset, last - charset);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Location:", 9)) {
cur += 9;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->location != NULL)
xmlFree(ctxt->location);
if (*cur == '/') {
xmlChar *tmp_http = xmlStrdup(BAD_CAST "http://");
xmlChar *tmp_loc =
xmlStrcat(tmp_http, (const xmlChar *) ctxt->hostname);
ctxt->location =
(char *) xmlStrcat (tmp_loc, (const xmlChar *) cur);
} else {
ctxt->location = xmlMemStrdup(cur);
}
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"WWW-Authenticate:", 17)) {
cur += 17;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->authHeader != NULL)
xmlFree(ctxt->authHeader);
ctxt->authHeader = xmlMemStrdup(cur);
} else if (!xmlStrncasecmp(BAD_CAST line, BAD_CAST"Proxy-Authenticate:", 19)) {
cur += 19;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if (ctxt->authHeader != NULL)
xmlFree(ctxt->authHeader);
ctxt->authHeader = xmlMemStrdup(cur);
#ifdef HAVE_ZLIB_H
} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Encoding:", 17) ) {
cur += 17;
while ((*cur == ' ') || (*cur == '\t')) cur++;
if ( !xmlStrncasecmp( BAD_CAST cur, BAD_CAST"gzip", 4) ) {
ctxt->usesGzip = 1;
ctxt->strm = xmlMalloc(sizeof(z_stream));
if (ctxt->strm != NULL) {
ctxt->strm->zalloc = Z_NULL;
ctxt->strm->zfree = Z_NULL;
ctxt->strm->opaque = Z_NULL;
ctxt->strm->avail_in = 0;
ctxt->strm->next_in = Z_NULL;
inflateInit2( ctxt->strm, 31 );
}
}
#endif
} else if ( !xmlStrncasecmp( BAD_CAST line, BAD_CAST"Content-Length:", 15) ) {
cur += 15;
ctxt->ContentLength = strtol( cur, NULL, 10 );
}
}
/**
* qtXslDbgShellReadline:
* @prompt: the prompt value
*
* Read a string
*
* Returns a copy of the text inputed or NULL if EOF in stdin found.
* The caller is expected to free the returned string.
*/
xmlChar *
qtXslDbgShellReadline(xmlChar * prompt)
{
const char *inputReadBuff;
static char last_read[DEBUG_BUFFER_SIZE] = { '\0' };
if (getThreadStatus() != XSLDBG_MSG_THREAD_RUN)
{
#ifdef HAVE_READLINE
xmlChar *line_read;
/* Get a line from the user. */
line_read = (xmlChar *) readline((char *) prompt);
/* If the line has any text in it, save it on the history. */
if (line_read && *line_read) {
add_history((char *) line_read);
strncpy((char*)last_read, (char*)line_read, DEBUG_BUFFER_SIZE - 1);
} else {
/* if only <Enter>is pressed then try last saved command line */
line_read = (xmlChar *) xmlMemStrdup(last_read);
}
return (line_read);
#else
char line_read[DEBUG_BUFFER_SIZE];
if (prompt != NULL)
xsltGenericError(xsltGenericErrorContext, "%s", prompt);
if (!fgets(line_read, DEBUG_BUFFER_SIZE - 1, stdin))
return (NULL);
line_read[DEBUG_BUFFER_SIZE - 1] = 0;
/* if only <Enter>is pressed then try last saved command line */
if ((strlen(line_read) == 0) || (line_read[0] == '\n')) {
strcpy(line_read, last_read);
} else {
strcpy(last_read, line_read);
}
return (xmlChar *) xmlMemStrdup(line_read);
#endif
}
else{
setInputStatus(XSLDBG_MSG_AWAITING_INPUT);
notifyXsldbgApp(XSLDBG_MSG_AWAITING_INPUT, NULL);
while (getInputReady() == 0){
usleep(10000);
/* have we been told to die */
if (getThreadStatus() == XSLDBG_MSG_THREAD_STOP){
fprintf(stderr, "About to stop thread\n");
xslDebugStatus = DEBUG_QUIT;
return NULL;
}
}
setInputStatus(XSLDBG_MSG_READ_INPUT);
inputReadBuff = getFakeInput();
if(inputReadBuff){
notifyXsldbgApp(XSLDBG_MSG_READ_INPUT, inputReadBuff);
return (xmlChar*)xmlMemStrdup(inputReadBuff);
}else{
return NULL;
}
}
}
