开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
http_win32.c
资源名称：tcpmp.rar　[点击查看]
上传用户：wstnjxml
上传日期：2014-04-03
资源大小：7248k
文件大小：22k
源码类别：

Windows CE

开发平台：

C/C++

http_win32.c：源码内容
  1. /*****************************************************************************
  2.  *
  3.  * This program is free software ; you can redistribute it and/or modify
  4.  * it under the terms of the GNU General Public License as published by
  5.  * the Free Software Foundation; either version 2 of the License, or
  6.  * (at your option) any later version.
  7.  *
  8.  * This program is distributed in the hope that it will be useful,
  9.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11.  * GNU General Public License for more details.
  12.  *
  13.  * You should have received a copy of the GNU General Public License
  14.  * along with this program; if not, write to the Free Software
  15.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16.  *
  17.  * $Id: http_win32.c 615 2006-01-26 16:57:51Z picard $
  18.  *
  19.  * The Core Pocket Media Player
  20.  * Copyright (c) 2004-2005 Gabor Kovacs
  21.  *
  22.  ****************************************************************************/
  24. #include "../common/common.h"
  25. #include "http.h"
  27. //#define DUMPHTTP
  29. #define TIMEOUT_CONNECT 30
  30. #define TIMEOUT_READ 180
  32. #if defined(TARGET_WIN32) || defined(TARGET_WINCE)
  34. #ifndef STRICT
  35. #define STRICT
  36. #endif
  37. #define WIN32_LEAN_AND_MEAN
  38. #include <windows.h>
  39. #if _MSC_VER > 1000
  40. #pragma warning(disable : 4201)
  41. #endif
  42. #include <wininet.h>
  44. #define MAXPRAGMA 512
  45. #define SEEK_READ 65536
  47. typedef HANDLE HINTERNET;
  48. #define HTTP_QUERY_CONTENT_TYPE 1
  49. #define HTTP_QUERY_CONTENT_LENGTH 5
  50. #define HTTP_QUERY_STATUS_CODE 19
  51. #define HTTP_QUERY_STATUS_TEXT 20
  52. #define HTTP_QUERY_RAW_HEADERS          21
  53. #define HTTP_QUERY_RAW_HEADERS_CRLF     22
  54. #define HTTP_QUERY_ACCEPT_RANGES        42
  55. #define HTTP_QUERY_PRAGMA               17
  56. #define HTTP_QUERY_CUSTOM               65535
  58. #define INTERNET_OPEN_TYPE_DIRECT 1
  59. #define INTERNET_FLAG_NO_CACHE_WRITE    0x04000000
  60. #define INTERNET_OPTION_CONNECT_TIMEOUT 2
  62. typedef struct http
  63. {
  64. stream Stream;
  65. HINTERNET Internet;
  66. HINTERNET Handle;
  67. filepos_t Length;
  68. filepos_t Pos;
  69. bool_t Silent;
  70. bool_t Ranges;
  71. bool_t ReOpen;
  72. pin Comments;
  74. bool_t Pending;
  75. void* Complete;
  76. DWORD CompleteResult;
  77. DWORD Avail;
  79. uint32_t MetaInt;
  80. uint32_t MetaLeft;
  82. char* EnumBuffer;
  83. char* EnumPos;
  84. int EnumType;
  85. const tchar_t* Exts;
  86. bool_t ExtFilter;
  87. int AccessType;
  88. int CodePage;
  90. tchar_t URL[MAXPATH];
  91. tchar_t Base[MAXPATH];
  92. tchar_t ContentType[MAXPATH];
  93. tchar_t PragmaSend[MAXPRAGMA];
  94. tchar_t PragmaGet[MAXPRAGMA];
  96. BOOL (WINAPI* InternetGoOnline)(LPCTSTR, HWND, DWORD);
  98. } http;
  100. static int Get(http* p, int No, void* Data, int Size)
  101. {
  102. int Result = ERR_INVALID_PARAM;
  103. switch (No)
  104. {
  105. case STREAM_URL: GETSTRING(p->URL); break;
  106. case STREAM_BASE: GETSTRING(p->Base); break;
  107. case STREAM_SILENT: GETVALUE(p->Silent,bool_t); break;
  108. case STREAM_LENGTH: GETVALUECOND(p->Length,int,p->Length>=0); break;
  109. case STREAM_CONTENTTYPE: GETSTRING(p->ContentType); break;
  110. case STREAM_COMMENT: GETVALUE(p->Comments,pin); break;
  111. case STREAM_PRAGMA_SEND: GETSTRING(p->PragmaSend); break;
  112. case STREAM_PRAGMA_GET: GETSTRING(p->PragmaGet); break;
  113. }
  114. return Result;
  115. }
  117. static NOINLINE void GetLine(const tchar_t* In,tchar_t* Out,int OutLen)
  118. {
  119. while (IsSpace(*In)) ++In;
  120. for (;*In && *In!=10 && *In!=13 && OutLen>1;++In,++Out,--OutLen)
  121. *Out = *In;
  122. *Out=0;
  123. }
  125. static void ProcessHead(http* p,const tchar_t* Head)
  126. {
  127. tchar_t s[128];
  129. #ifdef DUMPHTTP
  130. FILE* Dump;
  131. Dump = fopen("\dumphttp.head","wb+");
  132. if (Dump)
  133. {
  134. fwrite(Head,1,tcslen(Head)*sizeof(tchar_t),Dump);
  135. fclose(Dump);
  136. }
  137. #endif
  139. while (*Head)
  140. {
  141. if (tcsncmp(Head,T("Content-Type:"),13)==0 || tcsncmp(Head,T("content-type:"),13)==0)
  142. {
  143. GetLine(Head+13,p->ContentType,MAXPATH);
  144. tcsupr(p->ContentType);
  145. }
  147. if (tcsncmp(Head,T("icy-genre:"),10)==0)
  148. {
  149. tcscpy_s(s,TSIZEOF(s),T("GENRE="));
  150. GetLine(Head+10,s+6,128-6);
  151. if (p->Comments.Node)
  152. p->Comments.Node->Set(p->Comments.Node,p->Comments.No,s,sizeof(s));
  153. }
  154. else
  155. if (tcsncmp(Head,T("icy-name:"),9)==0)
  156. {
  157. tcscpy_s(s,TSIZEOF(s),T("TITLE="));
  158. GetLine(Head+9,s+6,128-6);
  159. if (p->Comments.Node)
  160. p->Comments.Node->Set(p->Comments.Node,p->Comments.No,s,sizeof(s));
  161. }
  162. else
  163. if (tcsncmp(Head,T("icy-metaint:"),12)==0)
  164. {
  165. GetLine(Head+12,s,128);
  166. p->MetaLeft = p->MetaInt = StringToInt(s,0);
  167. }
  169. while (*Head && *Head != 10)
  170. ++Head;
  171. if (*Head == 10) 
  172. ++Head;
  173. }
  174. }
  176. #ifdef DUMPHTTP
  177. static FILE* Dump = NULL;
  178. #endif
  180. static void CALLBACK InternetCallback(HINTERNET hInternet,
  181.                                DWORD dwContext,
  182.                                DWORD dwInternetStatus,
  183.                                LPVOID lpvStatusInformation,
  184.                                DWORD dwStatusInformationLength)
  185. {
  186. if (dwInternetStatus == INTERNET_STATUS_REQUEST_COMPLETE)
  187. {
  188. INTERNET_ASYNC_RESULT *Result = (INTERNET_ASYNC_RESULT*)lpvStatusInformation;
  189. http *p = (http*)dwContext;
  190. p->CompleteResult = Result->dwResult;
  191. EventSet(p->Complete);
  192. }
  193. }
  195. static DWORD Pending(http* p,DWORD v,int Timeout)
  196. {
  197. if (v || GetLastError()!=ERROR_IO_PENDING)
  198. return v;
  200. p->Pending = 1;
  201. if (EventWait(p->Complete,GetTimeFreq()*Timeout))
  202. {
  203. int Result = p->CompleteResult;
  204. p->Pending = 0;
  205. return Result;
  206. }
  207. return 0;
  208. }
  210. static int Open(http* p, const tchar_t* URL, bool_t ReOpen, bool_t UsePragma)
  211. {
  212. int Again = 0;
  214. again:
  215. if (p->Handle)
  216. {
  217. InternetCloseHandle(p->Handle);
  218. p->Handle = 0;
  219. }
  220. if (p->Internet)
  221. {
  222. InternetCloseHandle(p->Internet);
  223. p->Internet = 0;
  224. }
  226. //DEBUG_MSG(-1,T("closed %d"),p->Pending);
  227. if (p->Pending)
  228. {
  229. EventWait(p->Complete,GetTimeFreq());
  230. p->Pending = 0;
  231. }
  233. p->ContentType[0] = 0;
  234. p->Length = -1;
  235. if (!ReOpen)
  236. {
  237. p->AccessType = INTERNET_OPEN_TYPE_DIRECT;
  238. p->URL[0] = 0;
  239. }
  240. else
  241. Sleep(200);
  243. free(p->EnumBuffer);
  244. p->EnumBuffer = NULL;
  245. p->EnumPos = NULL;
  246. p->EnumType =0;
  247. p->MetaInt = 0;
  248. p->MetaLeft = 0;
  249. p->ReOpen = 0;
  251. #ifdef DUMPHTTP
  252. if (Dump)
  253. {
  254. fclose(Dump);
  255. Dump = NULL;
  256. }
  257. #endif
  259. if (URL && URL[0])
  260. {
  261. tchar_t URL2[MAXPATH];
  262. tchar_t s[MAXPRAGMA+32];
  263. DWORD n;
  264. int Secure = 0;
  266. #ifdef DUMPHTTP
  267. Dump = fopen("\dumphttp.asf","wb+");
  268. #endif
  270. if (tcsnicmp(URL,T("https"),5)==0)
  271. Secure = INTERNET_FLAG_SECURE|INTERNET_FLAG_KEEP_CONNECTION;
  273. if (tcsnicmp(URL,T("mms://"),6)==0)
  274. {
  275. tcscpy_s(URL2,TSIZEOF(URL2),T("http://"));
  276. tcscat_s(URL2,TSIZEOF(URL2),URL+6);
  277. URL = URL2;
  278. }
  280. if (!ReOpen && p->InternetGoOnline)
  281. p->InternetGoOnline(URL,Context()->Wnd,0);
  284. retry:
  285. //WMP9 p->Internet = InternetOpen(T("NSPlayer/4.1.0.3928"),p->AccessType,NULL,NULL,INTERNET_FLAG_ASYNC); 
  286. p->Internet = InternetOpen(T("NSPlayer/10.0.0.3802"),p->AccessType,NULL,NULL,INTERNET_FLAG_ASYNC); 
  287. InternetSetStatusCallback(p->Internet,InternetCallback);
  289. s[0] = 0;
  290. if (ReOpen && p->Ranges && p->Pos>0)
  291. stprintf_s(s,TSIZEOF(s),T("Range: bytes=%d-n"),p->Pos);
  292. else
  293. p->Pos = 0;
  295. if (UsePragma)
  296. tcscat_s(s,TSIZEOF(s),p->PragmaSend);
  298. //DEBUG_MSG1(-1,T("open %d"),p->Pending);
  300. p->Handle = (HANDLE)Pending(p,(DWORD)InternetOpenUrl(p->Internet, URL, s, (DWORD)-1, INTERNET_FLAG_NO_CACHE_WRITE|Secure, (DWORD)p),TIMEOUT_CONNECT);
  301. if (!p->Handle)
  302. {
  303. if (!ReOpen && p->AccessType == INTERNET_OPEN_TYPE_DIRECT)
  304. {
  305. p->AccessType = INTERNET_OPEN_TYPE_PRECONFIG;
  306. InternetCloseHandle(p->Internet);
  307. goto retry;
  308. }
  310. if (!ReOpen && !p->Silent)
  311. {
  312. if (URL2==URL)
  313. ShowError(0,ERR_ID,ERR_MIME_NOT_FOUND,T("MMS"));
  314. else
  315. ShowError(0,ERR_ID,ERR_CONNECT_FAILED,URL);
  316. }
  317. return ERR_FILE_NOT_FOUND;
  318. }
  320. n = sizeof(p->URL);
  321. if (!InternetQueryOption(p->Handle, INTERNET_OPTION_URL, p->URL, &n))
  322. tcscpy_s(p->URL,TSIZEOF(p->URL),URL);
  324. SplitURL(p->URL,p->Base,TSIZEOF(p->Base),p->Base,TSIZEOF(p->Base),NULL,0,NULL,0);
  326. n = sizeof(p->ContentType);
  327. if (!HttpQueryInfo(p->Handle, HTTP_QUERY_CONTENT_TYPE , p->ContentType, &n, NULL))
  328. p->ContentType[0] = 0;
  330. tcsupr(p->ContentType);
  332. n = sizeof(s);
  333. if (HttpQueryInfo(p->Handle, HTTP_QUERY_STATUS_CODE , &s, &n, NULL) && n>0)
  334. {
  335. n = StringToInt(s,0);
  336. //DEBUG_MSG1(-1,T("HTTP status %d"),n);
  337. if (n>=400 && n<500) // client error
  338. {
  339. if (Again<5 && n!=404 && n!=410)
  340. {
  341. ++Again;
  342. if (!ReOpen)
  343. Sleep(200);
  344. goto again;
  345. }
  347. if (!ReOpen && !p->Silent)
  348. switch (n)
  349. {
  350. case 401:
  351. ShowError(0,ERR_ID,ERR_UNAUTHORIZED);
  352. break;
  353. case 404:
  354. case 410:
  355. ShowError(0,ERR_ID,ERR_FILE_NOT_FOUND,URL);
  356. break;
  357. default:
  358. ShowError(0,ERR_ID,ERR_CONNECT_FAILED);
  359. break;
  360. }
  362. return ERR_FILE_NOT_FOUND;
  363. }
  364. }
  366. n = sizeof(s);
  367. if (HttpQueryInfo(p->Handle, HTTP_QUERY_CONTENT_LENGTH , &s, &n, NULL) && n>0)
  368. {
  369. n = StringToInt(s,0);
  370. if (n>0)
  371. p->Length = n + p->Pos;
  372. }
  374. if (UsePragma)
  375. {
  376. DWORD No = 0;
  377. p->PragmaGet[0] = 0;
  378. for (;;)
  379. {
  380. n = (TSIZEOF(p->PragmaGet) - tcslen(p->PragmaGet) - 2)*sizeof(tchar_t);
  381. if (!HttpQueryInfo(p->Handle, HTTP_QUERY_PRAGMA, p->PragmaGet+tcslen(p->PragmaGet), &n, &No) || n<=0)
  382. break;
  383. tcscat_s(p->PragmaGet,TSIZEOF(p->PragmaGet),T(","));
  384. ++No;
  385. }
  387. {
  388. tchar_t* Head;
  389. n = 0;
  390. HttpQueryInfo(p->Handle, HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &n, NULL);
  391. if (n>0 && (Head = (tchar_t*)malloc(n))!=NULL)
  392. {
  393. if (HttpQueryInfo(p->Handle, HTTP_QUERY_RAW_HEADERS_CRLF, Head, &n, NULL))
  394. ProcessHead(p,Head);
  395. free(Head);
  396. }
  397. }
  398. }
  400. if (!ReOpen)
  401. {
  402. n = sizeof(s);
  403. if (HttpQueryInfo(p->Handle, HTTP_QUERY_ACCEPT_RANGES, s, &n, NULL) && n>0)
  404. {
  405. tcsupr(s);
  406. p->Ranges = tcsstr(s,T("BYTES")) != NULL;
  407. }
  408. else 
  409. p->Ranges = p->Length>0; // assume range support for fixed length files
  410. }
  411. }
  412. else
  413. p->Length = -1;
  414. return ERR_NONE;
  415. }
  417. static int Set(http* p, int No, const void* Data, int Size)
  418. {
  419. int Result = ERR_INVALID_PARAM;
  420. switch (No)
  421. {
  422. case STREAM_COMMENT: SETVALUE(p->Comments,pin,ERR_NONE); break;
  423. case STREAM_SILENT: SETVALUE(p->Silent,bool_t,ERR_NONE); break;
  424. case STREAM_PRAGMA_SEND: SETSTRING(p->PragmaSend); p->ReOpen = 1; break;
  425. case STREAM_PRAGMA_GET: SETSTRING(p->PragmaGet); break;
  426. case STREAM_URL:
  427. tcscpy_s(p->PragmaSend,TSIZEOF(p->PragmaSend),
  428. T("Icy-MetaData:1n")
  429. T("Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=4294967295:4294967295,request-context=1,max-duration=2147492981n"));
  430. Result = Open(p,(const tchar_t*)Data,0,1);
  431. break;
  432. }
  433. return Result;
  434. }
  436. static void ProcessMeta(http* p,char* Meta,int Size)
  437. {
  438. tchar_t s[128];
  439. char *i,*j;
  440. for (i=Meta;i<Meta+Size;i++)
  441. if (memcmp(i,"StreamTitle='",13)==0 && i[13]!=''')
  442. {
  443. for (j=i+13;j<Meta+Size;++j)
  444. if (*j==''')
  445. break;
  446. *j=0;
  447. tcscpy_s(s,TSIZEOF(s),T("TITLE="));
  448. StrToTcs(s+6,TSIZEOF(s)-6,i+13);
  449. if (p->Comments.Node)
  450. p->Comments.Node->Set(p->Comments.Node,p->Comments.No,s,sizeof(s));
  451. break;
  452. }
  453. }
  455. static int DataAvailable(http* p)
  456. {
  457. for (;;)
  458. {
  459. if (p->Pending)
  460. {
  461. if (EventWait(p->Complete,0))
  462. {
  463. //DEBUG_MSG(-1,T("avail %d"),p->Avail);
  464. p->Pending = 0;
  465. return p->Avail;
  466. }
  467. break;
  468. }
  470. p->Avail = 0;
  471. if (InternetQueryDataAvailable(p->Handle,&p->Avail,0,0))
  472. {
  473. if (p->Avail==0)
  474. return -1;
  475. return p->Avail;
  476. }
  478. if (GetLastError()!=ERROR_IO_PENDING)
  479. return -1;
  481. //DEBUG_MSG(-1,T("pending"));
  482. p->Pending = 1;
  483. }
  484. return 0;
  485. }
  487. static int Read(http* p,void* Data,int Size)
  488. {
  489. #ifdef DUMPHTTP
  490. static bool_t SkipDump = 0;
  491. #endif
  493. DWORD Readed;
  494. DWORD Error;
  496. if (p->Pending && EventWait(p->Complete,GetTimeFreq()*TIMEOUT_READ))
  497. p->Pending = 0;
  499. if (!p->Pending && Pending(p,InternetReadFile(p->Handle,Data,Size,&Readed),TIMEOUT_READ))
  500. {
  501. //DEBUG_MSG2(-1,T("readed %d %d"),Size,Readed);
  503. p->Pos += Readed;
  504. if (p->Pos == (int)Readed && Readed > 16)
  505. {
  506. int Code;
  507. tchar_t Head[16];
  509. GetAsciiToken(Head,16,Data,Readed);
  510. if (stscanf(Head,T("ICY %d"),&Code)==1)
  511. {
  512. unsigned int n;
  513. char* ch = (char*)Data;
  515. if (Code!=200)
  516. return -1;
  518. tcscpy_s(p->ContentType,TSIZEOF(p->ContentType),T("AUDIO/MPEG")); // default for ICY
  520. for (n=0;n<Readed-4;++n,++ch)
  521. if (ch[0]==10 && (ch[1]==10 || (ch[1]==13 && ch[2]==10)))
  522. {
  523. tchar_t* Head;
  525. n += 2;
  526. if (ch[1]==13)
  527. ++n;
  529. Head = malloc(sizeof(tchar_t)*(n+1));
  530. if (Head)
  531. {
  532. ch[0] = 0;
  533. StrToTcs(Head,n+1,(char*)Data);
  534. ProcessHead(p,Head);
  535. free(Head);
  536. }
  538. Readed -= n;
  539. memmove(Data,(char*)Data+n,Readed);
  540. break;
  541. }
  542. }
  543. }
  545. if (p->MetaInt>0)
  546. {
  547. if (p->MetaLeft < Readed)
  548. {
  549. uint32_t Len;
  550. uint8_t* b = (uint8_t*)Data;
  552. while (p->MetaLeft < Readed)
  553. {
  554. // skip data bytes
  555. b += p->MetaLeft;
  556. Readed -= p->MetaLeft;
  558. Len = *b * 16;
  559. if (--Readed < Len)
  560. {
  561. // need more meta data 
  563. char Meta[16*255+1];
  564. memcpy(Meta,b+1,Readed);
  566. if (p->Pending && EventWait(p->Complete,GetTimeFreq()*TIMEOUT_READ))
  567. p->Pending = 0;
  569. if (!p->Pending && Pending(p,InternetReadFile(p->Handle,Meta+Readed,Len-Readed,&Readed),TIMEOUT_READ))
  570. {
  571. p->Pos += Readed;
  572. ProcessMeta(p,Meta,Len);
  573. }
  574. else
  575. goto error;
  577. Readed = 0;
  578. }
  579. else
  580. {
  581. Readed -= Len;
  582. if (Len)
  583. ProcessMeta(p,(char*)(b+1),Len);
  584. memmove(b,b+1+Len,Readed);
  585. }
  587. p->MetaLeft = p->MetaInt;
  588. }
  590. p->MetaLeft -= Readed;
  591. b += Readed;
  593. Len = b-(uint8_t*)Data;
  594. #ifdef DUMPHTTP
  595. SkipDump = 1;
  596. #endif
  597. Readed = Read(p,b,Size-Len);
  598. #ifdef DUMPHTTP
  599. SkipDump = 0;
  600. #endif
  602. if (Readed>=0)
  603. Readed += Len;
  604. }
  605. else
  606. p->MetaLeft -= Readed;
  607. }
  609. #ifdef DUMPHTTP
  610. if (!SkipDump && Dump)
  611. fwrite(Data,1,Readed,Dump);
  612. #endif
  613. return Readed;
  614. }
  616. error:
  617. Error = GetLastError();
  619. if (p->Pending || Error == ERROR_NOT_CONNECTED || Error == ERROR_INVALID_HANDLE)
  620. Open(p,p->URL,1,1);
  622. return -1;
  623. }
  625. static int ReadBlock(http* p,block* Block,int Ofs,int Size)
  626. {
  627. return Read(p,(char*)(Block->Ptr+Ofs),Size);
  628. }
  630. static filepos_t Seek(http* p,filepos_t Pos,int SeekMode)
  631. {
  632. filepos_t Length;
  634. switch (SeekMode)
  635. {
  636. case SEEK_CUR: 
  637. Pos += p->Pos; 
  638. break;
  639. case SEEK_END: 
  640. if (p->Length<0) 
  641. return -1;
  642. Pos += p->Length;
  643. break;
  644. }
  646. Length = Pos - p->Pos;
  647. if (Length<0 && Pos < SEEK_READ)
  648. {
  649. p->Pos = 0;
  650. Open(p,p->URL,1,1);
  651. Length = Pos - p->Pos;
  652. }
  654. if (Length == 0 && !p->ReOpen)
  655. return p->Pos;
  657. if (Length > 0 && Length < SEEK_READ && !p->ReOpen)
  658. {
  659. int Len = (int)Length;
  660. void* Buffer = malloc(Len);
  661. if (Buffer)
  662. {
  663. Read(p,Buffer,Len);
  664. free(Buffer);
  665. if (p->Pos == Pos)
  666. return Pos;
  667. }
  668. }
  670. if (p->Ranges || !Pos)
  671. {
  672. p->Pos = Pos;
  673. if (Open(p,p->URL,1,1) == ERR_NONE)
  674. return p->Pos;
  675. }
  677. return -1;
  678. }
  680. static char* FindUpper(char* p,const char* s)
  681. {
  682. int i;
  683. for (i=0;*p && s[i];++p)
  684. if (toupper(p[0]) == s[i])
  685. ++i;
  686. else
  687. i=0;
  688. return s[i] ? NULL:p;
  689. }
  691. typedef struct htmlchar
  692. {
  693. uint8_t ch;
  694. char sym[6+1];
  696. } htmlchar;
  698. static const htmlchar HTMLChar[] =
  699. {
  700. {34,"quot"},
  701. {38,"amp"},
  702. {60,"lt"},
  703. {62,"gt"},
  704. {160,"nbsp"},
  705. {161,"iexcl"},
  706. {162,"cent"},
  707. {163,"pound"},
  708. {164,"curren"},
  709. {165,"yen"},
  710. {166,"brvbar"},
  711. {167,"sect"},
  712. {168,"uml"},
  713. {169,"copy"},
  714. {170,"ordf"},
  715. {171,"laquo"},
  716. {172,"not"},
  717. {173,"shy"},
  718. {174,"reg"},
  719. {175,"hibar"},
  720. {176,"deg"},
  721. {177,"plusmn"},
  722. {185,"sup1"},
  723. {178,"sup2"},
  724. {179,"sup3"},
  725. {180,"acute"},
  726. {181,"micro"},
  727. {182,"para"},
  728. {183,"middot"},
  729. {184,"cedil"},
  730. {186,"ordm"},
  731. {187,"raquo"},
  732. {188,"frac14"},
  733. {189,"frac12"},
  734. {190,"frac34"},
  735. {191,"iquest"},
  736. {192,"Agrave"},
  737. {193,"Aacute"},
  738. {194,"Acirc"},
  739. {195,"Atilde"},
  740. {196,"Auml"},
  741. {197,"Aring"},
  742. {198,"AElig"},
  743. {199,"Ccedil"},
  744. {200,"Egrave"},
  745. {201,"Eacute"},
  746. {202,"Ecirc"},
  747. {203,"Euml"},
  748. {204,"Igrave"},
  749. {205,"Iacute"},
  750. {206,"Icirc"},
  751. {207,"Iuml"},
  752. {208,"ETH"},
  753. {209,"Ntilde"},
  754. {210,"Ograve"},
  755. {211,"Oacute"},
  756. {212,"Ocirc"},
  757. {213,"Otilde"},
  758. {214,"Ouml"},
  759. {215,"times"},
  760. {216,"Oslash"},
  761. {217,"Ugrave"},
  762. {218,"Uacute"},
  763. {219,"Ucirc"},
  764. {220,"Uuml"},
  765. {221,"Yacute"},
  766. {222,"THORN"},
  767. {223,"szlig"},
  768. {224,"agrave"},
  769. {225,"aacute"},
  770. {226,"acirc"},
  771. {227,"atilde"},
  772. {228,"auml"},
  773. {229,"aring"},
  774. {230,"aelig"},
  775. {231,"ccedil"},
  776. {232,"egrave"},
  777. {233,"eacute"},
  778. {234,"ecirc"},
  779. {235,"euml"},
  780. {236,"igrave"},
  781. {237,"iacute"},
  782. {238,"icirc"},
  783. {239,"iuml"},
  784. {240,"eth"},
  785. {241,"ntilde"},
  786. {242,"ograve"},
  787. {243,"oacute"},
  788. {244,"ocirc"},
  789. {245,"otilde"},
  790. {246,"ouml"},
  791. {247,"divide"},
  792. {248,"oslash"},
  793. {249,"ugrave"},
  794. {250,"uacute"},
  795. {251,"ucirc"},
  796. {252,"uuml"},
  797. {253,"yacute"},
  798. {254,"thorn"},
  799. {255,"yuml"},
  800. {0},
  801. };
  803. static void HTMLCharParse(char* p)
  804. {
  805. char* i;
  806. for (;*p;++p)
  807. if (*p=='&' && (i=strchr(p,';'))!=NULL)
  808. {
  809. const htmlchar* c;
  810. int n = i-p-1;
  811. for (c=HTMLChar;c->ch;++c)
  812. if (strncmp(c->sym,p+1,n)==0 && c->sym[n]==0)
  813. {
  814. *p = c->ch;
  815. memmove(p+1,i+1,strlen(i));
  816. break;
  817. }
  818. }
  819. }
  821. static void HTMLURLParse(char* p)
  822. {
  823. for (;*p;++p)
  824. if (p[0]=='%' && Hex(p[1])>=0 && Hex(p[2])>=0)
  825. {
  826. *p = (char)((Hex(p[1])<<4)+Hex(p[2]));
  827. memmove(p+1,p+3,strlen(p+3)+1);
  828. }
  829. }
  831. // detect Apache directory listing order links
  832. static bool_t ListingOrder(const tchar_t* Base,const tchar_t* FileName)
  833. {
  834. tchar_t Path[MAXPATH];
  835. int n = tcslen(Base);
  836. AbsPath(Path,TSIZEOF(Path),FileName,Base);
  837. return tcsncmp(Path,Base,n)==0 && tcsnicmp(Path+n,T("/?C="),4)==0;
  838. }
  840. static int EnumDir(http* p,const tchar_t* URL,const tchar_t* Exts,bool_t ExtFilter,streamdir* Item)
  841. {
  842. if (URL)
  843. {
  844. tchar_t Head[16];
  846. int Pos;
  847. int Result = Open(p,URL,0,0);
  848. if (Result != ERR_NONE)
  849. return Result;
  851. if (!tcsstr(p->ContentType,T("TEXT/HTML")))
  852. {
  853. Open(p,NULL,0,0);
  854. return ERR_NOT_DIRECTORY;
  855. }
  857. if (p->Length<=0)
  858. p->Length = 256*1024-1;
  859. if (p->Length >= 512*1024)
  860. p->Length = 512*1024-1;
  862. p->EnumBuffer = malloc((int)p->Length+1);
  863. if (!p->EnumBuffer)
  864. return ERR_OUT_OF_MEMORY;
  866. Pos = 0;
  867. while (Pos<p->Length)
  868. {
  869. int Size = Read(p,p->EnumBuffer+Pos,p->Length-Pos);
  870. if (Size <= 0)
  871. break;
  872. Pos += Size;
  873. }
  875. GetAsciiToken(Head,16,p->EnumBuffer,p->Length);
  876. if (tcsnicmp(Head,T("<ASX"),4)==0 || 
  877. tcsnicmp(Head,T("[playlist]"),10)==0 || 
  878. tcsnicmp(Head,T("[Reference]"),11)==0)
  879. {
  880. Open(p,NULL,0,0);
  881. return ERR_NOT_DIRECTORY;
  882. }
  884. p->CodePage = GetCodePage(p->ContentType);
  886. p->EnumBuffer[Pos] = 0;
  887. p->EnumPos = p->EnumBuffer;
  888. p->EnumType =0;
  889. p->Exts = Exts;
  890. p->ExtFilter = ExtFilter;
  891. }
  893. while (p->EnumType<4)
  894. {
  895. const char* Tag1;
  896. const char* Tag2;
  898. switch (p->EnumType)
  899. {
  900. case 0:
  901. Tag1 = "<A ";
  902. Tag2 = "HREF=";
  903. break;
  904. case 1:
  905. Tag1 = "<AREA ";
  906. Tag2 = "HREF=";
  907. break;
  908. case 2:
  909. Tag1 = "<EMBED ";
  910. Tag2 = "HREF=";
  911. break;
  912. default:
  913. Tag1 = "<EMBED ";
  914. Tag2 = "SRC=";
  915. break;
  916. }
  918. while (p->EnumPos && (p->EnumPos = FindUpper(p->EnumPos,Tag1))!=NULL)
  919. {
  920. char* End;
  921. p->EnumPos = FindUpper(p->EnumPos,Tag2);
  922. if (!p->EnumPos)
  923. break;
  924. if (*p->EnumPos=='"' || *p->EnumPos==''')
  925. {
  926. ++p->EnumPos;
  927. End = strchr(p->EnumPos,p->EnumPos[-1]);
  928. }
  929. else
  930. End = strchr(p->EnumPos,'>');
  932. if (End)
  933. {
  934. int Len;
  935. char Endch = *End;
  936. *End=0;
  938. HTMLCharParse(p->EnumPos);
  939. StrToTcsEx(Item->FileName,TSIZEOF(Item->FileName),p->EnumPos,p->CodePage);
  940. HTMLURLParse(p->EnumPos);
  941. StrToTcsEx(Item->DisplayName,TSIZEOF(Item->DisplayName),p->EnumPos,p->CodePage);
  943. *End = Endch;
  944. p->EnumPos = End+1;
  946. Item->Date = -1;
  947. Item->Size = -1;
  948. Len = tcslen(Item->FileName);
  950. if (ListingOrder(p->Base,Item->FileName))
  951. continue;
  953. if (Len && Item->FileName[Len-1]=='/')
  954. {
  955. Item->FileName[Len-1]=0;
  956. return ERR_NONE;
  957. }
  959. if (CheckExts(Item->FileName,T("html:H;htm:H;asp:H;php:H")))
  960. return ERR_NONE;
  962. Item->Type = CheckExts(Item->FileName,p->Exts);
  963. Item->Size = 0;
  965. if (Item->Type || !p->ExtFilter)
  966. return ERR_NONE;
  967. }
  968. }
  970. p->EnumPos = p->EnumBuffer;
  971. ++p->EnumType;
  972. }
  974. Open(p,NULL,0,0);
  975. return ERR_END_OF_FILE;
  976. }
  978. static int Create(http* p)
  979. {
  980. HMODULE Module;
  982. p->Stream.Get = (nodeget)Get,
  983. p->Stream.Set = (nodeset)Set,
  984. p->Stream.Read = Read;
  985. p->Stream.ReadBlock = ReadBlock;
  986. p->Stream.Seek = Seek;
  987. p->Stream.EnumDir = EnumDir;
  988. p->Stream.DataAvailable = DataAvailable;
  989. p->Complete = EventCreate(0,0);
  991. Module = GetModuleHandle(T("wininet.dll"));
  992. #ifdef UNICODE
  993. GetProc(&Module,&p->InternetGoOnline,T("InternetGoOnlineW"),1);
  994. #else
  995. GetProc(&Module,&p->InternetGoOnline,T("InternetGoOnlineA"),1);
  996. #endif
  998. return ERR_NONE;
  999. }
  1001. static void Delete(http* p)
  1002. {
  1003. Open(p,NULL,0,0);
  1004. EventClose(p->Complete);
  1005. }
  1007. static const nodedef HTTP =
  1008. {
  1009. sizeof(http),
  1010. HTTP_ID,
  1011. STREAM_CLASS,
  1012. PRI_MINIMUM,
  1013. (nodecreate)Create,
  1014. (nodedelete)Delete,
  1015. };
  1017. static const nodedef MMS =
  1018. {
  1019. 0, // parent size
  1020. MMS_ID,
  1021. HTTP_ID,
  1022. PRI_MINIMUM,
  1023. };
  1025. void HTTP_Init()
  1026. {
  1027. NodeRegisterClass(&HTTP);
  1028. NodeRegisterClass(&MMS);
  1029. }
  1031. void HTTP_Done()
  1032. {
  1033. NodeUnRegisterClass(MMS_ID);
  1034. NodeUnRegisterClass(HTTP_ID);
  1035. }
  1037. #endif