backup
/
gps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gps/GPSResources/tcpmpVerOld/network/http_win32.c

1038 lines
22 KiB
C
Executable File
Raw Blame History

/*****************************************************************************
*
* This program is free software ; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: http_win32.c 615 2006-01-26 16:57:51Z picard $
*
* The Core Pocket Media Player
* Copyright (c) 2004-2005 Gabor Kovacs
*
****************************************************************************/
#include "../common/common.h"
#include "http.h"
//#define DUMPHTTP
#define TIMEOUT_CONNECT 30
#define TIMEOUT_READ 180
#if defined(TARGET_WIN32) || defined(TARGET_WINCE)
#ifndef STRICT
#define STRICT
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#if _MSC_VER > 1000
#pragma warning(disable : 4201)
#endif
#include <wininet.h>
#define MAXPRAGMA 512
#define SEEK_READ 65536
typedef HANDLE HINTERNET;
#define HTTP_QUERY_CONTENT_TYPE 1
#define HTTP_QUERY_CONTENT_LENGTH 5
#define HTTP_QUERY_STATUS_CODE 19
#define HTTP_QUERY_STATUS_TEXT 20
#define HTTP_QUERY_RAW_HEADERS 21
#define HTTP_QUERY_RAW_HEADERS_CRLF 22
#define HTTP_QUERY_ACCEPT_RANGES 42
#define HTTP_QUERY_PRAGMA 17
#define HTTP_QUERY_CUSTOM 65535
#define INTERNET_OPEN_TYPE_DIRECT 1
#define INTERNET_FLAG_NO_CACHE_WRITE 0x04000000
#define INTERNET_OPTION_CONNECT_TIMEOUT 2
typedef struct http
{
stream Stream;
HINTERNET Internet;
HINTERNET Handle;
filepos_t Length;
filepos_t Pos;
bool_t Silent;
bool_t Ranges;
bool_t ReOpen;
pin Comments;
bool_t Pending;
void* Complete;
DWORD CompleteResult;
DWORD Avail;
uint32_t MetaInt;
uint32_t MetaLeft;
char* EnumBuffer;
char* EnumPos;
int EnumType;
const tchar_t* Exts;
bool_t ExtFilter;
int AccessType;
int CodePage;
tchar_t URL[MAXPATH];
tchar_t Base[MAXPATH];
tchar_t ContentType[MAXPATH];
tchar_t PragmaSend[MAXPRAGMA];
tchar_t PragmaGet[MAXPRAGMA];
BOOL (WINAPI* InternetGoOnline)(LPCTSTR, HWND, DWORD);
} http;
static int Get(http* p, int No, void* Data, int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case STREAM_URL: GETSTRING(p->URL); break;
case STREAM_BASE: GETSTRING(p->Base); break;
case STREAM_SILENT: GETVALUE(p->Silent,bool_t); break;
case STREAM_LENGTH: GETVALUECOND(p->Length,int,p->Length>=0); break;
case STREAM_CONTENTTYPE: GETSTRING(p->ContentType); break;
case STREAM_COMMENT: GETVALUE(p->Comments,pin); break;
case STREAM_PRAGMA_SEND: GETSTRING(p->PragmaSend); break;
case STREAM_PRAGMA_GET: GETSTRING(p->PragmaGet); break;
}
return Result;
}
static NOINLINE void GetLine(const tchar_t* In,tchar_t* Out,int OutLen)
{
while (IsSpace(*In)) ++In;
for (;*In && *In!=10 && *In!=13 && OutLen>1;++In,++Out,--OutLen)
*Out = *In;
*Out=0;
}
static void ProcessHead(http* p,const tchar_t* Head)
{
tchar_t s[128];
#ifdef DUMPHTTP
FILE* Dump;
Dump = fopen("\\dumphttp.head","wb+");
if (Dump)
{
fwrite(Head,1,tcslen(Head)*sizeof(tchar_t),Dump);
fclose(Dump);
}
#endif
while (*Head)
{
if (tcsncmp(Head,T("Content-Type:"),13)==0 || tcsncmp(Head,T("content-type:"),13)==0)
{
GetLine(Head+13,p->ContentType,MAXPATH);
tcsupr(p->ContentType);
}
if (tcsncmp(Head,T("icy-genre:"),10)==0)
{
tcscpy_s(s,TSIZEOF(s),T("GENRE="));
GetLine(Head+10,s+6,128-6);
if (p->Comments.Node)
p->Comments.Node->Set(p->Comments.Node,p->Comments.No,s,sizeof(s));
}
else
if (tcsncmp(Head,T("icy-name:"),9)==0)
{
tcscpy_s(s,TSIZEOF(s),T("TITLE="));
GetLine(Head+9,s+6,128-6);
if (p->Comments.Node)
p->Comments.Node->Set(p->Comments.Node,p->Comments.No,s,sizeof(s));
}
else
if (tcsncmp(Head,T("icy-metaint:"),12)==0)
{
GetLine(Head+12,s,128);
p->MetaLeft = p->MetaInt = StringToInt(s,0);
}
while (*Head && *Head != 10)
++Head;
if (*Head == 10)
++Head;
}
}
#ifdef DUMPHTTP
static FILE* Dump = NULL;
#endif
static void CALLBACK InternetCallback(HINTERNET hInternet,
DWORD dwContext,
DWORD dwInternetStatus,
LPVOID lpvStatusInformation,
DWORD dwStatusInformationLength)
{
if (dwInternetStatus == INTERNET_STATUS_REQUEST_COMPLETE)
{
INTERNET_ASYNC_RESULT *Result = (INTERNET_ASYNC_RESULT*)lpvStatusInformation;
http *p = (http*)dwContext;
p->CompleteResult = Result->dwResult;
EventSet(p->Complete);
}
}
static DWORD Pending(http* p,DWORD v,int Timeout)
{
if (v || GetLastError()!=ERROR_IO_PENDING)
return v;
p->Pending = 1;
if (EventWait(p->Complete,GetTimeFreq()*Timeout))
{
int Result = p->CompleteResult;
p->Pending = 0;
return Result;
}
return 0;
}
static int Open(http* p, const tchar_t* URL, bool_t ReOpen, bool_t UsePragma)
{
int Again = 0;
again:
if (p->Handle)
{
InternetCloseHandle(p->Handle);
p->Handle = 0;
}
if (p->Internet)
{
InternetCloseHandle(p->Internet);
p->Internet = 0;
}
//DEBUG_MSG(-1,T("closed %d"),p->Pending);
if (p->Pending)
{
EventWait(p->Complete,GetTimeFreq());
p->Pending = 0;
}
p->ContentType[0] = 0;
p->Length = -1;
if (!ReOpen)
{
p->AccessType = INTERNET_OPEN_TYPE_DIRECT;
p->URL[0] = 0;
}
else
Sleep(200);
free(p->EnumBuffer);
p->EnumBuffer = NULL;
p->EnumPos = NULL;
p->EnumType =0;
p->MetaInt = 0;
p->MetaLeft = 0;
p->ReOpen = 0;
#ifdef DUMPHTTP
if (Dump)
{
fclose(Dump);
Dump = NULL;
}
#endif
if (URL && URL[0])
{
tchar_t URL2[MAXPATH];
tchar_t s[MAXPRAGMA+32];
DWORD n;
int Secure = 0;
#ifdef DUMPHTTP
Dump = fopen("\\dumphttp.asf","wb+");
#endif
if (tcsnicmp(URL,T("https"),5)==0)
Secure = INTERNET_FLAG_SECURE|INTERNET_FLAG_KEEP_CONNECTION;
if (tcsnicmp(URL,T("mms://"),6)==0)
{
tcscpy_s(URL2,TSIZEOF(URL2),T("http://"));
tcscat_s(URL2,TSIZEOF(URL2),URL+6);
URL = URL2;
}
if (!ReOpen && p->InternetGoOnline)
p->InternetGoOnline(URL,Context()->Wnd,0);
retry:
//WMP9 p->Internet = InternetOpen(T("NSPlayer/4.1.0.3928"),p->AccessType,NULL,NULL,INTERNET_FLAG_ASYNC);
p->Internet = InternetOpen(T("NSPlayer/10.0.0.3802"),p->AccessType,NULL,NULL,INTERNET_FLAG_ASYNC);
InternetSetStatusCallback(p->Internet,InternetCallback);
s[0] = 0;
if (ReOpen && p->Ranges && p->Pos>0)
stprintf_s(s,TSIZEOF(s),T("Range: bytes=%d-\n"),p->Pos);
else
p->Pos = 0;
if (UsePragma)
tcscat_s(s,TSIZEOF(s),p->PragmaSend);
//DEBUG_MSG1(-1,T("open %d"),p->Pending);
p->Handle = (HANDLE)Pending(p,(DWORD)InternetOpenUrl(p->Internet, URL, s, (DWORD)-1, INTERNET_FLAG_NO_CACHE_WRITE|Secure, (DWORD)p),TIMEOUT_CONNECT);
if (!p->Handle)
{
if (!ReOpen && p->AccessType == INTERNET_OPEN_TYPE_DIRECT)
{
p->AccessType = INTERNET_OPEN_TYPE_PRECONFIG;
InternetCloseHandle(p->Internet);
goto retry;
}
if (!ReOpen && !p->Silent)
{
if (URL2==URL)
ShowError(0,ERR_ID,ERR_MIME_NOT_FOUND,T("MMS"));
else
ShowError(0,ERR_ID,ERR_CONNECT_FAILED,URL);
}
return ERR_FILE_NOT_FOUND;
}
n = sizeof(p->URL);
if (!InternetQueryOption(p->Handle, INTERNET_OPTION_URL, p->URL, &n))
tcscpy_s(p->URL,TSIZEOF(p->URL),URL);
SplitURL(p->URL,p->Base,TSIZEOF(p->Base),p->Base,TSIZEOF(p->Base),NULL,0,NULL,0);
n = sizeof(p->ContentType);
if (!HttpQueryInfo(p->Handle, HTTP_QUERY_CONTENT_TYPE , p->ContentType, &n, NULL))
p->ContentType[0] = 0;
tcsupr(p->ContentType);
n = sizeof(s);
if (HttpQueryInfo(p->Handle, HTTP_QUERY_STATUS_CODE , &s, &n, NULL) && n>0)
{
n = StringToInt(s,0);
//DEBUG_MSG1(-1,T("HTTP status %d"),n);
if (n>=400 && n<500) // client error
{
if (Again<5 && n!=404 && n!=410)
{
++Again;
if (!ReOpen)
Sleep(200);
goto again;
}
if (!ReOpen && !p->Silent)
switch (n)
{
case 401:
ShowError(0,ERR_ID,ERR_UNAUTHORIZED);
break;
case 404:
case 410:
ShowError(0,ERR_ID,ERR_FILE_NOT_FOUND,URL);
break;
default:
ShowError(0,ERR_ID,ERR_CONNECT_FAILED);
break;
}
return ERR_FILE_NOT_FOUND;
}
}
n = sizeof(s);
if (HttpQueryInfo(p->Handle, HTTP_QUERY_CONTENT_LENGTH , &s, &n, NULL) && n>0)
{
n = StringToInt(s,0);
if (n>0)
p->Length = n + p->Pos;
}
if (UsePragma)
{
DWORD No = 0;
p->PragmaGet[0] = 0;
for (;;)
{
n = (TSIZEOF(p->PragmaGet) - tcslen(p->PragmaGet) - 2)*sizeof(tchar_t);
if (!HttpQueryInfo(p->Handle, HTTP_QUERY_PRAGMA, p->PragmaGet+tcslen(p->PragmaGet), &n, &No) || n<=0)
break;
tcscat_s(p->PragmaGet,TSIZEOF(p->PragmaGet),T(","));
++No;
}
{
tchar_t* Head;
n = 0;
HttpQueryInfo(p->Handle, HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &n, NULL);
if (n>0 && (Head = (tchar_t*)malloc(n))!=NULL)
{
if (HttpQueryInfo(p->Handle, HTTP_QUERY_RAW_HEADERS_CRLF, Head, &n, NULL))
ProcessHead(p,Head);
free(Head);
}
}
}
if (!ReOpen)
{
n = sizeof(s);
if (HttpQueryInfo(p->Handle, HTTP_QUERY_ACCEPT_RANGES, s, &n, NULL) && n>0)
{
tcsupr(s);
p->Ranges = tcsstr(s,T("BYTES")) != NULL;
}
else
p->Ranges = p->Length>0; // assume range support for fixed length files
}
}
else
p->Length = -1;
return ERR_NONE;
}
static int Set(http* p, int No, const void* Data, int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case STREAM_COMMENT: SETVALUE(p->Comments,pin,ERR_NONE); break;
case STREAM_SILENT: SETVALUE(p->Silent,bool_t,ERR_NONE); break;
case STREAM_PRAGMA_SEND: SETSTRING(p->PragmaSend); p->ReOpen = 1; break;
case STREAM_PRAGMA_GET: SETSTRING(p->PragmaGet); break;
case STREAM_URL:
tcscpy_s(p->PragmaSend,TSIZEOF(p->PragmaSend),
T("Icy-MetaData:1\n")
T("Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=4294967295:4294967295,request-context=1,max-duration=2147492981\n"));
Result = Open(p,(const tchar_t*)Data,0,1);
break;
}
return Result;
}
static void ProcessMeta(http* p,char* Meta,int Size)
{
tchar_t s[128];
char *i,*j;
for (i=Meta;i<Meta+Size;i++)
if (memcmp(i,"StreamTitle='",13)==0 && i[13]!='\'')
{
for (j=i+13;j<Meta+Size;++j)
if (*j=='\'')
break;
*j=0;
tcscpy_s(s,TSIZEOF(s),T("TITLE="));
StrToTcs(s+6,TSIZEOF(s)-6,i+13);
if (p->Comments.Node)
p->Comments.Node->Set(p->Comments.Node,p->Comments.No,s,sizeof(s));
break;
}
}
static int DataAvailable(http* p)
{
for (;;)
{
if (p->Pending)
{
if (EventWait(p->Complete,0))
{
//DEBUG_MSG(-1,T("avail %d"),p->Avail);
p->Pending = 0;
return p->Avail;
}
break;
}
p->Avail = 0;
if (InternetQueryDataAvailable(p->Handle,&p->Avail,0,0))
{
if (p->Avail==0)
return -1;
return p->Avail;
}
if (GetLastError()!=ERROR_IO_PENDING)
return -1;
//DEBUG_MSG(-1,T("pending"));
p->Pending = 1;
}
return 0;
}
static int Read(http* p,void* Data,int Size)
{
#ifdef DUMPHTTP
static bool_t SkipDump = 0;
#endif
DWORD Readed;
DWORD Error;
if (p->Pending && EventWait(p->Complete,GetTimeFreq()*TIMEOUT_READ))
p->Pending = 0;
if (!p->Pending && Pending(p,InternetReadFile(p->Handle,Data,Size,&Readed),TIMEOUT_READ))
{
//DEBUG_MSG2(-1,T("readed %d %d"),Size,Readed);
p->Pos += Readed;
if (p->Pos == (int)Readed && Readed > 16)
{
int Code;
tchar_t Head[16];
GetAsciiToken(Head,16,Data,Readed);
if (stscanf(Head,T("ICY %d"),&Code)==1)
{
unsigned int n;
char* ch = (char*)Data;
if (Code!=200)
return -1;
tcscpy_s(p->ContentType,TSIZEOF(p->ContentType),T("AUDIO/MPEG")); // default for ICY
for (n=0;n<Readed-4;++n,++ch)
if (ch[0]==10 && (ch[1]==10 || (ch[1]==13 && ch[2]==10)))
{
tchar_t* Head;
n += 2;
if (ch[1]==13)
++n;
Head = malloc(sizeof(tchar_t)*(n+1));
if (Head)
{
ch[0] = 0;
StrToTcs(Head,n+1,(char*)Data);
ProcessHead(p,Head);
free(Head);
}
Readed -= n;
memmove(Data,(char*)Data+n,Readed);
break;
}
}
}
if (p->MetaInt>0)
{
if (p->MetaLeft < Readed)
{
uint32_t Len;
uint8_t* b = (uint8_t*)Data;
while (p->MetaLeft < Readed)
{
// skip data bytes
b += p->MetaLeft;
Readed -= p->MetaLeft;
Len = *b * 16;
if (--Readed < Len)
{
// need more meta data
char Meta[16*255+1];
memcpy(Meta,b+1,Readed);
if (p->Pending && EventWait(p->Complete,GetTimeFreq()*TIMEOUT_READ))
p->Pending = 0;
if (!p->Pending && Pending(p,InternetReadFile(p->Handle,Meta+Readed,Len-Readed,&Readed),TIMEOUT_READ))
{
p->Pos += Readed;
ProcessMeta(p,Meta,Len);
}
else
goto error;
Readed = 0;
}
else
{
Readed -= Len;
if (Len)
ProcessMeta(p,(char*)(b+1),Len);
memmove(b,b+1+Len,Readed);
}
p->MetaLeft = p->MetaInt;
}
p->MetaLeft -= Readed;
b += Readed;
Len = b-(uint8_t*)Data;
#ifdef DUMPHTTP
SkipDump = 1;
#endif
Readed = Read(p,b,Size-Len);
#ifdef DUMPHTTP
SkipDump = 0;
#endif
if (Readed>=0)
Readed += Len;
}
else
p->MetaLeft -= Readed;
}
#ifdef DUMPHTTP
if (!SkipDump && Dump)
fwrite(Data,1,Readed,Dump);
#endif
return Readed;
}
error:
Error = GetLastError();
if (p->Pending || Error == ERROR_NOT_CONNECTED || Error == ERROR_INVALID_HANDLE)
Open(p,p->URL,1,1);
return -1;
}
static int ReadBlock(http* p,block* Block,int Ofs,int Size)
{
return Read(p,(char*)(Block->Ptr+Ofs),Size);
}
static filepos_t Seek(http* p,filepos_t Pos,int SeekMode)
{
filepos_t Length;
switch (SeekMode)
{
case SEEK_CUR:
Pos += p->Pos;
break;
case SEEK_END:
if (p->Length<0)
return -1;
Pos += p->Length;
break;
}
Length = Pos - p->Pos;
if (Length<0 && Pos < SEEK_READ)
{
p->Pos = 0;
Open(p,p->URL,1,1);
Length = Pos - p->Pos;
}
if (Length == 0 && !p->ReOpen)
return p->Pos;
if (Length > 0 && Length < SEEK_READ && !p->ReOpen)
{
int Len = (int)Length;
void* Buffer = malloc(Len);
if (Buffer)
{
Read(p,Buffer,Len);
free(Buffer);
if (p->Pos == Pos)
return Pos;
}
}
if (p->Ranges || !Pos)
{
p->Pos = Pos;
if (Open(p,p->URL,1,1) == ERR_NONE)
return p->Pos;
}
return -1;
}
static char* FindUpper(char* p,const char* s)
{
int i;
for (i=0;*p && s[i];++p)
if (toupper(p[0]) == s[i])
++i;
else
i=0;
return s[i] ? NULL:p;
}
typedef struct htmlchar
{
uint8_t ch;
char sym[6+1];
} htmlchar;
static const htmlchar HTMLChar[] =
{
{34,"quot"},
{38,"amp"},
{60,"lt"},
{62,"gt"},
{160,"nbsp"},
{161,"iexcl"},
{162,"cent"},
{163,"pound"},
{164,"curren"},
{165,"yen"},
{166,"brvbar"},
{167,"sect"},
{168,"uml"},
{169,"copy"},
{170,"ordf"},
{171,"laquo"},
{172,"not"},
{173,"shy"},
{174,"reg"},
{175,"hibar"},
{176,"deg"},
{177,"plusmn"},
{185,"sup1"},
{178,"sup2"},
{179,"sup3"},
{180,"acute"},
{181,"micro"},
{182,"para"},
{183,"middot"},
{184,"cedil"},
{186,"ordm"},
{187,"raquo"},
{188,"frac14"},
{189,"frac12"},
{190,"frac34"},
{191,"iquest"},
{192,"Agrave"},
{193,"Aacute"},
{194,"Acirc"},
{195,"Atilde"},
{196,"Auml"},
{197,"Aring"},
{198,"AElig"},
{199,"Ccedil"},
{200,"Egrave"},
{201,"Eacute"},
{202,"Ecirc"},
{203,"Euml"},
{204,"Igrave"},
{205,"Iacute"},
{206,"Icirc"},
{207,"Iuml"},
{208,"ETH"},
{209,"Ntilde"},
{210,"Ograve"},
{211,"Oacute"},
{212,"Ocirc"},
{213,"Otilde"},
{214,"Ouml"},
{215,"times"},
{216,"Oslash"},
{217,"Ugrave"},
{218,"Uacute"},
{219,"Ucirc"},
{220,"Uuml"},
{221,"Yacute"},
{222,"THORN"},
{223,"szlig"},
{224,"agrave"},
{225,"aacute"},
{226,"acirc"},
{227,"atilde"},
{228,"auml"},
{229,"aring"},
{230,"aelig"},
{231,"ccedil"},
{232,"egrave"},
{233,"eacute"},
{234,"ecirc"},
{235,"euml"},
{236,"igrave"},
{237,"iacute"},
{238,"icirc"},
{239,"iuml"},
{240,"eth"},
{241,"ntilde"},
{242,"ograve"},
{243,"oacute"},
{244,"ocirc"},
{245,"otilde"},
{246,"ouml"},
{247,"divide"},
{248,"oslash"},
{249,"ugrave"},
{250,"uacute"},
{251,"ucirc"},
{252,"uuml"},
{253,"yacute"},
{254,"thorn"},
{255,"yuml"},
{0},
};
static void HTMLCharParse(char* p)
{
char* i;
for (;*p;++p)
if (*p=='&' && (i=strchr(p,';'))!=NULL)
{
const htmlchar* c;
int n = i-p-1;
for (c=HTMLChar;c->ch;++c)
if (strncmp(c->sym,p+1,n)==0 && c->sym[n]==0)
{
*p = c->ch;
memmove(p+1,i+1,strlen(i));
break;
}
}
}
static void HTMLURLParse(char* p)
{
for (;*p;++p)
if (p[0]=='%' && Hex(p[1])>=0 && Hex(p[2])>=0)
{
*p = (char)((Hex(p[1])<<4)+Hex(p[2]));
memmove(p+1,p+3,strlen(p+3)+1);
}
}
// detect Apache directory listing order links
static bool_t ListingOrder(const tchar_t* Base,const tchar_t* FileName)
{
tchar_t Path[MAXPATH];
int n = tcslen(Base);
AbsPath(Path,TSIZEOF(Path),FileName,Base);
return tcsncmp(Path,Base,n)==0 && tcsnicmp(Path+n,T("/?C="),4)==0;
}
static int EnumDir(http* p,const tchar_t* URL,const tchar_t* Exts,bool_t ExtFilter,streamdir* Item)
{
if (URL)
{
tchar_t Head[16];
int Pos;
int Result = Open(p,URL,0,0);
if (Result != ERR_NONE)
return Result;
if (!tcsstr(p->ContentType,T("TEXT/HTML")))
{
Open(p,NULL,0,0);
return ERR_NOT_DIRECTORY;
}
if (p->Length<=0)
p->Length = 256*1024-1;
if (p->Length >= 512*1024)
p->Length = 512*1024-1;
p->EnumBuffer = malloc((int)p->Length+1);
if (!p->EnumBuffer)
return ERR_OUT_OF_MEMORY;
Pos = 0;
while (Pos<p->Length)
{
int Size = Read(p,p->EnumBuffer+Pos,p->Length-Pos);
if (Size <= 0)
break;
Pos += Size;
}
GetAsciiToken(Head,16,p->EnumBuffer,p->Length);
if (tcsnicmp(Head,T("<ASX"),4)==0 ||
tcsnicmp(Head,T("[playlist]"),10)==0 ||
tcsnicmp(Head,T("[Reference]"),11)==0)
{
Open(p,NULL,0,0);
return ERR_NOT_DIRECTORY;
}
p->CodePage = GetCodePage(p->ContentType);
p->EnumBuffer[Pos] = 0;
p->EnumPos = p->EnumBuffer;
p->EnumType =0;
p->Exts = Exts;
p->ExtFilter = ExtFilter;
}
while (p->EnumType<4)
{
const char* Tag1;
const char* Tag2;
switch (p->EnumType)
{
case 0:
Tag1 = "<A ";
Tag2 = "HREF=";
break;
case 1:
Tag1 = "<AREA ";
Tag2 = "HREF=";
break;
case 2:
Tag1 = "<EMBED ";
Tag2 = "HREF=";
break;
default:
Tag1 = "<EMBED ";
Tag2 = "SRC=";
break;
}
while (p->EnumPos && (p->EnumPos = FindUpper(p->EnumPos,Tag1))!=NULL)
{
char* End;
p->EnumPos = FindUpper(p->EnumPos,Tag2);
if (!p->EnumPos)
break;
if (*p->EnumPos=='"' || *p->EnumPos=='\'')
{
++p->EnumPos;
End = strchr(p->EnumPos,p->EnumPos[-1]);
}
else
End = strchr(p->EnumPos,'>');
if (End)
{
int Len;
char Endch = *End;
*End=0;
HTMLCharParse(p->EnumPos);
StrToTcsEx(Item->FileName,TSIZEOF(Item->FileName),p->EnumPos,p->CodePage);
HTMLURLParse(p->EnumPos);
StrToTcsEx(Item->DisplayName,TSIZEOF(Item->DisplayName),p->EnumPos,p->CodePage);
*End = Endch;
p->EnumPos = End+1;
Item->Date = -1;
Item->Size = -1;
Len = tcslen(Item->FileName);
if (ListingOrder(p->Base,Item->FileName))
continue;
if (Len && Item->FileName[Len-1]=='/')
{
Item->FileName[Len-1]=0;
return ERR_NONE;
}
if (CheckExts(Item->FileName,T("html:H;htm:H;asp:H;php:H")))
return ERR_NONE;
Item->Type = CheckExts(Item->FileName,p->Exts);
Item->Size = 0;
if (Item->Type || !p->ExtFilter)
return ERR_NONE;
}
}
p->EnumPos = p->EnumBuffer;
++p->EnumType;
}
Open(p,NULL,0,0);
return ERR_END_OF_FILE;
}
static int Create(http* p)
{
HMODULE Module;
p->Stream.Get = (nodeget)Get,
p->Stream.Set = (nodeset)Set,
p->Stream.Read = Read;
p->Stream.ReadBlock = ReadBlock;
p->Stream.Seek = Seek;
p->Stream.EnumDir = EnumDir;
p->Stream.DataAvailable = DataAvailable;
p->Complete = EventCreate(0,0);
Module = GetModuleHandle(T("wininet.dll"));
#ifdef UNICODE
GetProc(&Module,&p->InternetGoOnline,T("InternetGoOnlineW"),1);
#else
GetProc(&Module,&p->InternetGoOnline,T("InternetGoOnlineA"),1);
#endif
return ERR_NONE;
}
static void Delete(http* p)
{
Open(p,NULL,0,0);
EventClose(p->Complete);
}
static const nodedef HTTP =
{
sizeof(http),
HTTP_ID,
STREAM_CLASS,
PRI_MINIMUM,
(nodecreate)Create,
(nodedelete)Delete,
};
static const nodedef MMS =
{
0, // parent size
MMS_ID,
HTTP_ID,
PRI_MINIMUM,
};
void HTTP_Init()
{
NodeRegisterClass(&HTTP);
NodeRegisterClass(&MMS);
}
void HTTP_Done()
{
NodeUnRegisterClass(MMS_ID);
NodeUnRegisterClass(HTTP_ID);
}
#endif
Reference in New Issue View Git Blame Copy Permalink