PRIVATE int SendCommand (HTRequest *request, news_info *news,
char *token, char *pars)
{
HTStream * input = HTRequest_inputStream(request);
int len = strlen(token) + (pars ? strlen(pars)+1:0) + 2;
HTChunk_setSize(news->cmd, len);
if (pars && *pars)
sprintf(HTChunk_data(news->cmd), "%s %s%c%c", token, pars, CR, LF);
else
sprintf(HTChunk_data(news->cmd), "%s%c%c", token, CR, LF);
HTTRACE(PROT_TRACE, "News Tx..... %s" _ HTChunk_data(news->cmd));
return (*input->isa->put_block)(input, HTChunk_data(news->cmd), len);
}
PRIVATE void HTML_end_element (HTStructured * me, int element_number)
{
if (!me->started) {
HTextImp_build(me->text, HTEXT_BEGIN);
me->started = YES;
}
/* Update our parse stack */
if (me->overflow > 0) {
me->overflow--;
return;
}
me->sp++;
if (me->sp > me->stack + MAX_NESTING - 1) {
HTTRACE(SGML_TRACE, "HTML Parser. Bottom of parse stack reached\n");
me->sp = me->stack + MAX_NESTING - 1;
}
/* Look at what element was closed */
switch(element_number) {
case HTML_TITLE:
HTAnchor_setTitle(me->node_anchor, HTChunk_data(me->title));
break;
case HTML_PRE:
if (me->comment_start)
HTextImp_addText(me->text, me->comment_start, strlen(me->comment_start));
break;
}
/* Call out to the layout engine */
HTextImp_endElement(me->text, element_number);
}
PRIVATE int terminate_handler (HTRequest * request, HTResponse * response,
void * param, int status)
{
if (status == HT_LOADED && result && HTChunk_data(result)) {
HTPrint("%s", HTChunk_data(result));
HTChunk_delete(result);
}
/* We are done with this request */
HTRequest_delete(request);
/* Terminate libwww */
HTProfile_delete();
exit(0);
}
/*
** Check whether the application provides us with a cookie or more.
*/
PRIVATE int HTCookie_beforeFilter (HTRequest * request, void * param, int mode)
{
if ((CookieMode & HT_COOKIE_SEND) && FindCookie) {
HTAssocList * cookies = (*FindCookie)(request, FindCookieContext);
if (cookies) {
HTChunk * cookie_header = HTChunk_new(64);
HTAssocList * cur = cookies;
HTAssoc * pres;
BOOL first=YES;
while ((pres = (HTAssoc *) HTAssocList_nextObject(cur))) {
if (!first) HTChunk_putc(cookie_header, ';');
HTChunk_puts(cookie_header, HTAssoc_name(pres));
HTChunk_putc(cookie_header, '=');
HTChunk_puts(cookie_header, HTAssoc_value(pres));
first = NO;
}
HTRequest_addExtraHeader(request, "Cookie", HTChunk_data(cookie_header));
HTChunk_delete(cookie_header);
/* Also delete the association list */
HTAssocList_delete(cookies);
}
}
return HT_OK;
}
/* L A B E L P A R S E R S */
PRIVATE StateRet_t callErrorHandler(CSParse_t * pCSParse,
const char * errorLocation,
char demark, StateRet_t errorCode)
{
char * token = HTChunk_data(pCSParse->token);
pCSParse->pParseContext->pTokenError = (char *) errorLocation;
return (*pCSParse->pParseContext->pParseErrorHandler)(pCSParse, token,
demark, StateRet_ERROR_BAD_CHAR);
}
PRIVATE int HTRule_flush (HTStream * me)
{
if (me) {
char * flush = HTChunk_data(me->buffer);
if (flush) HTRule_parseLine(rules, flush);
HTChunk_clear(me->buffer);
}
return HT_OK;
}
PRIVATE BOOL CSUserList_addLine(HTStream * me)
{
UserListStruct_t * newEl;
char * pURL;
char * end;
end = strrchr(HTChunk_data(me->buffer), ' ');
pURL = end + 1;
while (*(end-1) == ' ')
end--;
*end = 0;
if ((newEl = (UserListStruct_t *)HT_CALLOC(1, sizeof(UserListStruct_t))) == NULL)
HT_OUTOFMEM("UserListStruct_t");
StrAllocCopy(newEl->name, HTChunk_data(me->buffer));
StrAllocCopy(newEl->url, pURL);
/* HTList_addObject(me->URLs, (void *)pURL); */
HTList_addObject(UserList, (void *)newEl);
return YES;
}
/*
** Folding is either of CF LWS, LF LWS, CRLF LWS
*/
PRIVATE int HTRule_put_block (HTStream * me, const char * b, int l)
{
while (l > 0) {
if (me->EOLstate == EOL_FCR) {
if (*b == LF) /* CRLF */
me->EOLstate = EOL_FLF;
else if (isspace((int) *b)) /* Folding: CR SP */
me->EOLstate = EOL_DOT;
else { /* New line */
HTRule_parseLine(rules, HTChunk_data(me->buffer));
me->EOLstate = EOL_BEGIN;
HTChunk_clear(me->buffer);
continue;
}
} else if (me->EOLstate == EOL_FLF) {
if (isspace((int) *b)) /* Folding: LF SP or CR LF SP */
me->EOLstate = EOL_DOT;
else { /* New line */
HTRule_parseLine(rules, HTChunk_data(me->buffer));
me->EOLstate = EOL_BEGIN;
HTChunk_clear(me->buffer);
continue;
}
} else if (me->EOLstate == EOL_DOT) {
if (isspace((int) *b)) {
me->EOLstate = EOL_BEGIN;
HTChunk_putc(me->buffer, ' ');
} else {
HTRule_parseLine(rules, HTChunk_data(me->buffer));
me->EOLstate = EOL_BEGIN;
HTChunk_clear(me->buffer);
continue;
}
} else if (*b == CR) {
me->EOLstate = EOL_FCR;
} else if (*b == LF) {
me->EOLstate = EOL_FLF; /* Line found */
} else
HTChunk_putc(me->buffer, *b);
l--; b++;
}
return HT_OK;
}
/* _stream2dispatchParsers - extracts the arguments from a
* MIME stream before calling the generic _dispatchParser
* function.
*/
PRIVATE int _stream2dispatchParsers (HTStream * me)
{
char * token = HTChunk_data(me->token);
char * value = HTChunk_data(me->value);
/* In case we get an empty header consisting of a CRLF, we fall thru */
HTTRACE(STREAM_TRACE, "MIME header. %s: %s\n" _
token ? token : "<null>" _
value ? value : "<null>");
if (!token) return HT_OK; /* Ignore noop token */
/*
** Remember the original header
*/
HTResponse_addHeader(me->response, token, value);
/* call the parsers to set the headers */
return (_dispatchParsers (me->request, token, value));
}
/* Handle entity
** -------------
**
** On entry,
** s contains the entity name zero terminated
*/
PRIVATE void handle_entity (HTStream * context)
{
const char ** entities = context->dtd->entity_names;
const char *s = HTChunk_data(context->string);
int high, low, i, diff;
for(low=0, high = context->dtd->number_of_entities;
high > low ;
diff < 0 ? (low = i+1) : (high = i))
{
i = (low + (high-low)/2);
diff = strcmp(entities[i], s); /* Case sensitive! */
if (diff==0)
{ /* success: found it */
(*context->actions->put_entity)(context->target, i);
return;
}
}
/* If entity string not found */
HTTRACE(SGML_TRACE, "Unknown entity %s\n" _ s);
(*context->actions->unparsed_entity)
(context->target, HTChunk_data(context->string), HTChunk_size(context->string));
}
PRIVATE int NewsPost_put_block (HTStream * me, const char* b, int l)
{
if (!me->target) {
return HT_WOULD_BLOCK;
} else if (me->transparent)
return b ? PUTBLOCK(b, l) : HT_OK;
else {
int status;
NewsPost_start(me, me->request);
if ((status = PUTBLOCK(HTChunk_data(me->buffer),
HTChunk_size(me->buffer))) == HT_OK) {
me->transparent = YES;
return b ? PUTBLOCK(b, l) : HT_OK;
}
return status;
}
}
/* Handle attribute value
** ----------------------
*/
PRIVATE void handle_attribute_value (HTStream * context)
{
/* Deal with attributes only if tag is known,
ignore silently otherwise */
if (context->current_tag)
{
if (context->current_attribute_number != INVALID)
context->value[context->current_attribute_number] =
context->token;
else {
char * data = HTChunk_data(context->string);
HTTRACE(SGML_TRACE, "Attribute value %s ignored\n" _
data ? data+context->token : "<null>");
}
}
context->current_attribute_number = INVALID; /* can't have two assignments! */
}
/* NewsPost_start
** --------------
** NNTP needs two extra headers: "From" and "Newsgroups".
** Take the newsgroups from the Postweb model as destinations for this
** anchor.
** Return YES if OK else NO
*/
PRIVATE BOOL NewsPost_start (HTStream * me, HTRequest * request)
{
char linebuf[128]; /* @@@ */
HTChunk *header = me->buffer;
HTUserProfile * up = HTRequest_userProfile(request);
const char * mailaddress = HTUserProfile_email(up);
if (mailaddress) {
sprintf(linebuf, "From: %s%c%c", mailaddress, CR, LF);
HTChunk_puts(header, linebuf);
}
/*
** Find all the newsgroups we are posting to by looking at all the
** destinations from the source of this request.
** First the main link and then the sub links
*/
HTChunk_puts(header, "Newsgroups :");
if (HTRequest_isDestination(request)) {
HTRequest *src_req = HTRequest_source(request);
HTParentAnchor *src_anchor = HTRequest_anchor(src_req);
HTLink *link = HTAnchor_mainLink((HTAnchor *) src_anchor);
HTAnchor *dest = HTLink_destination(link);
HTMethod method = HTLink_method(link);
if (link && method == METHOD_POST &&
HTLink_result(link) == HT_LINK_NONE) {
char *desturl = HTAnchor_physical((HTParentAnchor *) dest);
char *access = HTParse(desturl, "", PARSE_ACCESS);
if (!strcasecomp(access, "news") || !strcasecomp(access, "nntp")) {
char *newsgroup = HTParse(desturl, "", PARSE_PATH);
HTUnEscape(newsgroup);
HTCleanTelnetString(newsgroup);
HTChunk_puts(header, newsgroup);
HT_FREE(newsgroup);
}
HT_FREE(access);
}
/* DO FOR ALL SUB ANCHOR DESTINATION S AS WELL */
}
HTTRACE(PROT_TRACE, "News Tx..... %s" _ HTChunk_data(header));
return YES;
}
/*
** Scan the request line for METHOD, URI and VERSION
** Returns: HT_OK if 1.x request and OK
** HT_LOADED if 0.9 request and OK
** HT_ERROR if invalid request line
*/
PRIVATE int ParseRequest (HTStream * me)
{
HTRequest * client = HTList_firstObject(me->http->clients);
char * line = HTChunk_data(me->buffer);
char * method_str = HTNextField(&line);
char * request_uri = HTNextField(&line);
char * version_str = HTNextField(&line);
HTMethod method;
/* Check if method is allowed */
if (!method_str || (method = HTMethod_enum(method_str))==METHOD_INVALID) {
HTRequest_addError(client, ERR_FATAL, NO, HTERR_NOT_ALLOWED,
NULL, 0, "ParseRequest");
return HT_ERROR;
}
HTRequest_setMethod(client, method);
/* Find an anchor for the request URI */
if (request_uri) {
char * uri = HTParse(request_uri, "file:", PARSE_ALL);
HTRequest_setAnchor(client, HTAnchor_findAddress(uri));
HT_FREE(uri);
} else {
HTRequest_addError(client, ERR_FATAL, NO, HTERR_BAD_REQUEST,
NULL, 0, "ParseRequest");
return HT_ERROR;
}
/* Get ready to get the rest of the request */
if (version_str) {
me->target = HTStreamStack(WWW_MIME_HEAD,
HTRequest_debugFormat(client),
HTRequest_debugStream(client),
client, NO);
return HT_OK;
} else {
HTRequest_addError(client, ERR_FATAL, NO, HTERR_BAD_VERSION,
NULL, 0, "ParseRequest");
return HT_ERROR;
}
}
/* Start an element
** ----------------
*/
PRIVATE void start_element (HTStream * context)
{
int i;
char *value[MAX_ATTRIBUTES];
HTTag *tag = context->current_tag;
HTTRACE(SGML_TRACE, "Start <%s>\n" _ tag->name);
context->contents = tag->contents;
/*
** Build the actual pointers to the value strings stored in the
** chunk buffer. (Must use offsets while collecting the values,
** because the string chunk may get resized during the collection
** and potentially relocated).
*/
for (i = 0; i < MAX_ATTRIBUTES; ++i)
value[i] = context->value[i] < 0 ? NULL :
HTChunk_data(context->string) + context->value[i];
(*context->actions->start_element)
(context->target,
tag - context->dtd->tags,
context->present,
(const char**)value); /* coerce type for think c */
}
PUBLIC NowIn_t CSParse_targetParser(CSParse_t * pCSParse, char demark, void * pVoid)
{
/* ParseContext_t * pParseContext = pCSParse->pParseContext; */
TargetObject_t * pTargetObject = pCSParse->pTargetObject;
BOOL failedOnPunct = NO;
char * token = 0;
StateRet_t ret = StateRet_OK;
int i;
static NowIn_t lastRet = NowIn_END;
if (HTChunk_size(pCSParse->token)) {
HTChunk_terminate(pCSParse->token);
token = HTChunk_data(pCSParse->token);
}
for (i = 0; i < pTargetObject->stateTokenCount; i++) {
StateToken_t * pStateToken = pTargetObject->stateTokens + i;
pCSParse->pStateToken = pStateToken;
if (!(pCSParse->currentSubState & pStateToken->validSubStates))
continue;
if (pStateToken->pCheck) { /* use check function */
StateRet_t checkRes;
checkRes = (*pStateToken->pCheck)(pCSParse, pStateToken, token, demark);
switch (checkRes) {
case StateRet_WARN_BAD_PUNCT:
failedOnPunct = YES;
case StateRet_WARN_NO_MATCH:
continue;
case StateRet_ERROR_BAD_CHAR:
(*pCSParse->pParseContext->pParseErrorHandler)(pCSParse, token, demark, StateRet_ERROR_BAD_CHAR);
/* if (pTargetObject->pDestroy)
(*pTargetObject->pDestroy)(pCSParse); */
return NowIn_ERROR;
default:
break;
}
} else { /* or match by name[s] */
if (!(pStateToken->command & Command_MATCHANY)) {
if (token && pStateToken->name1) {
if (strcasecomp(token, pStateToken->name1) && (!pStateToken->name2 || strcasecomp(token, pStateToken->name2)))
continue;
} else {
if (token != pStateToken->name1)
continue;
}
}
if (Punct_badDemark(pStateToken->validPunctuation, demark)) {
failedOnPunct = YES;
continue;
}
}
/* open or close and do the appropriate callbacks */
if (lastRet != NowIn_CHAIN)
ParseTrace("%30s %c ", token ? token : "", demark);
ParseTrace("%10s - %s:%10s => ", pCSParse->pTargetObject->note, CSParse_subState2str(pCSParse->currentSubState), pStateToken->note);
if (pStateToken->command & Command_NOTOKEN) {
HTChunk_clear(pCSParse->token);
token = 0;
}
if (pStateToken->command & Command_OPEN && pTargetObject->pOpen)
if ((*pTargetObject->pOpen)(pCSParse, token, demark) == StateRet_ERROR)
return NowIn_ERROR;
if (pStateToken->command & (Command_OPEN|Command_CLOSE) && pCSParse->pParseContext->pTargetChangeCallback) {
ParseTrace("%3d", pStateToken->command & Command_CLOSE ? -pTargetObject->targetChange : pTargetObject->targetChange);
if ((*pCSParse->pParseContext->pTargetChangeCallback)(pCSParse, pTargetObject, pTargetObject->targetChange,
(BOOL)(pStateToken->command & Command_CLOSE), pVoid) == StateRet_ERROR)
return NowIn_ERROR;
} else
ParseTrace(" ");
if (pStateToken->command & Command_CLOSE && pTargetObject->pClose)
ret = (*pTargetObject->pClose)(pCSParse, token, demark);
if (pStateToken->pPrep && ret != NowIn_ERROR)
ret = (*pStateToken->pPrep)(pCSParse, token, demark);
if (pStateToken->pNextTargetObject)
pCSParse->pTargetObject = pStateToken->pNextTargetObject;
if (pStateToken->nextSubState != SubState_X)
pCSParse->currentSubState = pStateToken->nextSubState;
ParseTrace("%10s - %s", pCSParse->pTargetObject->note, CSParse_subState2str(pCSParse->currentSubState));
if (pStateToken->command & Command_CHAIN) {
ParseTrace(" -O-O-");
return lastRet = NowIn_CHAIN;
}
ParseTrace("\n");
return lastRet = ret == StateRet_ERROR_BAD_CHAR ? NowIn_ERROR : ret == StateRet_DONE ? NowIn_END : NowIn_ENGINE;
}
(*pCSParse->pParseContext->pParseErrorHandler)(pCSParse, token, demark, failedOnPunct ? StateRet_WARN_BAD_PUNCT : StateRet_WARN_NO_MATCH);
if (pTargetObject->pDestroy)
(*pTargetObject->pDestroy)(pCSParse);
return NowIn_ERROR;
}
PUBLIC BOOL HTBind_add (const char * suffix,
const char * representation,
const char * encoding,
const char * transfer,
const char * language,
double value)
{
HTBind * suff;
if (!suffix)
return NO;
if (!strcmp(suffix, "*"))
suff = &no_suffix;
else if (!strcmp(suffix, "*.*"))
suff = &unknown_suffix;
else {
HTList * suflist;
int hash;
const unsigned char * p;
/* Select list from hash table */
for (p=suffix, hash=0; *p; p++) {
hash = (hash * 3 + TOLOWER(*p)) % HT_L_HASH_SIZE;
}
if (!HTBindings) HTBind_init();
if (!HTBindings[hash]) HTBindings[hash] = HTList_new();
suflist = HTBindings[hash];
/* Look for existing binding */
{
HTList *cur = suflist;
while ((suff = (HTBind *) HTList_nextObject(cur)) != NULL) {
if (!strcmp(suff->suffix, suffix))
break;
}
}
/* If not found -- create a new node */
if (!suff) {
if ((suff = (HTBind *) HT_CALLOC(1, sizeof(HTBind))) == NULL)
HT_OUTOFMEM("HTBind_add");
HTList_addObject(suflist, (void *) suff);
StrAllocCopy(suff->suffix, suffix);
}
}
/* Set the appropriate values */
{
HTChunk * chunk = HTChunk_new(32);
char *ptr;
if (representation) {
HTChunk_puts(chunk, representation);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->type = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (encoding) {
HTChunk_puts(chunk, encoding);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->encoding = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (transfer) {
HTChunk_puts(chunk, transfer);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->transfer = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
if (language) {
HTChunk_puts(chunk, language);
ptr = HTChunk_data(chunk);
for (; *ptr; ptr++)
*ptr = TOLOWER(*ptr);
suff->language = HTAtom_for(HTChunk_data(chunk));
HTChunk_truncate(chunk,0);
}
HTChunk_delete(chunk);
suff->quality = value;
}
return YES;
}
unsigned int BinURLInputStream::readBytes(XMLByte* const toFill
, const unsigned int maxToRead)
{
unsigned int retval = 0;
unsigned int bytesAsked = maxToRead;
unsigned int bytesForCopy = 0;
// Wipe out the old stuff from the destination buffer to fill.
memset((void*)toFill, 0x00, sizeof(XMLByte) * maxToRead);
// You can only read till the end of the remote resource file.
// So, adjust the count of bytes you want to read now.
if (fBytesProcessed + bytesAsked >= fRemoteFileSize)
{
bytesAsked = fRemoteFileSize - fBytesProcessed;
}
if (fBufferSize > 0)
bytesForCopy = fBufferSize - fBufferIndex;
if (bytesAsked <= bytesForCopy)
{
// ...then you can satisfy this request completely from fBuffer.
// Simply copy over the bytes to the destination array.
memcpy((void*) toFill, (void*) (fBuffer + fBufferIndex), bytesAsked);
fBufferIndex += bytesAsked;
if (fBufferIndex >= fBufferSize)
{
fBufferSize = 0;
fBufferIndex = 0;
}
fBytesProcessed += bytesAsked;
retval = bytesAsked;
}
else
{
// ...will need to read some more bytes out of the stream.
unsigned int bufToFillIndex = 0;
HTRequest* request = HTRequest_new();
HTChunk* result = NULL;
char ranges[64];
// First copy over what is left in fBuffer, before reading another
// chunk out of the stream.
if (bytesForCopy != 0)
{
memcpy((void*) toFill, (void*) (fBuffer + fBufferSize), bytesForCopy);
fBufferSize = 0;
fBufferIndex = 0;
fBytesProcessed += bytesForCopy;
bufToFillIndex = bytesForCopy;
retval = bytesForCopy;
}
unsigned int bytesRemainingForCopy = bytesAsked - bytesForCopy;
// Now read a new chunk from the stream. HTTP lets you specify the
// range of bytes that you would like.
sprintf(ranges, "%ld-%ld", fBytesProcessed,
fRemoteFileSize<(fBytesProcessed + URLISBUFMAXSIZE)? fRemoteFileSize - 1: fBytesProcessed + URLISBUFMAXSIZE - 1);
HTRequest_addRange(request, "bytes", ranges);
HTRequest_setOutputFormat(request, WWW_SOURCE);
result = HTLoadAnchorToChunk(fAnchor, request);
fBufferSize = HTChunk_size(result);
if (fBufferSize > 0)
{
// Store the read chunk in fBuffer.
memset((void*) fBuffer, 0x00, URLISBUFMAXSIZE);
memcpy((void*) fBuffer, (void*) HTChunk_data(result), fBufferSize);
fBufferIndex = 0;
}
HTRequest_delete(request);
HTChunk_delete(result);
// Now fill the destination buffer with the new data just read.
bytesForCopy = fBufferSize;
if (bytesRemainingForCopy > fBufferSize)
{
bytesRemainingForCopy = fBufferSize;
}
memcpy((void*) (toFill + bufToFillIndex),
(void*) fBuffer,
bytesRemainingForCopy);
// Update counters.
retval += bytesRemainingForCopy;
fBufferIndex += bytesRemainingForCopy;
fBytesProcessed += bytesRemainingForCopy;
}
return retval;
}
PRIVATE int SGML_write (HTStream * context, const char * b, int l)
{
const SGML_dtd *dtd = context->dtd;
HTChunk *string = context->string;
const char *text = b;
int count = 0;
while (l-- > 0)
{
char c = *b++;
switch(context->state)
{
got_element_open:
/*
** The label is jumped when the '>' of a the element
** start tag has been detected. This DOES NOT FALL TO
** THE CODE S_after_open, only processes the tag and
** sets the state (c should still contain the
** terminating character of the tag ('>'))
*/
if (context->current_tag && context->current_tag->name)
start_element(context);
context->state = S_after_open;
break;
case S_after_open:
/*
** State S_after_open is entered only for single
** character after the element opening tag to test
** against newline. Strip one trainling newline only
** after opening nonempty element. - SGML: Ugh!
*/
text = b;
count = 0;
if (c == '\n' && (context->contents != SGML_EMPTY))
{
context->state = S_text;
break;
}
--text;
goto S_text;
S_text:
context->state = S_text;
case S_text:
#ifdef ISO_2022_JP
if (c == '\033')
{
context->state = S_esc;
++count;
break;
}
#endif /* ISO_2022_JP */
if (c == '&')
{
if (count > 0)
PUTB(text, count);
count = 0;
HTChunk_clear(string);
context->state = S_ero;
}
else if (c == '<')
{
if (count > 0)
PUTB(text, count);
count = 0;
HTChunk_clear(string);
/* should scrap LITERAL, and use CDATA and
RCDATA -- msa */
context->state =
(context->contents == SGML_LITERAL) ?
S_literal : S_tag;
}
else if (c == '\n')
/* Newline - ignore if before end tag! */
context->state = S_nl;
else
++count;
break;
case S_nl:
if (c == '<')
{
if (count > 0)
PUTB(text, count);
count = 0;
HTChunk_clear(string);
context->state =
(context->contents == SGML_LITERAL) ?
S_literal : S_nl_tago;
}
else
{
++count;
goto S_text;
}
break;
case S_nl_tago: /* Had newline and tag opener */
if (c != '/')
PUTC('\n'); /* Only ignore newline before </ */
context->state = S_tag;
goto handle_S_tag;
#ifdef ISO_2022_JP
case S_esc:
if (c=='$')
context->state = S_dollar;
else if (c=='(')
context->state = S_paren;
else
context->state = S_text;
++count;
break;
case S_dollar:
if (c=='@' || c=='B')
context->state = S_nonascii_text;
else
context->state = S_text;
++count;
break;
case S_paren:
if (c=='B' || c=='J')
context->state = S_text;
else
context->state = S_text;
++count;
break;
case S_nonascii_text:
if (c == '\033')
context->state = S_esc;
++count;
break;
#endif /* ISO_2022_JP */
/* In literal mode, waits only for specific end tag!
** Only foir compatibility with old servers.
*/
case S_literal:
HTChunk_putc(string, c);
if ( TOUPPER(c) !=
((HTChunk_size(string) == 1) ? '/'
: context->current_tag->name[HTChunk_size(string)-2]))
{
/* If complete match, end literal */
if ((c == '>') &&
(!context->current_tag->name[HTChunk_size(string)-2]))
{
end_element
(context,context->current_tag);
/*
...setting SGML_MIXED below is a
bit of kludge, but a good guess that
currently works, anything other than
SGML_LITERAL would work... -- msa */
context->contents = SGML_MIXED;
}
else
{
/* If Mismatch: recover string. */
PUTC( '<');
PUTB(HTChunk_data(string), HTChunk_size(string));
}
context->state = S_text;
text = b;
count = 0;
}
break;
/*
** Character reference or Entity
*/
case S_ero:
if (c == '#')
{
/* &# is Char Ref Open */
context->state = S_cro;
break;
}
context->state = S_entity;
/** FALL THROUGH TO S_entity !! ***/
/*
** Handle Entities
*/
case S_entity:
if (isalnum((int) c))
HTChunk_putc(string, c);
else
{
HTChunk_terminate(string);
handle_entity(context);
text = b;
count = 0;
if (c != ';')
{
--text;
goto S_text;
}
context->state = S_text;
}
break;
/* Character reference
*/
case S_cro:
if (isalnum((int)c))
/* accumulate a character NUMBER */
HTChunk_putc(string, c);
else
{
int value;
HTChunk_terminate(string);
if (sscanf(HTChunk_data(string), "%d", &value)==1)
PUTC((char)value);
else
{
PUTB("&#", 2);
PUTB(HTChunk_data(string), HTChunk_size(string)-1);
}
text = b;
count = 0;
if (c != ';')
{
--text;
goto S_text;
}
context->state = S_text;
}
break;
case S_tag: /* new tag */
handle_S_tag:
if (isalnum((int)c))
HTChunk_putc(string, c);
else { /* End of tag name */
int i;
if (c == '/') {
if (HTChunk_size(string) > 0)
HTTRACE(SGML_TRACE, "`<%s/' found!\n" _ HTChunk_data(string));
context->state = S_end;
break;
} else if (c == '!') {
if (HTChunk_size(string) > 0)
HTTRACE(SGML_TRACE, " `<%s!' found!\n" _ HTChunk_data(string));
context->state = S_md;
break;
}
HTChunk_terminate(string);
context->current_tag = SGMLFindTag(dtd, HTChunk_data(string));
if (context->current_tag == NULL) {
HTTRACE(SGML_TRACE, "*** Unknown element %s\n" _ HTChunk_data(string));
(*context->actions->unparsed_begin_element)
(context->target, HTChunk_data(string), HTChunk_size(string));
} else {
for (i=0; i<context->current_tag->number_of_attributes; i++) {
context->present[i] = NO;
context->value[i] = -1;
}
}
context->token = 0;
HTChunk_clear(string);
context->current_attribute_number = INVALID;
goto S_tag_gap;
}
break;
S_tag_gap:
context->state = S_tag_gap;
case S_tag_gap: /* Expecting attribute or > */
if (isspace((int) c))
break; /* Gap between attributes */
if (c == '>')
goto got_element_open;
else
goto S_attr;
S_attr:
/*
** Start collecting the attribute name and collect
** it in S_attr.
*/
context->state = S_attr;
HTChunk_truncate(string, context->token);
case S_attr:
if (isspace((int) c) || c == '>' || c == '=')
goto got_attribute_name;
else
HTChunk_putc(string, c);
break;
got_attribute_name:
/*
** This label is entered when attribute name has been
** collected. Process it and enter S_attr_gap for
** potential value or start of the next attribute.
*/
HTChunk_terminate(string) ;
handle_attribute_name
(context, HTChunk_data(string) + context->token);
HTChunk_truncate(string, context->token);
context->state = S_attr_gap;
case S_attr_gap: /* Expecting attribute or = or > */
if (isspace((int) c))
break; /* Gap after attribute */
if (c == '>')
goto got_element_open;
else if (c == '=')
context->state = S_equals;
else
goto S_attr; /* Get next attribute */
break;
case S_equals: /* After attr = */
if (isspace((int) c))
break; /* Before attribute value */
if (c == '>')
{ /* End of tag */
HTTRACE(SGML_TRACE, "found = but no value\n");
goto got_element_open;
}
else if (c == '\'')
context->state = S_squoted;
else if (c == '"')
context->state = S_dquoted;
else
goto S_value;
break;
S_value:
context->state = S_value;
HTChunk_truncate(string, context->token);
case S_value:
if (isspace((int) c) || c == '>')
{
HTChunk_terminate(string);
handle_attribute_value(context);
context->token = HTChunk_size(string);
goto S_tag_gap;
}
else
HTChunk_putc(string, c);
break;
case S_squoted: /* Quoted attribute value */
if (c == '\'')
{
HTChunk_terminate(string);
handle_attribute_value(context);
context->token = HTChunk_size(string);
context->state = S_tag_gap;
}
else if (c && c != '\n' && c != '\r')
HTChunk_putc(string, c);
break;
case S_dquoted: /* Quoted attribute value */
if (c == '"')
{
HTChunk_terminate(string);
handle_attribute_value(context);
context->token = HTChunk_size(string);
context->state = S_tag_gap;
}
else if (c && c != '\n' && c != '\r')
HTChunk_putc(string, c);
break;
case S_end: /* </ */
if (isalnum((int) c))
HTChunk_putc(string, c);
else
{ /* End of end tag name */
HTTag *t;
char * first;
HTChunk_terminate(string);
if ((first=HTChunk_data(string))!=NULL && *first != '\0')
t = SGMLFindTag(dtd, HTChunk_data(string));
else
/* Empty end tag */
/* Original code popped here one
from the stack. If this feature
is required, I have to put the
stack back... -- msa */
t = NULL;
if (!t) {
HTTRACE(SGML_TRACE, "Unknown end tag </%s>\n" _ HTChunk_data(string));
(*context->actions->unparsed_end_element)
(context->target, HTChunk_data(string), HTChunk_size(string));
} else {
context->current_tag = NULL;
end_element(context, t);
}
HTChunk_clear(string);
context->current_attribute_number = INVALID;
if (c != '>')
{
if (!isspace((int) c))
HTTRACE(SGML_TRACE, "`</%s%c' found!\n" _ HTChunk_data(string) _ c);
context->state = S_junk_tag;
}
else
{
text = b;
count = 0;
context->state = S_text;
}
}
break;
case S_junk_tag:
if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
/*
** Scanning (actually skipping) declarations
*/
case S_md:
if (c == '-')
context->state = S_com_1;
else if (c == '"')
context->state = S_md_dqs;
else if (c == '\'')
context->state = S_md_sqs;
else if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_md_dqs: /* Skip double quoted string */
if (c == '"')
context->state = S_md;
else if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_md_sqs: /* Skip single quoted string */
if (c == '\'')
context->state = S_md;
else if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_com_1: /* Starting a comment? */
context->state = (c == '-') ? S_com : S_md;
if (c == '>')
{
text = b;
count = 0;
context->state = S_text;
}
break;
case S_com: /* ..within comment */
if (c == '-')
context->state = S_com_2;
break;
case S_com_2: /* Ending a comment ? */
context->state = (c == '-') ? S_com_2a : S_com;
break;
case S_com_2a:
if (c == '>') {
text = b;
count = 0;
context->state = S_text;
} else if (c == '-') {
context->state = S_com_2a;
} else
context->state = S_com;
break;
}
}
if (count > 0)
PUTB(text, count);
return HT_OK;
}
int main (int argc, char ** argv)
{
HTSQL * sql = NULL;
char * sqlserver = DEFAULT_SQL_SERVER;
char * sqldb = DEFAULT_SQL_DB;
char * sqluser = DEFAULT_SQL_USER;
char * sqlpw = DEFAULT_SQL_PW;
char * cvsuser = DEFAULT_CVS_USER;
time_t cvsdate = -1;
FILE * fin = stdin;
char * input_buffer[BUFSIZE];
HTChunk * loginfo = HTChunk_new(BUFSIZE);
int arg = 0;
BOOL create_db = YES;
/* Initiate libwww */
HTLibInit(APP_NAME, APP_VERSION);
/* Scan command line for parameters */
for (arg=1; arg<argc; arg++) {
if (*argv[arg] == '-') {
if (!strcmp(argv[arg], "-h") || !strcmp(argv[arg], "-?")) {
VersionInfo();
Cleanup(0, sql, loginfo);
} else if (!strcmp(argv[arg], "-v")) {
HTSetTraceMessageMask("q");
} else if (!strcmp(argv[arg], "-nocreate")) {
create_db = NO;
} else if (!strncmp(argv[arg], "-sqldb", 5)) {
sqldb = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_SQL_DB;
} else if (!strncmp(argv[arg], "-sqlpassword", 5)) {
sqlpw = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_SQL_PW;
} else if (!strncmp(argv[arg], "-sqlserver", 5)) {
sqlserver = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_SQL_SERVER;
} else if (!strncmp(argv[arg], "-sqluser", 5)) {
sqluser = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_SQL_USER;
} else if (!strncmp(argv[arg], "-cvsuser", 5)) {
cvsuser = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_CVS_USER;
} else if (!strncmp(argv[arg], "-cvsdate", 5)) {
cvsdate = (arg+1 < argc && *argv[arg+1] != '-') ?
HTParseTime(argv[++arg], NULL, NO) : -1;
} else {
fprintf(stderr, "Bad Argument (%s)\n", argv[arg]);
}
} else {
fprintf(stderr, "Bad Argument (%s)\n", argv[arg]);
}
}
/* Get an SQL object */
if ((sql = HTSQL_new(sqlserver, sqluser, sqlpw, 0)) == NULL)
Cleanup(-1, sql, loginfo);
/* Connect to the SQL server */
if (HTSQL_connect(sql) != YES) Cleanup(-1, sql, loginfo);
/* Select our database */
if (HTSQL_selectDB(sql, sqldb) != YES) Cleanup(-1, sql, loginfo);
/* Create our tables */
if (create_db) createTables(sql, 0);
/* Read the arguments from stdin */
for (;;) {
int status = fread(input_buffer, 1, BUFSIZE, fin);
if (status < 0) Cleanup(-1, sql, loginfo);
if (status == 0) break;
HTChunk_putb(loginfo, (const char *) input_buffer, status);
}
/* Parse the input chunk */
{
char * ptr = HTChunk_data(loginfo);
char * noop1 = HTNextField(&ptr);
char * noop2 = HTNextField(&ptr);
char * root = HTNextField(&ptr);
char * operation = NULL;
char * files = NULL;
char * comment = NULL;
int comment_id = -1;
int user_id = -1;
char * p, * q;
#ifdef HT_REENTRANT
char *lasts; /* For strtok_r */
#endif
/* Find shared log message and get id */
if ((q = HTStrCaseStr(ptr, "\nLog Message:")) != NULL) {
comment = q+14;
*q = '\0';
}
if ((comment_id = add_comment(sql, comment)) < 0)
Cleanup(-1, sql, loginfo);
/* Add/find user and get id */
if ((user_id = add_user(sql, cvsuser)) < 0)
Cleanup(-1, sql, loginfo);
/* For each operation, find the files involved */
while ((q = HTStrCaseStr(ptr, " Files:")) != NULL) {
/* Find the operation */
files = q+9;
for (p=q; p>HTChunk_data(loginfo) && *p && *p!='\n'; p--);
p++;
operation = HTNextField(&p);
/* Find the next line */
if ((q = strchr(files, '\n')) != NULL) {
*q++ = '\0';
ptr = q;
}
/* Create the query */
if (operation && files && comment) {
char * file;
int location_id = -1;
#ifdef HT_REENTRANT
if ((file = strtok_r(files, DELIMITERS, &lasts)) != NULL) {
#else
if ((file = strtok(files, DELIMITERS)) != NULL) {
#endif /* HT_REENTRANT */
do {
char * path = NULL;
StrAllocMCopy(&path, root, "/", file, NULL);
/* Add/find location and get id */
if ((location_id = add_location(sql, path)) < 0) {
Cleanup(-1, sql, loginfo);
break;
}
#if 0
fprintf(stderr, "location: `%s\', user: `%s\', operation: `%s\', comment: `%s\'\n",
path, cvsuser, operation, comment);
#endif
/* Add log entry */
{
char buf[16384];
char * query = HTSQL_printf(buf, 16384, "insert into %s values (%u,%u,%T,%S,%u)",
DEFAULT_SQL_LOG_TABLE,
location_id,
user_id,
cvsdate,
operation,
comment_id);
if (HTSQL_query(sql, query) != YES) {
Cleanup(-1, sql, loginfo);
break;
}
}
HT_FREE(path);
#ifdef HT_REENTRANT
} while ((file = (char *) strtok_r(NULL, DELIMITERS, &lasts)) != NULL);
#else
}
while ((file = strtok(NULL, DELIMITERS)) != NULL);
#endif /* HT_REENTRANT */
}
}
}
}
return 0;
}
