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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
HTFormat.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：17k
源码类别：

浏览器

开发平台：

Unix_Linux

HTFormat.c：源码内容
  1. /*      HTFormat.c
  2. ** MANAGE DIFFERENT FILE FORMATS
  3. **
  4. ** (c) COPYRIGHT MIT 1995.
  5. ** Please first read the full copyright statement in the file COPYRIGH.
  6. **
  7. ** Bugs:
  8. ** Assumes the incoming stream is ASCII, rather than a local file
  9. ** format, and so ALWAYS converts from ASCII on non-ASCII machines.
  10. ** Therefore, non-ASCII machines can't read local files.
  11. **
  12. ** HISTORY:
  13. ** 8 Jul 94  FM Insulate free() from _free structure element.
  14. ** 8 Nov 94  HFN Changed a lot to make reentrant
  15. */
  17. /* Library Include files */
  18. #include "tcp.h"
  19. #include "HTUtils.h"
  20. #include "HTString.h"
  21. #include "HTTCP.h"
  22. #include "HTFWrite.h"
  23. #include "HTNetMan.h"
  24. #include "HTError.h"
  25. #include "HTReqMan.h"
  26. #include "HTFormat.h"  /* Implemented here */
  28. #define NO_VALUE_FOUND -1e30  /* Stream Stack Value if none found */
  30. PRIVATE HTList * HTConversions = NULL;
  31. PRIVATE HTList * HTCharsets = NULL;
  32. PRIVATE HTList * HTEncodings = NULL;
  33. PRIVATE HTList * HTLanguages = NULL;
  35. PRIVATE double HTMaxSecs = 1e10; /* No effective limit */
  37. struct _HTStream {
  38.     CONST HTStreamClass * isa;
  39. };
  41. /* ------------------------------------------------------------------------- */
  42. /*    ACCEPT LISTS OF CONVERSIONS, ENCODINGS, LANGUAGE, AND CHARSET      */
  43. /* ------------------------------------------------------------------------- */
  45. /*
  46. ** For all `accept lists' there is a local list and a global list. The
  47. ** local list is a part of the request structure and the global list is
  48. ** internal to the HTFormat module. The global lists can be used when
  49. ** specifying accept lists for ALL requests and the local list can be 
  50. ** used to add specific accept headers to the request.
  51. */
  54. /* Define a presentation system command for a content-type
  55. ** -------------------------------------------------------
  56. ** INPUT:
  57. ** conversions: The list of conveters and presenters
  58. ** representation: the MIME-style format name
  59. ** command: the MAILCAP-style command template
  60. ** quality: A degradation faction [0..1]
  61. ** maxbytes: A limit on the length acceptable as input (0 infinite)
  62. ** maxsecs: A limit on the time user will wait (0 for infinity)
  63. */
  64. PUBLIC void HTPresentation_add (HTList * conversions,
  65. CONST char * representation,
  66. CONST char * command,
  67. CONST char * test_command,
  68. double quality,
  69. double secs, 
  70. double secs_per_byte)
  71. {
  72.     HTPresentation * pres;
  73.     if ((pres = (HTPresentation  *) HT_CALLOC(1,sizeof(HTPresentation))) == NULL)
  74.         HT_OUTOFMEM("HTSetPresentation");
  75.     
  76.     pres->rep = HTAtom_for(representation);
  77.     pres->rep_out = WWW_PRESENT; /* Fixed for now ... :-) */
  78.     pres->converter = HTSaveAndExecute; /* Fixed for now ...     */
  79.     pres->quality = quality;
  80.     pres->secs = secs;
  81.     pres->secs_per_byte = secs_per_byte;
  82.     pres->rep = HTAtom_for(representation);
  83.     pres->command = NULL;
  84.     StrAllocCopy(pres->command, command);
  85.     pres->test_command = NULL;
  86.     StrAllocCopy(pres->test_command, test_command);
  87.     HTList_addObject(conversions, pres);
  88. }
  90. PUBLIC void HTPresentation_deleteAll (HTList * list)
  91. {
  92.     if (list) {
  93. HTList *cur = list;
  94. HTPresentation *pres;
  95. while ((pres = (HTPresentation*) HTList_nextObject(cur))) {
  96.     HT_FREE(pres->command);
  97.     HT_FREE(pres);
  98. }
  99. HTList_delete(list);
  100.     }
  101. }
  103. /* Define a built-in function for a content-type
  104. ** ---------------------------------------------
  105. */
  106. PUBLIC void HTConversion_add (HTList * conversions,
  107.       CONST char * representation_in,
  108.       CONST char * representation_out,
  109.       HTConverter * converter,
  110.       double quality,
  111.       double secs, 
  112.       double secs_per_byte)
  113. {
  114.     HTPresentation * pres;
  115.     if ((pres = (HTPresentation  *) HT_CALLOC(1,sizeof(HTPresentation))) == NULL)
  116.         HT_OUTOFMEM("HTSetPresentation");
  117.     
  118.     pres->rep = HTAtom_for(representation_in);
  119.     pres->rep_out = HTAtom_for(representation_out);
  120.     pres->converter = converter;
  121.     pres->command = NULL; /* Fixed */
  122.     pres->test_command = NULL;
  123.     pres->quality = quality;
  124.     pres->secs = secs;
  125.     pres->secs_per_byte = secs_per_byte;
  126.     HTList_addObject(conversions, pres);
  127. }
  129. PUBLIC void HTConversion_deleteAll (HTList * list)
  130. {
  131.     HTPresentation_deleteAll(list);
  132. }
  134. PUBLIC void HTEncoding_add (HTList *  list,
  135.     CONST char * enc,
  136.     double quality)
  137. {
  138.     HTAcceptNode * node;
  139.     if (!list || !enc || !*enc) {
  140. if (WWWTRACE)
  141.     TTYPrint(TDEST, "Encodings... Bad argumentn");
  142. return;
  143.     }
  144.     if ((node = (HTAcceptNode *) HT_CALLOC(1, sizeof(HTAcceptNode))) == NULL)
  145.         HT_OUTOFMEM("HTAcceptEncoding");
  146.     HTList_addObject(list, (void*)node);
  148.     node->atom = HTAtom_for(enc);
  149.     node->quality = quality;
  150. }
  152. PUBLIC void HTEncoding_deleteAll (HTList * list)
  153. {
  154.     if (list) {
  155. HTList *cur = list;
  156. HTAcceptNode *pres;
  157. while ((pres = (HTAcceptNode *) HTList_nextObject(cur))) {
  158.     HT_FREE(pres);
  159. }
  160. HTList_delete(list);
  161.     }
  162. }
  164. PUBLIC void HTLanguage_add (HTList * list,
  165.     CONST char * lang,
  166.     double quality)
  167. {
  168.     HTAcceptNode * node;
  169.     if (!list || !lang || !*lang)  {
  170. if (WWWTRACE)
  171.     TTYPrint(TDEST, "Languages... Bad argumentn");
  172. return;
  173.     }
  174.     if ((node = (HTAcceptNode *) HT_CALLOC(1, sizeof(HTAcceptNode))) == NULL)
  175.         HT_OUTOFMEM("HTAcceptLanguage");
  177.     HTList_addObject(list, (void*)node);
  178.     node->atom = HTAtom_for(lang);
  179.     node->quality = quality;
  180. }
  182. PUBLIC void HTLanguage_deleteAll (HTList * list)
  183. {
  184.     HTEncoding_deleteAll(list);
  185. }
  187. PUBLIC void HTCharset_add (HTList * list,
  188.    CONST char * charset,
  189.    double quality)
  190. {
  191.     HTAcceptNode * node;
  192.     if (!list || !charset || !*charset)  {
  193. if (WWWTRACE)
  194.     TTYPrint(TDEST, "Charset..... Bad argumentn");
  195. return;
  196.     }
  197.     if ((node = (HTAcceptNode *) HT_CALLOC(1, sizeof(HTAcceptNode))) == NULL)
  198.         HT_OUTOFMEM("HTAcceptCharsetuage");
  200.     HTList_addObject(list, (void*)node);
  201.     node->atom = HTAtom_for(charset);
  202.     node->quality = quality;
  203. }
  205. PUBLIC void HTCharset_deleteAll (HTList * list)
  206. {
  207.     HTEncoding_deleteAll(list);
  208. }
  210. /* ------------------------------------------------------------------------- */
  211. /*  GLOBAL LIST OF CONVERTERS ETC.      */
  212. /* ------------------------------------------------------------------------- */
  214. /*
  215. ** Global Accept Format Types Conversions
  216. ** list can be NULL
  217. */
  218. PUBLIC void HTFormat_setConversion (HTList * list)
  219. {
  220.     HTConversions = list;
  221. }
  223. PUBLIC HTList * HTFormat_conversion (void)
  224. {
  225.     return HTConversions;
  226. }
  228. /*
  229. ** Global Accept Encodings
  230. ** list can be NULL
  231. */
  232. PUBLIC void HTFormat_setEncoding (HTList *list)
  233. {
  234.     HTEncodings = list;
  235. }
  237. PUBLIC HTList * HTFormat_encoding (void)
  238. {
  239.     return HTEncodings;
  240. }
  242. /*
  243. ** Global Accept Languages
  244. ** list can be NULL
  245. */
  246. PUBLIC void HTFormat_setLanguage (HTList *list)
  247. {
  248.     HTLanguages = list;
  249. }
  251. PUBLIC HTList * HTFormat_language (void)
  252. {
  253.     return HTLanguages;
  254. }
  256. /*
  257. ** Global Accept Charsets
  258. ** list can be NULL
  259. */
  260. PUBLIC void HTFormat_setCharset (HTList *list)
  261. {
  262.     HTCharsets = list;
  263. }
  265. PUBLIC HTList * HTFormat_charset (void)
  266. {
  267.     return HTCharsets;
  268. }
  270. /*
  271. ** Convenience function to clean up
  272. */
  273. PUBLIC void HTFormat_deleteAll (void)
  274. {
  275.     if (HTConversions) {
  276. HTConversion_deleteAll(HTConversions);
  277. HTConversions = NULL;
  278.     }
  279.     if (HTLanguages) {
  280. HTLanguage_deleteAll(HTLanguages);
  281. HTLanguages = NULL;
  282.     }
  283.     if (HTEncodings) {
  284. HTEncoding_deleteAll(HTEncodings);
  285. HTEncodings = NULL;
  286.     }
  287.     if (HTCharsets) {
  288. HTCharset_deleteAll(HTCharsets);
  289. HTCharsets = NULL;
  290.     }
  291. }
  293. /* ------------------------------------------------------------------------- */
  294. /*  FORMAT NEGOTIATION      */
  295. /* ------------------------------------------------------------------------- */
  297. PRIVATE BOOL better_match (HTFormat f, HTFormat g)
  298. {
  299.     CONST char *p, *q;
  301.     if (f && g  &&  (p = HTAtom_name(f))  &&  (q = HTAtom_name(g))) {
  302. int i,j;
  303. for(i=0 ; *p; p++) if (*p == '*') i++;
  304. for(j=0 ; *q; q++) if (*q == '*') j++;
  305. if (i < j) return YES;
  306.     }
  307.     return NO;
  308. }
  311. PRIVATE BOOL wild_match (HTAtom * tmplate, HTAtom * actual)
  312. {
  313.     char *t, *a, *st, *sa;
  314.     BOOL match = NO;
  316.     if (tmplate && actual && (t = HTAtom_name(tmplate))) {
  317. if (!strcmp(t, "*"))
  318.     return YES;
  320. if (strchr(t, '*') &&
  321.     (a = HTAtom_name(actual)) &&
  322.     (st = strchr(t, '/')) && (sa = strchr(a,'/'))) {
  324.     *sa = 0;
  325.     *st = 0;
  327.     if ((*(st-1)=='*' &&
  328.  (*(st+1)=='*' || !strcasecomp(st+1, sa+1))) ||
  329. (*(st+1)=='*' && !strcasecomp(t,a)))
  330. match = YES;
  332.     *sa = '/';
  333.     *st = '/';
  334. }    
  335.     }
  336.     return match;
  337. }
  339. /*
  340.  * Added by takada@seraph.ntt.jp (94/04/08)
  341.  */
  342. PRIVATE BOOL lang_match (HTAtom * tmplate, HTAtom * actual)
  343. {
  344.     char *t, *a, *st, *sa;
  345.     BOOL match = NO;
  347.     if (tmplate && actual &&
  348. (t = HTAtom_name(tmplate)) && (a = HTAtom_name(actual))) {
  349. st = strchr(t, '_');
  350. sa = strchr(a, '_');
  351. if ((st != NULL) && (sa != NULL)) {
  352.     if (!strcasecomp(t, a))
  353.       match = YES;
  354.     else
  355.       match = NO;
  356. }
  357. else {
  358.     if (st != NULL) *st = 0;
  359.     if (sa != NULL) *sa = 0;
  360.     if (!strcasecomp(t, a))
  361.       match = YES;
  362.     else
  363.       match = NO;
  364.     if (st != NULL) *st = '_';
  365.     if (sa != NULL) *sa = '_';
  366. }
  367.     }
  368.     return match;
  369. }
  370. /* end of addition */
  374. PRIVATE double type_value (HTAtom * content_type, HTList * accepted)
  375. {
  376.     HTList * cur = accepted;
  377.     HTPresentation * pres;
  378.     HTPresentation * wild = NULL;
  380.     if (!content_type || !accepted) return -1;
  382.     while ((pres = (HTPresentation*)HTList_nextObject(cur))) {
  383. if (pres->rep == content_type)
  384.     return pres->quality;
  385. else if (wild_match(pres->rep, content_type))
  386.     wild = pres;
  387.     }
  388.     if (wild) return wild->quality;
  389.     else return -1;
  390. }
  393. PRIVATE double lang_value (HTAtom * language, HTList * accepted)
  394. {
  395.     HTList * cur = accepted;
  396.     HTAcceptNode * node;
  397.     HTAcceptNode * wild = NULL;
  399.     if (!language || !accepted || HTList_isEmpty(accepted)) {
  400. return 0.1;
  401.     }
  403.     while ((node = (HTAcceptNode*)HTList_nextObject(cur))) {
  404. if (node->atom == language) {
  405.     return node->quality;
  406. }
  407. /*
  408.  * patch by takada@seraph.ntt.jp (94/04/08)
  409.  * the original line was
  410.  * else if (wild_match(node->atom, language)) {
  411.  * and the new line is
  412.  */
  413. else if (lang_match(node->atom, language)) {
  414.     wild = node;
  415. }
  416.     }
  418.     if (wild) {
  419. return wild->quality;
  420.     }
  421.     else {
  422. return 0.1;
  423.     }
  424. }
  427. PRIVATE double encoding_value (HTAtom * encoding, HTList * accepted)
  428. {
  429.     HTList * cur = accepted;
  430.     HTAcceptNode * node;
  431.     HTAcceptNode * wild = NULL;
  432.     char * e;
  434.     if (!encoding || !accepted || HTList_isEmpty(accepted))
  435. return 1;
  437.     e = HTAtom_name(encoding);
  438.     if (!strcmp(e, "7bit") || !strcmp(e, "8bit") || !strcmp(e, "binary"))
  439. return 1;
  441.     while ((node = (HTAcceptNode*)HTList_nextObject(cur))) {
  442. if (node->atom == encoding)
  443.     return node->quality;
  444. else if (wild_match(node->atom, encoding))
  445.     wild = node;
  446.     }
  447.     if (wild) return wild->quality;
  448.     else return 1;
  449. }
  452. PUBLIC BOOL HTRank (HTList * possibilities,
  453.     HTList * accepted_content_types,
  454.     HTList * accepted_languages,
  455.     HTList * accepted_encodings)
  456. {
  457.     int accepted_cnt = 0;
  458.     HTList * accepted;
  459.     HTList * sorted;
  460.     HTList * cur;
  461.     HTContentDescription * d;
  463.     if (!possibilities) return NO;
  465.     accepted = HTList_new();
  466.     cur = possibilities;
  467.     while ((d = (HTContentDescription*)HTList_nextObject(cur))) {
  468. double tv = type_value(d->content_type, accepted_content_types);
  469. double lv = lang_value(d->content_language, accepted_languages);
  470. double ev = encoding_value(d->content_encoding, accepted_encodings);
  472. if (tv > 0) {
  473.     d->quality *= tv * lv * ev;
  474.     HTList_addObject(accepted, d);
  475.     accepted_cnt++;
  476. }
  477. else {
  478.     if (d->filename) HT_FREE(d->filename);
  479.     HT_FREE(d);
  480. }
  481.     }
  483.     if (PROT_TRACE) TTYPrint(TDEST, "Ranking.....n");
  484.     if (PROT_TRACE) TTYPrint(TDEST,
  485.    "nRANK QUALITY CONTENT-TYPE         LANGUAGE ENCODING    FILEn");
  487.     sorted = HTList_new();
  488.     while (accepted_cnt-- > 0) {
  489. HTContentDescription * worst = NULL;
  490. cur = accepted;
  491. while ((d = (HTContentDescription*)HTList_nextObject(cur))) {
  492.     if (!worst || d->quality < worst->quality)
  493. worst = d;
  494. }
  495. if (worst) {
  496.     if (PROT_TRACE)
  497. TTYPrint(TDEST, "%d.   %.4f  %-20.20s %-8.8s %-10.10s %sn",
  498. accepted_cnt+1,
  499. worst->quality,
  500. (worst->content_type
  501.          ? HTAtom_name(worst->content_type)      : "-"),
  502. (worst->content_language
  503.          ? HTAtom_name(worst->content_language)  :"-"),
  504. (worst->content_encoding
  505.          ? HTAtom_name(worst->content_encoding)  :"-"),
  506. (worst->filename
  507.          ? worst->filename                       :"-"));
  508.     HTList_removeObject(accepted, (void*)worst);
  509.     HTList_addObject(sorted, (void*)worst);
  510. }
  511.     }
  512.     if (PROT_TRACE) TTYPrint(TDEST, "n");
  513.     HTList_delete(accepted);
  514.     HTList_delete(possibilities->next);
  515.     possibilities->next = sorted->next;
  516.     sorted->next = NULL;
  517.     HTList_delete(sorted);
  519.     if (!HTList_isEmpty(possibilities)) return YES;
  520.     else return NO;
  521. }
  524. /* Create a filter stack
  525. ** ---------------------
  526. **
  527. ** If a wildcard match is made, a temporary HTPresentation
  528. ** structure is made to hold the destination format while the
  529. ** new stack is generated. This is just to pass the out format to
  530. ** MIME so far.  Storing the format of a stream in the stream might
  531. ** be a lot neater.
  532. **
  533. ** The star/star format is special, in that if you can take
  534. ** that you can take anything.
  535. */
  536. PUBLIC HTStream * HTStreamStack (HTFormat rep_in,
  537.  HTFormat rep_out,
  538.  HTStream * output_stream,
  539.  HTRequest * request,
  540.  BOOL guess)
  541. {
  542.     HTList * conversion[2];
  543.     int which_list;
  544.     double best_quality = -1e30; /* Pretty bad! */
  545.     HTPresentation *pres, *best_match=NULL;
  546.     if (rep_out == WWW_RAW) {
  547. if (STREAM_TRACE) TTYPrint(TDEST,"StreamStack. Raw output...n");
  548. return output_stream ? output_stream : HTErrorStream();
  549.     }
  551.     if (rep_out == rep_in) {
  552. if (STREAM_TRACE)
  553.     TTYPrint(TDEST,"StreamStack. Identical input/output format (%s)n",
  554.      HTAtom_name(rep_out));
  555. return output_stream ? output_stream : HTErrorStream();
  556.     }
  557.     if (STREAM_TRACE) {
  558. char *p = HTAtom_name(rep_in);
  559. char *q = HTAtom_name(rep_out); 
  560. TTYPrint(TDEST,"StreamStack. Constructing stream stack for %s to %sn",
  561.  p ? p : "<NULL>", q ? q : "<NULL>");
  562.     }
  564.     conversion[0] = request->conversions;
  565.     conversion[1] = HTConversions;
  567.     for(which_list = 0; which_list<2; which_list++) {
  568. HTList * cur = conversion[which_list];
  569. while ((pres = (HTPresentation*)HTList_nextObject(cur))) {
  570.     if ((pres->rep==rep_in || wild_match(pres->rep, rep_in)) &&
  571. (pres->rep_out==rep_out || wild_match(pres->rep_out,rep_out))){
  572. if (!best_match || better_match(pres->rep, best_match->rep) ||
  573.     (!better_match(best_match->rep, pres->rep) &&
  574.      pres->quality > best_quality)) {
  575. #ifdef GOT_SYSTEM
  576.     int result=0;
  577.     if (pres->test_command) {
  578. result = system(pres->test_command);
  579. if (STREAM_TRACE) 
  580.     TTYPrint(TDEST, "StreamStack. system(%s) returns %dn", pres->test_command, result);
  581.     }
  582.     if (!result) {
  583. best_match = pres;
  584. best_quality = pres->quality;
  585.     }
  586. #else
  587.     best_match = pres;
  588.     best_quality = pres->quality;
  589. #endif /* GOT_SYSTEM */
  590. }
  591.     }
  592. }
  593.     }
  595.     if (best_match) {
  596.   if (rep_out == WWW_SOURCE && best_match->rep_out != WWW_SOURCE) {
  597.     if (STREAM_TRACE) TTYPrint(TDEST,"StreamStack. Source outputn");
  598.     return output_stream ? output_stream : HTErrorStream();
  599. }
  600. return (*best_match->converter)(request, best_match->command,
  601. rep_in, rep_out, output_stream);
  602.     }
  603.     if (rep_out == WWW_SOURCE) {
  604. if (STREAM_TRACE) TTYPrint(TDEST,"StreamStack. Source outputn");
  605. return output_stream ? output_stream : HTErrorStream();
  606.     }
  608.     if (STREAM_TRACE)
  609. TTYPrint(TDEST,"StreamStack. No match found, dumping to local filen");
  610.     return HTSaveLocally(request, NULL, rep_in, rep_out, output_stream);
  611. }
  614. /* Find the cost of a filter stack
  615. ** -------------------------------
  616. **
  617. ** Must return the cost of the same stack which StreamStack would set up.
  618. **
  619. ** On entry,
  620. ** length The size of the data to be converted
  621. */
  622. PUBLIC double HTStackValue (HTList * theseConversions,
  623.     HTFormat rep_in,
  624.     HTFormat rep_out,
  625.     double initial_value,
  626.     long int length)
  627. {
  628.     int which_list;
  629.     HTList* conversion[2];
  630.     
  631.     if (STREAM_TRACE) {
  632. TTYPrint(TDEST, "StackValue.. Evaluating stream stack for %s worth %.3f to %sn",
  633. HTAtom_name(rep_in), initial_value,
  634. HTAtom_name(rep_out));
  635.     }
  636.     if (rep_out == WWW_SOURCE ||
  637.      rep_out == rep_in) return 0.0;
  639.     conversion[0] = theseConversions;
  640.     conversion[1] = HTConversions;
  641.     
  642.     for(which_list = 0; which_list<2; which_list++)
  643.      if (conversion[which_list]) {
  644.         HTList * cur = conversion[which_list];
  645. HTPresentation * pres;
  646. while ((pres = (HTPresentation*)HTList_nextObject(cur))) {
  647.     if (pres->rep == rep_in &&
  648. (pres->rep_out == rep_out || wild_match(pres->rep_out, rep_out))) {
  649.         double value = initial_value * pres->quality;
  650. if (HTMaxSecs != 0.0)
  651.     value = value - (length*pres->secs_per_byte + pres->secs)
  652.                  /HTMaxSecs;
  653. return value;
  654.     }
  655. }
  656.     }
  657.     return NO_VALUE_FOUND; /* Really bad */
  658. }