/* PUBLIC HTAAScheme_enum()
* TRANSLATE SCHEME NAME INTO
* A SCHEME ENUMERATION
*
* ON ENTRY:
* name is a string representing the scheme name.
*
* ON EXIT:
* returns the enumerated constant for that scheme.
*/
HTAAScheme HTAAScheme_enum(const char *name)
{
char *upcased = NULL;
if (!name)
return HTAA_UNKNOWN;
StrAllocCopy(upcased, name);
LYUpperCase(upcased);
if (!StrNCmp(upcased, "NONE", 4)) {
FREE(upcased);
return HTAA_NONE;
} else if (!StrNCmp(upcased, "BASIC", 5)) {
FREE(upcased);
return HTAA_BASIC;
} else if (!StrNCmp(upcased, "PUBKEY", 6)) {
FREE(upcased);
return HTAA_PUBKEY;
} else if (!StrNCmp(upcased, "KERBEROSV4", 10)) {
FREE(upcased);
return HTAA_KERBEROS_V4;
} else if (!StrNCmp(upcased, "KERBEROSV5", 10)) {
FREE(upcased);
return HTAA_KERBEROS_V5;
} else {
FREE(upcased);
return HTAA_UNKNOWN;
}
}
I64 KMCompare(U8 *e1,U8 *e2)
{
I64 i;
U8 *ee1,*ee2,ch1,ch2;
Bool e1_shift=FALSE,e2_shift=FALSE;
if (e1) {
if (e2) {
while (*e1==CH_SPACE)
e1++;
while (*e2==CH_SPACE)
e2++;
while (*e1 && *e1==*e2) {
e1++;
e2++;
}
if (!StrNCmp(e1,"SHIFT",5)) {
e1+=6;
e1_shift=TRUE;
} else if (!StrNCmp(e1," ",5))
e1+=6;
if (!StrNCmp(e2,"SHIFT",5)) {
e2+=6;
e2_shift=TRUE;
} else if (!StrNCmp(e2," ",5))
e2+=6;
ee1=e1;
while (*ee1 && *ee1!='$$')
ee1++;
ch1=*ee1;
*ee1=0;
ee2=e2;
while (*ee2 && *ee2!='$$')
ee2++;
ch2=*ee2;
*ee2=0;
i=StrCmp(e1,e2);
*ee1=ch1;
*ee2=ch2;
if (i)
return i;
else
return e1_shift-e2_shift;
} else
return 1;
} else {
if (e2)
return -1;
else
return 0;
}
}
bool AudioFormat_YM::TestAsset(const Asset& asset)
{
if (asset.Open())
{
char buffer[7];
asset.Read(buffer,7);
asset.Close();
if (StrNCmp(&buffer[2],"-lh5-",5)==0 || StrNCmp(buffer,"YM3!",4)==0)
{
return true;
}
}
return false;
}
U0 KeyMapFamily2(U8 **entries,U8 *family,CTask *task,I64 scf)
{
I64 i,p2,p1;
U8 *st,*st2;
CTask *old_hash=Fs->hash_table;
Fs->hash_table=task->hash_table;
for (i=0;i<256;i++) {
p2=scf|i|SCF_KEY_DESC;
p1=ScanCode2A(p2);
*key_desc=0;
key_handler=NULL;
if (task==Fs)
PutKey(p1,p2);
else if (TaskValidate(task)) {
PostMsg(task,MSG_KEY_DOWN,p1,p2);
while (!key_handler)
Yield;
}
if (*key_desc && StrNCmp(key_desc,"Char/",5)) {
st=ScanCode2KeyName(p2&~(SCF_CTRL|SCF_ALT|SCF_SHIFT));
st2=MSPrintF("%s %s",family,st);
Free(st);
st=SrcEdLink(key_handler,256);
entries[i]=MSPrintF("%20s $$LK,\"%s\",\"%s\"$$\n",
st2,key_desc,st);
Free(st);
Free(st2);
}
}
Fs->hash_table=old_hash;
}
void CCmd_Depots::OnOutputInfo( char level, LPCTSTR data, LPCTSTR msg )
{
if( APP_ABORTING( ) && m_Asynchronous )
{
ReleaseServerLock();
ExitThread(0);
}
if ( StrNCmp(data, _T("Depot "), 6) ==0 )
m_GotDepot = TRUE;
else
ASSERT(0);
CTokenString str;
str.Create( data + 6);
CString depotName;
depotName.Format(_T("//%s"), str.GetToken());
CString date= str.GetToken();
ASSERT(StrStr(date, _T("/")));
CString depotType= str.GetToken();
if( depotType.CompareNoCase(_T("local")) == 0)
m_LocalDepotList.AddHead( depotName );
else if( depotType.CompareNoCase(_T("remote")) == 0)
m_RemoteDepotList.AddHead( depotName );
else if( depotType.CompareNoCase(_T("spec")) == 0)
{
if (GET_SERVERLEVEL() >= 18)
m_RemoteDepotList.AddHead( depotName );
}
else
ASSERT(0);
}
void SimpleString::replace(const char* to, const char* with)
{
size_t c = count(to);
size_t len = size();
size_t tolen = StrLen(to);
size_t withlen = StrLen(with);
size_t newsize = len + (withlen * c) - (tolen * c) + 1;
if (newsize > 1) {
char* newbuf = allocStringBuffer(newsize, __FILE__, __LINE__);
for (size_t i = 0, j = 0; i < len;) {
if (StrNCmp(&buffer_[i], to, tolen) == 0) {
StrNCpy(&newbuf[j], with, withlen + 1);
j += withlen;
i += tolen;
}
else {
newbuf[j] = buffer_[i];
j++;
i++;
}
}
deallocStringBuffer(buffer_, __FILE__, __LINE__);
buffer_ = newbuf;
buffer_[newsize - 1] = '\0';
}
else {
deallocStringBuffer(buffer_, __FILE__, __LINE__);
buffer_ = getEmptyString();
}
}
char* SimpleString::StrStr(const char* s1, const char* s2)
{
if(!*s2) return (char*) s1;
for (; *s1; s1++)
if (StrNCmp(s1, s2, StrLen(s2)) == 0)
return (char*) s1;
return NULL;
}
// EndsWith
//------------------------------------------------------------------------------
bool AString::EndsWith( const AString & other ) const
{
const size_t otherLen = other.GetLength();
if ( otherLen > GetLength() )
{
return false;
}
return ( StrNCmp( GetEnd() - otherLen, other.Get(), otherLen ) == 0 );
}
// BeginsWith
//------------------------------------------------------------------------------
bool AString::BeginsWith( const char * string ) const
{
size_t otherLen = StrLen( string );
if ( otherLen > GetLength() )
{
return false;
}
return ( StrNCmp( m_Contents, string, otherLen ) == 0 );
}
// BeginsWith
//------------------------------------------------------------------------------
bool AString::BeginsWith( const AString & string ) const
{
uint32_t otherLen = string.GetLength();
if ( otherLen > GetLength() )
{
return false;
}
return ( StrNCmp( m_Contents, string.Get(), otherLen ) == 0 );
}
int WINAPI StrPosStr(const char *str,const char *s,int pos)
{
if(!str || !s || !*s || pos < 0 || pos >= (int)strlen(str)) return -1;
for(int l = (int)strlen(s),n = pos; str[n]; n++)
if(StrNCmp(str+n,s,l) == 0) return n;
return -1;
}
// EndsWith
//------------------------------------------------------------------------------
bool AString::EndsWith( const char * string ) const
{
const size_t stringLen = StrLen( string );
const char * possiblePos = m_Contents + m_Length - stringLen;
if ( possiblePos < m_Contents )
{
return false; // string to search is longer than this string
}
return ( StrNCmp( possiblePos, string, stringLen ) == 0 );
}
BOOL CCmd_Describe::HandledCmdSpecificError(LPCTSTR errBuf, LPCTSTR errMsg)
{
BOOL handledError=TRUE;
#ifndef UNICODE
if (!StrNCmp(errBuf, NOTRANS, sizeof(NOTRANS)-1))
{
CString utf8;
TCHAR *p = (TCHAR *)errBuf + sizeof(NOTRANS)-1;
while (*p && *p != '\'')
{
TCHAR c1 = *p++;
TCHAR c2 = *p++;
if (_istdigit(c1))
c1 &= 0x0F;
else
c1 = (c1 & 0x0F) + 9;
if (_istdigit(c2))
c2 &= 0x0F;
else
c2 = (c2 & 0x0F) + 9;
TCHAR c3 = (c1 << 4) + c2;
utf8.Insert(0x7FFFFFFF, c3);
}
// allocate widechar buffer and convert into it
int lenw = MultiByteToWideChar(CP_UTF8, 0, utf8, -1, 0, 0);
LPWSTR utf16 = (LPWSTR)::VirtualAlloc(NULL, lenw*sizeof(WCHAR), MEM_COMMIT, PAGE_READWRITE);
MultiByteToWideChar(CP_UTF8, 0, utf8, -1, utf16, lenw);
// allocate char buffer and convert back into it, using '?' for
// unmappable characters
int len = WideCharToMultiByte(CP_ACP, 0, utf16, -1, 0, 0, NULL, NULL);
LPSTR buf = (LPSTR)::VirtualAlloc(NULL, len*sizeof(TCHAR), MEM_COMMIT, PAGE_READWRITE);
WideCharToMultiByte(CP_ACP, 0, utf16, -1, buf, len, NULL, NULL);
// append to description
m_Description += buf;
m_Description += g_CRLF;
::VirtualFree(buf, 0, MEM_RELEASE);
::VirtualFree(utf16, 0, MEM_RELEASE);
handledError = FALSE;
}
else
#endif
{
m_FatalError = TRUE;
TheApp()->StatusAdd( errMsg, SV_WARNING, true );
}
return handledError;
}
BOOL MYRTLEXP QnxCmpFile( char *f1, char *f2, int len )
{ BOOL b1,b2;
static struct _osinfo oi;
static char name[16] = "";
static int nmlen;
//CCurrent machine name
if ( !name[0] ) {
qnx_osinfo( 0, &oi );
Sprintf( name,"//%ld",oi.nodename );
nmlen = strLen( name );
}
//Cmp not paths
if ( !f1 || !f2 || f1[0] != '/' || f2[0] != '/' )
if ( len < 0 )
return StrCmp(f1,f2) == 0;
else
return StrNCmp(f1,f2,len) == 0;
//Paths cmp
b1 = (f1[0] == '/' && f1[1] == '/');
b2 = (f2[0] == '/' && f2[1] == '/');
if ( b1 != b2 ) {
if ( !b1 ) {
if ( StrNCmp(name,f2,nmlen) != 0 ) return FALSE;
if ( len >= 0 && strLen(f2) == len ) len -= nmlen;
f2 += nmlen;
}
if ( !b2 ) {
if ( StrNCmp(name,f1,nmlen) != 0 ) return FALSE;
if ( len >= 0 && strLen(f1) == len ) len -= nmlen;
f1 += nmlen;
}
}
if ( len < 0 )
return StrCmp(f1,f2) == 0;
else
return StrNCmp(f1,f2,len) == 0;
}
CDirEntry *Cd2DirEntry(CDirEntry *tempm,U8 *abs_name)
{
I64 i;
while (tempm) {
i=StrLen(tempm->full_name);
if (StrNCmp(tempm->full_name,abs_name,i)||
i && tempm->full_name[i-1]!='/' && abs_name[i] && abs_name[i]!='/')
tempm=tempm->next;
else if (StrLen(abs_name)==i)
return tempm;
else
return Cd2DirEntry(tempm->sub,abs_name);
}
return NULL;
}
bool ImageFormat_GIF::TestAsset(const Asset& asset)
{
if (asset.Open())
{
char buffer[3];
asset.Read(buffer,3);
asset.Close();
if (StrNCmp(buffer,"GIF",3)==0)
{
return true;
}
}
return false;
}
// Find
//------------------------------------------------------------------------------
const char * AString::Find( const char * subString ) const
{
size_t subStrLen = StrLen( subString );
const char * pos = m_Contents;
const char * end = pos + m_Length - subStrLen;
while ( pos <= end )
{
if ( StrNCmp( pos, subString, subStrLen ) == 0 )
{
return pos;
}
pos++;
}
return nullptr;
}
/*
* Returns true if this is a page that we would push onto the stack if not
* forced. If docurl is NULL, only the title is considered; otherwise also
* check the URL whether it is (likely to be) a generated special page.
*/
BOOLEAN LYwouldPush(const char *title,
const char *docurl)
{
BOOLEAN rc = FALSE;
/*
* All non-pushable generated pages have URLs that begin with
* "file://localhost/" and end with HTML_SUFFIX. - kw
*/
if (docurl) {
size_t ulen;
if (StrNCmp(docurl, "file://localhost/", 17) != 0 ||
(ulen = strlen(docurl)) <= strlen(HTML_SUFFIX) ||
strcmp(docurl + ulen - strlen(HTML_SUFFIX), HTML_SUFFIX) != 0) {
/*
* If it is not a local HTML file, it may be a Web page that
* accidentally has the same title. So return TRUE now. - kw
*/
return TRUE;
}
}
if (docurl) {
rc = (BOOLEAN)
!(LYIsUIPage(docurl, UIP_HISTORY)
|| LYIsUIPage(docurl, UIP_PRINT_OPTIONS)
#ifdef DIRED_SUPPORT
|| LYIsUIPage(docurl, UIP_DIRED_MENU)
|| LYIsUIPage(docurl, UIP_UPLOAD_OPTIONS)
|| LYIsUIPage(docurl, UIP_PERMIT_OPTIONS)
#endif /* DIRED_SUPPORT */
);
} else {
rc = (BOOLEAN)
!(!strcmp(title, HISTORY_PAGE_TITLE)
|| !strcmp(title, PRINT_OPTIONS_TITLE)
#ifdef DIRED_SUPPORT
|| !strcmp(title, DIRED_MENU_TITLE)
|| !strcmp(title, UPLOAD_OPTIONS_TITLE)
|| !strcmp(title, PERMIT_OPTIONS_TITLE)
#endif /* DIRED_SUPPORT */
);
}
return rc;
}
// Replace ( char *, char * )
//------------------------------------------------------------------------------
uint32_t AString::Replace( const char * from, const char * to, uint32_t maxReplaces )
{
AStackString< 2 * KILOBYTE > temp;
uint32_t replaceCount = 0;
// loop until the last possible position for a potential match
const char * pos = m_Contents;
const char * end = m_Contents + m_Length;
const size_t fromLength = StrLen( from );
while ( pos <= ( end - fromLength ) )
{
if ( StrNCmp( pos, from, fromLength ) == 0 )
{
temp += to;
pos += fromLength;
maxReplaces--;
replaceCount++;
if ( maxReplaces == 0 )
{
break;
}
}
else
{
temp += *pos;
pos++;
}
}
// did we actually replace anything?
if ( replaceCount > 0 )
{
// copy remaining unmatchable characters to the temp
while ( pos < end )
{
temp += *pos;
pos++;
}
// keep the result
Assign( temp );
}
return replaceCount;
}
bool ImageFormat_TGA::TestAsset(const Asset& asset)
{
// Check if the footer says that this is a TGA file
if (asset.Open())
{
asset.Seek(-18,Asset::SEEK_FROM_END);
char buffer[16];
asset.Read(buffer,16);
asset.Close();
if (StrNCmp(buffer,"TRUEVISION-XFILE",16)==0)
{
return true;
}
}
// If the footer doesn't match, this might still be a tga file (version < 2)
// so try and load it as a tga and see if it works...
int size=asset.GetSize();
char* buffer=new char[size];
asset.Open();
asset.Read(buffer,size);
asset.Close();
tga_image image;
tga_read_from_Buffer(&image,buffer);
delete[] buffer;
// Check to see if the header data makes sense...
if (image.width<32767 && image.height<32767 && image.image_data && (image.pixel_depth==8 || image.pixel_depth==24 || image.pixel_depth==16 || image.pixel_depth==32))
{
// Yeah, sure, this looks like proper data, so give thumbs up and hope for the best
return true;
}
tga_free_buffers(&image);
// Nope, not likely to be a TGA
return false;
}
static int response(char *command,
char *sitename,
HTParentAnchor *anAnchor,
HTFormat format_out,
HTStream *sink)
{
int status;
int length = (int) strlen(command);
int ch, i;
char line[BIG], *l, *cmd = NULL;
char *p = line, *href = NULL;
if (length == 0)
return (-1);
/* Set up buffering.
*/
HTInitInput(finger_fd);
/* Send the command.
*/
CTRACE((tfp, "HTFinger command to be sent: %s", command));
status = (int) NETWRITE(finger_fd, (char *) command, (unsigned) length);
if (status < 0) {
CTRACE((tfp, "HTFinger: Unable to send command. Disconnecting.\n"));
NETCLOSE(finger_fd);
finger_fd = -1;
return status;
}
/* if bad status */
/* Make a hypertext object with an anchor list.
*/
target = HTML_new(anAnchor, format_out, sink);
targetClass = *target->isa; /* Copy routine entry points */
/* Create the results report.
*/
CTRACE((tfp, "HTFinger: Reading finger information\n"));
START(HTML_HTML);
PUTC('\n');
START(HTML_HEAD);
PUTC('\n');
START(HTML_TITLE);
PUTS("Finger server on ");
PUTS(sitename);
END(HTML_TITLE);
PUTC('\n');
END(HTML_HEAD);
PUTC('\n');
START(HTML_BODY);
PUTC('\n');
START(HTML_H1);
PUTS("Finger server on ");
START(HTML_EM);
PUTS(sitename);
END(HTML_EM);
PUTS(": ");
StrAllocCopy(cmd, command);
for (i = ((int) strlen(cmd) - 1); i >= 0; i--) {
if (cmd[i] == LF || cmd[i] == CR) {
cmd[i] = '\0';
} else {
break;
}
}
PUTS(cmd);
FREE(cmd);
END(HTML_H1);
PUTC('\n');
START(HTML_PRE);
while ((ch = NEXT_CHAR) != EOF) {
if (interrupted_in_htgetcharacter) {
CTRACE((tfp,
"HTFinger: Interrupted in HTGetCharacter, apparently.\n"));
_HTProgress(CONNECTION_INTERRUPTED);
goto end_html;
}
if (ch != LF) {
*p = (char) ch; /* Put character in line */
if (p < &line[BIG - 1]) {
p++;
}
} else {
*p = '\0'; /* Terminate line */
/*
* OK we now have a line.
* Load it as 'l' and parse it.
*/
p = l = line;
while (*l) {
if (StrNCmp(l, STR_NEWS_URL, LEN_NEWS_URL) &&
StrNCmp(l, "snews://", 8) &&
StrNCmp(l, "nntp://", 7) &&
StrNCmp(l, "snewspost:", 10) &&
StrNCmp(l, "snewsreply:", 11) &&
StrNCmp(l, "newspost:", 9) &&
StrNCmp(l, "newsreply:", 10) &&
StrNCmp(l, "ftp://", 6) &&
StrNCmp(l, "file:/", 6) &&
StrNCmp(l, "finger://", 9) &&
StrNCmp(l, "http://", 7) &&
StrNCmp(l, "https://", 8) &&
StrNCmp(l, "wais://", 7) &&
StrNCmp(l, STR_MAILTO_URL, LEN_MAILTO_URL) &&
StrNCmp(l, "cso://", 6) &&
StrNCmp(l, "gopher://", 9))
PUTC(*l++);
else {
StrAllocCopy(href, l);
start_anchor(strtok(href, " \r\n\t,>)\""));
while (*l && !StrChr(" \r\n\t,>)\"", *l))
PUTC(*l++);
END(HTML_A);
FREE(href);
}
}
PUTC('\n');
}
}
NETCLOSE(finger_fd);
finger_fd = -1;
end_html:
END(HTML_PRE);
PUTC('\n');
END(HTML_BODY);
PUTC('\n');
END(HTML_HTML);
PUTC('\n');
FREE_TARGET;
return (0);
}
void LYDownload(char *line)
{
char *Line = NULL, *method, *file, *sug_file = NULL;
int method_number;
int count;
char *the_command = 0;
bstring *buffer = NULL;
bstring *command = NULL;
char *cp;
lynx_list_item_type *download_command = 0;
int ch;
RecallType recall;
int FnameTotal;
int FnameNum;
BOOLEAN FirstRecall = TRUE;
BOOLEAN SecondS = FALSE;
#ifdef VMS
LYDidRename = FALSE;
#endif /* VMS */
/*
* Make sure we have a valid download file comparison string loaded via the
* download options menu. - FM
*/
if (LYValidDownloadFile[0] == '\0') {
goto failed;
}
/*
* Make a copy of the LYNXDOWNLOAD internal URL for parsing. - FM
*/
StrAllocCopy(Line, line);
/*
* Parse out the File, sug_file, and the Method.
*/
if ((file = strstr(Line, "/File=")) == NULL)
goto failed;
*file = '\0';
/*
* Go past "File=".
*/
file += 6;
if ((sug_file = strstr(file + 1, "/SugFile=")) != NULL) {
*sug_file = '\0';
/*
* Go past "SugFile=".
*/
sug_file += 9;
HTUnEscape(sug_file);
}
/*
* Make sure that the file string is the one from the last displayed
* download options menu. - FM
*/
if (strcmp(file, LYValidDownloadFile)) {
goto failed;
}
#if defined(DIRED_SUPPORT)
/* FIXME: use HTLocalName */
if (!StrNCmp(file, "file://localhost", 16)) {
#ifdef __DJGPP__
if (!StrNCmp(file + 16, "/dev/", 5))
file += 16;
else {
file += 17;
file = HTDOS_name(file);
}
#else
file += 16;
#endif /* __DJGPP__ */
} else if (isFILE_URL(file))
file += LEN_FILE_URL;
HTUnEscape(file);
#else
#if defined(_WINDOWS) /* 1997/10/15 (Wed) 16:27:38 */
if (!StrNCmp(file, "file://localhost/", 17))
file += 17;
else if (!StrNCmp(file, "file:/", 6))
file += 6;
HTUnEscape(file);
#endif /* _WINDOWS */
#endif /* DIRED_SUPPORT */
if ((method = strstr(Line, "Method=")) == NULL)
goto failed;
/*
* Go past "Method=".
*/
method += 7;
method_number = atoi(method);
/*
* Set up the sug_filenames recall buffer.
*/
FnameTotal = (sug_filenames ? HTList_count(sug_filenames) : 0);
recall = ((FnameTotal >= 1) ? RECALL_URL : NORECALL);
FnameNum = FnameTotal;
if (method_number < 0) {
/*
* Write to local file.
*/
_statusline(FILENAME_PROMPT);
retry:
if (sug_file) {
BStrCopy0(buffer, sug_file);
} else {
BStrCopy0(buffer, "");
}
check_recall:
if ((ch = LYgetBString(&buffer, FALSE, 0, recall)) < 0 ||
isBEmpty(buffer) ||
ch == UPARROW_KEY ||
ch == DNARROW_KEY) {
if (recall && ch == UPARROW_KEY) {
if (FirstRecall) {
FirstRecall = FALSE;
/*
* Use the last Fname in the list. - FM
*/
FnameNum = 0;
} else {
/*
* Go back to the previous Fname in the list. - FM
*/
FnameNum++;
}
if (FnameNum >= FnameTotal) {
/*
* Reset the FirstRecall flag, and use sug_file or a blank.
* - FM
*/
FirstRecall = TRUE;
FnameNum = FnameTotal;
_statusline(FILENAME_PROMPT);
goto retry;
} else if ((cp = (char *) HTList_objectAt(sug_filenames,
FnameNum)) != NULL) {
BStrCopy0(buffer, cp);
if (FnameTotal == 1) {
_statusline(EDIT_THE_PREV_FILENAME);
} else {
_statusline(EDIT_A_PREV_FILENAME);
}
goto check_recall;
}
} else if (recall && ch == DNARROW_KEY) {
if (FirstRecall) {
FirstRecall = FALSE;
/*
* Use the first Fname in the list. - FM
*/
FnameNum = FnameTotal - 1;
} else {
/*
* Advance to the next Fname in the list. - FM
*/
FnameNum--;
}
if (FnameNum < 0) {
/*
* Set the FirstRecall flag, and use sug_file or a blank.
* - FM
*/
FirstRecall = TRUE;
FnameNum = FnameTotal;
_statusline(FILENAME_PROMPT);
goto retry;
} else if ((cp = (char *) HTList_objectAt(sug_filenames,
FnameNum)) != NULL) {
BStrCopy0(buffer, cp);
if (FnameTotal == 1) {
_statusline(EDIT_THE_PREV_FILENAME);
} else {
_statusline(EDIT_A_PREV_FILENAME);
}
goto check_recall;
}
}
/*
* Save cancelled.
*/
goto cancelled;
}
BStrCopy(command, buffer);
if (!LYValidateFilename(&buffer, &command))
goto cancelled;
#ifdef HAVE_POPEN
else if (LYIsPipeCommand(buffer->str)) {
/* I don't know how to download to a pipe */
HTAlert(CANNOT_WRITE_TO_FILE);
_statusline(NEW_FILENAME_PROMPT);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
}
#endif
/*
* See if it already exists.
*/
switch (LYValidateOutput(buffer->str)) {
case 'Y':
break;
case 'N':
_statusline(NEW_FILENAME_PROMPT);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
default:
goto cleanup;
}
/*
* See if we can write to it.
*/
CTRACE((tfp, "LYDownload: filename is %s\n", buffer->str));
SecondS = TRUE;
HTInfoMsg(SAVING);
#ifdef VMS
/*
* Try rename() first. - FM
*/
CTRACE((tfp, "command: rename(%s, %s)\n", file, buffer->str));
if (rename(file, buffer->str)) {
/*
* Failed. Use spawned COPY_COMMAND. - FM
*/
CTRACE((tfp, " FAILED!\n"));
LYCopyFile(file, buffer->str);
} else {
/*
* We don't have the temporary file (it was renamed to a permanent
* file), so set a flag to pop out of the download menu. - FM
*/
LYDidRename = TRUE;
}
chmod(buffer->str, HIDE_CHMOD);
#else /* Unix: */
LYCopyFile(file, buffer->str);
LYRelaxFilePermissions(buffer->str);
#endif /* VMS */
} else {
/*
* Use configured download commands.
*/
BStrCopy0(buffer, "");
for (count = 0, download_command = downloaders;
count < method_number;
count++, download_command = download_command->next) ; /* null body */
/*
* Commands have the form "command %s [etc]" where %s is the filename.
*/
if (download_command->command != NULL) {
/*
* Check for two '%s' and ask for the local filename if there is.
*/
if (HTCountCommandArgs(download_command->command) >= 2) {
_statusline(FILENAME_PROMPT);
again:
if (sug_file) {
BStrCopy0(buffer, sug_file);
} else {
BStrCopy0(buffer, "");
}
check_again:
if ((ch = LYgetBString(&buffer, FALSE, 0, recall)) < 0 ||
isBEmpty(buffer) ||
ch == UPARROW_KEY ||
ch == DNARROW_KEY) {
if (recall && ch == UPARROW_KEY) {
if (FirstRecall) {
FirstRecall = FALSE;
/*
* Use the last Fname in the list. - FM
*/
FnameNum = 0;
} else {
/*
* Go back to the previous Fname in the list. - FM
*/
FnameNum++;
}
if (FnameNum >= FnameTotal) {
/*
* Reset the FirstRecall flag, and use sug_file or
* a blank. - FM
*/
FirstRecall = TRUE;
FnameNum = FnameTotal;
_statusline(FILENAME_PROMPT);
goto again;
} else if ((cp = (char *) HTList_objectAt(sug_filenames,
FnameNum))
!= NULL) {
BStrCopy0(buffer, cp);
if (FnameTotal == 1) {
_statusline(EDIT_THE_PREV_FILENAME);
} else {
_statusline(EDIT_A_PREV_FILENAME);
}
goto check_again;
}
} else if (recall && ch == DNARROW_KEY) {
if (FirstRecall) {
FirstRecall = FALSE;
/*
* Use the first Fname in the list. - FM
*/
FnameNum = FnameTotal - 1;
} else {
/*
* Advance to the next Fname in the list. - FM
*/
FnameNum--;
}
if (FnameNum < 0) {
/*
* Set the FirstRecall flag, and use sug_file or a
* blank. - FM
*/
FirstRecall = TRUE;
FnameNum = FnameTotal;
_statusline(FILENAME_PROMPT);
goto again;
} else if ((cp = (char *) HTList_objectAt(sug_filenames,
FnameNum))
!= NULL) {
BStrCopy0(buffer, cp);
if (FnameTotal == 1) {
_statusline(EDIT_THE_PREV_FILENAME);
} else {
_statusline(EDIT_A_PREV_FILENAME);
}
goto check_again;
}
}
/*
* Download cancelled.
*/
goto cancelled;
}
if (no_dotfiles || !show_dotfiles) {
if (*LYPathLeaf(buffer->str) == '.') {
HTAlert(FILENAME_CANNOT_BE_DOT);
_statusline(NEW_FILENAME_PROMPT);
goto again;
}
}
/*
* Cancel if the user entered "/dev/null" on Unix, or an "nl:"
* path on VMS. - FM
*/
if (LYIsNullDevice(buffer->str)) {
goto cancelled;
}
SecondS = TRUE;
}
/*
* The following is considered a bug by the community. If the
* command only takes one argument on the command line, then the
* suggested file name is not used. It actually is not a bug at
* all and does as it should, putting both names on the command
* line.
*/
count = 1;
HTAddParam(&the_command, download_command->command, count, file);
if (HTCountCommandArgs(download_command->command) > 1)
HTAddParam(&the_command, download_command->command, ++count, buffer->str);
HTEndParam(&the_command, download_command->command, count);
} else {
HTAlert(MISCONF_DOWNLOAD_COMMAND);
goto failed;
}
CTRACE((tfp, "command: %s\n", the_command));
stop_curses();
LYSystem(the_command);
FREE(the_command);
start_curses();
/* don't remove(file); */
}
if (SecondS == TRUE) {
#ifdef VMS
if (0 == strncasecomp(buffer->str, "sys$disk:", 9)) {
if (0 == StrNCmp((buffer->str + 9), "[]", 2)) {
HTAddSugFilename(buffer->str + 11);
} else {
HTAddSugFilename(buffer->str + 9);
}
} else {
HTAddSugFilename(buffer->str);
}
#else
HTAddSugFilename(buffer->str);
#endif /* VMS */
}
goto cleanup;
failed:
HTAlert(CANNOT_DOWNLOAD_FILE);
goto cleanup;
cancelled:
HTInfoMsg(CANCELLING);
cleanup:
FREE(Line);
BStrFree(buffer);
return;
}
/*
* Utility for listing visited links, making any repeated links the most
* current in the list. - FM
*/
void LYAddVisitedLink(DocInfo *doc)
{
VisitedLink *tmp;
HTList *cur;
const char *title = (doc->title ? doc->title : NO_TITLE);
if (isEmpty(doc->address)) {
PrevVisitedLink = NULL;
return;
}
/*
* Exclude POST or HEAD replies, and bookmark, menu or list files. - FM
*/
if (doc->post_data || doc->isHEAD || doc->bookmark ||
( /* special url or a temp file */
(!StrNCmp(doc->address, "LYNX", 4) ||
!StrNCmp(doc->address, "file://localhost/", 17)))) {
int related = 1; /* First approximation only */
if (LYIsUIPage(doc->address, UIP_HISTORY) ||
LYIsUIPage(doc->address, UIP_VLINKS) ||
LYIsUIPage(doc->address, UIP_SHOWINFO) ||
isLYNXMESSAGES(doc->address) ||
((related = 0) != 0) ||
#ifdef DIRED_SUPPORT
LYIsUIPage(doc->address, UIP_DIRED_MENU) ||
LYIsUIPage(doc->address, UIP_UPLOAD_OPTIONS) ||
LYIsUIPage(doc->address, UIP_PERMIT_OPTIONS) ||
#endif /* DIRED_SUPPORT */
LYIsUIPage(doc->address, UIP_PRINT_OPTIONS) ||
LYIsUIPage(doc->address, UIP_DOWNLOAD_OPTIONS) ||
LYIsUIPage(doc->address, UIP_OPTIONS_MENU) ||
isLYNXEDITMAP(doc->address) ||
isLYNXKEYMAP(doc->address) ||
LYIsUIPage(doc->address, UIP_LIST_PAGE) ||
#ifdef USE_ADDRLIST_PAGE
LYIsUIPage(doc->address, UIP_ADDRLIST_PAGE) ||
#endif
LYIsUIPage(doc->address, UIP_CONFIG_DEF) ||
LYIsUIPage(doc->address, UIP_LYNXCFG) ||
isLYNXCOOKIE(doc->address) ||
LYIsUIPage(doc->address, UIP_TRACELOG)) {
if (!related)
PrevVisitedLink = NULL;
return;
}
}
if (!Visited_Links) {
Visited_Links = HTList_new();
#ifdef LY_FIND_LEAKS
atexit(Visited_Links_free);
#endif
Latest_last.prev_latest = &Latest_first;
Latest_first.next_latest = &Latest_last;
Latest_last.next_latest = NULL; /* Find bugs quick! */
Latest_first.prev_latest = NULL;
Last_by_first = Latest_tree = First_tree = NULL;
}
cur = Visited_Links;
while (NULL != (tmp = (VisitedLink *) HTList_nextObject(cur))) {
if (!strcmp(NonNull(tmp->address),
NonNull(doc->address))) {
PrevVisitedLink = PrevActiveVisitedLink = tmp;
/* Already visited. Update the last-visited info. */
if (tmp->next_latest == &Latest_last) /* optimization */
return;
/* Remove from "latest" chain */
tmp->prev_latest->next_latest = tmp->next_latest;
tmp->next_latest->prev_latest = tmp->prev_latest;
/* Insert at the end of the "latest" chain */
Latest_last.prev_latest->next_latest = tmp;
tmp->prev_latest = Latest_last.prev_latest;
tmp->next_latest = &Latest_last;
Latest_last.prev_latest = tmp;
return;
}
}
if ((tmp = typecalloc(VisitedLink)) == NULL)
outofmem(__FILE__, "LYAddVisitedLink");
StrAllocCopy(tmp->address, doc->address);
LYformTitle(&(tmp->title), title);
/* First-visited chain */
HTList_appendObject(Visited_Links, tmp); /* At end */
tmp->prev_first = Last_by_first;
Last_by_first = tmp;
/* Tree structure */
if (PrevVisitedLink) {
VisitedLink *a = PrevVisitedLink;
VisitedLink *b = a->next_tree;
int l = PrevVisitedLink->level;
/* Find last on the deeper levels */
while (b && b->level > l)
a = b, b = b->next_tree;
if (!b) /* a == Latest_tree */
Latest_tree = tmp;
tmp->next_tree = a->next_tree;
a->next_tree = tmp;
tmp->level = PrevVisitedLink->level + 1;
} else {
if (Latest_tree)
Latest_tree->next_tree = tmp;
tmp->level = 0;
tmp->next_tree = NULL;
Latest_tree = tmp;
}
PrevVisitedLink = PrevActiveVisitedLink = tmp;
if (!First_tree)
First_tree = tmp;
/* "latest" chain */
Latest_last.prev_latest->next_latest = tmp;
tmp->prev_latest = Latest_last.prev_latest;
tmp->next_latest = &Latest_last;
Latest_last.prev_latest = tmp;
return;
}
void Bitmap_RLE8::Load(const Asset& asset)
{
if (asset.Open())
{
char header[8];
asset.Read(header,8);
if (StrNCmp(header,"PIXRLE8B",8)==0)
{
int version=0;
asset.Read(&version);
if (version==0)
{
int celCount=0;
asset.Read(&celCount);
if (celCount>=1)
{
ReadFromAsset(&asset);
}
}
}
else if (StrNCmp(header,"PIXIE_RL",8)==0)
{
char c;
asset.Read(&c);
int version=0;
asset.Read(&version);
if (version==0)
{
int celCount=0;
asset.Read(&celCount);
if (celCount>=1)
{
ReadFromAsset(&asset);
}
}
}
else
{
Assert(false,"Invalid RLE header");
}
}
// Report missing file
#ifdef _DEBUG
else
{
const char* filename=asset.GetFilename().GetString();
if (filename)
{
char errorMessage[1024];
SNPrintF(errorMessage,1024,"File not found: %s",filename);
Assert(false,errorMessage);
}
else
{
Assert(false,"An asset could not be accessed.");
}
}
#endif
}
NLM_EXTERN int LIBCALL Nlm_StringNCmp (const char FAR *a, const char FAR *b, size_t max)
{
return (a && b) ? StrNCmp(a, b, max) : (a ? 1 : (b ? -1 : 0));
}
/*
* General purpose filename getter.
*
* Returns a pointer to an absolute filename string, if the input filename
* exists, and is readable. Returns NULL if the input was cancelled (^G, or CR
* on empty input).
*
* The pointer to the filename string needs to be free()'d by the caller (when
* non-NULL).
*
* --KED 02/21/99
*/
char *GetFileName(void)
{
struct stat stat_info;
bstring *fbuf = NULL;
bstring *tbuf = NULL;
char *result = NULL;
BOOLEAN FirstRecall = TRUE;
int FnameNum = -1;
int FnameTotal;
_statusline(FILENAME_PROMPT);
retry:
/*
* No initial filename.
*/
SetupFilename(&fbuf, "");
check_recall:
/*
* Go get a filename (it would be nice to do TAB == filename-completion as
* the name is entered, but we'll save doing that for another time.
*/
switch (RecallFilename(&fbuf, &FirstRecall, &FnameNum,
&FnameTotal, GENERIC_FLAG)) {
case FN_INIT:
goto retry;
case FN_READ:
goto check_recall;
case FN_QUIT:
goto cleanup;
default:
break;
}
/*
* Add raw input form to list ... we may want to reuse/edit it on a
* subsequent call, etc.
*/
#ifdef VMS
if (0 == strncasecomp(fbuf->str, "sys$disk:", 9)) {
if (0 == StrNCmp((fbuf->str + 9), "[]", 2)) {
HTAddSugFilename(fbuf->str + 11);
} else {
HTAddSugFilename(fbuf->str + 9);
}
} else {
HTAddSugFilename(fbuf->str);
}
#else
HTAddSugFilename(fbuf->str);
#endif /* VMS */
/*
* Expand tilde's, make filename absolute, etc.
*/
BStrCopy0(tbuf, "");
if (!LYValidateFilename(&tbuf, &fbuf))
goto cleanup;
/*
* Check for file existence; readability.
*/
if ((stat(tbuf->str, &stat_info) < 0) ||
(!(S_ISREG(stat_info.st_mode)
#ifdef S_IFLNK
|| S_ISLNK(stat_info.st_mode)
#endif /* S_IFLNK */
))) {
HTInfoMsg(FILE_DOES_NOT_EXIST);
_statusline(FILE_DOES_NOT_EXIST_RE);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
}
if (!LYCanReadFile(tbuf->str)) {
HTInfoMsg(FILE_NOT_READABLE);
_statusline(FILE_NOT_READABLE_RE);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
}
/*
* We have a valid filename, and readable file. Return it to the caller.
*
* The returned pointer should be free()'d by the caller.
*/
StrAllocCopy(result, tbuf->str);
cleanup:
BStrFree(fbuf);
BStrFree(tbuf);
return (result);
}
static void send_file_to_file(DocInfo *newdoc,
char *content_base,
char *sug_filename)
{
BOOLEAN FirstRecall = TRUE;
BOOLEAN use_cte;
const char *disp_charset;
FILE *outfile_fp;
bstring *buffer = NULL;
bstring *filename = NULL;
int FnameNum = -1;
int FnameTotal;
int c = 0;
_statusline(FILENAME_PROMPT);
retry:
SetupFilename(&filename, sug_filename);
if (lynx_save_space) {
BStrCopy0(buffer, lynx_save_space);
BStrCat(buffer, filename);
BStrCopy(filename, buffer);
} else {
BStrCopy0(buffer, "");
}
check_recall:
switch (RecallFilename(&filename, &FirstRecall, &FnameNum,
&FnameTotal, PRINT_FLAG)) {
case FN_INIT:
goto retry;
case FN_READ:
goto check_recall;
case FN_QUIT:
goto done;
default:
break;
}
if (!LYValidateFilename(&buffer, &filename)) {
CancelPrint(SAVE_REQUEST_CANCELLED);
}
/*
* See if it already exists.
*/
switch (c = LYValidateOutput(buffer->str)) {
case 'Y':
break;
case 'N':
_statusline(NEW_FILENAME_PROMPT);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
default:
goto done;
}
/*
* See if we can write to it.
*/
CTRACE((tfp, "LYPrint: filename is %s, action is `%c'\n", buffer->str, c));
#ifdef HAVE_POPEN
if (buffer->str[0] == '|') {
if (no_shell) {
HTUserMsg(SPAWNING_DISABLED);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
} else if ((outfile_fp = popen(buffer->str + 1, "w")) == NULL) {
CTRACE((tfp, "LYPrint: errno is %d\n", errno));
HTAlert(CANNOT_WRITE_TO_FILE);
_statusline(NEW_FILENAME_PROMPT);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
}
} else
#endif
if ((outfile_fp = (TOUPPER(c) == 'A'
? LYAppendToTxtFile(buffer->str)
: LYNewTxtFile(buffer->str))) == NULL) {
CTRACE((tfp, "LYPrint: errno is %d\n", errno));
HTAlert(CANNOT_WRITE_TO_FILE);
_statusline(NEW_FILENAME_PROMPT);
FirstRecall = TRUE;
FnameNum = FnameTotal;
goto retry;
}
if (LYPrependBaseToSource && HTisDocumentSource()) {
/*
* Added the document's base as a BASE tag to the top of the file. May
* create technically invalid HTML, but will help get any partial or
* relative URLs resolved properly if no BASE tag is present to replace
* it. - FM
*
* Add timestamp (last reload).
*/
fprintf(outfile_fp,
"<!-- X-URL: %s -->\n", newdoc->address);
if (HText_getDate() != NULL) {
fprintf(outfile_fp,
"<!-- Date: %s -->\n", HText_getDate());
if (HText_getLastModified() != NULL
&& strcmp(HText_getLastModified(), HText_getDate())
&& strcmp(HText_getLastModified(),
"Thu, 01 Jan 1970 00:00:01 GMT")) {
fprintf(outfile_fp,
"<!-- Last-Modified: %s -->\n", HText_getLastModified());
}
}
fprintf(outfile_fp,
"<BASE HREF=\"%s\">\n", content_base);
}
if (LYPrependCharsetToSource && HTisDocumentSource()) {
/*
* Added the document's charset as a META CHARSET tag to the top of the
* file. May create technically invalid HTML, but will help to resolve
* properly the document converted via chartrans: printed document
* correspond to a display charset and we *should* override both
* assume_local_charset and original document's META CHARSET (if any).
*
* Currently, if several META CHARSETs are found Lynx uses the first
* only, and it is opposite to BASE where the original BASE in the
* <HEAD> overrides ones from the top.
*
* As in print-to-email we write charset only if the document has 8-bit
* characters, and we have no CJK or an unofficial "x-" charset.
*/
use_cte = HTLoadedDocumentEightbit();
disp_charset = LYCharSet_UC[current_char_set].MIMEname;
if (!use_cte || LYHaveCJKCharacterSet ||
strncasecomp(disp_charset, "x-", 2) == 0) {
} else {
fprintf(outfile_fp,
"<META HTTP-EQUIV=\"Content-Type\" CONTENT=\"text/html; charset=%s\">\n\n",
disp_charset);
}
}
print_wwwfile_to_fd(outfile_fp, FALSE, FALSE); /* FILE */
if (keypad_mode)
printlist(outfile_fp, FALSE);
#ifdef HAVE_POPEN
if (LYIsPipeCommand(buffer->str))
pclose(outfile_fp);
else
#endif
LYCloseOutput(outfile_fp);
#ifdef VMS
if (0 == strncasecomp(buffer->str, "sys$disk:", 9)) {
if (0 == StrNCmp((buffer->str + 9), "[]", 2)) {
HTAddSugFilename(buffer->str + 11);
} else {
HTAddSugFilename(buffer->str + 9);
}
} else {
HTAddSugFilename(buffer->str);
}
#else
HTAddSugFilename(buffer->str);
#endif /* VMS */
done:
BStrFree(buffer);
BStrFree(filename);
return;
}
char * iNode_getName ( struct iNode * aNode )
{
return (!StrNCmp(aNode->File_Struct.name,"root",4)? "": aNode->File_Struct.name) ;
}
static int LYLoadCGI(const char *arg,
HTParentAnchor *anAnchor,
HTFormat format_out,
HTStream *sink)
{
int status = 0;
#ifdef LYNXCGI_LINKS
#ifndef VMS
char *cp;
struct stat stat_buf;
char *pgm = NULL; /* executable */
char *pgm_args = NULL; /* and its argument(s) */
int statrv;
char *orig_pgm = NULL; /* Path up to ? as given, URL-escaped */
char *document_root = NULL; /* Corrected value of DOCUMENT_ROOT */
char *path_info = NULL; /* PATH_INFO extracted from pgm */
char *pgm_buff = NULL; /* PATH_INFO extraction buffer */
char *path_translated; /* From document_root/path_info */
if (isEmpty(arg) || strlen(arg) <= 8) {
HTAlert(BAD_REQUEST);
status = -2;
return (status);
} else {
if (StrNCmp(arg, "lynxcgi://localhost", 19) == 0) {
StrAllocCopy(pgm, arg + 19);
} else {
StrAllocCopy(pgm, arg + 8);
}
if ((cp = StrChr(pgm, '?')) != NULL) { /* Need to terminate executable */
*cp++ = '\0';
pgm_args = cp;
}
}
StrAllocCopy(orig_pgm, pgm);
if (trimPoundSelector(pgm) != NULL) {
/*
* Strip a #fragment from path. In this case any pgm_args found above
* will also be bogus, since the '?' came after the '#' and is part of
* the fragment. Note that we don't handle the case where a '#'
* appears after a '?' properly according to URL rules. - kw
*/
pgm_args = NULL;
}
HTUnEscape(pgm);
/* BEGIN WebSter Mods */
/* If pgm is not stat-able, see if PATH_INFO data is at the end of pgm */
if ((statrv = stat(pgm, &stat_buf)) < 0) {
StrAllocCopy(pgm_buff, pgm);
while (statrv < 0 || (statrv = stat(pgm_buff, &stat_buf)) < 0) {
if ((cp = strrchr(pgm_buff, '/')) != NULL) {
*cp = '\0';
statrv = 1; /* force new stat() - kw */
} else {
PERROR("strrchr(pgm_buff, '/') returned NULL");
break;
}
}
if (statrv < 0) {
/* Did not find PATH_INFO data */
PERROR("stat() of pgm_buff failed");
} else {
/* Found PATH_INFO data. Strip it off of pgm and into path_info. */
StrAllocCopy(path_info, pgm + strlen(pgm_buff));
/* The following is safe since pgm_buff was derived from pgm
by stripping stuff off its end and by HTUnEscaping, so we
know we have enough memory allocated for pgm. Note that
pgm_args may still point into that memory, so we cannot
reallocate pgm here. - kw */
strcpy(pgm, pgm_buff);
CTRACE((tfp,
"LYNXCGI: stat() of %s succeeded, path_info=\"%s\".\n",
pgm_buff, path_info));
}
FREE(pgm_buff);
}
/* END WebSter Mods */
if (statrv != 0) {
/*
* Neither the path as given nor any components examined by backing up
* were stat()able. - kw
*/
HTAlert(gettext("Unable to access cgi script"));
PERROR("stat() failed");
status = -4;
} else
#ifdef _WINDOWS /* 1998/01/14 (Wed) 09:16:04 */
#define isExecutable(mode) (mode & (S_IXUSR))
#else
#define isExecutable(mode) (mode & (S_IXUSR|S_IXGRP|S_IXOTH))
#endif
if (!(S_ISREG(stat_buf.st_mode) && isExecutable(stat_buf.st_mode))) {
/*
* Not a runnable file, See if we can load it using "file:" code.
*/
char *new_arg = NULL;
/*
* But try "file:" only if the file we are looking at is the path as
* given (no path_info was extracted), otherwise it will be to
* confusing to know just what file is loaded. - kw
*/
if (path_info) {
CTRACE((tfp,
"%s is not a file and %s not an executable, giving up.\n",
orig_pgm, pgm));
FREE(path_info);
FREE(pgm);
FREE(orig_pgm);
status = -4;
return (status);
}
LYLocalFileToURL(&new_arg, orig_pgm);
CTRACE((tfp, "%s is not an executable file, passing the buck.\n", arg));
status = HTLoadFile(new_arg, anAnchor, format_out, sink);
FREE(new_arg);
} else if (path_info &&
anAnchor != HTMainAnchor &&
!(reloading && anAnchor->document) &&
strcmp(arg, HTLoadedDocumentURL()) &&
HText_AreDifferent(anAnchor, arg) &&
HTUnEscape(orig_pgm) &&
!can_exec_cgi(orig_pgm, "")) {
/*
* If we have extra path info and are not just reloading the current,
* check the full file path (after unescaping) now to catch forbidden
* segments. - kw
*/
status = HT_NOT_LOADED;
} else if (no_lynxcgi) {
HTUserMsg(CGI_DISABLED);
status = HT_NOT_LOADED;
} else if (no_bookmark_exec &&
anAnchor != HTMainAnchor &&
!(reloading && anAnchor->document) &&
strcmp(arg, HTLoadedDocumentURL()) &&
HText_AreDifferent(anAnchor, arg) &&
HTLoadedDocumentBookmark()) {
/*
* If we are reloading a lynxcgi document that had already been loaded,
* the various checks above should allow it even if no_bookmark_exec is
* TRUE an we are not now coming from a bookmark page. - kw
*/
HTUserMsg(BOOKMARK_EXEC_DISABLED);
status = HT_NOT_LOADED;
} else if (anAnchor != HTMainAnchor &&
!(reloading && anAnchor->document) &&
strcmp(arg, HTLoadedDocumentURL()) &&
HText_AreDifferent(anAnchor, arg) &&
!can_exec_cgi(pgm, pgm_args)) {
/*
* If we are reloading a lynxcgi document that had already been loaded,
* the various checks above should allow it even if exec_ok() would
* reject it because we are not now coming from a document with a URL
* allowed by TRUSTED_LYNXCGI rules. - kw
*/
status = HT_NOT_LOADED;
} else {
HTFormat format_in;
HTStream *target = NULL; /* Unconverted data */
int fd1[2], fd2[2];
char buf[MAX_LINE];
int pid;
#ifdef HAVE_TYPE_UNIONWAIT
union wait wstatus;
#else
int wstatus;
#endif
fd1[0] = -1;
fd1[1] = -1;
fd2[0] = -1;
fd2[1] = -1;
if (anAnchor->isHEAD || keep_mime_headers) {
/* Show output as plain text */
format_in = WWW_PLAINTEXT;
} else {
/* Decode full HTTP response */
format_in = HTAtom_for("www/mime");
}
target = HTStreamStack(format_in,
format_out,
sink, anAnchor);
if (!target || target == NULL) {
char *tmp = 0;
HTSprintf0(&tmp, CANNOT_CONVERT_I_TO_O,
HTAtom_name(format_in),
HTAtom_name(format_out));
HTAlert(tmp);
FREE(tmp);
status = HT_NOT_LOADED;
} else if (anAnchor->post_data && pipe(fd1) < 0) {
HTAlert(CONNECT_SET_FAILED);
PERROR("pipe() failed");
status = -3;
} else if (pipe(fd2) < 0) {
HTAlert(CONNECT_SET_FAILED);
PERROR("pipe() failed");
close(fd1[0]);
close(fd1[1]);
status = -3;
} else {
static BOOL first_time = TRUE; /* One time setup flag */
if (first_time) { /* Set up static environment variables */
first_time = FALSE; /* Only once */
add_environment_value("REMOTE_HOST=localhost");
add_environment_value("REMOTE_ADDR=127.0.0.1");
HTSprintf0(&user_agent, "HTTP_USER_AGENT=%s/%s libwww/%s",
LYNX_NAME, LYNX_VERSION, HTLibraryVersion);
add_environment_value(user_agent);
HTSprintf0(&server_software, "SERVER_SOFTWARE=%s/%s",
LYNX_NAME, LYNX_VERSION);
add_environment_value(server_software);
}
fflush(stdout);
fflush(stderr);
CTRACE_FLUSH(tfp);
if ((pid = fork()) > 0) { /* The good, */
ssize_t chars;
off_t total_chars;
close(fd2[1]);
if (anAnchor->post_data) {
ssize_t written;
int remaining, total_written = 0;
close(fd1[0]);
/* We have form data to push across the pipe */
if (TRACE) {
CTRACE((tfp,
"LYNXCGI: Doing post, content-type '%s'\n",
anAnchor->post_content_type));
CTRACE((tfp, "LYNXCGI: Writing:\n"));
trace_bstring(anAnchor->post_data);
CTRACE((tfp, "----------------------------------\n"));
}
remaining = BStrLen(anAnchor->post_data);
while ((written = write(fd1[1],
BStrData(anAnchor->post_data) + total_written,
(size_t) remaining)) != 0) {
if (written < 0) {
#ifdef EINTR
if (errno == EINTR)
continue;
#endif /* EINTR */
#ifdef ERESTARTSYS
if (errno == ERESTARTSYS)
continue;
#endif /* ERESTARTSYS */
PERROR("write() of POST data failed");
break;
}
CTRACE((tfp, "LYNXCGI: Wrote %d bytes of POST data.\n",
(int) written));
total_written += (int) written;
remaining -= (int) written;
if (remaining == 0)
break;
}
if (remaining != 0) {
CTRACE((tfp, "LYNXCGI: %d bytes remain unwritten!\n",
remaining));
}
close(fd1[1]);
}
HTReadProgress(total_chars = 0, (off_t) 0);
while ((chars = read(fd2[0], buf, sizeof(buf))) != 0) {
if (chars < 0) {
#ifdef EINTR
if (errno == EINTR)
continue;
#endif /* EINTR */
#ifdef ERESTARTSYS
if (errno == ERESTARTSYS)
continue;
#endif /* ERESTARTSYS */
PERROR("read() of CGI output failed");
break;
}
total_chars += (int) chars;
HTReadProgress(total_chars, (off_t) 0);
CTRACE((tfp, "LYNXCGI: Rx: %.*s\n", (int) chars, buf));
(*target->isa->put_block) (target, buf, (int) chars);
}
if (chars < 0 && total_chars == 0) {
status = HT_NOT_LOADED;
(*target->isa->_abort) (target, NULL);
target = NULL;
} else if (chars != 0) {
status = HT_PARTIAL_CONTENT;
} else {
status = HT_LOADED;
}
#ifndef HAVE_WAITPID
while (wait(&wstatus) != pid) ; /* do nothing */
#else
while (-1 == waitpid(pid, &wstatus, 0)) { /* wait for child */
#ifdef EINTR
if (errno == EINTR)
continue;
#endif /* EINTR */
#ifdef ERESTARTSYS
if (errno == ERESTARTSYS)
continue;
#endif /* ERESTARTSYS */
break;
}
#endif /* !HAVE_WAITPID */
close(fd2[0]);
} else if (pid == 0) { /* The Bad, */
char **argv = NULL;
int argv_cnt = 3; /* name, one arg and terminator */
char **cur_argv = NULL;
int exec_errno;
/* Set up output pipe */
close(fd2[0]);
dup2(fd2[1], fileno(stdout)); /* Should check success code */
dup2(fd2[1], fileno(stderr));
close(fd2[1]);
if (non_empty(language)) {
HTSprintf0(&accept_language, "HTTP_ACCEPT_LANGUAGE=%s", language);
add_environment_value(accept_language);
}
if (non_empty(pref_charset)) {
cp = NULL;
StrAllocCopy(cp, "HTTP_ACCEPT_CHARSET=");
StrAllocCat(cp, pref_charset);
add_environment_value(cp);
}
if (anAnchor->post_data &&
anAnchor->post_content_type) {
cp = NULL;
StrAllocCopy(cp, "CONTENT_TYPE=");
StrAllocCat(cp, anAnchor->post_content_type);
add_environment_value(cp);
}
if (anAnchor->post_data) { /* post script, read stdin */
close(fd1[1]);
dup2(fd1[0], fileno(stdin));
close(fd1[0]);
/* Build environment variables */
add_environment_value("REQUEST_METHOD=POST");
HTSprintf0(&post_len, "CONTENT_LENGTH=%d",
BStrLen(anAnchor->post_data));
add_environment_value(post_len);
} else {
close(fileno(stdin));
if (anAnchor->isHEAD) {
add_environment_value("REQUEST_METHOD=HEAD");
}
}
/*
* Set up argument line, mainly for <index> scripts
*/
if (pgm_args != NULL) {
for (cp = pgm_args; *cp != '\0'; cp++) {
if (*cp == '+') {
argv_cnt++;
}
}
}
argv = (char **) malloc((unsigned) argv_cnt * sizeof(char *));
if (argv == NULL) {
outofmem(__FILE__, "LYCgi");
}
assert(argv != NULL);
cur_argv = argv + 1; /* For argv[0] */
if (pgm_args != NULL) {
char *cr;
/* Data for a get/search form */
if (is_www_index) {
add_environment_value("REQUEST_METHOD=SEARCH");
} else if (!anAnchor->isHEAD && !anAnchor->post_data) {
add_environment_value("REQUEST_METHOD=GET");
}
cp = NULL;
StrAllocCopy(cp, "QUERY_STRING=");
StrAllocCat(cp, pgm_args);
add_environment_value(cp);
/*
* Split up arguments into argv array
*/
cp = pgm_args;
cr = cp;
while (1) {
if (*cp == '\0') {
*(cur_argv++) = HTUnEscape(cr);
break;
} else if (*cp == '+') {
*cp++ = '\0';
*(cur_argv++) = HTUnEscape(cr);
cr = cp;
}
cp++;
}
} else if (!anAnchor->isHEAD && !anAnchor->post_data) {
add_environment_value("REQUEST_METHOD=GET");
}
*cur_argv = NULL; /* Terminate argv */
argv[0] = pgm;
/* Begin WebSter Mods -jkt */
if (LYCgiDocumentRoot != NULL) {
/* Add DOCUMENT_ROOT to env */
cp = NULL;
StrAllocCopy(cp, "DOCUMENT_ROOT=");
StrAllocCat(cp, LYCgiDocumentRoot);
add_environment_value(cp);
}
if (path_info != NULL) {
/* Add PATH_INFO to env */
cp = NULL;
StrAllocCopy(cp, "PATH_INFO=");
StrAllocCat(cp, path_info);
add_environment_value(cp);
}
if (LYCgiDocumentRoot != NULL && path_info != NULL) {
/* Construct and add PATH_TRANSLATED to env */
StrAllocCopy(document_root, LYCgiDocumentRoot);
LYTrimHtmlSep(document_root);
path_translated = document_root;
StrAllocCat(path_translated, path_info);
cp = NULL;
StrAllocCopy(cp, "PATH_TRANSLATED=");
StrAllocCat(cp, path_translated);
add_environment_value(cp);
FREE(path_translated);
}
/* End WebSter Mods -jkt */
execve(argv[0], argv, env);
exec_errno = errno;
PERROR("execve failed");
printf("Content-Type: text/plain\r\n\r\n");
if (!anAnchor->isHEAD) {
printf("exec of %s failed", pgm);
printf(": %s.\r\n", LYStrerror(exec_errno));
}
fflush(stdout);
fflush(stderr);
_exit(1);
} else { /* and the Ugly */
HTAlert(CONNECT_FAILED);
PERROR("fork() failed");
close(fd1[0]);
close(fd1[1]);
close(fd2[0]);
close(fd2[1]);
status = -1;
}
}
if (target != NULL) {
(*target->isa->_free) (target);
}
}
FREE(path_info);
FREE(pgm);
FREE(orig_pgm);
#else /* VMS */
HTStream *target;
char *buf = 0;
target = HTStreamStack(WWW_HTML,
format_out,
sink, anAnchor);
HTSprintf0(&buf, "<html>\n<head>\n<title>%s</title>\n</head>\n<body>\n",
gettext("Good Advice"));
PUTS(buf);
HTSprintf0(&buf, "<h1>%s</h1>\n", gettext("Good Advice"));
PUTS(buf);
HTSprintf0(&buf, "%s <a\n",
gettext("An excellent http server for VMS is available via"));
PUTS(buf);
HTSprintf0(&buf,
"href=\"http://www.ecr6.ohio-state.edu/www/doc/serverinfo.html\"\n");
PUTS(buf);
HTSprintf0(&buf, ">%s</a>.\n", gettext("this link"));
PUTS(buf);
HTSprintf0(&buf, "<p>%s\n",
gettext("It provides state of the art CGI script support.\n"));
PUTS(buf);
HTSprintf0(&buf, "</body>\n</html>\n");
PUTS(buf);
(*target->isa->_free) (target);
FREE(buf);
status = HT_LOADED;
#endif /* VMS */
#else /* LYNXCGI_LINKS */
HTUserMsg(CGI_NOT_COMPILED);
status = HT_NOT_LOADED;
#endif /* LYNXCGI_LINKS */
(void) arg;
(void) anAnchor;
(void) format_out;
(void) sink;
return (status);
}
static void PrvImgView(WND wnd)
{
int fd, len;
ruint16 i, j;
char tmp[10];
struct img_data *picture;
unsigned char *p;
COLORVAL color;
MemSet(tmp, 0, 10);
fd = RalOpenFile((char *)&fileList[imgfocusedList]);
if (fd == -1 )
{
GdiTextOut(wnd, "File Not Found", StrLen("File Not Found"), 20, 300);
return ;
}
//GdiTextOut(wnd, "check", StrLen("test"), 140, 10);
picture = NULL;
len = StrLen(fileList[imgfocusedList]);
p = &fileList[imgfocusedList][len-3];
if ( !StrNCmp(p, "jpg", 3) || !StrNCmp(p, "JPG", 3) )
{
picture = img_jpeg_read(fd, 240, 320);
}
else if ( !StrNCmp(p, "gif", 3) || !StrNCmp(p, "GIF", 3) )
{
picture = img_gif_read(fd, 240, 320);
}
else if ( !StrNCmp(p, "png", 3) || !StrNCmp(p, "PNG", 3) )
{
picture = img_png_read(fd, 240, 320);
}
if (picture == NULL)
{
GdiTextOut(wnd, "Image File Read fail", StrLen("Image File Read fail"), 20, 300);
return ;
}
imgStateID = IMAGEVIEW_STATE_FILE_SHOW;
GdiLockScreen(wnd);
GdiClrScreen(wnd, COLOR_BLACK);
StrIToA(picture->size, tmp);
//GdiTextOut(wnd, tmp, StrLen(tmp), 100, 310);
p = picture->data;
for(i=0; i<picture->height; i++)
{
for(j=0; j<picture->width; j++)
{
color = *p <<8 | (*(p+1) );
GdiSetPixel(wnd, j, i, color );
p += 2;
}
}
GdiTextOut(wnd, fileList[imgfocusedList], StrLen(fileList[imgfocusedList]), 80, 300);
if (picture)
{
if (picture->data)
free(picture->data);
free(picture);
}
GdiUnlockScreen(wnd);
}
