home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / include / msgnet.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  19.8 KB  |  492 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. /*   msgnet.h --- prototypes for API's between libmsg and libnet.
  19.  */
  20.  
  21. #ifndef _MSGNET_H_
  22. #define _MSGNET_H_
  23. #include "msgcom.h"
  24.  
  25. XP_BEGIN_PROTOS
  26.  
  27. /* so libnet can mark expired articles as read. */
  28. extern int MSG_MarkMessageKeyRead (MSG_Pane *pane, MessageKey key, const char *xref);
  29.  
  30. /* record imap message flags in the db of the current pane (message or thread panes) */
  31. extern void MSG_RecordImapMessageFlags(MSG_Pane* pane, 
  32.                                        MessageKey msgKey, 
  33.                                        imapMessageFlagsType flags);
  34.  
  35. /* notify libmsg of deleted messages */
  36. extern void MSG_ImapMsgsDeleted(MSG_Pane *urlPane,
  37.                                 const char *onlineMailboxName,
  38.                                 XP_Bool deleteAllMsgs, 
  39.                                 const char *doomedKeyString);
  40.  
  41. /* called to setup state before a copy download */
  42. extern void MSG_StartImapMessageToOfflineFolderDownload(MWContext* context);
  43.  
  44. /* notify libmsg that inbox filtering is complete */
  45. extern void MSG_ImapInboxFilteringComplete(MSG_Pane *urlPane);
  46.  
  47. /* notify libmsg that the online/offline synch is complete */                              
  48. extern void MSG_ImapOnOffLineSynchComplete(MSG_Pane *urlPane);
  49.  
  50. /* notify libmsg that an imap folder load was interrupted */
  51. extern void MSG_InterruptImapFolderLoad(MSG_Pane *urlPane, const char *hostName, const char *onlineFolderPath);
  52.  
  53. /* find a reference or NULL to the specified imap folder */
  54. extern MSG_FolderInfo* MSG_FindImapFolder(MSG_Pane *urlPane, const char *hostName, const char *onlineFolderPath);
  55.  
  56. /* If there is a cached connection, for this folder, uncache it and return it */
  57. extern TNavigatorImapConnection* MSG_UnCacheImapConnection(MSG_Master* master, const char *host, const char *folderName);
  58.  
  59. /* Cache this connection and return TRUE if there is not one there already, else false */
  60. extern XP_Bool MSG_TryToCacheImapConnection(MSG_Master* master, const char *host, const char *folderName, TNavigatorImapConnection *connection);
  61.  
  62. extern void MSG_SetIMAPMessageUID (MessageKey key,
  63.                                    void *state);
  64.  
  65.  
  66. extern const char *MSG_GetMessageIdFromState (void *state);
  67. extern XP_Bool MSG_IsSaveDraftDeliveryState (void *state);
  68.  
  69. extern void MSG_SetUserAuthenticated (MSG_Master* master, XP_Bool bAuthenticated);
  70.  
  71. extern XP_Bool MSG_IsUserAuthenticated (MSG_Master* master);
  72.  
  73. extern void MSG_SetMailAccountURL(MSG_Master* master, const char *urlString);
  74.  
  75. extern const char *MSG_GetMailAccountURL(MSG_Master* master);
  76.  
  77. extern void MSG_SetNewsgroupUsername(MSG_Pane* pane, const char *username);
  78. extern const char *MSG_GetNewsgroupUsername(MSG_Pane *pane);
  79.  
  80. extern void MSG_SetNewsgroupPassword(MSG_Pane* pane, const char *password);
  81. extern const char *MSG_GetNewsgroupPassword(MSG_Pane *pane);
  82.  
  83. extern const char* MSG_GetPopHost(MSG_Prefs* prefs);
  84.  
  85. extern XP_Bool MSG_GetUseSSLForIMAP4(MSG_Pane *pane);
  86. extern int32 MSG_GetIMAPSSLPort(MSG_Pane *pane);
  87.  
  88. /* called from libnet to clean up state from mailbox:copymessages */
  89. extern void MSG_MessageCopyIsCompleted (struct MessageCopyInfo**);
  90.  
  91. /* called from libnet to determine if the current copy is finished */
  92. extern XP_Bool MSG_IsMessageCopyFinished(struct MessageCopyInfo*);
  93.  
  94. /* called from mailbox and url libnet modules */
  95. extern
  96. int MSG_BeginCopyingMessages(MWContext *context);
  97.  
  98. extern
  99. int MSG_FinishCopyingMessages(MWContext *context);
  100.  
  101. extern const char *MSG_GetIMAPHostUsername(MSG_Master *master, const char *hostName);
  102. extern const char *MSG_GetIMAPHostPassword(MSG_Master *master, const char *hostName);
  103. extern void MSG_SetIMAPHostPassword(MSG_Master *master, const char *hostName, const char *password);
  104. extern int MSG_GetIMAPHostIsUsingSubscription(MSG_Master *master, const char *hostName, XP_Bool *usingSubscription);
  105. extern XP_Bool MSG_GetIMAPHostDeleteIsMoveToTrash(MSG_Master *master, const char *hostName);
  106. extern int IMAP_AddIMAPHost(const char *hostName, XP_Bool usingSubscription, XP_Bool overrideNamespaces,
  107.                             const char *personalNamespacePrefix, const char *publicNamespacePrefixes, const char *otherUsersNamespacePrefixes);
  108.  
  109. typedef enum
  110. {    MSG_NotRunning        = 0x00000000
  111. ,    MSG_RunningOnline    = 0x00000001
  112. ,    MSG_RunningOffline    = 0x00000002
  113. } MSG_RunningState;
  114.  
  115. extern MSG_FolderInfo *MSG_SetFolderRunningIMAPUrl(MSG_Pane *urlPane, const char *hostName, const char *onlineFolderPath, MSG_RunningState runningState);
  116. extern void MSG_IMAPUrlFinished(MSG_FolderInfo *folder, URL_Struct *URL_s);
  117.  
  118. /* ===========================================================================
  119.                                    OFFLINE IMAP
  120.    ===========================================================================
  121.  */
  122.  
  123. extern uint32 MSG_GetImapMessageFlags(MSG_Pane *urlPane, 
  124.                                         const char *hostName,
  125.                                         const char *onlineBoxName, 
  126.                                         uint32 key);
  127.  
  128. extern void MSG_StartOfflineImapRetrieval(MSG_Pane *urlPane, 
  129.                                         const char *hostName,
  130.                                             const char *onlineBoxName, 
  131.                                             uint32 key,
  132.                                             void **offLineRetrievalData);
  133.                                             
  134. extern uint32 MSG_GetOfflineMessageSize(void *offLineRetrievalData);
  135.  
  136. extern int MSG_ProcessOfflineImap(void *offLineRetrievalData, char *socketBuffer, uint32 read_size);
  137.  
  138. extern int MSG_InterruptOfflineImap(void *offLineRetrievalData);
  139.  
  140. extern void MSG_GetNextURL(MSG_Pane *pane);
  141.  
  142. /* Returns the original pane that a progress pane was associated with.  If
  143.    the given pane is not a progresspane, returns NULL. */
  144. extern MSG_Pane* MSG_GetParentPane(MSG_Pane* progresspane);
  145.  
  146. /* do an imap biff of the imap inbox */
  147. extern void MSG_ImapBiff(MWContext* context, MSG_Prefs* prefs);
  148.  
  149. /* The NNTP module of netlib calls these to feed XOVER data to the message
  150.    library, in response to a news:group.name URL having been opened.
  151.    If MSG_FinishXOVER() returns a message ID, that message will be loaded
  152.    next (used for selecting the first unread message in a group after
  153.    listing that group.)
  154.  
  155.    The "out" arguments are (if non-NULL) a file descriptor to write the XOVER
  156.    line to, followed by a "\n".  This is used by the XOVER-caching code.
  157.  */
  158. extern int MSG_InitXOVER (MSG_Pane* pane,
  159.                           MSG_NewsHost* host,
  160.                           const char* group_name,
  161.                           uint32 first_msg, uint32 last_msg,
  162.                           uint32 oldest_msg, uint32 youngest_msg,
  163.                           void **data);
  164. extern int MSG_ProcessXOVER (MSG_Pane* pane, char *line, void **data);
  165. extern int MSG_ProcessNonXOVER (MSG_Pane* pane, char *line, void **data);
  166. extern int MSG_FinishXOVER (MSG_Pane* pane, void **data, int status);
  167.  
  168. /* In case of XOVER failed due to the authentication process, we need to
  169.    do some clean up. So that we could have a fresh start once we pass the
  170.    authentication check.
  171. */
  172. extern int MSG_ResetXOVER (MSG_Pane* pane, void **data);
  173.  
  174.  
  175. /* These calls are used by libnet to determine which articles it ought to
  176.    get in a big newsgroup. */
  177.  
  178. extern int
  179. MSG_GetRangeOfArtsToDownload(MSG_Pane* pane, void** data, MSG_NewsHost* host,
  180.                              const char* group_name,
  181.                              int32 first_possible, /* Oldest article available
  182.                                                       from newsserver*/
  183.                              int32 last_possible, /* Newest article available
  184.                                                      from newsserver*/
  185.                              int32 maxextra,
  186.                              int32* first,
  187.                              int32* last);
  188.  
  189.  
  190. extern int
  191. MSG_AddToKnownArticles(MSG_Pane *pane, MSG_NewsHost* host,
  192.                        const char* groupname, int32 first, int32 last);
  193.  
  194. extern int MSG_InitAddArticleKeyToGroup(MSG_Pane *pane, MSG_NewsHost* host,
  195.                                      const char* groupName,  void **parseState);
  196.  
  197. extern int    MSG_AddArticleKeyToGroup(void *parse_state, int32 first);
  198.  
  199. extern int    MSG_FinishAddArticleKeyToGroup(MSG_Pane *pane, void **parse_state);
  200.  
  201. /* After displaying a list of newsgroups, we need the NNTP module to go and
  202.    run "GROUP" commands for the ones for which we don't know the unread
  203.    article count.  This function returns a count of how many groups we think
  204.    we're going to need this for (so we can display progress in a reasonable
  205.    way).
  206.  */
  207. extern int32 MSG_GetNewsRCCount(MSG_Pane* pane, MSG_NewsHost* host);
  208.  
  209. /* Gets the name of the next group that we want to get article counts for.
  210.    The caller must free the given name using XP_FREE().
  211.    MSG_DisplaySubscribedGroup() should get called with this group before
  212.    this call happens again. */
  213.  
  214. extern char* MSG_GetNewsRCGroup(MSG_Pane* pane, MSG_NewsHost* host);
  215.  
  216.  
  217.  
  218. /* In response to a "news://host/" URL; this is called once for each group
  219.    that was returned by MSG_GetNewsRCGroup(), after the NNTP GROUP command has
  220.    been run.  It's also called whenever we actually visit the group (the user
  221.    clicks on the newsgroup line), in case the data has changed since the
  222.    initial passthrough.  The "nowvisiting" parameter is TRUE in the latter
  223.    case, FALSE otherwise. */
  224. extern int MSG_DisplaySubscribedGroup(MSG_Pane* pane,
  225.                                       MSG_NewsHost* host,
  226.                                       const char *group,
  227.                                       int32 oldest_message,
  228.                                       int32 youngest_message,
  229.                                       int32 total_messages,
  230.                                       XP_Bool nowvisiting);
  231.  
  232. /* In response to an NNTP GROUP command, the server said the group doesn't exist */
  233. extern int MSG_GroupNotFound(MSG_Pane* pane,
  234.                              MSG_NewsHost* host,
  235.                              const char *group,
  236.                              XP_Bool opening);
  237.  
  238. /* In response to a "news://host/?newgroups" URL, to ask the server for a 
  239.    list of recently-added newsgroups.  Similar to MSG_DisplaySubscribedGroup,
  240.    except that in this case, the group is not already in the list. */
  241. extern int MSG_DisplayNewNewsGroup (MWContext *context,
  242.                                     MSG_NewsHost* host, const char *group_name,
  243.                                     int32 oldest_message,
  244.                                     int32 youngest_message);
  245.  
  246.  
  247. /* News servers work better if you ask for message numbers instead of IDs.
  248.    So, the NNTP module asks us what the group and number of an ID is with
  249.    this.  If we don't know, we return 0 for both.   If the pane is not a 
  250.    thead or message pane, this routine will fail.
  251.  */
  252. extern void MSG_NewsGroupAndNumberOfID (MSG_Pane *pane,
  253.                                         const char *message_id,
  254.                                         const char **group_return,
  255.                                         uint32 *message_number_return);
  256.  
  257. /*    This routine is used by netlib to see if we have this article off-line 
  258.     It might be combined with the above routine, but I'm not sure if this
  259.     is the way we're ultimately going to do this.
  260. */
  261. extern XP_Bool MSG_IsOfflineArticle        (MSG_Pane *pane,
  262.                                         const char *message_id,
  263.                                         const char **group_return,
  264.                                         uint32 *message_number_return);
  265.  
  266. extern int MSG_StartOfflineRetrieval(MSG_Pane *pane,
  267.                                         const char *group,
  268.                                         uint32 message_number,
  269.                                         void **offlineState);
  270.  
  271. extern int MSG_ProcessOfflineNews(void *offlineState, char *outputBuffer, int outputBufSize);
  272.  
  273. extern int MSG_InterruptOfflineNews(void *offlineState);
  274.  
  275. /* libnet callbacks for Dredd NNTP extensions */
  276.  
  277. extern void MSG_SupportsNewsExtensions (MSG_NewsHost *host, XP_Bool supports);
  278. extern void MSG_AddNewsExtension (MSG_NewsHost *host, const char *ext);
  279. extern XP_Bool MSG_QueryNewsExtension (MSG_NewsHost *host, const char *ext);
  280. extern XP_Bool MSG_NeedsNewsExtension (MSG_NewsHost *host, const char *ext);
  281.  
  282. extern void MSG_AddSearchableGroup (MSG_NewsHost *host, const char *group);
  283. extern void MSG_AddSearchableHeader (MSG_NewsHost *host, const char *header);
  284. extern int MSG_AddProfileGroup (MSG_Pane *pane,
  285.                                 MSG_NewsHost* host,
  286.                                 const char *groupName);
  287.  
  288. extern int MSG_AddPrettyName(MSG_NewsHost* host,
  289.                              const char *groupName, const char *prettyName);
  290.  
  291. extern int     MSG_SetXActiveFlags(MSG_Pane *pane, char *groupName, 
  292.                                 int32 firstPossibleArt, 
  293.                                 int32 lastPossibleArt, 
  294.                                 char *flags);
  295.  
  296. extern int MSG_AddSubscribedGroup (MSG_Pane *pane, const char *groupUrl);
  297.  
  298. extern void MSG_AddPropertyForGet (MSG_NewsHost *host, const char *property,
  299.                                    const char *value);
  300.  
  301. /* libnet calls this if it got an error 441 back from the newsserver.  That
  302.    error almost certainly means that the newsserver already has a message
  303.    with the same message id.  If this routine returns TRUE, then we were
  304.    pretty much expecting that error code, because we know we tried twice to
  305.    post the same message, and we can just ignore it. */
  306. extern XP_Bool MSG_IsDuplicatePost(MSG_Pane* comppane);
  307.  
  308.  
  309. /* libnet uses this on an error condition to tell libmsg to generate a new
  310.    message-id for the given composition. */
  311. extern void MSG_ClearCompositionMessageID(MSG_Pane* comppane);
  312.  
  313.  
  314. /* libnet uses this to determine the message-id for the given composition (so
  315.    it can test if this message was already posted.) */
  316. extern const char* MSG_GetCompositionMessageID(MSG_Pane* comppane);
  317.  
  318. /* The "news:" and "mailbox:" protocol handlers call this when a message is
  319.    displayed, so that we can use the contents of the headers when composing
  320.    replies.
  321.  */
  322. extern void 
  323. MSG_ActivateReplyOptions(MSG_Pane* messagepane, MimeHeaders *headers);
  324.  
  325. /* Tell the subscribe pane about a new newsgroup we noticed. */
  326.  
  327. extern int
  328. MSG_AddNewNewsGroup(MSG_Pane* pane, MSG_NewsHost* host,
  329.                     const char* groupname, int32 oldest, int32 youngest,
  330.                     const char *flag, XP_Bool bXactiveFlags);
  331.  
  332. /* tell the host info database that we're going to need to get the extra info
  333.    for this new newsgroup
  334. */
  335. extern int        MSG_SetGroupNeedsExtraInfo(MSG_NewsHost *host,
  336.                     const char* groupname, XP_Bool needsExtra);
  337.  
  338. /* returns the name of the first group which needs extra info */
  339. extern char *MSG_GetFirstGroupNeedingExtraInfo(MSG_NewsHost *host);
  340.  
  341. /* Find out from libmsg when we last checked for new newsgroups (so we know
  342.    what date to give the "newgroups" command.) */
  343.  
  344. extern time_t
  345. MSG_NewsgroupsLastUpdatedTime(MSG_NewsHost* host);
  346.  
  347.                     
  348.  
  349. /* The "mailbox:" protocol module uses these routines to invoke the mailbox
  350.    parser in libmsg.
  351.  */
  352. extern int MSG_BeginOpenFolderSock (MSG_Pane* pane,
  353.                                     const char *folder_name,
  354.                                     const char *message_id, int32 msgnum,
  355.                                     void **folder_ptr);
  356. extern int MSG_FinishOpenFolderSock (MSG_Pane* pane,
  357.                                      const char *folder_name,
  358.                                      const char *message_id, int32 msgnum,
  359.                                      void **folder_ptr);
  360. extern void MSG_CloseFolderSock (MSG_Pane* pane, const char *folder_name,
  361.                                  const char *message_id, int32 msgnum,
  362.                                  void *folder_ptr);
  363. extern int MSG_OpenMessageSock (MSG_Pane* messagepane, const char *folder_name,
  364.                                 const char *msg_id, int32 msgnum,
  365.                                 void *folder_ptr, void **message_ptr,
  366.                                 int32 *content_length);
  367. extern int MSG_ReadMessageSock (MSG_Pane* messagepane, const char *folder_name,
  368.                                 void *message_ptr, const char *message_id,
  369.                                 int32 msgnum, char *buffer, int32 buffer_size);
  370. extern void MSG_CloseMessageSock (MSG_Pane* messagepane,
  371.                                   const char *folder_name,
  372.                                   const char *message_id, int32 msgnum,
  373.                                   void *message_ptr);
  374. extern void MSG_PrepareToIncUIDL(MSG_Pane* messagepane, URL_Struct* url,
  375.                                  const char* uidl);
  376.  
  377. /* This is how "mailbox:?empty-trash" works
  378.  */
  379. extern int MSG_BeginEmptyTrash(MSG_Pane* folderpane, URL_Struct* url,
  380.                                void** closure);
  381. extern int MSG_FinishEmptyTrash(MSG_Pane* folderpane, URL_Struct* url,
  382.                                 void* closure);
  383. extern int MSG_CloseEmptyTrashSock(MSG_Pane* folderpane, URL_Struct* url,
  384.                                    void* closure);
  385.  
  386. /* This is how "mailbox:?compress-folder" and
  387.    "mailbox:/foo/baz/nsmail/inbox?compress-folder" works. */
  388.  
  389. extern int MSG_BeginCompressFolder(MSG_Pane* pane, URL_Struct* url,
  390.                                    const char* foldername, void** closure);
  391. extern int MSG_FinishCompressFolder(MSG_Pane* pane, URL_Struct* url,
  392.                                     const char* foldername, void* closure);
  393. extern int MSG_CloseCompressFolderSock(MSG_Pane* pane, URL_Struct* url,
  394.                                        void* closure);
  395. /* This is how "mailbox:?deliver-queued" works
  396.  */
  397. extern int MSG_BeginDeliverQueued(MSG_Pane* pane, URL_Struct* url,
  398.                                   void** closure);
  399. extern int MSG_FinishDeliverQueued(MSG_Pane* pane, URL_Struct* url,
  400.                                    void* closure);
  401. extern int MSG_CloseDeliverQueuedSock(MSG_Pane* pane, URL_Struct* url,
  402.                                       void* closure);
  403.  
  404. /* This is how "mailbox:?background" works */
  405. extern int MSG_ProcessBackground(URL_Struct* urlstruct);
  406.  
  407. /* libnet --> libmsg glue for newsgroup searching */
  408. extern void MSG_AddNewsXpatHit (MWContext *context, uint32 artNum);
  409. extern void MSG_AddNewsSearchHit (MWContext *context, const char *resultLine);
  410.  
  411. /* libnet --> libmsg glue for imap mail folder searching */
  412. extern void MSG_AddImapSearchHit (MWContext *context, const char *resultLine);
  413. /* The POP3 protocol module uses these routines to hand us new messages.
  414.  */
  415. extern XP_Bool MSG_BeginMailDelivery (MSG_Pane* folderpane);
  416. extern void MSG_AbortMailDelivery (MSG_Pane* folderpane);
  417. extern void MSG_EndMailDelivery (MSG_Pane* folderpane);
  418. extern void *MSG_IncorporateBegin (MSG_Pane* folderpane,
  419.                                    FO_Present_Types format_out,
  420.                                    char *pop3_uidl,
  421.                                    URL_Struct *url,
  422.                                    uint32 flags);
  423. extern int MSG_IncorporateWrite (MSG_Pane* folderpane, void *closure,
  424.                                  const char *block, int32 length);
  425. extern int MSG_IncorporateComplete(MSG_Pane* folderpane, void *closure);
  426. extern int MSG_IncorporateAbort (MSG_Pane* folderpane, void *closure,
  427.                                  int status);
  428. extern void MSG_ClearSenderAuthedFlag(MSG_Pane* folderpane, void *closure);
  429.  
  430.  
  431.  
  432.  
  433. /* This is how the netlib registers the converters relevant to MIME message
  434.    display and composition.
  435.  */
  436. void MSG_RegisterConverters (void);
  437.  
  438. extern void
  439. MSG_StartMessageDelivery (MSG_Pane *pane,
  440.                           void      *fe_data,
  441.                           MSG_CompositionFields *fields,
  442.                           XP_Bool digest_p,
  443.                           XP_Bool dont_deliver_p,
  444.                           const char *attachment1_type,
  445.                           const char *attachment1_body,
  446.                           uint32 attachment1_body_length,
  447.                           const struct MSG_AttachmentData *attachments,
  448.                           void *mimeRelatedPart, /* only used in compose pane */
  449.                           void (*message_delivery_done_callback)
  450.                                (MWContext *context, 
  451.                                 void *fe_data,
  452.                                 int status,
  453.                                 const char *error_message));
  454.  
  455. /* When a message which has the `partial' bit set, meaning we only downloaded
  456.    the first 20 lines because it was huge, this function will be called to 
  457.    return some HTML to tack onto the end of the message to explain that it
  458.    is truncated, and provide a clickable link which will download the whole
  459.    message.
  460.  */
  461. extern char *MSG_GeneratePartialMessageBlurb (MSG_Pane* messagepane,
  462.                                               URL_Struct *url, void *closure,
  463.                                               MimeHeaders *headers);
  464.  
  465.  
  466. extern int MSG_GetUrlQueueSize (const char *url, MWContext *context);
  467.  
  468. extern XP_Bool MSG_RequestForReturnReceipt(MSG_Pane* pane);
  469. extern XP_Bool MSG_SendingMDNInProgress(MSG_Pane* pane);
  470.  
  471. extern uint32 MSG_GetIMAPMessageSizeFromDB(MSG_Pane *masterPane, const char *hostName, char *folderName, char *id, XP_Bool idIsUid);
  472.  
  473. extern void MSG_RefreshFoldersForUpdatedIMAPHosts(MWContext *context);
  474.  
  475. extern XP_Bool MSG_MailCheck(MWContext *context, MSG_Prefs *prefs);
  476.  
  477. extern void MSG_Pop3MailCheck(MWContext *context);
  478.  
  479. extern int NET_parse_news_url (const char *url,
  480.                     char **host_and_portP,
  481.                     XP_Bool *securepP,
  482.                     char **groupP,
  483.                     char **message_idP,
  484.                     char **command_specific_dataP);
  485.  
  486. extern char *MSG_GetArbitraryHeadersForHost(MSG_Master *master, const char *hostName);
  487.  
  488. XP_END_PROTOS
  489.  
  490.  
  491. #endif
  492.