home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / libnet / cvmime.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  35.6 KB  |  1,053 lines
  1. /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. /* Please leave outside of ifdef for window precompiled headers */
  20. #include "mkutils.h"
  21.  
  22. #ifdef MOZILLA_CLIENT
  23.  
  24.  
  25. #include "xp.h"
  26. #include "mkstream.h"
  27. #include "mkgeturl.h"
  28. #include "cvextcon.h"
  29. #include "mkformat.h"
  30. #include "il_strm.h"            /* Image Library stream converters. */
  31.  
  32. #include "mime.h"
  33. #include "cvactive.h"
  34. #include "cvunzip.h"
  35. #include "cvchunk.h"
  36. #include "gui.h"
  37. #include "msgcom.h"
  38. #include "msgnet.h"
  39. #include "mkautocf.h"    /* Proxy auto-config */
  40. #include "mkjscfg.h"    /* Javascript config */
  41. #include "mkhelp.h"
  42.  
  43. #include "xlate.h"        /* Text and PostScript converters */
  44. #include "libi18n.h"        /* For INTL_ConvCharCode()   */
  45. #include "edt.h"
  46. #include "secnav.h"
  47. #include "intl_csi.h"
  48.  
  49.  
  50. #ifdef JAVA
  51. #include "softupdt.h"    /* software update converters */
  52. #endif
  53.  
  54. #include "m_cvstrm.h"
  55. #include "cvmime.h"
  56.  
  57. #include "mimeenc.h"
  58.  
  59. #include "xpgetstr.h"
  60. extern int XP_EDITOR_NON_HTML;
  61.  
  62. #include "mkmarimb.h"
  63.  
  64. #ifdef CRAWLER
  65. /* crawler converters */
  66. #include "pagescan.h"
  67. #include "crawler.h"
  68. #include "robotxt.h"
  69. #endif
  70.  
  71. #ifdef MOZ_MAIL_NEWS
  72. /* #### defined in libmsg/msgutils.c */
  73. extern NET_StreamClass * 
  74. msg_MakeRebufferingStream (NET_StreamClass *next_stream,
  75.                            URL_Struct *url,
  76.                            MWContext *context);
  77. #endif /* MOZ_MAIL_NEWS */
  78.  
  79. /* defined at the bottom of this file */
  80. NET_StreamClass *
  81. NET_PrintRawToDisk(int format_out, 
  82.                    void *data_obj,
  83.                    URL_Struct *url_struct, 
  84.                    MWContext *context);
  85.  
  86. #ifdef MOZ_MAIL_NEWS
  87. typedef struct MIME_DataObject {
  88.   MimeDecoderData *decoder;        /* State used by the decoder */  
  89.   NET_StreamClass *next_stream;    /* Where the output goes */
  90.   XP_Bool partial_p;            /* Whether we should close that stream */
  91. } MIME_DataObject;
  92.  
  93.  
  94.  
  95.  
  96.  
  97. static int
  98. net_mime_decoder_cb (const char *buf, int32 size, void *closure)
  99. {
  100.   MIME_DataObject *obj = (MIME_DataObject *) closure;
  101.   NET_StreamClass *stream = (obj ? obj->next_stream : 0);
  102.   if (stream)
  103.     return stream->put_block (stream, (char *) buf, size);
  104.   else
  105.     return 0;
  106. }
  107.  
  108. static int
  109. net_MimeEncodingConverterWrite (NET_StreamClass *stream, CONST char* buffer,
  110.                                 int32 length)
  111. {
  112.   MIME_DataObject *obj = (MIME_DataObject *) stream->data_object;  
  113.   return MimeDecoderWrite (obj->decoder, (char *) buffer, length);
  114. }
  115.  
  116.  
  117. PRIVATE unsigned int net_MimeEncodingConverterWriteReady (NET_StreamClass *stream)
  118. {
  119. #if 1
  120.   return (MAX_WRITE_READY);
  121. #else
  122.   MIME_DataObject *data = (MIME_DataObject *) stream->data_object;
  123.   if(data->next_stream)
  124.     return ((*data->next_stream->is_write_ready)
  125.             (data->next_stream));
  126.   else
  127.     return (MAX_WRITE_READY);
  128. #endif
  129. }
  130.  
  131. PRIVATE void net_MimeEncodingConverterComplete (NET_StreamClass *stream)
  132. {
  133.   MIME_DataObject *data = (MIME_DataObject *) stream->data_object;  
  134.  
  135.   if (data->decoder)
  136.     {
  137.       MimeDecoderDestroy(data->decoder, FALSE);
  138.       data->decoder = 0;
  139.     }
  140.  
  141.   /* complete the next stream */
  142.   if (!data->partial_p && data->next_stream)
  143.     {
  144.       (*data->next_stream->complete) (data->next_stream);
  145.       XP_FREE (data->next_stream);
  146.     }
  147.   XP_FREE (data);
  148. }
  149.  
  150. PRIVATE void net_MimeEncodingConverterAbort (NET_StreamClass *stream, int status)
  151. {
  152.   MIME_DataObject *data = (MIME_DataObject *) stream->data_object;  
  153.  
  154.   if (data->decoder)
  155.     {
  156.       MimeDecoderDestroy(data->decoder, TRUE);
  157.       data->decoder = 0;
  158.     }
  159.  
  160.   /* abort the next stream */
  161.   if (!data->partial_p && data->next_stream)
  162.     {
  163.       (*data->next_stream->abort) (data->next_stream, status);
  164.       XP_FREE (data->next_stream);
  165.     }
  166.   XP_FREE (data);
  167. }
  168. #endif /* MOZ_MAIL_NEWS */
  169.  
  170. PRIVATE NET_StreamClass * 
  171. NET_MimeEncodingConverter_1 (int          format_out,
  172.                              void        *data_obj,
  173.                              URL_Struct  *URL_s,
  174.                              MWContext   *window_id,
  175.                              XP_Bool partial_p,
  176.                              NET_StreamClass *next_stream)
  177. {
  178. #ifdef MOZ_MAIL_NEWS
  179.    MIME_DataObject* obj;
  180.    MimeDecoderData *(*fn) (int (*) (const char*, int32, void*), void*) = 0;
  181.  
  182.     NET_StreamClass* stream;
  183.     char *type = (char *) data_obj;
  184.  
  185.     TRACEMSG(("Setting up encoding stream. Have URL: %s\n", URL_s->address));
  186.  
  187.     stream = XP_NEW(NET_StreamClass);
  188.     if(stream == NULL) 
  189.       return(NULL);
  190.  
  191.     XP_MEMSET(stream, 0, sizeof(NET_StreamClass));
  192.  
  193.     obj = XP_NEW(MIME_DataObject);
  194.     if (obj == NULL) 
  195.       return(NULL);
  196.     memset(obj, 0, sizeof(MIME_DataObject));
  197.  
  198.     if (!strcasecomp (type, ENCODING_QUOTED_PRINTABLE))
  199.       fn = &MimeQPDecoderInit;
  200.     else if (!strcasecomp (type, ENCODING_BASE64))
  201.       fn = &MimeB64DecoderInit;
  202.     else if (!strcasecomp (type, ENCODING_UUENCODE) ||
  203.              !strcasecomp (type, ENCODING_UUENCODE2) ||
  204.              !strcasecomp (type, ENCODING_UUENCODE3) ||
  205.              !strcasecomp (type, ENCODING_UUENCODE4))
  206.       fn = &MimeUUDecoderInit;
  207.     else
  208.       abort ();
  209.     obj->decoder = fn (net_mime_decoder_cb, obj);
  210.     if (!obj->decoder)
  211.       {
  212.         XP_FREE(obj);
  213.         return 0;
  214.       }
  215.  
  216.     stream->put_block      = net_MimeEncodingConverterWrite;
  217.  
  218.     stream->name           = "Mime Stream";
  219.     stream->complete       = net_MimeEncodingConverterComplete;
  220.     stream->abort          = net_MimeEncodingConverterAbort;
  221.     stream->is_write_ready = net_MimeEncodingConverterWriteReady;
  222.     stream->data_object    = obj;  /* document info object */
  223.     stream->window_id      = window_id;
  224.  
  225.     if (partial_p)
  226.       {
  227.         XP_ASSERT (next_stream);
  228.         obj->next_stream = next_stream;
  229.         TRACEMSG(("Using existing stream in NET_MimeEncodingConverter\n"));
  230.       }
  231.     else
  232.       {
  233.         XP_ASSERT (!next_stream);
  234.  
  235.         /* open next stream
  236.          */
  237.         FREEIF (URL_s->content_encoding);
  238.         obj->next_stream = NET_StreamBuilder (format_out, URL_s, window_id);
  239.  
  240.         if (!obj->next_stream)
  241.           return (NULL);
  242.  
  243.         /* When uudecoding, we tend to come up with tiny chunks of data
  244.            at a time.  Make a stream to put them back together, so that
  245.            we hand bigger pieces to the image library.
  246.          */
  247.         {
  248.           NET_StreamClass *buffer =
  249.             msg_MakeRebufferingStream (obj->next_stream, URL_s, window_id);
  250.           if (buffer)
  251.             obj->next_stream = buffer;
  252.         }
  253.  
  254.         TRACEMSG(("Returning stream from NET_MimeEncodingConverter\n"));
  255.       }
  256.  
  257.     return stream;
  258. #else
  259.    XP_ASSERT(0);
  260.    return(NULL);
  261. #endif /* MOZ_MAIL_NEWS */
  262. }
  263.  
  264.  
  265. PUBLIC NET_StreamClass * 
  266. NET_MimeEncodingConverter (int          format_out,
  267.                            void        *data_obj,
  268.                            URL_Struct  *URL_s,
  269.                            MWContext   *window_id)
  270. {
  271.   return NET_MimeEncodingConverter_1 (format_out, data_obj, URL_s, window_id,
  272.                                       FALSE, 0);
  273. }
  274.  
  275. NET_StreamClass * 
  276. NET_MimeMakePartialEncodingConverterStream (int          format_out,
  277.                                             void        *data_obj,
  278.                                             URL_Struct  *URL_s,
  279.                                             MWContext   *window_id,
  280.                                             NET_StreamClass *next_stream)
  281. {
  282.   return NET_MimeEncodingConverter_1 (format_out, data_obj, URL_s, window_id,
  283.                                       TRUE, next_stream);
  284. }
  285.  
  286. /* Registers the default things that should be registered cross-platform.
  287.    Really this doesn't belong in this file.
  288.  */
  289.  
  290.  
  291. PRIVATE
  292. NET_StreamClass *
  293. EDT_ErrorOut (int format_out,
  294.               void *data_obj,    
  295.               URL_Struct *URL_s,
  296.               MWContext  *window_id)
  297. {
  298.  
  299.      FE_Alert(window_id, XP_GetString(XP_EDITOR_NON_HTML));
  300.  
  301.     return(NULL);
  302. }
  303.         
  304.  
  305. PRIVATE void
  306. net_RegisterDefaultDecoders (void)
  307. {
  308.   static PA_InitData parser_data;
  309.  
  310. #ifdef XP_UNIX
  311.   NET_ClearExternalViewerConverters ();
  312. #endif /* XP_UNIX */
  313.  
  314.   /* for the parser/layout functionality
  315.    */
  316. #ifdef EDITOR
  317.   parser_data.output_func = EDT_ProcessTag;
  318. #else
  319.   parser_data.output_func = LO_ProcessTag;
  320. #endif
  321.  
  322.   /* Convert the charsets of HTML into the canonical internal form.
  323.    */
  324.   NET_RegisterContentTypeConverter (TEXT_HTML, FO_PRESENT,
  325.                                     NULL, INTL_ConvCharCode);
  326.  
  327.   NET_RegisterContentTypeConverter (TEXT_HTML, FO_PRESENT_INLINE,
  328.                                     NULL, INTL_ConvCharCode);
  329.  
  330.   /* send all HTML to the editor, everything else as error
  331.    */
  332.   NET_RegisterContentTypeConverter (TEXT_HTML, FO_EDIT,
  333.                                       NULL, INTL_ConvCharCode);
  334.  
  335.   /* send file listings to html converter */
  336.   NET_RegisterContentTypeConverter (APPLICATION_HTTP_INDEX, FO_PRESENT,
  337.                                       NULL, NET_HTTPIndexFormatToHTMLConverter);
  338.  
  339.   NET_RegisterContentTypeConverter ("*", FO_EDIT,
  340.                                       NULL, EDT_ErrorOut);
  341.  
  342.   NET_RegisterContentTypeConverter("*", FO_LOAD_HTML_HELP_MAP_FILE,
  343.                                    NULL, NET_HTMLHelpMapToURL);
  344.  
  345. #ifdef CRAWLER
  346.   NET_RegisterContentTypeConverter(TEXT_HTML, FO_CRAWL_PAGE, 
  347.                                     NULL, INTL_ConvCharCode);
  348.  
  349.   NET_RegisterContentTypeConverter("*", FO_CRAWL_PAGE, 
  350.                                     NULL, CRAWL_CrawlerConverter);
  351.  
  352.   NET_RegisterContentTypeConverter("*", FO_CRAWL_RESOURCE, 
  353.                                     NULL, CRAWL_CrawlerResourceConverter);
  354.  
  355.   NET_RegisterContentTypeConverter("*", FO_ROBOTS_TXT, 
  356.                                     NULL, CRAWL_RobotsTxtConverter);
  357. #endif /* CRAWLER */
  358.  
  359.     /* this should be windows and mac soon too... */
  360. #ifdef XP_UNIX
  361.     /* the view source converter */
  362.   NET_RegisterContentTypeConverter ("*", FO_VIEW_SOURCE,
  363.                                     TEXT_PLAIN, net_ColorHTMLStream);
  364.   NET_RegisterContentTypeConverter (TEXT_HTML, FO_VIEW_SOURCE,
  365.                                     NULL, INTL_ConvCharCode);
  366.   NET_RegisterContentTypeConverter (MESSAGE_RFC822, FO_VIEW_SOURCE,
  367.                                     NULL, INTL_ConvCharCode);
  368.   NET_RegisterContentTypeConverter (MESSAGE_NEWS, FO_VIEW_SOURCE,
  369.                                     NULL, INTL_ConvCharCode);
  370.   NET_RegisterContentTypeConverter (INTERNAL_PARSER, FO_VIEW_SOURCE,
  371.                                     TEXT_HTML, net_ColorHTMLStream);
  372.   NET_RegisterContentTypeConverter (APPLICATION_HTTP_INDEX, FO_VIEW_SOURCE,
  373.                                       NULL, NET_HTTPIndexFormatToHTMLConverter);
  374. #endif /* XP_UNIX */
  375.  
  376.   NET_RegisterContentTypeConverter (TEXT_HTML, FO_SAVE_AS_TEXT,
  377.                                     NULL, INTL_ConvCharCode);
  378.   NET_RegisterContentTypeConverter (TEXT_HTML, FO_QUOTE_MESSAGE,
  379.                                     NULL, INTL_ConvCharCode);
  380.   NET_RegisterContentTypeConverter (APPLICATION_HTTP_INDEX, FO_QUOTE_MESSAGE,
  381.                                       NULL, NET_HTTPIndexFormatToHTMLConverter);
  382.   NET_RegisterContentTypeConverter (APPLICATION_HTTP_INDEX, FO_SAVE_AS_TEXT,
  383.                                       NULL, NET_HTTPIndexFormatToHTMLConverter);
  384.  
  385. #ifdef XP_UNIX
  386.   NET_RegisterContentTypeConverter (TEXT_HTML, FO_SAVE_AS_POSTSCRIPT,
  387.                                     NULL, INTL_ConvCharCode);
  388.   NET_RegisterContentTypeConverter (APPLICATION_HTTP_INDEX,
  389.                                      FO_SAVE_AS_POSTSCRIPT,
  390.                                       NULL, NET_HTTPIndexFormatToHTMLConverter);
  391. #endif /* XP_UNIX */
  392.  
  393.   /* And MDL too, sigh. */
  394.   NET_RegisterContentTypeConverter (TEXT_MDL, FO_PRESENT,
  395.                                     NULL, INTL_ConvCharCode);
  396.   NET_RegisterContentTypeConverter (TEXT_MDL, FO_SAVE_AS_TEXT,
  397.                                     NULL, INTL_ConvCharCode);
  398.   NET_RegisterContentTypeConverter (TEXT_MDL, FO_QUOTE_MESSAGE,
  399.                                     NULL, INTL_ConvCharCode);
  400. #ifdef XP_UNIX
  401.   NET_RegisterContentTypeConverter (TEXT_MDL, FO_SAVE_AS_POSTSCRIPT,
  402.                                     NULL, INTL_ConvCharCode);
  403. #endif /* XP_UNIX */
  404.  
  405.   /* Convert the charsets of plain text into the canonical internal form.
  406.    */
  407.   NET_RegisterContentTypeConverter (TEXT_PLAIN, FO_PRESENT,
  408.                                     NULL, NET_PlainTextConverter);
  409.   NET_RegisterContentTypeConverter (TEXT_PLAIN, FO_EDIT,
  410.                                     NULL, NET_PlainTextConverter);
  411.   NET_RegisterContentTypeConverter (TEXT_PLAIN, FO_QUOTE_MESSAGE,
  412.                                     NULL, NET_PlainTextConverter);
  413.     /* don't register TEXT_PLAIN for FO_SAVE_AS_TEXT
  414.      * since it is already text
  415.      */
  416. #ifdef XP_UNIX
  417.   NET_RegisterContentTypeConverter (TEXT_PLAIN, FO_SAVE_AS_POSTSCRIPT,
  418.                                     NULL, NET_PlainTextConverter);
  419. #endif /* XP_UNIX */
  420.  
  421.   /* always treat unknown content types as text/plain */
  422.   NET_RegisterContentTypeConverter (UNKNOWN_CONTENT_TYPE, FO_PRESENT,
  423.                                     NULL, NET_PlainTextConverter);
  424.   NET_RegisterContentTypeConverter (UNKNOWN_CONTENT_TYPE, FO_QUOTE_MESSAGE,
  425.                                     NULL, NET_PlainTextConverter);
  426.   /* let mail view forms sent via web browsers */
  427.   NET_RegisterContentTypeConverter (APPLICATION_WWW_FORM_URLENCODED, 
  428.                                     FO_PRESENT,
  429.                                     NULL, 
  430.                                     NET_PlainTextConverter);
  431.  
  432. #ifdef MOZ_MAIL_NEWS
  433. #if defined(XP_MAC)
  434.   NET_RegisterContentTypeConverter (MULTIPART_APPLEDOUBLE, FO_SAVE_AS,
  435.                                     NULL, fe_MakeAppleDoubleDecodeStream_1);
  436.   NET_RegisterContentTypeConverter (APPLICATION_APPLEFILE, FO_SAVE_AS,
  437.                                     NULL, fe_MakeAppleSingleDecodeStream_1);
  438. #endif
  439. #if defined(XP_MAC) || defined(XP_UNIX) || defined(XP_WIN) || defined(XP_OS2)
  440.   /* the new apple single/double and binhex decode.    20oct95     */
  441.   NET_RegisterContentTypeConverter (APPLICATION_BINHEX, FO_PRESENT,
  442.                                     NULL, fe_MakeBinHexDecodeStream);
  443.   NET_RegisterContentTypeConverter (MULTIPART_APPLEDOUBLE, FO_PRESENT,
  444.                                     NULL, fe_MakeAppleDoubleDecodeStream_1);
  445.   NET_RegisterContentTypeConverter (MULTIPART_HEADER_SET, FO_PRESENT,
  446.                                     NULL, fe_MakeAppleDoubleDecodeStream_1);
  447.   NET_RegisterContentTypeConverter (APPLICATION_APPLEFILE, FO_PRESENT,
  448.                                     NULL, fe_MakeAppleSingleDecodeStream_1);
  449.  
  450.   NET_RegisterContentTypeConverter (UUENCODE_APPLE_SINGLE, FO_PRESENT,
  451.                                     NULL, fe_MakeAppleSingleDecodeStream_1);
  452.   NET_RegisterContentTypeConverter (UUENCODE_APPLE_SINGLE, FO_SAVE_AS,
  453.                                     NULL, fe_MakeAppleSingleDecodeStream_1);
  454.                                     
  455. #endif /* XP_MAC || XP_UNIX */
  456. #endif /* MOZ_MAIL_NEWS */
  457.     /* don't register UNKNOWN_CONTENT_TYPE for FO_SAVE_AS_TEXT
  458.      * since it is already text
  459.      */
  460. #ifdef XP_UNIX
  461.   NET_RegisterContentTypeConverter (UNKNOWN_CONTENT_TYPE,
  462.                                     FO_SAVE_AS_POSTSCRIPT,
  463.                                     NULL, NET_PlainTextConverter);
  464. #endif /* XP_UNIX */
  465.  
  466.  
  467.   /* Take the canonical internal form and do layout on it.
  468.      We do the same thing when the format_out is PRESENT or any of
  469.      the SAVE_AS types; the different behavior is gotten by the use
  470.      of a different context rather than a different stream.
  471.    */
  472.   NET_RegisterContentTypeConverter (INTERNAL_PARSER, FO_PRESENT,
  473.                                     (void *) &parser_data, PA_BeginParseMDL);
  474.   NET_RegisterContentTypeConverter (INTERNAL_PARSER, FO_PRESENT_INLINE,
  475.                                     (void *) &parser_data, PA_BeginParseMDL);
  476.   NET_RegisterContentTypeConverter (INTERNAL_PARSER, FO_SAVE_AS_TEXT,
  477.                                     (void *) &parser_data, PA_BeginParseMDL);
  478.   NET_RegisterContentTypeConverter (INTERNAL_PARSER, FO_QUOTE_MESSAGE,
  479.                                     (void *) &parser_data, PA_BeginParseMDL);
  480. #ifdef XP_UNIX
  481.   NET_RegisterContentTypeConverter (INTERNAL_PARSER, FO_SAVE_AS_POSTSCRIPT,
  482.                                     (void *) &parser_data, PA_BeginParseMDL);
  483. #endif /* XP_UNIX */
  484.  
  485.   /* one for the editor */
  486.   NET_RegisterContentTypeConverter (INTERNAL_PARSER, FO_EDIT,
  487.                                     (void *) &parser_data, PA_BeginParseMDL);
  488.  
  489.   /* Note that we don't register a converter for "*" to FO_SAVE_AS,
  490.      because the FE needs to do that specially to set up an output file.
  491.      (The file I/O stuff for SAVE_AS_TEXT and SAVE_AS_POSTSCRIPT is dealt
  492.      with by libxlate.a, which could also handle SAVE_AS, but it's probably
  493.      not worth the effort.)
  494.    */
  495.  
  496.  
  497.   /* Do the same for the internally-handled image types when the format_out
  498.      is SAVE_AS_POSTSCRIPT, because the TEXT->PS code can handle that.  But
  499.      do not register converters to feed the image types to the HTML->TEXT
  500.      code, because that doesn't work.
  501.    */
  502. #ifdef XP_UNIX
  503.   NET_RegisterContentTypeConverter (IMAGE_GIF, FO_SAVE_AS_POSTSCRIPT,
  504.                                     NULL, IL_ViewStream);
  505.   NET_RegisterContentTypeConverter (IMAGE_JPG, FO_SAVE_AS_POSTSCRIPT,
  506.                                     NULL, IL_ViewStream);
  507.   NET_RegisterContentTypeConverter (IMAGE_PJPG, FO_SAVE_AS_POSTSCRIPT,
  508.                                     NULL, IL_ViewStream);
  509.  
  510.   NET_RegisterContentTypeConverter (IMAGE_PNG, FO_SAVE_AS_POSTSCRIPT,
  511.                                     NULL, IL_ViewStream);
  512.   NET_RegisterContentTypeConverter (IMAGE_XBM, FO_SAVE_AS_POSTSCRIPT,
  513.                                     NULL, IL_ViewStream);
  514.   NET_RegisterContentTypeConverter (IMAGE_XBM2, FO_SAVE_AS_POSTSCRIPT,
  515.                                     NULL, IL_ViewStream);
  516.   NET_RegisterContentTypeConverter (IMAGE_XBM3, FO_SAVE_AS_POSTSCRIPT,
  517.                                     NULL, IL_ViewStream);
  518. #endif /* XP_UNIX */
  519.  
  520.  
  521.   /* Set things up so that the image library gets reconnected once the
  522.      internally-handled images have been started. */
  523.   NET_RegisterContentTypeConverter (IMAGE_GIF, FO_INTERNAL_IMAGE,
  524.                                     (void *) IL_GIF, IL_NewStream);
  525.   NET_RegisterContentTypeConverter (IMAGE_JPG, FO_INTERNAL_IMAGE,
  526.                                     (void *) IL_JPEG, IL_NewStream);
  527.   NET_RegisterContentTypeConverter (IMAGE_PJPG, FO_INTERNAL_IMAGE,
  528.                                     (void *) IL_JPEG, IL_NewStream);
  529.   
  530.   NET_RegisterContentTypeConverter (IMAGE_PNG, FO_INTERNAL_IMAGE,
  531.                                     (void *) IL_PNG, IL_NewStream);
  532.  
  533.   NET_RegisterContentTypeConverter (IMAGE_XBM, FO_INTERNAL_IMAGE,
  534.                                     (void *) IL_XBM, IL_NewStream);
  535.   NET_RegisterContentTypeConverter (IMAGE_XBM2, FO_INTERNAL_IMAGE,
  536.                                     (void *) IL_XBM, IL_NewStream);
  537.   NET_RegisterContentTypeConverter (IMAGE_XBM3, FO_INTERNAL_IMAGE,
  538.                                     (void *) IL_XBM, IL_NewStream);
  539.   NET_RegisterContentTypeConverter ("*", FO_INTERNAL_IMAGE,
  540.                                     (void *) IL_UNKNOWN, IL_NewStream);
  541.  
  542.   NET_RegisterContentTypeConverter (IMAGE_GIF, FO_PRESENT,NULL, IL_ViewStream);
  543.   NET_RegisterContentTypeConverter (IMAGE_JPG, FO_PRESENT,NULL, IL_ViewStream);
  544.   NET_RegisterContentTypeConverter (IMAGE_PJPG,FO_PRESENT,NULL, IL_ViewStream);
  545.   
  546.   NET_RegisterContentTypeConverter (IMAGE_PNG, FO_PRESENT,NULL, IL_ViewStream);
  547.  
  548.   NET_RegisterContentTypeConverter (IMAGE_XBM, FO_PRESENT,NULL, IL_ViewStream);
  549.   NET_RegisterContentTypeConverter (IMAGE_XBM2,FO_PRESENT,NULL, IL_ViewStream);
  550.   NET_RegisterContentTypeConverter (IMAGE_XBM3,FO_PRESENT,NULL, IL_ViewStream);
  551.  
  552.   NET_RegisterContentTypeConverter (IMAGE_GIF, FO_PRESENT_INLINE,NULL,
  553.                                     IL_ViewStream);
  554.   NET_RegisterContentTypeConverter (IMAGE_JPG, FO_PRESENT_INLINE,NULL,
  555.                                     IL_ViewStream);
  556.   NET_RegisterContentTypeConverter (IMAGE_PJPG,FO_PRESENT_INLINE,NULL,
  557.                                     IL_ViewStream);
  558.   
  559.   NET_RegisterContentTypeConverter (IMAGE_PNG,FO_PRESENT_INLINE,NULL,
  560.                                     IL_ViewStream);
  561.  
  562.   NET_RegisterContentTypeConverter (IMAGE_XBM, FO_PRESENT_INLINE,NULL,
  563.                                     IL_ViewStream);
  564.   NET_RegisterContentTypeConverter (IMAGE_XBM2,FO_PRESENT_INLINE,NULL,
  565.                                     IL_ViewStream);
  566.   NET_RegisterContentTypeConverter (IMAGE_XBM3,FO_PRESENT_INLINE,NULL,
  567.                                     IL_ViewStream);
  568.  
  569.   /* register default (non)decoders for the text printer
  570.    */
  571.   NET_RegisterContentTypeConverter ("*", FO_SAVE_AS_TEXT,
  572.                                     NULL, NET_PrintRawToDisk);
  573.   NET_RegisterContentTypeConverter ("*", FO_QUOTE_MESSAGE,
  574.                                     NULL, NET_PrintRawToDisk);
  575. #ifdef XP_UNIX
  576.   NET_RegisterContentTypeConverter ("*", FO_SAVE_AS_POSTSCRIPT,
  577.                                     NULL, NET_PrintRawToDisk);
  578. #endif /* XP_UNIX */
  579.  
  580.   /* cache things */
  581.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_PRESENT,
  582.                                     NULL, NET_CacheConverter);
  583.  
  584.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_PRESENT_INLINE,
  585.                                     NULL, NET_CacheConverter);
  586.  
  587.   NET_RegisterContentTypeConverter ("*", FO_CACHE_ONLY,
  588.                                     NULL, NET_CacheConverter);
  589.  
  590.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_INTERNAL_IMAGE,
  591.                                     NULL, NET_CacheConverter);
  592.  
  593.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_SAVE_AS,
  594.                                     NULL, NET_CacheConverter);
  595.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_SAVE_AS_TEXT,
  596.                                     NULL, NET_CacheConverter);
  597. #ifdef XP_UNIX
  598.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_SAVE_AS_POSTSCRIPT,
  599.                                     NULL, NET_CacheConverter);
  600. #endif /* XP_UNIX */
  601.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_QUOTE_MESSAGE,
  602.                                     NULL, NET_CacheConverter);
  603.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_VIEW_SOURCE,
  604.                                     NULL, NET_CacheConverter);
  605.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_MAIL_TO,
  606.                                     NULL, NET_CacheConverter);
  607.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_EDIT,
  608.                                       NULL, NET_CacheConverter);
  609.   NET_RegisterContentTypeConverter("*", FO_CACHE_AND_LOAD_HTML_HELP_MAP_FILE,
  610.                                    NULL, NET_CacheConverter);
  611.   NET_RegisterContentTypeConverter("*", FO_CACHE_AND_SOFTUPDATE, 
  612.                                     NULL, NET_CacheConverter);
  613. #ifdef CRAWLER
  614.   NET_RegisterContentTypeConverter("*", FO_CACHE_AND_CRAWL_PAGE, 
  615.                                     NULL, NET_CacheConverter);
  616.   NET_RegisterContentTypeConverter("*", FO_CACHE_AND_CRAWL_RESOURCE, 
  617.                                     NULL, NET_CacheConverter);
  618.   NET_RegisterContentTypeConverter("*", FO_CACHE_AND_ROBOTS_TXT, 
  619.                                     NULL, NET_CacheConverter);
  620. #endif /* CRAWLER */
  621. #ifdef JAVA
  622.   NET_RegisterContentTypeConverter("*", FO_SOFTWARE_UPDATE, NULL, SU_NewStream);
  623.   NET_RegisterContentTypeConverter(APPLICATION_JAVAARCHIVE, FO_PRESENT, NULL, SU_NewStream);
  624.   NET_cdataCommit(APPLICATION_JAVAARCHIVE, ".jar");
  625. #endif
  626.  
  627. #ifndef MCC_PROXY
  628.   NET_RegisterContentTypeConverter(APPLICATION_NS_PROXY_AUTOCONFIG,
  629.                                    FO_CACHE_AND_PRESENT,
  630.                                    (void *)0, NET_ProxyAutoConfig);
  631.   NET_RegisterContentTypeConverter(APPLICATION_NS_PROXY_AUTOCONFIG,
  632.                                    FO_PRESENT,
  633.                                    (void *)0, NET_ProxyAutoConfig);
  634.   NET_RegisterContentTypeConverter(APPLICATION_NS_JAVASCRIPT_AUTOCONFIG,
  635.                                    FO_CACHE_AND_PRESENT,
  636.                                    (void *)0, NET_JavascriptConfig);
  637.   NET_RegisterContentTypeConverter(APPLICATION_NS_JAVASCRIPT_AUTOCONFIG,
  638.                                    FO_PRESENT,
  639.                                    (void *)0, NET_JavascriptConfig);
  640. #endif
  641.  
  642.   /*
  643.    * call security library to register all security related content
  644.    * type converters.
  645.    */
  646.   SECNAV_RegisterNetlibMimeConverters();
  647. #ifdef JAVA
  648.   {        /* stuff from ns/sun-java/netscape/net/netStubs.c */
  649.       extern void  NSN_RegisterJavaConverter(void);
  650.       NSN_RegisterJavaConverter();
  651.   }
  652. #endif /* JAVA */
  653.  
  654.   /* Register object data handler (see layobj.c) */
  655.   NET_RegisterContentTypeConverter("*", FO_OBJECT, NULL, LO_NewObjectStream);
  656.   NET_RegisterContentTypeConverter("*", FO_CACHE_AND_OBJECT, NULL, NET_CacheConverter);
  657.  
  658. #ifdef JAVA
  659.   /* Castanet stuff can't work in non-java enabled environments */
  660.   /* Register Marimba handler only if netcaster installed */
  661.     if (FE_IsNetcasterInstalled()) {
  662.         NET_RegisterContentTypeConverter(APPLICATION_MARIMBA, 
  663.                                    FO_PRESENT, 
  664.                                    NULL, 
  665.                                    NET_DoMarimbaApplication);
  666.  
  667.         NET_RegisterContentTypeConverter(APPLICATION_XMARIMBA, 
  668.                                    FO_PRESENT, 
  669.                                    NULL, 
  670.                                    NET_DoMarimbaApplication);
  671.     }
  672. #endif
  673.  
  674.     /* RDF */
  675.     {
  676.       /* XXX - move these to a header file soon */
  677. NET_StreamClass * rdf_Converter(FO_Present_Types  format_out, void *data_object, URL_Struct *URL_s, MWContext  *window_id);
  678. NET_StreamClass * XML_XMLConverter(FO_Present_Types  format_out, void *data_object, URL_Struct *URL_s, MWContext  *window_id);
  679. NET_StreamClass * XML_CSSConverter(FO_Present_Types  format_out, void *data_object, URL_Struct *URL_s, MWContext  *window_id);
  680. NET_StreamClass * XML_HTMLConverter(FO_Present_Types  format_out, void *data_object, URL_Struct *URL_s, MWContext  *window_id);
  681.  
  682.   NET_RegisterContentTypeConverter( "*", FO_CACHE_AND_RDF, NULL, NET_CacheConverter);
  683.   NET_RegisterContentTypeConverter( "*", FO_RDF, NULL, rdf_Converter);
  684.  
  685.   /* XML for direct presentation */
  686.  
  687.   NET_RegisterContentTypeConverter (TEXT_XML, FO_CACHE_AND_PRESENT, NULL, NET_CacheConverter);
  688.   NET_RegisterContentTypeConverter (TEXT_XML, FO_PRESENT, NULL, XML_XMLConverter);
  689.   NET_RegisterContentTypeConverter (TEXT_XML, FO_EDIT, NULL, XML_XMLConverter);
  690.   NET_RegisterContentTypeConverter ("*", FO_XMLHTML, NULL, XML_HTMLConverter);
  691.   NET_RegisterContentTypeConverter ("*", FO_XMLCSS, NULL, XML_CSSConverter);
  692.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_XMLHTML, NULL, NET_CacheConverter);
  693.   NET_RegisterContentTypeConverter ("*", FO_CACHE_AND_XMLCSS, NULL, NET_CacheConverter);
  694.     }
  695.  
  696. }
  697.  
  698.  
  699. PRIVATE void
  700. net_RegisterDefaultEncodingDecoders (void)
  701. {
  702.   /* Register the decompression content-encoding converters for those
  703.      types which are displayed internally. */
  704.   NET_RegisterAllEncodingConverters (INTERNAL_PARSER, FO_PRESENT);
  705.   NET_RegisterAllEncodingConverters (TEXT_HTML,       FO_PRESENT);
  706.   NET_RegisterAllEncodingConverters (TEXT_MDL,        FO_PRESENT);
  707.   NET_RegisterAllEncodingConverters (TEXT_PLAIN,      FO_PRESENT);
  708.   NET_RegisterAllEncodingConverters (IMAGE_GIF,       FO_PRESENT);
  709.   NET_RegisterAllEncodingConverters (IMAGE_JPG,       FO_PRESENT);
  710.   NET_RegisterAllEncodingConverters (IMAGE_PJPG,      FO_PRESENT);
  711.   
  712.   NET_RegisterAllEncodingConverters (IMAGE_PNG,      FO_PRESENT);
  713.   NET_RegisterAllEncodingConverters (IMAGE_XBM,       FO_PRESENT);
  714.   NET_RegisterAllEncodingConverters (IMAGE_XBM2,      FO_PRESENT);
  715.   NET_RegisterAllEncodingConverters (IMAGE_XBM3,      FO_PRESENT);
  716.   /* always treat unknown content types as text/plain */
  717.   NET_RegisterAllEncodingConverters (UNKNOWN_CONTENT_TYPE, FO_PRESENT);
  718.  
  719.   /* when displaying anything in a news mime-multipart image
  720.    * de compress it first
  721.    */
  722.   NET_RegisterAllEncodingConverters ("*",  FO_MULTIPART_IMAGE);
  723.  
  724.   /* When saving anything as Text or PostScript, it's necessary to
  725.      uncompress it first. */
  726.   NET_RegisterAllEncodingConverters ("*",  FO_SAVE_AS_TEXT);
  727. # ifdef XP_UNIX
  728.   NET_RegisterAllEncodingConverters ("*",  FO_SAVE_AS_POSTSCRIPT);
  729. # endif /* XP_UNIX */
  730.  
  731.   /* Whenever we save text or HTML to disk, we uncompress it first,
  732.      because the rules we decided upon is:
  733.  
  734.     - When Netscape saves text/plain or text/html documents to a
  735.       user-specified file, they are always uncompressed first.
  736.  
  737.     - When Netscape saves any other kind of document to a user-specified
  738.       file, it is always saved in its compressed state.
  739.  
  740.     - When Netscape saves a document to a temporary file before handing
  741.       it off to an external viewer, it is always uncompressed first.
  742.    */
  743.   NET_RegisterAllEncodingConverters (TEXT_HTML,       FO_SAVE_AS);
  744.   NET_RegisterAllEncodingConverters (TEXT_MDL,        FO_SAVE_AS);
  745.   NET_RegisterAllEncodingConverters (TEXT_PLAIN,      FO_SAVE_AS);
  746.   NET_RegisterAllEncodingConverters (INTERNAL_PARSER, FO_SAVE_AS);
  747.   /* always treat unknown content types as text/plain */
  748.   NET_RegisterAllEncodingConverters (UNKNOWN_CONTENT_TYPE, FO_SAVE_AS);
  749. }
  750.  
  751.  
  752. PUBLIC void
  753. NET_RegisterMIMEDecoders (void)
  754. {
  755.   net_RegisterDefaultDecoders ();
  756.  
  757.   NET_RegisterEncodingConverter (ENCODING_GZIP,
  758.                                  (void *) ENCODING_GZIP,
  759.                                  NET_UnZipConverter);
  760.   NET_RegisterEncodingConverter (ENCODING_GZIP2,
  761.                                  (void *) ENCODING_GZIP2,
  762.                                  NET_UnZipConverter);
  763.   NET_RegisterEncodingConverter (ENCODING_QUOTED_PRINTABLE,
  764.                                  (void *) ENCODING_QUOTED_PRINTABLE,
  765.                                  NET_MimeEncodingConverter);
  766.   NET_RegisterEncodingConverter (ENCODING_BASE64,
  767.                                  (void *) ENCODING_BASE64,
  768.                                  NET_MimeEncodingConverter);
  769. #ifndef IRIX_STARTUP_SPEEDUPS
  770.   NET_RegisterEncodingConverter (ENCODING_UUENCODE,
  771.                                  (void *) ENCODING_UUENCODE,
  772.                                  NET_MimeEncodingConverter);
  773.   NET_RegisterEncodingConverter (ENCODING_UUENCODE2,
  774.                                  (void *) ENCODING_UUENCODE2,
  775.                                  NET_MimeEncodingConverter);
  776. #endif
  777.   NET_RegisterEncodingConverter (ENCODING_UUENCODE3,
  778.                                  (void *) ENCODING_UUENCODE3,
  779.                                  NET_MimeEncodingConverter);
  780. #ifndef IRIX_STARTUP_SPEEDUPS
  781.   NET_RegisterEncodingConverter (ENCODING_UUENCODE4,
  782.                                  (void *) ENCODING_UUENCODE4,
  783.                                  NET_MimeEncodingConverter);
  784. #endif  
  785.  
  786.   NET_RegisterContentTypeConverter ("*", FO_MULTIPART_IMAGE,
  787.                                     (void *) 1, IL_ViewStream);
  788.  
  789. #ifdef MOZ_MAIL_NEWS
  790.   /* Decoders for libmsg/compose.c */
  791.   MSG_RegisterConverters ();
  792. #endif  
  793.  
  794.   NET_RegisterUniversalEncodingConverter("chunked",
  795.                                  NULL,
  796.                                  NET_ChunkedDecoderStream);
  797.  
  798.   NET_RegisterContentTypeConverter("multipart/x-mixed-replace", 
  799.                                  FO_CACHE_AND_PRESENT, 
  800.                                  (void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART, 
  801.                                  CV_MakeMultipleDocumentStream);
  802.   NET_RegisterContentTypeConverter("multipart/x-mixed-replace", 
  803.                                  FO_CACHE_AND_PRINT, 
  804.                                  (void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART, 
  805.                                  CV_MakeMultipleDocumentStream);
  806.   NET_RegisterContentTypeConverter("multipart/x-mixed-replace", 
  807.                                  FO_CACHE_AND_INTERNAL_IMAGE, 
  808.                                  (void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART, 
  809.                                  CV_MakeMultipleDocumentStream);
  810.   NET_RegisterContentTypeConverter("multipart/x-byteranges", 
  811.                                  FO_CACHE_AND_PRESENT, 
  812.                                  (void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART, 
  813.                                  CV_MakeMultipleDocumentStream);
  814.   NET_RegisterContentTypeConverter("multipart/byteranges", 
  815.                                  FO_CACHE_AND_PRESENT, 
  816.                                  (void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART, 
  817.                                  CV_MakeMultipleDocumentStream);
  818.   NET_RegisterContentTypeConverter("multipart/mixed", 
  819.                                   FO_CACHE_AND_PRESENT, 
  820.                                   (void *) CVACTIVE_SIGNAL_AT_END_OF_MULTIPART, 
  821.                                   CV_MakeMultipleDocumentStream);
  822.  
  823.   net_RegisterDefaultEncodingDecoders ();
  824. }
  825.  
  826.  
  827. #if 0
  828. void
  829. main ()
  830. {
  831.   unsigned char *s;
  832.   int32 i;
  833. #define TEST(S) \
  834.   /*MIME_EncodeBase64String*/ \
  835.   MIME_EncodeQuotedPrintableString \
  836.    (S, strlen(S), &s, &i); \
  837.   printf ("---------\n" \
  838.           "%s\n" \
  839.           "---------\n" \
  840.           "%s\n" \
  841.           "---------\n", \
  842.           S, s); \
  843.   free(s)
  844.  
  845.   TEST("ThisThisThisThis\n"
  846.        "This is a line with a c\238ntr\001l character in it.\n"
  847.        "This line has whitespace at EOL.    \n"
  848.        "This is a long line.  All work and no play makes Jack a dull boy.  "
  849.        "All work and no play makes Jack a dull boy.  "
  850.        "All work and no play makes Jack a dull boy.  "
  851.        "All work and no play makes Jack a dull boy.  \n"
  852.        "\n"
  853.        "Here's an equal sign: =\n"
  854.        "and here's a return\r..."
  855.        "Now make it realloc:"
  856.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  857.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  858.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  859.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  860.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  861.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  862.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  863.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  864.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  865.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  866.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  867.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  868.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  869.        "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377"
  870.        );
  871. }
  872. #endif
  873.  
  874. typedef struct _NET_PrintRawToDiskStruct {
  875.     XP_File    fp;
  876.     MWContext *context;
  877.     int32      content_length;
  878.     int32      bytes_read;
  879.     int16       mail_csid;
  880.     int16       win_csid;
  881.     CCCDataObject conv;
  882.     XP_Bool       doConvert;
  883. } NET_PrintRawToDiskStruct;
  884.  
  885. /* this converter uses the
  886.  * (context->prSetup->filename) variable to
  887.  * open the filename specified and save all data raw to
  888.  * the file.
  889.  */
  890. PRIVATE
  891. int
  892. net_PrintRawToDiskWrite (NET_StreamClass *stream, CONST char *str, int32 len)
  893. {
  894.   NET_PrintRawToDiskStruct *obj = (NET_PrintRawToDiskStruct *) stream->data_object;
  895.   char *newStr = NULL;
  896.   int32 origLen = len;
  897.   int32 rv = 0;
  898.  
  899.   if (obj->doConvert)
  900.   {
  901.       char *dupStr = (char *) XP_ALLOC(len+1);
  902.  
  903.       if (dupStr)
  904.       {
  905.           XP_MEMCPY(dupStr, str, len);
  906.           *(dupStr + len) = 0;
  907.           newStr = (char *) INTL_CallCharCodeConverter(obj->conv,
  908.                                               (unsigned char *)dupStr,
  909.                                               len);
  910.           if (!newStr)
  911.               newStr = dupStr;
  912.           else if (newStr != dupStr)
  913.               XP_FREE(dupStr);
  914.  
  915.           if (newStr)
  916.           {
  917.               str = newStr;
  918.               len = INTL_GetCCCLen(obj->conv);
  919.           }
  920.       }
  921.   }
  922.  
  923. /*  int32 rv = fwrite ((char *) str, 1, len, obj->fp);*/
  924.   rv = XP_FileWrite(str, len, obj->fp);
  925.  
  926.   if (newStr)
  927.       XP_FREE(newStr);
  928.  
  929.   obj->bytes_read += origLen;
  930.  
  931.   if (obj->content_length > 0)
  932.     FE_SetProgressBarPercent (obj->context,
  933.                   (obj->bytes_read * 100) /
  934.                   obj->content_length);
  935.  
  936.   if(rv == len)
  937.     return(0);
  938.   else
  939.     return(-1);
  940. }
  941.  
  942. PRIVATE unsigned int
  943. net_PrintRawToDiskIsWriteReady (NET_StreamClass *stream)
  944. {
  945.   return(MAX_WRITE_READY);
  946. }
  947.  
  948. PRIVATE void
  949. net_PrintRawToDiskComplete (NET_StreamClass *stream)
  950. {
  951.   NET_PrintRawToDiskStruct *obj = (NET_PrintRawToDiskStruct *) stream->data_object;
  952.  
  953.   if (obj->conv) {
  954.     INTL_DestroyCharCodeConverter(obj->conv);
  955.     obj->conv = NULL;
  956.   }
  957.  
  958.   /* XP_FileClose(obj->fp); DONT DO THIS the FE's do this */
  959. }
  960.  
  961. PRIVATE void
  962. net_PrintRawToDiskAbort (NET_StreamClass *stream, int status)
  963. {
  964.   NET_PrintRawToDiskStruct *obj = (NET_PrintRawToDiskStruct *) stream->data_object;
  965.  
  966.   if (obj->conv) {
  967.     INTL_DestroyCharCodeConverter(obj->conv);
  968.     obj->conv = NULL;
  969.   }
  970.  
  971.   /* XP_FileClose(obj->fp); DONT DO THIS the FE's do this */
  972. }
  973.  
  974. /* this converter uses the
  975.  * (context->prSetup->out) file pointer variable to
  976.  * save all data raw to the file.
  977.  */
  978. PUBLIC NET_StreamClass *
  979. NET_PrintRawToDisk(int format_out, 
  980.                    void *data_obj,
  981.                    URL_Struct *url_struct, 
  982.                    MWContext *context)
  983. {
  984.   NET_PrintRawToDiskStruct *obj = XP_NEW(NET_PrintRawToDiskStruct);
  985.   NET_StreamClass * stream;
  986.   INTL_CharSetInfo csi = NULL;
  987.   char *mime_charset = NULL;
  988.  
  989.   if(!obj)
  990.     return(NULL);
  991.  
  992.   XP_MEMSET(obj, 0, sizeof(NET_PrintRawToDiskStruct));
  993.  
  994.   if(!context->prSetup || !context->prSetup->out)
  995.     {
  996.       FREE(obj);
  997.       return NULL;
  998.     }
  999.  
  1000. #ifdef NOT /* file ptr should already be open in context->prSetup->out */
  1001.   if(!(obj->fp = XP_FileOpen(context->prSetup->filename, 
  1002.                         xpTemporary, 
  1003.                         XP_FILE_WRITE_BIN)))
  1004.     {
  1005.       FREE(obj);
  1006.       return NULL;
  1007.     }
  1008. #endif
  1009.  
  1010.   obj->fp = context->prSetup->out;
  1011.  
  1012.   obj->context = context;
  1013.   obj->content_length = url_struct->content_length;
  1014.  
  1015.   stream = (NET_StreamClass *) XP_NEW(NET_StreamClass);
  1016.   if (!stream) 
  1017.     {
  1018.       FREE(obj);
  1019.       return NULL;
  1020.     }
  1021.  
  1022.   XP_MEMSET(stream, 0, sizeof(NET_StreamClass));
  1023.  
  1024.   stream->name           = "PrintRawToDisk";
  1025.   stream->complete       = net_PrintRawToDiskComplete;
  1026.   stream->abort          = net_PrintRawToDiskAbort;
  1027.   stream->put_block      = net_PrintRawToDiskWrite;
  1028.   stream->is_write_ready = net_PrintRawToDiskIsWriteReady;
  1029.   stream->data_object    = obj;
  1030.   stream->window_id      = context;
  1031.  
  1032.   csi = LO_GetDocumentCharacterSetInfo(context);
  1033.   mime_charset = INTL_GetCSIMimeCharset(csi);
  1034.   if (mime_charset && *(mime_charset))
  1035.   {
  1036.       obj->conv = INTL_CreateCharCodeConverter();
  1037.       obj->mail_csid = INTL_CharSetNameToID(mime_charset);
  1038.       obj->win_csid = INTL_DocToWinCharSetID(obj->mail_csid);
  1039.           
  1040.       if (obj->conv)
  1041.           obj->doConvert = INTL_GetCharCodeConverter(obj->mail_csid, 
  1042.                                                      obj->win_csid,
  1043.                                                      obj->conv);
  1044.   }
  1045.  
  1046.   return(stream);
  1047. }
  1048.  
  1049.  
  1050.  
  1051.  
  1052. #endif /*  MOZILLA_CLIENT */
  1053.