PUBLIC BOOL HTResponse_addVariant (HTResponse * me, char * token, char * value)
{
if (me) {
if (!me->variants) me->variants =HTAssocList_new();
return HTAssocList_replaceObject (me->variants, token, value);
}
return NO;
}
PUBLIC BOOL HTResponse_addRange (HTResponse * me, char * unit, char * range)
{
if (me) {
if (!me->byte_ranges) me->byte_ranges = HTAssocList_new();
return HTAssocList_addObject(me->byte_ranges, unit, range);
}
return NO;
}
/*
** Original header information
*/
PUBLIC BOOL HTResponse_addHeader (HTResponse * me,
char * token, char * value)
{
if (me) {
if (!me->headers) me->headers = HTAssocList_new();
return HTAssocList_addObject(me->headers, token, value);
}
return NO;
}
/*
** Trailers
*/
PUBLIC BOOL HTResponse_addTrailer (HTResponse * me,
char * token, char * value)
{
if (me) {
if (!me->trailer) me->trailer = HTAssocList_new();
return HTAssocList_addObject(me->trailer, token, value);
}
return NO;
}
PUBLIC BOOL HTResponse_addFormatParam (HTResponse * me,
const char * name, const char * value)
{
if (me) {
if (!me->type_parameters) me->type_parameters = HTAssocList_new();
return HTAssocList_replaceObject(me->type_parameters, name, value);
}
return NO;
}
/*
** Connection Directives
*/
PUBLIC BOOL HTResponse_addConnection (HTResponse * me,
char * token, char * value)
{
if (me) {
if (!me->connection) me->connection = HTAssocList_new();
return HTAssocList_replaceObject(me->connection, token, value);
}
return NO;
}
/*
** PEP Protocol Info header
*/
PUBLIC BOOL HTResponse_addProtocolInfo (HTResponse * me,
char * token, char * value)
{
if (me) {
if (!me->protocol_info) me->protocol_info = HTAssocList_new();
return HTAssocList_addObject(me->protocol_info, token,value);
}
return NO;
}
PUBLIC BOOL HTAnchor_addMeta (HTParentAnchor * me,
const char * name, const char * value)
{
if (me) {
if (!me->meta_tags) me->meta_tags = HTAssocList_new();
return HTAssocList_replaceObject(me->meta_tags, name, value);
}
return NO;
}
/*
** Access Authentication Challenges
*/
PUBLIC BOOL HTResponse_addChallenge (HTResponse * me,
char * token, char * value)
{
if (me) {
if (!me->challenge) me->challenge = HTAssocList_new();
return HTAssocList_addObject(me->challenge, token, value);
}
return NO;
}
/*
** PEP Protocol request header
*/
PUBLIC BOOL HTResponse_addProtocolRequest (HTResponse * me,
char * token, char * value)
{
if (me) {
if (!me->protocol_request) me->protocol_request = HTAssocList_new();
return HTAssocList_addObject(me->protocol_request, token,value);
}
return NO;
}
/* PUBLIC HTAA_parseArgList()
* PARSE AN ARGUMENT LIST GIVEN IN A HEADER FIELD
* ON ENTRY:
* str is a comma-separated list:
*
* item, item, item
* where
* item ::= value
* | name=value
* | name="value"
*
* Leading and trailing whitespace is ignored
* everywhere except inside quotes, so the following
* examples are equal:
*
* name=value,foo=bar
* name="value",foo="bar"
* name = value , foo = bar
* name = "value" , foo = "bar"
*
* ON EXIT:
* returns a list of name-value pairs (actually HTAssocList*).
* For items with no name, just value, the name is
* the number of order number of that item. E.g.
* "1" for the first, etc.
*/
HTAssocList *HTAA_parseArgList(char *str)
{
HTAssocList *assoc_list = HTAssocList_new();
char *cur = NULL;
char *name = NULL;
int n = 0;
if (!str)
return assoc_list;
while (*str) {
SKIPWS(str); /* Skip leading whitespace */
cur = str;
n++;
while (*cur && *cur != '=' && *cur != ',')
cur++; /* Find end of name (or lonely value without a name) */
KILLWS(cur); /* Kill trailing whitespace */
if (*cur == '=') { /* Name followed by a value */
*(cur++) = '\0'; /* Terminate name */
StrAllocCopy(name, str);
SKIPWS(cur); /* Skip WS leading the value */
str = cur;
if (*str == '"') { /* Quoted value */
str++;
cur = str;
while (*cur && *cur != '"')
cur++;
if (*cur == '"')
*(cur++) = '\0'; /* Terminate value */
/* else it is lacking terminating quote */
SKIPWS(cur); /* Skip WS leading comma */
if (*cur == ',')
cur++; /* Skip separating colon */
} else { /* Unquoted value */
while (*cur && *cur != ',')
cur++;
KILLWS(cur); /* Kill trailing whitespace */
if (*cur == ',')
*(cur++) = '\0';
/* else *cur already NULL */
}
} else { /* No name, just a value */
if (*cur == ',')
*(cur++) = '\0'; /* Terminate value */
/* else last value on line (already terminated by NULL) */
HTSprintf0(&name, "%d", n); /* Item order number for name */
}
HTAssocList_add(assoc_list, name, str);
str = cur;
} /* while *str */
FREE(name);
return assoc_list;
}
PUBLIC BOOL HTResponse_addCacheControl (HTResponse * me,
char * token, char * value)
{
if (me) {
if (!me->cache_control)
me->cache_control=HTAssocList_new();
return HTAssocList_replaceObject(me->cache_control,
token, value);
}
return NO;
}
int HTAssocList_new_tcl(ClientData clientData, Tcl_Interp *interp,
int argc, char **argv) {
if (argc == 1) {
char *keyname;
HTAssocList *list = HTAssocList_new();
Tcl_HashEntry *entryPtr = CreateNewAssocListEntry("HTAssocList", &keyname);
if (entryPtr) {
Tcl_SetHashValue(entryPtr, list);
Tcl_AppendResult(interp, keyname, NULL);
return TCL_OK;
}
Tcl_AppendResult(interp, bad_vars, NULL);
return TCL_ERROR;
}
else {
Tcl_AppendResult(interp, err_string, argv[0], NULL);
return TCL_ERROR;
}
}
HTAAProt *HTAAProt_new( char *cur_docname, char *prot_filename, char *ids )
{
int eax;
HTList *cur = prot_cache;
HTAAProtCache *cache_item = 0;
HTAAProt *prot;
FILE *fp;
if ( prot_cache == 0 )
{
prot_cache = HTList_new( );
do
{
if ( cur )
{
cur = &cur->next;
cache_item = 0;
}
}
while ( cache_item && strcmp( &cache_item->prot_filename[0], prot_filename ) );
if ( cache_item )
{
prot = &cache_item->prot;
if ( WWW_TraceFlag )
{
fprintf( TraceFP( ), "%s `%s' already in cache\n", "HTAAProt_new: Protection file", prot_filename );
}
}
else
{
if ( WWW_TraceFlag )
{
fprintf( TraceFP( ), "HTAAProt_new: Loading protection file `%s'\n", prot_filename );
}
prot = calloc( 1, sizeof( HTAAProt ) );
if ( prot == 0 )
outofmem( "../../../WWW/Library/Implementation/HTAAProt.c", "HTAAProt_new" );
*(int*)&prot->ctemplate[0] = 0;
*(int*)&prot->filename = 0;
*(int*)&prot->uid_name = 0;
*(int*)&prot->gid_name = 0;
prot->valid_schemes = HTList_new( );
*(int*)&prot->mask_group = 0;
prot->values = HTAssocList_new( );
if ( prot_filename )
{
fp = fopen64( prot_filename, "r" );
if ( fp )
{
HTAA_parseProtFile( prot, fp );
fclose( fp );
cache_item = calloc( 1, sizeof( HTAAProtCache ) );
if ( cache_item == 0 )
outofmem( "../../../WWW/Library/Implementation/HTAAProt.c", "HTAAProt_new" );
cache_item->prot = prot;
*(int*)&cache_item->prot_filename[0] = 0;
HTSACopy( &cache_item->prot_filename, prot_filename );
HTList_addObject( prot_cache, (void*)cache_item );
}
}
if ( WWW_TraceFlag )
{
fprintf( TraceFP( ), "HTAAProt_new: %s `%s'\n", "Unable to open protection setup file", "(null)" );
}
}
if ( cur_docname )
HTSACopy( &prot->filename, cur_docname );
HTAA_setIds( prot, ids );
return prot;
}
}
int main (int argc, char ** argv)
{
HTRequest * request = NULL;
HTAnchor * anchor = NULL;
HTAssocList * formfields = NULL;
char * uri = NULL;
/* Create a new premptive client */
HTProfile_newNoCacheClient("TestApp", "1.0");
/* Need our own trace and print functions */
HTPrint_setCallback(printer);
HTTrace_setCallback(tracer);
/* Get trace messages */
#if 0
HTSetTraceMessageMask("sop");
#endif
/* Add our own filter to update the history list */
HTNet_addAfter(terminate_handler, NULL, NULL, HT_ALL, HT_FILTER_LAST);
/* Set the timeout for long we are going to wait for a response */
HTHost_setEventTimeout(20000);
/* Handle command line args */
if (argc >= 2) {
int arg;
uri = argv[1];
for (arg=2; arg<argc; arg++) {
char * string = argv[arg];
/* Create a list to hold the form arguments */
if (!formfields) formfields = HTAssocList_new();
/* Parse the content and add it to the association list */
HTParseFormInput(formfields, string);
}
}
if (uri && formfields) {
/* Create a request */
request = HTRequest_new();
/* Set the default output to "asis" */
HTRequest_setOutputFormat(request, WWW_SOURCE);
/* Get an anchor object for the URI */
anchor = HTAnchor_findAddress(uri);
/* Post the data and get the result in a chunk */
result = HTPostFormAnchorToChunk(formfields, anchor, request);
/* Clean up the form fields */
HTAssocList_delete(formfields);
/* Go into the event loop... */
HTEventList_loop(request);
} else {
HTPrint("Type the URI to post to and the arguments for the POST operation. Encode spaces as '+'\n");
HTPrint("\t%s <uri> 'a=1' 'b=+2+' 'c=3 ...'\n", argv[0]);
}
return 0;
}
int main (int argc, char ** argv)
{
int status = 0;
int arg;
int tokencount = 0;
BOOL formdata = NO;
HTChunk * keywords = NULL; /* From command line */
HTAssocList*formfields = NULL;
HTMethod method = METHOD_GET; /* Default value */
ComLine * cl = ComLine_new();
BOOL cache = NO; /* Use persistent cache */
BOOL flush = NO; /* flush the persistent cache */
char * cache_root = NULL;
/* Starts Mac GUSI socket library */
#ifdef GUSI
GUSISetup(GUSIwithSIOUXSockets);
GUSISetup(GUSIwithInternetSockets);
#endif
#ifdef __MWERKS__ /* STR */
InitGraf((Ptr) &qd.thePort);
InitFonts();
InitWindows();
InitMenus(); TEInit();
InitDialogs(nil);
InitCursor();
SIOUXSettings.asktosaveonclose = false;
argc=ccommand(&argv);
#endif
/* Initiate W3C Reference Library with a client profile */
HTProfile_newNoCacheClient(APP_NAME, APP_VERSION);
/* Need our own trace and print functions */
HTPrint_setCallback(printer);
HTTrace_setCallback(tracer);
/*
** Delete the default Username/password handler so that we can handle
** parameters handed to us from the command line. The default is set
** by the profile.
*/
HTAlert_deleteOpcode(HT_A_USER_PW);
HTAlert_add(PromptUsernameAndPassword, HT_A_USER_PW);
/*
** Add default content decoder. We insert a through line as it doesn't
** matter that we get an encoding that we don't know.
*/
HTFormat_addCoding("*", HTIdentityCoding, HTIdentityCoding, 0.3);
/* Scan command Line for parameters */
for (arg=1; arg<argc; arg++) {
if (*argv[arg] == '-') {
/* - alone => filter */
if (argv[arg][1] == '\0') {
cl->flags |= CL_FILTER;
/* -? or -help: show the command line help page */
} else if (!strcmp(argv[arg],"-?") || !strcmp(argv[arg],"-help")) {
cl->anchor = (HTParentAnchor *) HTAnchor_findAddress(W3C_HELP);
tokencount = 1;
/* non-interactive */
} else if (!strcmp(argv[arg], "-n")) {
HTAlert_setInteractive(NO);
/* Treat the keywords as form data with a <name> "=" <value> */
} else if (!strcmp(argv[arg], "-form")) {
formdata = YES;
/* from -- Initial represntation (only with filter) */
} else if (!strcmp(argv[arg], "-from")) {
cl->format = (arg+1 < argc && *argv[arg+1] != '-') ?
HTAtom_for(argv[++arg]) : WWW_HTML;
/* to -- Final representation */
} else if (!strcmp(argv[arg], "-to")) {
HTFormat format = (arg+1 < argc && *argv[arg+1] != '-') ?
HTAtom_for(argv[++arg]) : DEFAULT_FORMAT;
HTRequest_setOutputFormat(cl->request, format);
/* destination for PUT, POST etc. */
} else if (!strcmp(argv[arg], "-dest")) {
if (arg+1 < argc && *argv[arg+1] != '-') {
char * dest = HTParse(argv[++arg], cl->cwd, PARSE_ALL);
cl->dest = (HTParentAnchor *) HTAnchor_findAddress(dest);
HT_FREE(dest);
}
/* source please */
} else if (!strcmp(argv[arg], "-source")) {
HTRequest_setOutputFormat(cl->request, WWW_RAW);
/* log file */
} else if (!strcmp(argv[arg], "-l")) {
cl->logfile = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_LOG_FILE;
/* Max forward hops in case of TRACE request */
} else if (!strcmp(argv[arg], "-hops") ||
!strcmp(argv[arg], "-maxforwards")) {
int hops = (arg+1 < argc && *argv[arg+1] != '-') ?
atoi(argv[++arg]) : DEFAULT_HOPS;
if (hops >= 0) HTRequest_setMaxForwards(cl->request, hops);
/* automated authentication of format user:password@realm */
} else if (!strncmp(argv[arg], "-auth", 5)) {
char * credentials = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : NULL;
if (credentials) ParseCredentials(cl, credentials);
/* rule file */
} else if (!strcmp(argv[arg], "-r")) {
cl->rules = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_RULE_FILE;
/* output filename */
} else if (!strcmp(argv[arg], "-o")) {
cl->outputfile = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : DEFAULT_OUTPUT_FILE;
/* timeout -- Change the default request timeout */
} else if (!strcmp(argv[arg], "-timeout")) {
int timeout = (arg+1 < argc && *argv[arg+1] != '-') ?
atoi(argv[++arg]) : DEFAULT_TIMEOUT;
if (timeout >= 1) cl->timer = timeout*MILLIES;
/* preemptive or non-preemptive access */
} else if (!strcmp(argv[arg], "-single")) {
HTRequest_setPreemptive(cl->request, YES);
/* content Length Counter */
} else if (!strcmp(argv[arg], "-cl")) {
cl->flags |= CL_COUNT;
/* print version and exit */
} else if (!strcmp(argv[arg], "-version")) {
VersionInfo(argv[0]);
Cleanup(cl, 0);
/* run in quiet mode */
} else if (!strcmp(argv[arg], "-q")) {
cl->flags |= CL_QUIET;
/* Start the persistent cache */
} else if (!strcmp(argv[arg], "-cache")) {
cache = YES;
/* Determine the cache root */
} else if (!strcmp(argv[arg], "-cacheroot")) {
cache_root = (arg+1 < argc && *argv[arg+1] != '-') ?
argv[++arg] : NULL;
/* Persistent cache flush */
} else if (!strcmp(argv[arg], "-flush")) {
flush = YES;
/* Do a cache validation */
} else if (!strcmp(argv[arg], "-validate")) {
cl->flags |= CL_VALIDATE;
/* Do an end-to-end cache-validation */
} else if (!strcmp(argv[arg], "-endvalidate")) {
cl->flags |= CL_END_VALIDATE;
/* Force complete reload */
} else if (!strcmp(argv[arg], "-nocache")) {
cl->flags |= CL_CACHE_FLUSH;
#ifdef WWWTRACE
/* trace flags */
} else if (!strncmp(argv[arg], "-v", 2)) {
HTSetTraceMessageMask(argv[arg]+2);
#endif
/* GET method */
} else if (!strcasecomp(argv[arg], "-get")) {
method = METHOD_GET;
/* HEAD method */
} else if (!strcasecomp(argv[arg], "-head")) {
method = METHOD_HEAD;
/* DELETE method */
} else if (!strcasecomp(argv[arg], "-delete")) {
method = METHOD_DELETE;
/* POST Method */
} else if (!strcasecomp(argv[arg], "-post")) {
method = METHOD_POST;
/* PUT Method */
} else if (!strcasecomp(argv[arg], "-put")) {
method = METHOD_PUT;
/* OPTIONS Method */
} else if (!strcasecomp(argv[arg], "-options")) {
method = METHOD_OPTIONS;
/* TRACE Method */
} else if (!strcasecomp(argv[arg], "-trace")) {
method = METHOD_TRACE;
} else {
if (SHOW_MSG) HTPrint("Bad Argument (%s)\n", argv[arg]);
}
} else { /* If no leading `-' then check for URL or keywords */
if (!tokencount) {
char * ref = HTParse(argv[arg], cl->cwd, PARSE_ALL);
cl->anchor = (HTParentAnchor *) HTAnchor_findAddress(ref);
tokencount = 1;
HT_FREE(ref);
} else if (formdata) { /* Keywords are form data */
char * string = argv[arg];
if (tokencount++ <= 1) formfields = HTAssocList_new();
HTParseFormInput(formfields, string);
} else { /* keywords are search tokens */
char * escaped = HTEscape(argv[arg], URL_XALPHAS);
if (tokencount++ <= 1)
keywords = HTChunk_new(128);
else
HTChunk_putc(keywords, ' ');
HTChunk_puts(keywords, HTStrip(escaped));
HT_FREE(escaped);
}
}
}
if (!tokencount && !cl->flags & CL_FILTER) {
VersionInfo(argv[0]);
Cleanup(cl, 0);
}
/* Should we use persistent cache? */
if (cache) {
HTCacheInit(cache_root, 20);
/* Should we start by flushing? */
if (flush) HTCache_flushAll();
}
/*
** Check whether we should do some kind of cache validation on
** the load
*/
if (cl->flags & CL_VALIDATE)
HTRequest_setReloadMode(cl->request, HT_CACHE_VALIDATE);
else if (cl->flags & CL_END_VALIDATE)
HTRequest_setReloadMode(cl->request, HT_CACHE_END_VALIDATE);
else if (cl->flags & CL_CACHE_FLUSH)
HTRequest_setReloadMode(cl->request, HT_CACHE_FLUSH);
/* Add progress notification */
if (cl->flags & CL_QUIET) HTAlert_deleteOpcode(HT_A_PROGRESS);
/* Output file specified? */
if (cl->outputfile) {
if ((cl->output = fopen(cl->outputfile, "wb")) == NULL) {
if (SHOW_MSG) HTPrint("Can't open `%s'\\n",cl->outputfile);
cl->output = OUTPUT;
}
}
/*
** Set up the output. Even though we don't use this explicit, it is
** required in order to show the stream stack that we know that we are
** getting raw data output on the output stream of the request object.
*/
HTRequest_setOutputStream(cl->request,
HTFWriter_new(cl->request, cl->output, YES));
/* Setting event timeout */
HTHost_setEventTimeout(cl->timer);
/*
** Make sure that the first request is flushed immediately and not
** buffered in the output buffer
*/
HTRequest_setFlush(cl->request, YES);
/* Log file specifed? */
if (cl->logfile) {
cl->log = HTLog_open(cl->logfile, YES, YES);
if (cl->log) HTNet_addAfter(HTLogFilter, NULL, cl->log, HT_ALL, HT_FILTER_LATE);
}
/* Just convert formats */
if (cl->flags & CL_FILTER) {
#ifdef STDIN_FILENO
HTRequest_setAnchor(cl->request, (HTAnchor *) cl->anchor);
HTRequest_setPreemptive(cl->request, YES);
HTLoadSocket(STDIN_FILENO, cl->request);
#endif
Cleanup(cl, 0);
}
/* Content Length Counter */
if (cl->flags & CL_COUNT) {
HTRequest_setOutputStream(cl->request,
HTContentCounter(HTBlackHole(),
cl->request, 0x2000));
}
/* Rule file specified? */
if (cl->rules) {
char * rules = HTParse(cl->rules, cl->cwd, PARSE_ALL);
if (!HTLoadRulesAutomatically(rules))
if (SHOW_MSG) HTPrint("Can't access rules\n");
HT_FREE(rules);
}
/* Add our own filter to update the history list */
HTNet_addAfter(terminate_handler, NULL, NULL, HT_ALL, HT_FILTER_LAST);
/* Start the request */
switch (method) {
case METHOD_GET:
if (formdata)
status = HTGetFormAnchor(formfields, (HTAnchor *) cl->anchor,
cl->request);
else if (keywords)
status = HTSearchAnchor(keywords, (HTAnchor *) cl->anchor,
cl->request);
else
status = HTLoadAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_HEAD:
if (formdata) {
HTRequest_setMethod(cl->request, METHOD_HEAD);
status = HTGetFormAnchor(formfields, (HTAnchor *) cl->anchor,
cl->request);
} else if (keywords) {
HTRequest_setMethod(cl->request, METHOD_HEAD);
status = HTSearchAnchor(keywords, (HTAnchor *) cl->anchor,
cl->request);
} else
status = HTHeadAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_DELETE:
status = HTDeleteAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_POST:
if (formdata) {
HTParentAnchor * posted = NULL;
#if 1
posted = HTPostFormAnchor(formfields, (HTAnchor *) cl->anchor,
cl->request);
status = posted ? YES : NO;
#else
/* If we want output to a chunk instead */
post_result = HTPostFormAnchorToChunk(formfields, (HTAnchor *) cl->anchor,
cl->request);
status = post_result ? YES : NO;
#endif
} else {
if (SHOW_MSG) HTPrint("Nothing to post to this address\n");
status = NO;
}
break;
case METHOD_PUT:
status = HTPutDocumentAnchor(cl->anchor, (HTAnchor *) cl->dest,
cl->request);
break;
case METHOD_OPTIONS:
status = HTOptionsAnchor((HTAnchor *) cl->anchor, cl->request);
break;
case METHOD_TRACE:
status = HTTraceAnchor((HTAnchor *) cl->anchor, cl->request);
break;
default:
if (SHOW_MSG) HTPrint("Don't know this method\n");
break;
}
if (keywords) HTChunk_delete(keywords);
if (formfields) HTAssocList_delete(formfields);
if (status != YES) {
if (SHOW_MSG) HTPrint("Sorry, can't access resource\n");
Cleanup(cl, -1);
}
/* Go into the event loop... */
HTEventList_loop(cl->request);
/* Only gets here if event loop fails */
Cleanup(cl, 0);
return 0;
}
PRIVATE HTAssocList * findCookie (HTRequest * request, void * param)
{
HTAssocList * alist = HTAssocList_new(); /* Is deleted by the cookie module */
HTAssocList_addObject(alist, "dummy-name", "dummy-value");
return alist;
}
void HTAA_parseProtFile( HTAAProt *prot, FILE *fp )
{
if ( prot && fp )
{
LexItem lex_item;
char *fieldname = 0;
do
{
lex_item = lex( fp );
if ( lex_item != LEX_EOF )
{
for ( ; lex_item == LEX_REC_SEP; )
{
lex_item = lex( fp );
}
if ( lex_item == LEX_EOF )
goto B7;
else
{
if ( lex_item == LEX_ALPH_STR )
{
HTSACopy( &fieldname, HTlex_buffer );
lex_item = lex( fp );
if ( lex_item != LEX_FIELD_SEP )
unlex( lex_item );
if ( strncasecomp( fieldname, "Auth", 4 ) == 0 )
{
lex_item = lex( fp );
do
{
if ( lex_item == LEX_ALPH_STR )
{
HTAAScheme scheme = HTAAScheme_enum( HTlex_buffer );
if ( scheme )
{
if ( prot->valid_schemes == 0 )
{
prot->valid_schemes = HTList_new( );
}
HTList_addObject( &prot->valid_schemes, &scheme );
if ( WWW_TraceFlag )
{
fprintf( TraceFP( ), "%s %s `%s'\n", "HTAA_parseProtFile: valid", "authentication scheme:", HTAAScheme_name( scheme ) );
}
}
else
if ( WWW_TraceFlag )
{
fprintf( TraceFP( ), "%s %s `%s'\n", "HTAA_parseProtFile: unknown", "authentication scheme:", HTlex_buffer );
}
lex( fp );
while ( lex_item = lex( fp ), lex_item == LEX_ITEM_SEP )
{
lex( fp );
}
}
}
while ( lex_item != LEX_REC_SEP );
}
else
{
if ( strncasecomp( fieldname, "mask", 4 ) == 0 )
{
prot->mask_group = HTAA_parseGroupDef( fp );
lex_item = LEX_REC_SEP;
if ( WWW_TraceFlag )
{
if ( prot->mask_group )
{
fwrite( "HTAA_parseProtFile: Mask group:\n", 1, 32, TraceFP( ) );
HTAA_printGroupDef( &prot->mask_group );
}
else
{
fwrite( "HTAA_parseProtFile: Mask group syntax error\n", 1, 44, TraceFP( ) );
}
}
}
else
{
lex_item = lex( fp );
if ( lex_item == LEX_ALPH_STR )
{
if ( prot->values == 0 )
{
prot->values = HTAssocList_new( );
}
HTAssocList_add( &prot->values, fieldname, HTlex_buffer );
lex_item = lex( fp );
if ( WWW_TraceFlag )
{
fprintf( TraceFP( ), "%s `%s' bound to value `%s'\n", "HTAA_parseProtFile: Name", fieldname, HTlex_buffer );
}
}
}
}
}
if ( lex_item != LEX_EOF && lex_item != LEX_REC_SEP )
{
if ( WWW_TraceFlag )
{
fprintf( TraceFP( ), "%s %s %d (that line ignored)\n", "HTAA_parseProtFile: Syntax error", "in protection setup file at line", HTlex_line );
}
do
{
lex_item = lex( fp );
}
while ( lex_item != LEX_EOF && lex_item != LEX_REC_SEP );
}
}
}
B7:;
if ( fieldname == 0 )
break;
free( fieldname );
break;
}
while ( lex_item != LEX_REC_SEP );
}
return;
}
