| 1 |
/* |
| 2 |
* $LynxId: HTWAIS.c,v 1.43 2025/01/07 22:56:37 tom Exp $ |
| 3 |
* |
| 4 |
* WorldWideWeb - Wide Area Information Server Access HTWAIS.c |
| 5 |
* ================================================== |
| 6 |
* |
| 7 |
* This module allows a WWW server or client to read data from a |
| 8 |
* remote WAIS |
| 9 |
* server, and provide that data to a WWW client in hypertext form. |
| 10 |
* Source files, once retrieved, are stored and used to provide |
| 11 |
* information about the index when that is accessed. |
| 12 |
* |
| 13 |
* Authors |
| 14 |
* BK Brewster Kahle, Thinking Machines, <[email protected]> |
| 15 |
* TBL Tim Berners-Lee, CERN <[email protected]> |
| 16 |
* FM Foteos Macrides, WFEB <[email protected]> |
| 17 |
* |
| 18 |
* History |
| 19 |
* Sep 91 TBL adapted shell-ui.c (BK) with HTRetrieve.c from WWW. |
| 20 |
* Feb 91 TBL Generated HTML cleaned up a bit (quotes, escaping) |
| 21 |
* Refers to lists of sources. |
| 22 |
* Mar 93 TBL Lib 2.0 compatible module made. |
| 23 |
* May 94 FM Added DIRECT_WAIS support for VMS. |
| 24 |
* |
| 25 |
* Bugs |
| 26 |
* Uses C stream i/o to read and write sockets, which won't work |
| 27 |
* on VMS TCP systems. |
| 28 |
* |
| 29 |
* Should cache connections. |
| 30 |
* |
| 31 |
* ANSI C only as written |
| 32 |
* |
| 33 |
* Bugs fixed |
| 34 |
* NT Nathan Torkington ([email protected]) |
| 35 |
* |
| 36 |
* WAIS comments: |
| 37 |
* |
| 38 |
* 1. Separate directories for different system's .o would help |
| 39 |
* 2. Document ids are rather long! |
| 40 |
* |
| 41 |
* W WW Address mapping convention: |
| 42 |
* |
| 43 |
* /servername/database/type/length/document-id |
| 44 |
* |
| 45 |
* /servername/database?word+word+word |
| 46 |
*/ |
| 47 |
/* WIDE AREA INFORMATION SERVER SOFTWARE: |
| 48 |
No guarantees or restrictions. See the readme file for the full standard |
| 49 |
disclaimer. |
| 50 |
|
| 51 |
[email protected] |
| 52 |
*/ |
| 53 |
|
| 54 |
#include <HTUtils.h> |
| 55 |
#include <HTParse.h> |
| 56 |
#include <HTAccess.h> /* We implement a protocol */ |
| 57 |
#include <HTML.h> /* The object we will generate */ |
| 58 |
#include <HTWSRC.h> |
| 59 |
#include <HTTCP.h> |
| 60 |
#include <HTCJK.h> |
| 61 |
#include <HTAlert.h> |
| 62 |
#include <LYStrings.h> |
| 63 |
|
| 64 |
#undef lines /* term.h conflict with wais.h */ |
| 65 |
#undef alloca /* alloca.h conflict with wais.h */ |
| 66 |
|
| 67 |
/* From WAIS |
| 68 |
* --------- |
| 69 |
*/ |
| 70 |
#ifdef VMS |
| 71 |
#include <HTVMS_WaisUI.h> |
| 72 |
#include <HTVMS_WaisProt.h> |
| 73 |
#elif defined(HAVE_WAIS_H) |
| 74 |
#include <wais.h> |
| 75 |
#else |
| 76 |
#include <ui.h> |
| 77 |
#endif /* VMS */ |
| 78 |
|
| 79 |
#define MAX_MESSAGE_LEN 100000 |
| 80 |
#define CHARS_PER_PAGE 10000 /* number of chars retrieved in each request */ |
| 81 |
|
| 82 |
#define WAISSEARCH_DATE "Fri Jul 19 1991" |
| 83 |
|
| 84 |
/* FROM WWW |
| 85 |
* -------- |
| 86 |
*/ |
| 87 |
#include <LYUtils.h> |
| 88 |
#include <LYLeaks.h> |
| 89 |
|
| 90 |
#define DIRECTORY "/cnidr.org:210/directory-of-servers" |
| 91 |
/* #define DIRECTORY "/quake.think.com:210/directory-of-servers" */ |
| 92 |
|
| 93 |
#define BIG 1024 /* identifier size limit @@@@@ */ |
| 94 |
|
| 95 |
#define BUFFER_SIZE 4096 /* Arbitrary size for efficiency */ |
| 96 |
|
| 97 |
#define HEX_ESCAPE '%' |
| 98 |
|
| 99 |
static BOOL as_gate; /* Client is using us as gateway */ |
| 100 |
|
| 101 |
static char line[2048]; /* For building strings to display */ |
| 102 |
|
| 103 |
/* Must be able to take id */ |
| 104 |
|
| 105 |
#define PUTC(c) (*target->isa->put_character)(target, c) |
| 106 |
#define PUTS(s) (*target->isa->put_string)(target, s) |
| 107 |
#define START(e) (*target->isa->start_element)(target, e, 0, 0, -1, 0) |
| 108 |
#define END(e) (*target->isa->end_element)(target, e, 0) |
| 109 |
#define MAYBE_END(e) if (HTML_dtd.tags[e].contents != SGML_EMPTY) \ |
| 110 |
(*target->isa->end_element)(target, e, 0) |
| 111 |
#define FREE_TARGET (*target->isa->_free)(target) |
| 112 |
|
| 113 |
struct _HTStructured { |
| 114 |
const HTStructuredClass *isa; |
| 115 |
/* ... */ |
| 116 |
}; |
| 117 |
|
| 118 |
/* ------------------------------------------------------------------------ */ |
| 119 |
/* ---------------- Local copy of connect_to_server calls ----------------- */ |
| 120 |
/* ------------------------------------------------------------------------ */ |
| 121 |
/* Returns 1 on success, 0 on fail, -1 on interrupt. */ |
| 122 |
static int fd_mosaic_connect_to_server(char *host_name, |
| 123 |
long port, |
| 124 |
long *fd) |
| 125 |
{ |
| 126 |
char *dummy = NULL; |
| 127 |
int status; |
| 128 |
int result; |
| 129 |
|
| 130 |
HTSprintf0(&dummy, "%s//%s:%ld/", STR_WAIS_URL, host_name, port); |
| 131 |
|
| 132 |
status = HTDoConnect(dummy, "WAIS", 210, (int *) fd); |
| 133 |
if (status == HT_INTERRUPTED) { |
| 134 |
result = -1; |
| 135 |
} else if (status < 0) { |
| 136 |
result = 0; |
| 137 |
} else { |
| 138 |
result = 1; |
| 139 |
} |
| 140 |
FREE(dummy); |
| 141 |
return result; |
| 142 |
} |
| 143 |
|
| 144 |
/* Returns 1 on success, 0 on fail, -1 on interrupt. */ |
| 145 |
#ifdef VMS |
| 146 |
static int mosaic_connect_to_server(char *host_name, |
| 147 |
long port, |
| 148 |
long *fdp) |
| 149 |
#else |
| 150 |
static int mosaic_connect_to_server(char *host_name, |
| 151 |
long port, |
| 152 |
FILE **fp) |
| 153 |
#endif /* VMS */ |
| 154 |
{ |
| 155 |
#ifndef VMS |
| 156 |
FILE *file; |
| 157 |
#endif /* VMS */ |
| 158 |
long fd; |
| 159 |
int rv; |
| 160 |
|
| 161 |
rv = fd_mosaic_connect_to_server(host_name, port, &fd); |
| 162 |
if (rv == 0) { |
| 163 |
HTAlert(gettext("Could not connect to WAIS server.")); |
| 164 |
return 0; |
| 165 |
} else if (rv == -1) { |
| 166 |
HTAlert(CONNECTION_INTERRUPTED); |
| 167 |
return -1; |
| 168 |
} |
| 169 |
#ifndef VMS |
| 170 |
if ((file = fdopen(fd, "r+")) == NULL) { |
| 171 |
HTAlert(gettext("Could not open WAIS connection for reading.")); |
| 172 |
return 0; |
| 173 |
} |
| 174 |
|
| 175 |
*fp = file; |
| 176 |
#else |
| 177 |
*fdp = fd; |
| 178 |
#endif /* VMS */ |
| 179 |
return 1; |
| 180 |
} |
| 181 |
/* ------------------------------------------------------------------------ */ |
| 182 |
/* ------------------------------------------------------------------------ */ |
| 183 |
|
| 184 |
/* showDiags |
| 185 |
*/ |
| 186 |
/* modified from Jonny G's version in ui/question.c */ |
| 187 |
static void showDiags(HTStream *target, diagnosticRecord ** d) |
| 188 |
{ |
| 189 |
long i; |
| 190 |
|
| 191 |
for (i = 0; d[i] != NULL; i++) { |
| 192 |
if (d[i]->ADDINFO != NULL) { |
| 193 |
PUTS(gettext("Diagnostic code is ")); |
| 194 |
PUTS(d[i]->DIAG); |
| 195 |
PUTC(' '); |
| 196 |
PUTS(d[i]->ADDINFO); |
| 197 |
PUTC('\n'); |
| 198 |
} |
| 199 |
} |
| 200 |
} |
| 201 |
|
| 202 |
/* Matrix of allowed characters in filenames |
| 203 |
* ----------------------------------------- |
| 204 |
*/ |
| 205 |
|
| 206 |
static BOOL acceptable[256]; |
| 207 |
static BOOL acceptable_inited = NO; |
| 208 |
|
| 209 |
static void init_acceptable(void) |
| 210 |
{ |
| 211 |
unsigned int i; |
| 212 |
char *good = |
| 213 |
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./-_$"; |
| 214 |
|
| 215 |
for (i = 0; i < 256; i++) |
| 216 |
acceptable[i] = NO; |
| 217 |
for (; *good; good++) |
| 218 |
acceptable[(unsigned int) *good] = YES; |
| 219 |
acceptable_inited = YES; |
| 220 |
} |
| 221 |
|
| 222 |
/* Transform file identifier into WWW address |
| 223 |
* ------------------------------------------ |
| 224 |
* |
| 225 |
* |
| 226 |
* On exit, |
| 227 |
* returns nil if error |
| 228 |
* pointer to malloced string (must be freed) if ok |
| 229 |
*/ |
| 230 |
static char *WWW_from_archie(char *file) |
| 231 |
{ |
| 232 |
char *end; |
| 233 |
char *result; |
| 234 |
char *colon; |
| 235 |
|
| 236 |
for (end = file; *end > ' '; end++) ; /* assumes ASCII encoding */ |
| 237 |
result = (char *) malloc(10 + (end - file)); |
| 238 |
if (!result) |
| 239 |
return result; /* Malloc error */ |
| 240 |
strcpy(result, "file://"); |
| 241 |
StrNCat(result, file, end - file); |
| 242 |
colon = StrChr(result + 7, ':'); /* Expect colon after host */ |
| 243 |
if (colon) { |
| 244 |
for (; colon[0]; colon[0] = colon[1], colon++) ; /* move down */ |
| 245 |
} |
| 246 |
return result; |
| 247 |
} /* WWW_from_archie */ |
| 248 |
|
| 249 |
/* Transform document identifier into URL |
| 250 |
* -------------------------------------- |
| 251 |
* |
| 252 |
* Bugs: A static buffer of finite size is used! |
| 253 |
* The format of the docid MUST be good! |
| 254 |
* |
| 255 |
* On exit, |
| 256 |
* returns nil if error |
| 257 |
* pointer to malloced string (must be freed) if ok |
| 258 |
*/ |
| 259 |
static char hex[17] = "0123456789ABCDEF"; |
| 260 |
|
| 261 |
static char *WWW_from_WAIS(any *docid) |
| 262 |
{ |
| 263 |
static char buf[BIG]; |
| 264 |
char *q = buf; |
| 265 |
char *p = (docid->bytes); |
| 266 |
char *result = NULL; |
| 267 |
int i, l; |
| 268 |
|
| 269 |
if (TRACE) { |
| 270 |
char *p2; |
| 271 |
|
| 272 |
fprintf(tfp, "WAIS id (%d bytes) is ", (int) docid->size); |
| 273 |
for (p2 = docid->bytes; p2 < docid->bytes + docid->size; p2++) { |
| 274 |
if ((*p2 >= ' ') && (*p2 <= '~')) /* Assume ASCII! */ |
| 275 |
fprintf(tfp, "%c", *p2); |
| 276 |
else |
| 277 |
fprintf(tfp, "<%x>", (unsigned) *p2); |
| 278 |
} |
| 279 |
fprintf(tfp, "\n"); |
| 280 |
} |
| 281 |
for (p = docid->bytes; |
| 282 |
(p < docid->bytes + docid->size) && (q < &buf[BIG]);) { |
| 283 |
CTRACE((tfp, " Record type %d, length %d\n", p[0], p[1])); |
| 284 |
if (*p > 10) { |
| 285 |
CTRACE((tfp, "Eh? DOCID record type of %d!\n", *p)); |
| 286 |
return 0; |
| 287 |
} { /* Bug fix -- allow any byte value 15 Apr 93 */ |
| 288 |
unsigned int i2 = (unsigned) *p++; |
| 289 |
|
| 290 |
if (i2 > 99) { |
| 291 |
*q++ = (i2 / 100) + '0'; |
| 292 |
i2 = i2 % 100; |
| 293 |
} |
| 294 |
if (i2 > 9) { |
| 295 |
*q++ = (i2 / 10) + '0'; |
| 296 |
i2 = i2 % 10; |
| 297 |
} |
| 298 |
*q++ = i2 + '0'; /* Record type */ |
| 299 |
} |
| 300 |
*q++ = '='; /* Separate */ |
| 301 |
l = *p++; /* Length */ |
| 302 |
for (i = 0; i < l; i++, p++) { |
| 303 |
if (!acceptable[UCH(*p)]) { |
| 304 |
*q++ = HEX_ESCAPE; /* Means hex coming */ |
| 305 |
*q++ = hex[(*p) >> 4]; |
| 306 |
*q++ = hex[(*p) & 15]; |
| 307 |
} else |
| 308 |
*q++ = *p; |
| 309 |
} |
| 310 |
*q++ = ';'; /* Terminate field */ |
| 311 |
} |
| 312 |
*q++ = 0; /* Terminate string */ |
| 313 |
CTRACE((tfp, "WWW form of id: %s\n", buf)); |
| 314 |
StrAllocCopy(result, buf); |
| 315 |
return result; |
| 316 |
} /* WWW_from_WAIS */ |
| 317 |
|
| 318 |
/* Transform URL into WAIS document identifier |
| 319 |
* ------------------------------------------- |
| 320 |
* |
| 321 |
* On entry, |
| 322 |
* docname points to valid name produced originally by |
| 323 |
* WWW_from_WAIS |
| 324 |
* On exit, |
| 325 |
* docid->size is valid |
| 326 |
* docid->bytes is malloced and must later be freed. |
| 327 |
*/ |
| 328 |
static any *WAIS_from_WWW(any *docid, char *docname) |
| 329 |
{ |
| 330 |
char *z; /* Output pointer */ |
| 331 |
char *sor; /* Start of record - points to size field. */ |
| 332 |
char *p; /* Input pointer */ |
| 333 |
char *q; /* Position of "=" */ |
| 334 |
char *s; /* Position of semicolon */ |
| 335 |
int n; /* size */ |
| 336 |
|
| 337 |
CTRACE((tfp, "WWW id (to become WAIS id): %s\n", docname)); |
| 338 |
for (n = 0, p = docname; *p; p++) { /* Count sizes of strings */ |
| 339 |
n++; |
| 340 |
if (*p == ';') |
| 341 |
n--; /* Not converted */ |
| 342 |
else if (*p == HEX_ESCAPE) |
| 343 |
n = n - 2; /* Save two bytes */ |
| 344 |
docid->size = n; |
| 345 |
} |
| 346 |
|
| 347 |
if (!(docid->bytes = (char *) malloc(docid->size))) /* result record */ |
| 348 |
outofmem(__FILE__, "WAIS_from_WWW"); |
| 349 |
z = docid->bytes; |
| 350 |
|
| 351 |
for (p = docname; *p;) { /* Convert of strings */ |
| 352 |
/* Record type */ |
| 353 |
|
| 354 |
*z = 0; /* Initialize record type */ |
| 355 |
while (*p >= '0' && *p <= '9') { |
| 356 |
*z = *z * 10 + (*p++ - '0'); /* Decode decimal record type */ |
| 357 |
} |
| 358 |
z++; |
| 359 |
if (*p != '=') |
| 360 |
return 0; |
| 361 |
q = p; |
| 362 |
|
| 363 |
s = StrChr(q, ';'); /* (Check only) */ |
| 364 |
if (!s) |
| 365 |
return 0; /* Bad! No ';'; */ |
| 366 |
sor = z; /* Remember where the size field was */ |
| 367 |
z++; /* Skip record size for now */ |
| 368 |
for (p = q + 1; *p != ';';) { |
| 369 |
if (*p == HEX_ESCAPE) { |
| 370 |
char c; |
| 371 |
unsigned int b; |
| 372 |
|
| 373 |
p++; |
| 374 |
c = *p++; |
| 375 |
b = from_hex(c); |
| 376 |
c = *p++; |
| 377 |
if (!c) |
| 378 |
break; /* Odd number of chars! */ |
| 379 |
*z++ = (b << 4) + from_hex(c); |
| 380 |
} else { |
| 381 |
*z++ = *p++; /* Record */ |
| 382 |
} |
| 383 |
} |
| 384 |
*sor = (z - sor - 1); /* Fill in size -- not counting size itself */ |
| 385 |
p++; /* After semicolon: start of next record */ |
| 386 |
} |
| 387 |
|
| 388 |
if (TRACE) { |
| 389 |
char *p2; |
| 390 |
|
| 391 |
fprintf(tfp, "WAIS id (%d bytes) is ", (int) docid->size); |
| 392 |
for (p2 = docid->bytes; p2 < docid->bytes + docid->size; p2++) { |
| 393 |
if ((*p2 >= ' ') && (*p2 <= '~')) /* Assume ASCII! */ |
| 394 |
fprintf(tfp, "%c", *p2); |
| 395 |
else |
| 396 |
fprintf(tfp, "<%x>", (unsigned) *p2); |
| 397 |
} |
| 398 |
fprintf(tfp, "\n"); |
| 399 |
} |
| 400 |
return docid; /* Ok */ |
| 401 |
|
| 402 |
} /* WAIS_from_WWW */ |
| 403 |
|
| 404 |
/* Send a plain text record to the client output_text_record() |
| 405 |
* -------------------------------------- |
| 406 |
*/ |
| 407 |
static void output_text_record(HTStream *target, |
| 408 |
WAISDocumentText *record, |
| 409 |
boolean binary) |
| 410 |
{ |
| 411 |
unsigned long count; |
| 412 |
|
| 413 |
/* printf(" Text\n"); |
| 414 |
print_any(" DocumentID: ", record->DocumentID); |
| 415 |
printf(" VersionNumber: %d\n", record->VersionNumber); |
| 416 |
*/ |
| 417 |
|
| 418 |
if (binary) { |
| 419 |
(*target->isa->put_block) (target, |
| 420 |
record->DocumentText->bytes, |
| 421 |
record->DocumentText->size); |
| 422 |
return; |
| 423 |
} |
| 424 |
|
| 425 |
for (count = 0; count < record->DocumentText->size; count++) { |
| 426 |
long ch = (unsigned char) record->DocumentText->bytes[count]; |
| 427 |
|
| 428 |
if (ch == 27) { /* What is this in for? Tim */ |
| 429 |
/* then we have an escape code */ |
| 430 |
/* if the next letter is '(' or ')', then ignore two letters */ |
| 431 |
if ('(' == record->DocumentText->bytes[count + 1] || |
| 432 |
')' == record->DocumentText->bytes[count + 1]) |
| 433 |
count += 1; /* it is a term marker */ |
| 434 |
else |
| 435 |
count += 4; /* it is a paragraph marker */ |
| 436 |
} else if (ch == '\n' || ch == '\r') { |
| 437 |
PUTC('\n'); |
| 438 |
} else if (IS_CJK_TTY || ch == '\t' || isprint(ch)) { |
| 439 |
PUTC(ch); |
| 440 |
} |
| 441 |
} |
| 442 |
} /* output text record */ |
| 443 |
|
| 444 |
/* Format A Search response for the client display_search_response |
| 445 |
* --------------------------------------- |
| 446 |
*/ |
| 447 |
/* modified from tracy shen's version in wutil.c |
| 448 |
* displays either a text record or a set of headlines. |
| 449 |
*/ |
| 450 |
static void display_search_response(HTStructured * target, SearchResponseAPDU *response, |
| 451 |
char *the_database, |
| 452 |
char *keywords) |
| 453 |
{ |
| 454 |
WAISSearchResponse *info; |
| 455 |
long i, k; |
| 456 |
|
| 457 |
BOOL archie = strstr(the_database, "archie") != 0; /* Special handling */ |
| 458 |
|
| 459 |
CTRACE((tfp, "HTWAIS: Displaying search response\n")); |
| 460 |
PUTS(gettext("Index ")); |
| 461 |
START(HTML_EM); |
| 462 |
PUTS(the_database); |
| 463 |
END(HTML_EM); |
| 464 |
sprintf(line, LY_MSG(" contains the following %d item%s relevant to \""), |
| 465 |
(int) (response->NumberOfRecordsReturned), |
| 466 |
response->NumberOfRecordsReturned == 1 ? "" : "s"); |
| 467 |
PUTS(line); |
| 468 |
START(HTML_EM); |
| 469 |
PUTS(keywords); |
| 470 |
END(HTML_EM); |
| 471 |
PUTS("\".\n"); |
| 472 |
PUTS(gettext("The first figure after each entry is its relative score, ")); |
| 473 |
PUTS(gettext("the second is the number of lines in the item.")); |
| 474 |
START(HTML_BR); |
| 475 |
START(HTML_BR); |
| 476 |
PUTC('\n'); |
| 477 |
START(HTML_OL); |
| 478 |
|
| 479 |
if (response->DatabaseDiagnosticRecords != 0) { |
| 480 |
info = (WAISSearchResponse *) response->DatabaseDiagnosticRecords; |
| 481 |
i = 0; |
| 482 |
|
| 483 |
if (info->Diagnostics != NULL) |
| 484 |
showDiags((HTStream *) target, info->Diagnostics); |
| 485 |
|
| 486 |
if (info->DocHeaders != 0) { |
| 487 |
for (k = 0; info->DocHeaders[k] != 0; k++) { |
| 488 |
WAISDocumentHeader *head = info->DocHeaders[k]; |
| 489 |
char *headline = trim_junk(head->Headline); |
| 490 |
any *docid = head->DocumentID; |
| 491 |
char *docname; /* printable version of docid */ |
| 492 |
|
| 493 |
i++; |
| 494 |
/* |
| 495 |
* Make a printable string out of the document id. |
| 496 |
*/ |
| 497 |
CTRACE((tfp, "HTWAIS: %2ld: Score: %4ld, lines:%4ld '%s'\n", |
| 498 |
i, |
| 499 |
(long int) (info->DocHeaders[k]->Score), |
| 500 |
(long int) (info->DocHeaders[k]->Lines), |
| 501 |
headline)); |
| 502 |
|
| 503 |
START(HTML_LI); |
| 504 |
|
| 505 |
if (archie) { |
| 506 |
char *www_name = WWW_from_archie(headline); |
| 507 |
|
| 508 |
if (www_name) { |
| 509 |
HTStartAnchor(target, NULL, www_name); |
| 510 |
PUTS(headline); |
| 511 |
END(HTML_A); |
| 512 |
FREE(www_name); |
| 513 |
} else { |
| 514 |
PUTS(headline); |
| 515 |
PUTS(gettext(" (bad file name)")); |
| 516 |
} |
| 517 |
} else { /* Not archie */ |
| 518 |
docname = WWW_from_WAIS(docid); |
| 519 |
if (docname) { |
| 520 |
if ((head->Types) && |
| 521 |
(!strcmp(head->Types[0], "URL"))) { |
| 522 |
HTStartAnchor(target, NULL, headline); |
| 523 |
} else { |
| 524 |
char *dbname = HTEscape(the_database, URL_XPALPHAS); |
| 525 |
char *w3_address = NULL; |
| 526 |
|
| 527 |
HTSprintf0(&w3_address, |
| 528 |
"/%s/%s/%d/%s", |
| 529 |
dbname, |
| 530 |
head->Types ? head->Types[0] : "TEXT", |
| 531 |
(int) (head->DocumentLength), |
| 532 |
docname); |
| 533 |
HTStartAnchor(target, NULL, w3_address); |
| 534 |
FREE(w3_address); |
| 535 |
FREE(dbname); |
| 536 |
} |
| 537 |
PUTS(headline); |
| 538 |
END(HTML_A); |
| 539 |
FREE(docname); |
| 540 |
} else { |
| 541 |
PUTS(gettext("(bad doc id)")); |
| 542 |
} |
| 543 |
} |
| 544 |
|
| 545 |
sprintf(line, "%5ld %5ld ", |
| 546 |
head->Score, |
| 547 |
head->Lines); |
| 548 |
PUTS(line); |
| 549 |
MAYBE_END(HTML_LI); |
| 550 |
} /* next document header */ |
| 551 |
} |
| 552 |
/* if there were any document headers */ |
| 553 |
if (info->ShortHeaders != 0) { |
| 554 |
k = 0; |
| 555 |
while (info->ShortHeaders[k] != 0) { |
| 556 |
i++; |
| 557 |
PUTS(gettext("(Short Header record, can't display)")); |
| 558 |
} |
| 559 |
} |
| 560 |
if (info->LongHeaders != 0) { |
| 561 |
k = 0; |
| 562 |
while (info->LongHeaders[k] != 0) { |
| 563 |
i++; |
| 564 |
PUTS(gettext("\nLong Header record, can't display\n")); |
| 565 |
} |
| 566 |
} |
| 567 |
if (info->Text != 0) { |
| 568 |
k = 0; |
| 569 |
while (info->Text[k] != 0) { |
| 570 |
i++; |
| 571 |
PUTS(gettext("\nText record\n")); |
| 572 |
output_text_record((HTStream *) target, |
| 573 |
info->Text[k++], false); |
| 574 |
} |
| 575 |
} |
| 576 |
if (info->Headlines != 0) { |
| 577 |
k = 0; |
| 578 |
while (info->Headlines[k] != 0) { |
| 579 |
i++; |
| 580 |
PUTS(gettext("\nHeadline record, can't display\n")); |
| 581 |
/* dsply_headline_record( info->Headlines[k++]); */ |
| 582 |
} |
| 583 |
} |
| 584 |
if (info->Codes != 0) { |
| 585 |
k = 0; |
| 586 |
while (info->Codes[k] != 0) { |
| 587 |
i++; |
| 588 |
PUTS(gettext("\nCode record, can't display\n")); |
| 589 |
/* dsply_code_record( info->Codes[k++]); */ |
| 590 |
} |
| 591 |
} |
| 592 |
} /* Loop: display user info */ |
| 593 |
END(HTML_OL); |
| 594 |
PUTC('\n'); |
| 595 |
} |
| 596 |
|
| 597 |
/* Load by name HTLoadWAIS |
| 598 |
* ============ |
| 599 |
* |
| 600 |
* This renders any object or search as required. |
| 601 |
*/ |
| 602 |
int HTLoadWAIS(const char *arg, |
| 603 |
HTParentAnchor *anAnchor, |
| 604 |
HTFormat format_out, |
| 605 |
HTStream *sink) |
| 606 |
#define MAX_KEYWORDS_LENGTH 1000 |
| 607 |
#define MAX_SERVER_LENGTH 1000 |
| 608 |
#define MAX_DATABASE_LENGTH 1000 |
| 609 |
#define MAX_SERVICE_LENGTH 1000 |
| 610 |
#define MAXDOCS 200 |
| 611 |
|
| 612 |
{ |
| 613 |
char *key; /* pointer to keywords in URL */ |
| 614 |
char *request_message = NULL; /* arbitrary message limit */ |
| 615 |
char *response_message = NULL; /* arbitrary message limit */ |
| 616 |
long request_buffer_length; /* how of the request is left */ |
| 617 |
SearchResponseAPDU *retrieval_response = 0; |
| 618 |
char keywords[MAX_KEYWORDS_LENGTH + 1]; |
| 619 |
char *the_server_name; |
| 620 |
char *wais_database = NULL; /* name of current database */ |
| 621 |
char *www_database; /* Same name escaped */ |
| 622 |
char *service; |
| 623 |
char *doctype; |
| 624 |
char *doclength; |
| 625 |
long document_length = 0; |
| 626 |
char *docname = 0; |
| 627 |
|
| 628 |
#ifdef VMS |
| 629 |
long connection = 0; |
| 630 |
|
| 631 |
#else |
| 632 |
FILE *connection = NULL; |
| 633 |
#endif /* VMS */ |
| 634 |
char *names; /* Copy of arg to be hacked up */ |
| 635 |
BOOL ok = NO; |
| 636 |
int return_status = HT_LOADED; |
| 637 |
int rv; |
| 638 |
|
| 639 |
if (!acceptable_inited) |
| 640 |
init_acceptable(); |
| 641 |
|
| 642 |
/* Decipher and check syntax of WWW address: |
| 643 |
* ---------------------------------------- |
| 644 |
* |
| 645 |
* First we remove the "wais:" if it was specified. 920110 |
| 646 |
*/ |
| 647 |
names = HTParse(arg, "", PARSE_HOST | PARSE_PATH | PARSE_PUNCTUATION); |
| 648 |
key = StrChr(names, '?'); |
| 649 |
|
| 650 |
if (key) { |
| 651 |
char *p; |
| 652 |
|
| 653 |
*key++ = 0; /* Split off keywords */ |
| 654 |
for (p = key; *p; p++) |
| 655 |
if (*p == '+') |
| 656 |
*p = ' '; |
| 657 |
HTUnEscape(key); |
| 658 |
} |
| 659 |
if (names[0] == '/') { |
| 660 |
the_server_name = names + 1; |
| 661 |
if ((as_gate = (*the_server_name == '/')) != 0) |
| 662 |
the_server_name++; /* Accept one or two */ |
| 663 |
www_database = StrChr(the_server_name, '/'); |
| 664 |
if (www_database) { |
| 665 |
*www_database++ = 0; /* Separate database name */ |
| 666 |
doctype = StrChr(www_database, '/'); |
| 667 |
if (key) |
| 668 |
ok = YES; /* Don't need doc details */ |
| 669 |
else if (doctype) { /* If not search parse doc details */ |
| 670 |
*doctype++ = 0; /* Separate rest of doc address */ |
| 671 |
doclength = StrChr(doctype, '/'); |
| 672 |
if (doclength) { |
| 673 |
*doclength++ = 0; |
| 674 |
document_length = atol(doclength); |
| 675 |
if (document_length) { |
| 676 |
docname = StrChr(doclength, '/'); |
| 677 |
if (docname) { |
| 678 |
*docname++ = 0; |
| 679 |
ok = YES; /* To avoid a goto! */ |
| 680 |
} /* if docname */ |
| 681 |
} /* if document_length valid */ |
| 682 |
} /* if doclength */ |
| 683 |
} else { /* no doctype? Assume index required */ |
| 684 |
if (!key) |
| 685 |
key = ""; |
| 686 |
ok = YES; |
| 687 |
} /* if doctype */ |
| 688 |
} /* if database */ |
| 689 |
} |
| 690 |
|
| 691 |
if (!ok) |
| 692 |
return HTLoadError(sink, 500, gettext("Syntax error in WAIS URL")); |
| 693 |
|
| 694 |
CTRACE((tfp, "HTWAIS: Parsed OK\n")); |
| 695 |
|
| 696 |
service = StrChr(names, ':'); |
| 697 |
if (service) |
| 698 |
*service++ = 0; |
| 699 |
else |
| 700 |
service = "210"; |
| 701 |
|
| 702 |
if (the_server_name[0] == 0) { |
| 703 |
#ifdef VMS |
| 704 |
connection = 0; |
| 705 |
#else |
| 706 |
connection = NULL; |
| 707 |
#endif /* VMS */ |
| 708 |
|
| 709 |
} else if (!(key && !*key)) { |
| 710 |
int status; |
| 711 |
|
| 712 |
CTRACE((tfp, "===WAIS=== calling mosaic_connect_to_server\n")); |
| 713 |
status = mosaic_connect_to_server(the_server_name, |
| 714 |
atoi(service), |
| 715 |
&connection); |
| 716 |
if (status == 0) { |
| 717 |
CTRACE((tfp, "===WAIS=== connection failed\n")); |
| 718 |
FREE(names); |
| 719 |
return HT_NOT_LOADED; |
| 720 |
} else if (status == -1) { |
| 721 |
CTRACE((tfp, "===WAIS=== connection interrupted\n")); |
| 722 |
FREE(names); |
| 723 |
return HT_NOT_LOADED; |
| 724 |
} |
| 725 |
} |
| 726 |
|
| 727 |
StrAllocCopy(wais_database, www_database); |
| 728 |
HTUnEscape(wais_database); |
| 729 |
|
| 730 |
/* |
| 731 |
* This below fixed size stuff is terrible. |
| 732 |
*/ |
| 733 |
#ifdef VMS |
| 734 |
if ((request_message = typecallocn(char, MAX_MESSAGE_LEN)) == 0) |
| 735 |
outofmem(__FILE__, "HTLoadWAIS"); |
| 736 |
if ((response_message = typecallocn(char, MAX_MESSAGE_LEN)) == 0) |
| 737 |
outofmem(__FILE__, "HTLoadWAIS"); |
| 738 |
|
| 739 |
#else |
| 740 |
request_message = (char *) s_malloc((size_t) MAX_MESSAGE_LEN * sizeof(char)); |
| 741 |
response_message = (char *) s_malloc((size_t) MAX_MESSAGE_LEN * sizeof(char)); |
| 742 |
#endif /* VMS */ |
| 743 |
|
| 744 |
/* |
| 745 |
* If keyword search is performed but there are no keywords, the user has |
| 746 |
* followed a link to the index itself. It would be appropriate at this |
| 747 |
* point to send him the .SRC file - how? |
| 748 |
*/ |
| 749 |
if (key && !*key) { /* I N D E X */ |
| 750 |
#ifdef CACHE_FILE_PREFIX |
| 751 |
char *filename = NULL; |
| 752 |
FILE *fp; |
| 753 |
#endif |
| 754 |
HTStructured *target = HTML_new(anAnchor, format_out, sink); |
| 755 |
|
| 756 |
START(HTML_HEAD); |
| 757 |
PUTC('\n'); |
| 758 |
HTStartIsIndex(target, HTWAIS_SOLICIT_QUERY, NULL); |
| 759 |
PUTC('\n'); |
| 760 |
|
| 761 |
{ |
| 762 |
START(HTML_TITLE); |
| 763 |
PUTS(wais_database); |
| 764 |
PUTS(gettext(" (WAIS Index)")); |
| 765 |
END(HTML_TITLE); |
| 766 |
PUTC('\n'); |
| 767 |
END(HTML_HEAD); |
| 768 |
PUTC('\n'); |
| 769 |
|
| 770 |
START(HTML_H1); |
| 771 |
PUTS(gettext("WAIS Index: ")); |
| 772 |
START(HTML_EM); |
| 773 |
PUTS(wais_database); |
| 774 |
END(HTML_EM); |
| 775 |
END(HTML_H1); |
| 776 |
PUTC('\n'); |
| 777 |
PUTS(gettext("This is a link for searching the ")); |
| 778 |
START(HTML_EM); |
| 779 |
PUTS(wais_database); |
| 780 |
END(HTML_EM); |
| 781 |
PUTS(gettext(" WAIS Index.\n")); |
| 782 |
|
| 783 |
} |
| 784 |
/* |
| 785 |
* If we have seen a source file for this database, use that. |
| 786 |
*/ |
| 787 |
#ifdef CACHE_FILE_PREFIX |
| 788 |
HTSprintf0(&filename, "%sWSRC-%s:%s:%.100s.txt", |
| 789 |
CACHE_FILE_PREFIX, |
| 790 |
the_server_name, service, www_database); |
| 791 |
|
| 792 |
fp = fopen(filename, "r"); /* Have we found this already? */ |
| 793 |
CTRACE((tfp, "HTWAIS: Description of server %s %s.\n", |
| 794 |
filename, |
| 795 |
fp ? "exists already" : "does NOT exist!")); |
| 796 |
|
| 797 |
if (fp) { |
| 798 |
char c; |
| 799 |
|
| 800 |
START(HTML_PRE); /* Preformatted description */ |
| 801 |
PUTC('\n'); |
| 802 |
while ((c = getc(fp)) != EOF) |
| 803 |
PUTC(c); /* Transfer file */ |
| 804 |
END(HTML_PRE); |
| 805 |
fclose(fp); |
| 806 |
} |
| 807 |
FREE(filename); |
| 808 |
#endif |
| 809 |
START(HTML_P); |
| 810 |
PUTS(gettext("\nEnter the 's'earch command and then specify search words.\n")); |
| 811 |
|
| 812 |
FREE_TARGET; |
| 813 |
} else if (key) { /* S E A R C H */ |
| 814 |
char *p; |
| 815 |
HTStructured *target; |
| 816 |
|
| 817 |
LYStrNCpy(keywords, key, MAX_KEYWORDS_LENGTH); |
| 818 |
while ((p = StrChr(keywords, '+')) != 0) |
| 819 |
*p = ' '; |
| 820 |
|
| 821 |
/* |
| 822 |
* Send advance title to get something fast to the other end. |
| 823 |
*/ |
| 824 |
target = HTML_new(anAnchor, format_out, sink); |
| 825 |
|
| 826 |
START(HTML_HEAD); |
| 827 |
PUTC('\n'); |
| 828 |
HTStartIsIndex(target, HTWAIS_SOLICIT_QUERY, NULL); |
| 829 |
PUTC('\n'); |
| 830 |
START(HTML_TITLE); |
| 831 |
PUTS(keywords); |
| 832 |
PUTS(gettext(" (in ")); |
| 833 |
PUTS(wais_database); |
| 834 |
PUTC(')'); |
| 835 |
END(HTML_TITLE); |
| 836 |
PUTC('\n'); |
| 837 |
END(HTML_HEAD); |
| 838 |
PUTC('\n'); |
| 839 |
|
| 840 |
START(HTML_H1); |
| 841 |
PUTS(gettext("WAIS Search of \"")); |
| 842 |
START(HTML_EM); |
| 843 |
PUTS(keywords); |
| 844 |
END(HTML_EM); |
| 845 |
PUTS(gettext("\" in: ")); |
| 846 |
START(HTML_EM); |
| 847 |
PUTS(wais_database); |
| 848 |
END(HTML_EM); |
| 849 |
END(HTML_H1); |
| 850 |
PUTC('\n'); |
| 851 |
|
| 852 |
request_buffer_length = MAX_MESSAGE_LEN; /* Amount left */ |
| 853 |
CTRACE((tfp, "HTWAIS: Search for `%s' in `%s'\n", |
| 854 |
keywords, wais_database)); |
| 855 |
if (NULL == |
| 856 |
generate_search_apdu(request_message + HEADER_LENGTH, |
| 857 |
&request_buffer_length, |
| 858 |
keywords, wais_database, NULL, MAXDOCS)) { |
| 859 |
#ifdef VMS |
| 860 |
HTAlert(gettext("HTWAIS: Request too large.")); |
| 861 |
return_status = HT_NOT_LOADED; |
| 862 |
FREE_TARGET; |
| 863 |
goto CleanUp; |
| 864 |
#else |
| 865 |
panic("request too large"); |
| 866 |
#endif /* VMS */ |
| 867 |
} |
| 868 |
|
| 869 |
HTProgress(gettext("Searching WAIS database...")); |
| 870 |
rv = interpret_message(request_message, |
| 871 |
MAX_MESSAGE_LEN - request_buffer_length, |
| 872 |
response_message, |
| 873 |
MAX_MESSAGE_LEN, |
| 874 |
connection, |
| 875 |
false /* true verbose */ |
| 876 |
); |
| 877 |
|
| 878 |
if (rv == HT_INTERRUPTED) { |
| 879 |
HTAlert(gettext("Search interrupted.")); |
| 880 |
return_status = HT_INTERRUPTED; |
| 881 |
FREE_TARGET; |
| 882 |
goto CleanUp; |
| 883 |
} else if (!rv) { |
| 884 |
#ifdef VMS |
| 885 |
HTAlert(HTWAIS_MESSAGE_TOO_BIG); |
| 886 |
return_status = HT_NOT_LOADED; |
| 887 |
FREE_TARGET; |
| 888 |
goto CleanUp; |
| 889 |
#else |
| 890 |
panic("returned message too large"); |
| 891 |
#endif /* VMS */ |
| 892 |
} else { /* returned message ok */ |
| 893 |
SearchResponseAPDU *query_response = 0; |
| 894 |
|
| 895 |
readSearchResponseAPDU(&query_response, |
| 896 |
response_message + HEADER_LENGTH); |
| 897 |
display_search_response(target, |
| 898 |
query_response, wais_database, keywords); |
| 899 |
if (query_response->DatabaseDiagnosticRecords) |
| 900 |
freeWAISSearchResponse(query_response->DatabaseDiagnosticRecords); |
| 901 |
freeSearchResponseAPDU(query_response); |
| 902 |
} /* returned message not too large */ |
| 903 |
FREE_TARGET; |
| 904 |
} else { /* D O C U M E N T F E T C H */ |
| 905 |
HTFormat format_in; |
| 906 |
boolean binary; /* how to transfer stuff coming over */ |
| 907 |
HTStream *target; |
| 908 |
long count; |
| 909 |
any doc_chunk; |
| 910 |
any *docid = &doc_chunk; |
| 911 |
|
| 912 |
CTRACE((tfp, |
| 913 |
"HTWAIS: Retrieve document id `%s' type `%s' length %ld\n", |
| 914 |
NonNull(docname), doctype, document_length)); |
| 915 |
|
| 916 |
format_in = |
| 917 |
!strcmp(doctype, "WSRC") ? HTAtom_for("application/x-wais-source") : |
| 918 |
!strcmp(doctype, "TEXT") ? HTAtom_for(STR_PLAINTEXT) : |
| 919 |
!strcmp(doctype, "HTML") ? HTAtom_for(STR_HTML) : |
| 920 |
!strcmp(doctype, "GIF") ? HTAtom_for("image/gif") : |
| 921 |
HTAtom_for(STR_BINARY); |
| 922 |
binary = |
| 923 |
0 != strcmp(doctype, "WSRC") && |
| 924 |
0 != strcmp(doctype, "TEXT") && |
| 925 |
0 != strcmp(doctype, "HTML"); |
| 926 |
|
| 927 |
target = HTStreamStack(format_in, format_out, sink, anAnchor); |
| 928 |
if (!target) |
| 929 |
return HTLoadError(sink, 500, |
| 930 |
gettext("Can't convert format of WAIS document")); |
| 931 |
/* |
| 932 |
* Decode hex or literal format for document ID. |
| 933 |
*/ |
| 934 |
WAIS_from_WWW(docid, docname); |
| 935 |
|
| 936 |
/* |
| 937 |
* Loop over slices of the document. |
| 938 |
*/ |
| 939 |
for (count = 0; |
| 940 |
count * CHARS_PER_PAGE < document_length; |
| 941 |
count++) { |
| 942 |
#ifdef VMS |
| 943 |
char *type = NULL; |
| 944 |
|
| 945 |
StrAllocCopy(type, doctype); |
| 946 |
#else |
| 947 |
char *type = s_strdup(doctype); /* Gets freed I guess */ |
| 948 |
#endif /* VMS */ |
| 949 |
request_buffer_length = MAX_MESSAGE_LEN; /* Amount left */ |
| 950 |
CTRACE((tfp, "HTWAIS: Slice number %ld\n", count)); |
| 951 |
|
| 952 |
if (HTCheckForInterrupt()) { |
| 953 |
HTAlert(TRANSFER_INTERRUPTED); |
| 954 |
(*target->isa->_abort) (target, NULL); |
| 955 |
#ifdef VMS |
| 956 |
FREE(type); |
| 957 |
#endif /* VMS */ |
| 958 |
return_status = HT_NOT_LOADED; |
| 959 |
goto CleanUp; |
| 960 |
} |
| 961 |
|
| 962 |
if (0 == |
| 963 |
generate_retrieval_apdu(request_message + HEADER_LENGTH, |
| 964 |
&request_buffer_length, |
| 965 |
docid, |
| 966 |
CT_byte, |
| 967 |
count * CHARS_PER_PAGE, |
| 968 |
(((count + 1) * CHARS_PER_PAGE <= document_length) |
| 969 |
? (count + 1) * CHARS_PER_PAGE |
| 970 |
: document_length), |
| 971 |
type, |
| 972 |
wais_database)) { |
| 973 |
#ifdef VMS |
| 974 |
HTAlert(gettext("HTWAIS: Request too long.")); |
| 975 |
return_status = HT_NOT_LOADED; |
| 976 |
FREE_TARGET; |
| 977 |
FREE(type); |
| 978 |
FREE(docid->bytes); |
| 979 |
goto CleanUp; |
| 980 |
#else |
| 981 |
panic("request too long"); |
| 982 |
#endif /* VMS */ |
| 983 |
} |
| 984 |
|
| 985 |
/* |
| 986 |
* Actually do the transaction given by request_message. |
| 987 |
*/ |
| 988 |
HTProgress(gettext("Fetching WAIS document...")); |
| 989 |
rv = interpret_message(request_message, |
| 990 |
MAX_MESSAGE_LEN - request_buffer_length, |
| 991 |
response_message, |
| 992 |
MAX_MESSAGE_LEN, |
| 993 |
connection, |
| 994 |
false /* true verbose */ |
| 995 |
); |
| 996 |
if (rv == HT_INTERRUPTED) { |
| 997 |
HTAlert(TRANSFER_INTERRUPTED); |
| 998 |
return_status = HT_INTERRUPTED; |
| 999 |
FREE_TARGET; |
| 1000 |
FREE(type); |
| 1001 |
FREE(docid->bytes); |
| 1002 |
goto CleanUp; |
| 1003 |
} else if (!rv) { |
| 1004 |
#ifdef VMS |
| 1005 |
HTAlert(HTWAIS_MESSAGE_TOO_BIG); |
| 1006 |
return_status = HT_NOT_LOADED; |
| 1007 |
FREE_TARGET; |
| 1008 |
FREE(type); |
| 1009 |
FREE(docid->bytes); |
| 1010 |
goto CleanUp; |
| 1011 |
#else |
| 1012 |
panic("Returned message too large"); |
| 1013 |
#endif /* VMS */ |
| 1014 |
} |
| 1015 |
|
| 1016 |
/* |
| 1017 |
* Parse the result which came back into memory. |
| 1018 |
*/ |
| 1019 |
readSearchResponseAPDU(&retrieval_response, |
| 1020 |
response_message + HEADER_LENGTH); |
| 1021 |
|
| 1022 |
if (NULL == |
| 1023 |
((WAISSearchResponse *) |
| 1024 |
retrieval_response->DatabaseDiagnosticRecords)->Text) { |
| 1025 |
/* display_search_response(target, retrieval_response, |
| 1026 |
wais_database, keywords); */ |
| 1027 |
PUTS(gettext("No text was returned!\n")); |
| 1028 |
/* panic("No text was returned"); */ |
| 1029 |
} else { |
| 1030 |
output_text_record(target, |
| 1031 |
((WAISSearchResponse *) |
| 1032 |
retrieval_response->DatabaseDiagnosticRecords)->Text[0], |
| 1033 |
binary); |
| 1034 |
} /* If text existed */ |
| 1035 |
|
| 1036 |
#ifdef VMS |
| 1037 |
FREE(type); |
| 1038 |
#endif /* VMS */ |
| 1039 |
} /* Loop over slices */ |
| 1040 |
|
| 1041 |
FREE_TARGET; |
| 1042 |
FREE(docid->bytes); |
| 1043 |
|
| 1044 |
freeWAISSearchResponse(retrieval_response->DatabaseDiagnosticRecords); |
| 1045 |
freeSearchResponseAPDU(retrieval_response); |
| 1046 |
|
| 1047 |
} /* If document rather than search */ |
| 1048 |
|
| 1049 |
CleanUp: |
| 1050 |
/* |
| 1051 |
* (This postponed until later, after a timeout:) |
| 1052 |
*/ |
| 1053 |
#ifdef VMS |
| 1054 |
if (connection) |
| 1055 |
NETCLOSE((int) connection); |
| 1056 |
#else |
| 1057 |
if (connection) |
| 1058 |
fclose(connection); |
| 1059 |
#endif /* VMS */ |
| 1060 |
FREE(wais_database); |
| 1061 |
#ifdef VMS |
| 1062 |
FREE(request_message); |
| 1063 |
FREE(response_message); |
| 1064 |
#else |
| 1065 |
s_free(request_message); |
| 1066 |
s_free(response_message); |
| 1067 |
#endif /* VMS */ |
| 1068 |
FREE(names); |
| 1069 |
return (return_status); |
| 1070 |
} |
| 1071 |
|
| 1072 |
#ifdef GLOBALDEF_IS_MACRO |
| 1073 |
#define _HTWAIS_C_1_INIT { "wais", HTLoadWAIS, NULL } |
| 1074 |
GLOBALDEF(HTProtocol, HTWAIS, _HTWAIS_C_1_INIT); |
| 1075 |
#else |
| 1076 |
GLOBALDEF HTProtocol HTWAIS = |
| 1077 |
{"wais", HTLoadWAIS, NULL}; |
| 1078 |
#endif /* GLOBALDEF_IS_MACRO */ |