/* Create new or find old parent anchor
** ------------------------------------
**
** Me one is for a reference which is found in a document, and might
** not be already loaded.
** Note: You are not guaranteed a new anchor -- you might get an old one,
** like with fonts.
*/
PUBLIC HTParentAnchor * HTAnchor_findAddress ARGS1(
CONST DocAddress *, newdoc)
{
/* Anchor tag specified ? */
CONST char *tag = HTParseAnchor(newdoc->address);
CTRACE((tfp,"Entered HTAnchor_findAddress\n"));
/*
** If the address represents a sub-anchor, we load its parent,
** then we create a named child anchor within that parent.
*/
if (*tag) {
DocAddress parsed_doc;
HTParentAnchor0 * foundParent;
HTChildAnchor * foundAnchor;
parsed_doc.address = HTParse(newdoc->address, "",
PARSE_ALL_WITHOUT_ANCHOR);
parsed_doc.post_data = newdoc->post_data;
parsed_doc.post_content_type = newdoc->post_content_type;
parsed_doc.bookmark = newdoc->bookmark;
parsed_doc.isHEAD = newdoc->isHEAD;
parsed_doc.safe = newdoc->safe;
foundParent = HTAnchor_findAddress_in_adult_table(&parsed_doc);
foundAnchor = HTAnchor_findNamedChild (foundParent, tag);
FREE(parsed_doc.address);
return HTAnchor_parent((HTAnchor *)foundParent);
}
return HTAnchor_parent((HTAnchor *)HTAnchor_findAddress_in_adult_table(newdoc));
}
// Operations
BOOL CLinks::AddLinkRelationships (HTAnchor * source)
{
ASSERT(source != NULL);
if (!m_hWnd) return FALSE;
HTParentAnchor * src = HTAnchor_parent(source);
// Update the list control with three columns
CListCtrl &ListCtrl = m_pLinkList->GetListCtrl();
int iItem = ListCtrl.GetItemCount();
int cnt;
for (cnt=0; cnt<iItem; cnt++) {
CString l_type = ListCtrl.GetItemText(cnt, 0);
CString l_dir = ListCtrl.GetItemText(cnt, 1);
CString l_dest = ListCtrl.GetItemText(cnt, 2);
if (!l_type.IsEmpty() && !l_dir.IsEmpty() && !l_dest.IsEmpty()) {
char * link_addr = HTParse(l_dest, "", PARSE_ALL);
HTParentAnchor * dest = HTAnchor_parent(HTAnchor_findAddress(link_addr));
/* Now add the new relation */
if (l_dir == "forward") {
HTLink_add((HTAnchor *) src, (HTAnchor *) dest,
(HTLinkType) HTAtom_caseFor(l_type),
METHOD_INVALID);
} else if (l_dir == "reverse") {
HTLink_add((HTAnchor *) dest, (HTAnchor *) src,
(HTLinkType) HTAtom_caseFor(l_type),
METHOD_INVALID);
} else
ASSERT(1);
}
}
return TRUE;
}
void HText_beginAnchor (HText * text, HTChildAnchor * anchor)
{
TextAnchor * a;
if (text && anchor) {
Robot * mr = (Robot *) HTRequest_context(text->request);
HTAnchor * dest = HTAnchor_followMainLink((HTAnchor *) anchor);
HTParentAnchor * dest_parent = HTAnchor_parent(dest);
char * uri = HTAnchor_address((HTAnchor *) dest_parent);
#if 0
if (SHOW_MSG) HTTrace("Robot....... Found `%s\' \n", uri ? uri : "NULL");
#endif
if (uri) {
HTList_addObject(mr->urilist, (void *) uri);
mr->count++;
}
if ((a = (TextAnchor *) HT_MALLOC(sizeof(*a))) == NULL)
HT_OUTOFMEM("HText_beginAnchor");
if (text->last_anchor) {
text->last_anchor->next = a;
} else {
text->first_anchor = a;
}
a->next = 0;
a->anchor = anchor;
text->last_anchor = a;
if (HTAnchor_followMainLink((HTAnchor*)anchor)) {
a->number = ++(text->anchors);
} else {
a->number = 0;
}
}
}
char *Reference_List (HText *text, BOOL titles)
{
char *temp = malloc(1000);
char *output = malloc(1000);
int refs = HText_sourceAnchors(text);
if (refs <= 0) {
return("\n\nThere are no references from this document.\n\n");
} else {
int cnt;
StrAllocCat(output,"\n*** References from this document ***\n");
for (cnt=1; cnt<=refs; cnt++) {
HTAnchor *dest =
HTAnchor_followMainLink((HTAnchor *)
HText_childNumber(text, cnt));
HTParentAnchor * parent = HTAnchor_parent(dest);
char * address = HTAnchor_address(dest);
const char * title = titles ? HTAnchor_title(parent) : NULL;
sprintf(temp, "[%d] ", cnt);
StrAllocCat(output, temp);
sprintf(temp, "%s\n",
(char *)(title ? title : address));
StrAllocCat(output, temp);
HT_FREE(address);
}
}
}
PUBLIC BOOL HTResponse_setRedirection (HTResponse * me, HTAnchor * anchor)
{
if (me && anchor) {
me->redirectionAnchor = (HTAnchor *) HTAnchor_parent(anchor);
return YES;
}
return NO;
}
static void print_refs(FILE *fp, BOOLEAN titles, int refs)
{
int cnt;
char *address = NULL;
const char *desc = gettext("unknown field or link");
void *helper = NULL; /* init */
for (cnt = 1; cnt <= refs; cnt++) {
HTChildAnchor *child = HText_childNextNumber(cnt, &helper);
HTAnchor *dest;
HTParentAnchor *parent;
const char *title;
if (child == 0) {
/*
* child should not be 0 unless form field numbering is on and
* cnt is the number of a form input field.
* HText_FormDescNumber() will set desc to a description of
* what type of input field this is. We'll create a
* within-document link to ensure that the link numbers on the
* list page match the numbering in the original document, but
* won't create a forward link to the form. - FM && LE
*/
if (fields_are_numbered()) {
HText_FormDescNumber(cnt, &desc);
fprintf(fp, "%4d. form field = %s\n", cnt, desc);
}
continue;
}
dest = HTAnchor_followLink(child);
/*
* Ignore if child anchor points to itself, i.e., we had something
* like <A NAME=xyz HREF="#xyz"> and it is not treated as a hidden
* link. Useful if someone 'P'rints the List Page (which isn't a
* very useful action to do, but anyway...) - kw
*/
if (dest == (HTAnchor *) child)
continue;
parent = HTAnchor_parent(dest);
title = titles ? HTAnchor_title(parent) : NULL;
address = HTAnchor_address(dest);
fprintf(fp, "%4d. %s%s\n", cnt,
((HTAnchor *) parent != dest) && title ? "in " : "",
(title ? title : address));
FREE(address);
#ifdef VMS
if (HadVMSInterrupt)
break;
#endif /* VMS */
}
}
/*
** Creates a temporary anchor that doesn't exist
*/
PUBLIC HTParentAnchor * HTTmpAnchor (HTUserProfile * up)
{
static int offset = 0; /* Just keep counting... */
HTParentAnchor * htpa = NULL;
time_t t = time(NULL);
char * tmpfile = HTGetTmpFileName(HTUserProfile_tmp(up));
char * tmpurl = HTParse(tmpfile, "file:", PARSE_ALL);
if (tmpfile && tmpurl && t >= 0) {
char * result;
if (!(result = (char *) HT_MALLOC(strlen(tmpurl)+20)))
HT_OUTOFMEM("HTTmpAnchor");
#ifdef HAVE_LONG_TIME_T
sprintf(result, "%s.%ld.%d", tmpurl, t, offset++);
#else
sprintf(result, "%s.%d.%d", tmpurl, t, offset++);
#endif
HTTRACE(APP_TRACE, "Tmp Anchor.. With location `%s\'\n" _ result);
htpa = HTAnchor_parent(HTAnchor_findAddress(result));
HT_FREE(result);
}
HT_FREE(tmpfile);
HT_FREE(tmpurl);
return htpa;
}
int main (int argc, char ** argv)
{
HTRequest * request = NULL;
HTAnchor * src = NULL;
HTAnchor * dst = NULL;
char * src_str = NULL;
char * dst_str = NULL;
BOOL status = NO;
/* Create a new premptive client */
HTProfile_newNoCacheClient("libwww-PUT", "1.0");
/* Need our own trace and print functions */
HTPrint_setCallback(printer);
HTTrace_setCallback(tracer);
/* And the traces... */
#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);
/* Handle command line args */
if (argc >= 3) {
src_str = argv[1];
dst_str = argv[2];
} else {
HTPrint("Type the URI of the source and the URI of the destination.\n");
HTPrint("\t%s <src> <dst>\n", argv[0]);
HTPrint("For example, %s http://www.w3.org http://myserver/destination.html\n",
argv[0]);
return -1;
}
if (src_str && *src_str && dst_str && *dst_str) {
/* Make source relative to where we are */
char * cwd = HTGetCurrentDirectoryURL();
char * full_src_str = HTParse(src_str, cwd, PARSE_ALL);
HTPrint("Saving %s to %s\n", full_src_str, dst_str);
/* Create a request */
request = HTRequest_new();
/* Get an anchor object for the src and dest URIs */
src = HTAnchor_findAddress(full_src_str);
dst = HTAnchor_findAddress(dst_str);
/* PUT the source to the dest */
status = HTPutDocumentAnchor(HTAnchor_parent(src), dst, request);
/* We don't need these anymore */
HT_FREE(cwd);
HT_FREE(full_src_str);
/* Go into the event loop... */
if (status == YES) HTEventList_loop(request);
}
return 0;
}
PRIVATE void HTML_start_element (HTStructured * me,
int element_number,
const BOOL * present,
const char ** value)
{
HTChildAnchor * address = NULL;
if (!me->started) {
HTextImp_build(me->text, HTEXT_BEGIN);
me->started = YES;
}
/* Look at what element was started */
switch (element_number) {
case HTML_A:
if (present[HTML_A_HREF] && value[HTML_A_HREF]) {
address = HTAnchor_findChildAndLink(
me->node_anchor, /* parent */
present[HTML_A_NAME] ? value[HTML_A_NAME] : NULL, /* Tag */
value[HTML_A_HREF], /* Addresss */
present[HTML_A_REL] && value[HTML_A_REL] ?
(HTLinkType) HTAtom_caseFor(value[HTML_A_REL]) : NULL);
if (present[HTML_A_TITLE] && value[HTML_A_TITLE]) {
HTLink * link = HTAnchor_mainLink((HTAnchor *) address);
HTParentAnchor * dest = HTAnchor_parent(HTLink_destination(link));
if (!HTAnchor_title(dest)) HTAnchor_setTitle(dest, value[HTML_A_TITLE]);
}
HTextImp_foundLink(me->text, element_number, HTML_A_HREF,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Anchor `%s\'\n" _ value[HTML_A_HREF]);
}
break;
case HTML_AREA:
if (present[HTML_AREA_HREF] && value[HTML_AREA_HREF]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_AREA_HREF], NULL);
HTextImp_foundLink(me->text, element_number, HTML_AREA_HREF,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Image map area `%s\'\n" _ value[HTML_AREA_HREF]);
}
break;
case HTML_BASE:
if (present[HTML_BASE_HREF] && value[HTML_BASE_HREF]) {
HTAnchor_setBase(me->node_anchor, (char *) value[HTML_BASE_HREF]);
HTTRACE(SGML_TRACE, "HTML Parser. New base `%s\'\n" _ value[HTML_BASE_HREF]);
}
break;
case HTML_BODY:
if (present[HTML_BODY_BACKGROUND] && value[HTML_BODY_BACKGROUND]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_BODY_BACKGROUND], NULL);
HTextImp_foundLink(me->text, element_number, HTML_BODY_BACKGROUND,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Background `%s\'\n" _ value[HTML_BODY_BACKGROUND]);
}
break;
case HTML_FORM:
if (present[HTML_FORM_ACTION] && value[HTML_FORM_ACTION]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_FORM_ACTION], NULL);
HTextImp_foundLink(me->text, element_number, HTML_FORM_ACTION,
address, present, value);
}
break;
case HTML_FRAME:
if (present[HTML_FRAME_SRC] && value[HTML_FRAME_SRC]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_FRAME_SRC], NULL);
HTextImp_foundLink(me->text, element_number, HTML_FRAME_SRC,
address, present, value);
HTTRACE(SGML_TRACE, "HTML Parser. Frame `%s\'\n" _ value[HTML_FRAME_SRC]);
}
break;
case HTML_INPUT:
if (present[HTML_INPUT_SRC] && value[HTML_INPUT_SRC]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_INPUT_SRC], NULL);
HTextImp_foundLink(me->text, element_number, HTML_INPUT_SRC,
address, present, value);
}
break;
case HTML_IMG:
if (present[HTML_IMG_SRC] && value[HTML_IMG_SRC]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_IMG_SRC], NULL);
HTextImp_foundLink(me->text, element_number, HTML_IMG_SRC,
address, present, value);
}
break;
case HTML_ISINDEX:
HTAnchor_setIndex(me->node_anchor);
break;
case HTML_LINK:
if (present[HTML_LINK_HREF] && value[HTML_LINK_HREF]) {
HTParentAnchor * dest = NULL;
address = HTAnchor_findChildAndLink(
me->node_anchor, /* parent */
present[HTML_A_NAME] ? value[HTML_A_NAME] : NULL, /* Tag */
present[HTML_A_HREF] ? value[HTML_A_HREF] : NULL, /* Addresss */
NULL); /* Rels */
dest = HTAnchor_parent(HTAnchor_followMainLink((HTAnchor *) address));
/* If forward reference */
if ((present[HTML_LINK_REL] && value[HTML_LINK_REL])) {
char * strval = NULL;
char * ptr = NULL;
char * relation = NULL;
StrAllocCopy(strval, value[HTML_LINK_REL]);
ptr = strval;
while ((relation = HTNextLWSToken(&ptr)) != NULL) {
HTLink_add((HTAnchor *) me->node_anchor, (HTAnchor *) dest,
(HTLinkType) HTAtom_caseFor(relation),
METHOD_INVALID);
}
HT_FREE(strval);
}
/* If reverse reference */
if ((present[HTML_LINK_REV] && value[HTML_LINK_REV])) {
char * strval = NULL;
char * ptr = NULL;
char * relation = NULL;
StrAllocCopy(strval, value[HTML_LINK_REV]);
ptr = strval;
while ((relation = HTNextLWSToken(&ptr)) != NULL) {
HTLink_add((HTAnchor *) dest, (HTAnchor *) me->node_anchor,
(HTLinkType) HTAtom_caseFor(relation),
METHOD_INVALID);
}
HT_FREE(strval);
}
/* If we got any type information as well */
if (present[HTML_LINK_TYPE] && value[HTML_LINK_TYPE]) {
if (HTAnchor_format(dest) == WWW_UNKNOWN)
HTAnchor_setFormat(dest,
(HTFormat) HTAtom_caseFor(value[HTML_LINK_TYPE]));
}
/* Call out to the layout engine */
HTextImp_foundLink(me->text, element_number, HTML_LINK_HREF,
address, present, value);
}
break;
case HTML_META:
if (present[HTML_META_NAME] && value[HTML_META_NAME]) {
HTAnchor_addMeta (me->node_anchor,
value[HTML_META_NAME],
(present[HTML_META_CONTENT] && value[HTML_META_CONTENT]) ?
value[HTML_META_CONTENT] : "");
}
break;
case HTML_OBJECT:
if (present[HTML_OBJECT_CLASSID] && value[HTML_OBJECT_CLASSID]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_CLASSID], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_CLASSID,
address, present, value);
}
if (present[HTML_OBJECT_CODEBASE] && value[HTML_OBJECT_CODEBASE]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_CODEBASE], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_CODEBASE,
address, present, value);
}
if (present[HTML_OBJECT_DATA] && value[HTML_OBJECT_DATA]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_DATA], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_DATA,
address, present, value);
}
if (present[HTML_OBJECT_ARCHIVE] && value[HTML_OBJECT_ARCHIVE]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_ARCHIVE], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_ARCHIVE,
address, present, value);
}
if (present[HTML_OBJECT_USEMAP] && value[HTML_OBJECT_USEMAP]) {
address = HTAnchor_findChildAndLink(me->node_anchor, NULL,
value[HTML_OBJECT_USEMAP], NULL);
HTextImp_foundLink(me->text, element_number, HTML_OBJECT_USEMAP,
address, present, value);
}
break;
case HTML_PRE:
if (me->comment_end)
HTextImp_addText(me->text, me->comment_end, strlen(me->comment_end));
break;
case HTML_TITLE:
HTChunk_truncate(me->title,0);
break;
}
/* Update our parse stack */
if (SGML_findTagContents(me->dtd, element_number) != SGML_EMPTY) {
if (me->sp == me->stack) {
HTTRACE(SGML_TRACE, "HTML Parser. Maximum nesting of %d exceded!\n" _ MAX_NESTING);
me->overflow++;
return;
}
--(me->sp);
me->sp[0] = element_number;
}
/* Call out to the layout engine */
HTextImp_beginElement(me->text, element_number, present, value);
}
int showlist(DocInfo *newdoc, BOOLEAN titles)
{
int cnt;
int refs, hidden_links;
static char tempfile[LY_MAXPATH];
static BOOLEAN last_titles = TRUE;
FILE *fp0;
char *Address = NULL, *Title = NULL, *cp = NULL;
char *LinkTitle = NULL; /* Rel stored as property of link, not of dest */
BOOLEAN intern_w_post = FALSE;
const char *desc = "unknown field or link";
void *helper;
refs = HText_sourceAnchors(HTMainText);
hidden_links = HText_HiddenLinkCount(HTMainText);
if (refs <= 0 && hidden_links > 0 &&
LYHiddenLinks != HIDDENLINKS_SEPARATE) {
HTUserMsg(NO_VISIBLE_REFS_FROM_DOC);
return (-1);
}
if (refs <= 0 && hidden_links <= 0) {
HTUserMsg(NO_REFS_FROM_DOC);
return (-1);
}
if ((fp0 = InternalPageFP(tempfile, titles == last_titles)) == 0)
return (-1);
LYLocalFileToURL(&(newdoc->address), tempfile);
LYRegisterUIPage(newdoc->address,
titles ? UIP_LIST_PAGE : UIP_ADDRLIST_PAGE);
last_titles = titles;
LYforce_HTML_mode = TRUE; /* force this file to be HTML */
LYforce_no_cache = TRUE; /* force this file to be new */
#ifdef EXP_ADDRLIST_PAGE
if (titles != TRUE)
BeginInternalPage(fp0, ADDRLIST_PAGE_TITLE, LIST_PAGE_HELP);
else
#endif
BeginInternalPage(fp0, LIST_PAGE_TITLE, LIST_PAGE_HELP);
StrAllocCopy(Address, HTLoadedDocumentURL());
LYEntify(&Address, FALSE);
fprintf(fp0, "%s%s<p>\n", gettext("References in "),
(non_empty(Address)
? Address
: gettext("this document:")));
FREE(Address);
if (refs > 0) {
fprintf(fp0, "<%s compact>\n", ((keypad_mode == NUMBERS_AS_ARROWS) ?
"ol" : "ul"));
if (hidden_links > 0)
fprintf(fp0, "<lh><em>%s</em>\n", gettext("Visible links:"));
}
if (hidden_links > 0) {
if (LYHiddenLinks == HIDDENLINKS_IGNORE)
hidden_links = 0;
}
helper = NULL; /* init */
for (cnt = 1; cnt <= refs; cnt++) {
HTChildAnchor *child = HText_childNextNumber(cnt, &helper);
HTAnchor *dest_intl = NULL;
HTAnchor *dest;
HTParentAnchor *parent;
char *address;
const char *title;
if (child == 0) {
/*
* child should not be 0 unless form field numbering is on and cnt
* is the number of a form input field. HText_FormDescNumber()
* will set desc to a description of what type of input field this
* is. We'll list it to ensure that the link numbers on the list
* page match the numbering in the original document, but won't
* create a forward link to the form. - FM && LE
*
* Changed to create a fake hidden link, to get the numbering right
* in connection with always treating this file as
* HIDDENLINKS_MERGE in GridText.c - kw
*/
if (fields_are_numbered()) {
HText_FormDescNumber(cnt, &desc);
fprintf(fp0,
"<li><a id=%d href=\"#%d\">form field</a> = <em>%s</em>\n",
cnt, cnt, desc);
}
continue;
}
#ifndef DONT_TRACK_INTERNAL_LINKS
dest_intl = HTAnchor_followTypedLink(child, HTInternalLink);
#endif
dest = dest_intl ?
dest_intl : HTAnchor_followLink(child);
parent = HTAnchor_parent(dest);
if (!intern_w_post && dest_intl &&
HTMainAnchor &&
HTMainAnchor->post_data &&
parent->post_data &&
BINEQ(HTMainAnchor->post_data, parent->post_data)) {
/*
* Set flag to note that we had at least one internal link, if the
* document from which we are generating the list has associated
* POST data; after an extra check that the link destination really
* has the same POST data so that we can believe it is an internal
* link.
*/
intern_w_post = TRUE;
}
address = HTAnchor_address(dest);
title = titles ? HTAnchor_title(parent) : NULL;
if (dest_intl) {
HTSprintf0(&LinkTitle, "(internal)");
} else if (titles && child->type &&
dest == child->dest &&
!strncmp(HTAtom_name(child->type),
"RelTitle: ", 10)) {
HTSprintf0(&LinkTitle, "(%s)", HTAtom_name(child->type) + 10);
} else {
FREE(LinkTitle);
}
StrAllocCopy(Address, address);
FREE(address);
LYEntify(&Address, TRUE);
if (non_empty(title)) {
LYformTitle(&Title, title);
LYEntify(&Title, TRUE);
if (*Title) {
cp = findPoundSelector(Address);
} else {
FREE(Title);
}
}
fprintf(fp0, "<li><a href=\"%s\"%s>%s%s%s%s%s</a>\n", Address,
dest_intl ? " TYPE=\"internal link\"" : "",
NonNull(LinkTitle),
((HTAnchor *) parent != dest) && Title ? "in " : "",
(char *) (Title ? Title : Address),
(Title && cp) ? " - " : "",
(Title && cp) ? (cp + 1) : "");
FREE(Address);
FREE(Title);
}
FREE(LinkTitle);
if (hidden_links > 0) {
if (refs > 0)
fprintf(fp0, "\n</%s>\n\n<p>\n",
((keypad_mode == NUMBERS_AS_ARROWS) ?
"ol" : "ul"));
fprintf(fp0, "<%s compact>\n", ((keypad_mode == NUMBERS_AS_ARROWS) ?
"ol continue" : "ul"));
fprintf(fp0, "<lh><em>%s</em>\n", gettext("Hidden links:"));
}
for (cnt = 0; cnt < hidden_links; cnt++) {
StrAllocCopy(Address, HText_HiddenLinkAt(HTMainText, cnt));
LYEntify(&Address, FALSE);
if (isEmpty(Address)) {
FREE(Address);
continue;
}
fprintf(fp0, "<li><a href=\"%s\">%s</a>\n", Address, Address);
FREE(Address);
}
fprintf(fp0, "\n</%s>\n", ((keypad_mode == NUMBERS_AS_ARROWS) ?
"ol" : "ul"));
EndInternalPage(fp0);
LYCloseTempFP(fp0);
/*
* Make necessary changes to newdoc before returning to caller. If the
* intern_w_post flag is set, we keep the POST data in newdoc that have
* been passed in. They should be the same as in the loaded document for
* which we generated the list. In that case the file we have written will
* be associated with the same POST data when it is loaded after we are
* done here, so that following one of the links we have marked as
* "internal link" can lead back to the underlying document with the right
* address+post_data combination. - kw
*/
if (intern_w_post) {
newdoc->internal_link = TRUE;
} else {
LYFreePostData(newdoc);
newdoc->internal_link = FALSE;
}
newdoc->isHEAD = FALSE;
newdoc->safe = FALSE;
return (0);
}
BOOL CWinComDoc::SaveDocument()
{
CRequest * request = new CRequest(this);
HTAnchor * source = NULL;
HTAnchor * destination = NULL;
// Create the source anchor
char * src = HTParse(m_Location.m_source, m_cwd, PARSE_ALL);
source = HTAnchor_findAddress(src);
HT_FREE(src);
/* If destination is not http://... then error */
if (!m_Location.m_destination.IsEmpty()) {
char * access = HTParse(m_Location.m_destination, "", PARSE_ACCESS);
if (strcasecomp(access, "http")) {
CString strMessage;
AfxFormatString1(strMessage, IDS_CANNOT_WRITE_TO_DESTINATION, m_Location.m_destination);
AfxMessageBox(strMessage);
HT_FREE(access);
return FALSE;
} else {
char * dest = HTParse(m_Location.m_destination, m_cwd, PARSE_ALL);
destination = HTAnchor_findAddress(dest);
HT_FREE(dest);
HT_FREE(access);
}
}
// Do we have any metadata to set up?
{
HTParentAnchor * source_parent = HTAnchor_parent(source);
if (!m_EntityInfo.m_mediaType.IsEmpty()) {
HTAnchor_setFormat(source_parent, HTAtom_for(m_EntityInfo.m_mediaType));
}
if (!m_EntityInfo.m_contentEncoding.IsEmpty()) {
HTAnchor_deleteEncodingAll(source_parent);
HTAnchor_addEncoding(source_parent, HTAtom_for(m_EntityInfo.m_contentEncoding));
}
if (!m_EntityInfo.m_charset.IsEmpty()) {
HTAnchor_setCharset(source_parent, HTAtom_for(m_EntityInfo.m_charset));
}
if (!m_EntityInfo.m_language.IsEmpty()) {
HTAnchor_deleteLanguageAll(source_parent);
HTAnchor_addLanguage(source_parent, HTAtom_for(m_EntityInfo.m_language));
}
}
// Do we have any link relationships to set up?
m_Links.AddLinkRelationships(source);
/* Start the request */
if (m_detectVersionConflict) {
char * etag = HTAnchor_etag(HTAnchor_parent(destination));
if (etag) {
request->PutDocument(source, destination, HT_MATCH_THIS);
} else {
request->PutDocumentWithPrecheck(source, destination);
}
} else {
request->PutDocument(source, destination, HT_NO_MATCH);
}
return TRUE;
}
/****************************************************************************
* name: HtLoadHTTPANN (PRIVATE)
* purpose: Issue a command to a group annotation server.
* inputs:
* - char *arg:
* - char *data:
* - int len:
* - char *com:
* returns:
*
* remarks:
*
****************************************************************************/
static int
HtLoadHTTPANN(char *arg, char *data, int len, char *com)
{
int s; /* Socket number for returned data */
char *command; /* The whole command */
int status; /* tcp return */
SockA soc_address; /* Binary network address */
SockA *sin = &soc_address;
char *tptr;
int fmt, compressed;
int command_len;
HTParentAnchor *anchor;
/*
* Set up defaults:
*/
#ifdef DECNET
sin->sdn_family = AF_DECnet; /* Family = DECnet, host order */
sin->sdn_objnum = DNP_OBJ; /* Default: http object number */
#else /* Internet */
sin->sin_family = AF_INET; /* Family = internet, host order */
sin->sin_port = htons(TCP_PORT); /* Default: http port */
#endif
tptr = HTParse(arg, "", PARSE_HOST);
status = HTParseInet(sin, tptr);
free(tptr);
if (status)
{
return(status);
}
/*
* Now, let's get a socket set up from the server for the data.
*/
#ifdef DECNET
s = socket(AF_DECnet, SOCK_STREAM, 0);
#else
s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#endif
status = connect
(s, (struct sockaddr*)&soc_address,sizeof(soc_address));
if (status < 0)
{
return(HTInetStatus("connect"));
}
/* If there's an anchor at this point, leave it in. */
tptr = HTParse(arg, "", PARSE_PATH|PARSE_PUNCTUATION|PARSE_ANCHOR);
#ifndef DISABLE_TRACE
if (srcTrace) {
fprintf(stderr, "HTParse(%s) returns:\n\t(%s)\n", arg, tptr);
}
#endif
command_len = strlen(com) + strlen(tptr);
command = malloc(command_len + len + 1);
if (command == NULL) outofmem(__FILE__, "HTLoadHTTP");
strcpy(command, com);
strcat(command, tptr);
if (len != 0)
{
char *bptr;
bptr = (char *)(command + command_len);
/* bcopy(data, bptr, len);*/
memcpy(bptr, data, len);
command_len += len;
}
else
{
command_len++;
}
free(tptr);
status = NETWRITE(s, command, command_len);
free(command);
if (status < 0)
{
return(HTInetStatus("send"));
}
tptr = HTParse(arg, "",
PARSE_ACCESS | PARSE_HOST | PARSE_PATH |
PARSE_PUNCTUATION);
#if 0
/* fmt = HTFileFormat (tptr, WWW_HTML, &compressed); */
fmt = WWW_HTML;
anchor = HTAnchor_parent(HTAnchor_findAddress(arg));
HTParseFormat(fmt, anchor, s, 0);
#endif
free(tptr);
status = NETCLOSE(s);
return(HT_LOADED);
}
