gecko-dev/lib/mailto/msgglue.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

#include "rosetta.h"
#include "msg.h"
#include "msgcom.h"
#include "error.h"
#include "client.h"
#include "xpgetstr.h"
#include "msgcpane.h"
#include "msgprefs.h"
#include "msgmast.h"
#include "msgcflds.h"
#include "shist.h"
#include "msgppane.h"
#include "mime.h"
#include "msgbg.h"
#include "prefapi.h"
#include "msgurlq.h"
#include "msgsend.h"
#include "pw_public.h"
#include HG99874

extern "C"
{
	extern int MK_OUT_OF_MEMORY;
	extern int MK_MSG_ID_NOT_IN_FOLDER;
	extern int MK_MSG_CANT_OPEN;
	extern int MK_MSG_INBOX_L10N_NAME;
	extern int MK_MSG_OUTBOX_L10N_NAME;
	extern int MK_MSG_OUTBOX_L10N_NAME_OLD;
	extern int MK_MSG_TRASH_L10N_NAME;
	extern int MK_MSG_DRAFTS_L10N_NAME;
	extern int MK_MSG_SENT_L10N_NAME;
	extern int MK_MSG_TEMPLATES_L10N_NAME;
	extern int XP_MSG_IMAP_ACL_FULL_RIGHTS;
	extern int XP_MSG_IMAP_PERSONAL_FOLDER_TYPE_NAME;
	extern int XP_MSG_IMAP_PERSONAL_FOLDER_TYPE_DESCRIPTION;
}

#ifndef IMAP4_PORT_SSL_DEFAULT 
#define IMAP4_PORT_SSL_DEFAULT 993 /* use a separate port for imap4 over ssl */
#endif

#if defined(XP_MAC) && defined (__MWERKS__)
#pragma require_prototypes off
#endif

extern "C"
int ConvertMsgErrToMKErr(uint32 err); // ### Need to get from a header file...


inline MSG_CompositionPane* CastCompositionPane(MSG_Pane* pane) {
  XP_ASSERT(pane && pane->GetPaneType() == MSG_COMPOSITIONPANE);
  return (MSG_CompositionPane*) pane;
}

extern "C" MSG_Pane* MSG_FindPane(MWContext* context, MSG_PaneType type) {
  return MSG_Pane::FindPane(context, type, FALSE);
}

extern "C" XP_Bool
MSG_RequiresMailWindow (const char *) { return FALSE; }
extern "C" XP_Bool
MSG_RequiresNewsWindow (const char *) { return FALSE; }

/* If this URL requires a particular kind of window, and this is not
   that kind of window, then we need to find or create one.
 */
XP_Bool msg_NewWindowRequired (MWContext *context, const char *url)
{
  if (!context) 
	  return TRUE;
  if (context->type == MWContextSearch || context->type == MWContextPrint || context->type == MWContextBiff) 
	  return FALSE;

  /* Search URLs always run in the pane they started in */
  if (!XP_STRNCASECMP(url, "search-libmsg:", 14))
	  return FALSE;

  // If we can figure out the content type, and there is no converter,
  // return FALSE so we'll run the save as url in our window instead
  // of creating an empty browser window.
  char *contentType = MimeGetURLContentType(context, url);
  if (contentType && !NET_HaveConverterForMimeType(contentType))
	  return FALSE;

  /* This is not a browser window, and one is required. */
  if (context->type != MWContextBrowser && context->type != MWContextPane && MSG_RequiresBrowserWindow(url))
	  return TRUE;

    return FALSE; /*!msgPane && threadPane; */	// if msgPane is NULL, but we have a thread pane, return FALSE because we have the wrong window.
}

extern "C" XP_Bool MSG_NewWindowRequiredForURL (MWContext *context, URL_Struct *urlStruct)
{
	if (urlStruct->open_new_window_specified)
		return urlStruct->open_new_window;

	if (context->type != MWContextBrowser && !strncasecomp (urlStruct->address, "about:", 6) && !urlStruct->internal_url
		&& strncasecomp(urlStruct->address, "about:editfilenew", 17))
		return TRUE;

	return msg_NewWindowRequired(context, urlStruct->address);
}

extern "C"
{
	void MSG_InitMsgLib(void) { } ;
}

extern "C" MSG_Master* MSG_InitializeMail(MSG_Prefs* prefs) 
{
	MSG_Master *master = prefs->GetMasterForBiff();
	if (master)
		return (master);		// already initialized
	
	MSG_InitMsgLib();			// make sure db code is initialized

	master = new MSG_Master(prefs);
	prefs->SetMasterForBiff(master);
	return master;
}


extern "C" MSG_Pane* MSG_CreateProgressPane (MWContext *context,
										 MSG_Master *master,
										 MSG_Pane *parentPane)
{
	return new MSG_ProgressPane(context, master, parentPane);
}

extern "C" MSG_Pane* MSG_CreateCompositionPane(MWContext* context,
											   MWContext* old_context,
											   MSG_Prefs* prefs,
											   MSG_CompositionFields* fields,
											   MSG_Master* master)
{
	return new MSG_CompositionPane(context, old_context, prefs, fields, master);
}

extern "C" int
MSG_SetCompositionPaneCallbacks(MSG_Pane* composepane,
								MSG_CompositionPaneCallbacks* callbacks,
								void* closure)
{
	return CastCompositionPane(composepane)->SetCallbacks(callbacks, closure);
}

extern "C" MSG_Pane* MSG_CreateCompositionPaneNoInit(MWContext* context,
													 MSG_Prefs* prefs,
													 MSG_Master* master)
{
	return new MSG_CompositionPane(context, prefs, master);
}


extern "C" int MSG_InitializeCompositionPane(MSG_Pane* comppane,
											 MWContext* old_context,
											 MSG_CompositionFields* fields)
{
	return CastCompositionPane(comppane)->Initialize(old_context, fields);
}


extern "C" void MSG_SetFEData(MSG_Pane* pane, void* data) {
  pane->SetFEData(data);
}

extern "C" void* MSG_GetFEData(MSG_Pane* pane) {
  return pane->GetFEData();
}

extern "C" MSG_PaneType MSG_GetPaneType(MSG_Pane* pane) {
  return pane->GetPaneType();
}

extern "C" MWContext* MSG_GetContext(MSG_Pane* pane) {
	if (pane)
		return pane->GetContext();
	else
		return NULL;
}

extern "C" MSG_Prefs* MSG_GetPrefs(MSG_Pane* pane) {
  return pane->GetPrefs();
}

extern "C" void MSG_WriteNewProfileAge() {
	PREF_SetIntPref("mailnews.profile_age", MSG_IMAP_CURRENT_START_FLAGS);
}

extern "C" MSG_Prefs* MSG_GetPrefsForMaster(MSG_Master* master) {
  return master->GetPrefs();
}

extern "C" int MSG_GetURL(MSG_Pane *pane, URL_Struct* url)
{
	XP_ASSERT(pane && url);
	if (pane && url)
	{
		url->msg_pane = pane;
		return msg_GetURL(pane->GetContext(), url, FALSE);
	}
	else
		return 0;
}

extern "C" void MSG_Command(MSG_Pane* pane, MSG_CommandType command,
							MSG_ViewIndex* indices, int32 numindices) {
	int status =
		ConvertMsgErrToMKErr(pane->DoCommand(command, indices, numindices));
	if (status < 0) {
		char* pString = XP_GetString(status);
		if (pString && strlen(pString))
			FE_Alert(pane->GetContext(), pString);
	}
}

extern "C" int MSG_CommandStatus(MSG_Pane* pane,
								 MSG_CommandType command,
								 MSG_ViewIndex* indices, int32 numindices,
								 XP_Bool *selectable_p,
								 MSG_COMMAND_CHECK_STATE *selected_p,
								 const char **display_string,
								 XP_Bool *plural_p) {
  return ConvertMsgErrToMKErr(pane->GetCommandStatus(command,
													 indices, numindices,
													 selectable_p,
													 selected_p,
													 display_string,
													 plural_p));
}

extern "C" int MSG_SetToggleStatus(MSG_Pane* pane, MSG_CommandType command,
								   MSG_ViewIndex* indices, int32 numindices,
								   MSG_COMMAND_CHECK_STATE value) {
  return ConvertMsgErrToMKErr(pane->SetToggleStatus(command,
													indices, numindices,
													value));
}


extern "C" MSG_COMMAND_CHECK_STATE MSG_GetToggleStatus(MSG_Pane* pane,
													   MSG_CommandType command,
													   MSG_ViewIndex* indices,
													   int32 numindices)
{
  return pane->GetToggleStatus(command, indices, numindices);
}


extern "C" void MSG_DestroyMaster (MSG_Master* master) {
	delete master;
}


extern "C" void MSG_DestroyPane(MSG_Pane* pane) {
  delete pane;
}


extern "C" void MSG_SetLineWidth(MSG_Pane* composepane, int width)
{
	CastCompositionPane(composepane)->SetLineWidth(width);
}

extern "C" int MSG_SetHTMLAction(MSG_Pane* composepane,
								 MSG_HTMLComposeAction action)
{
	return CastCompositionPane(composepane)->SetHTMLAction(action);
}

extern "C" MSG_HTMLComposeAction MSG_GetHTMLAction(MSG_Pane* composepane)
{
	return CastCompositionPane(composepane)->GetHTMLAction();
}

extern "C" int MSG_PutUpRecipientsDialog(MSG_Pane* composepane, void *pWnd)
{
	return CastCompositionPane(composepane)->PutUpRecipientsDialog(pWnd);
}

extern "C" int MSG_ResultsRecipients(MSG_Pane* composepane,
									 XP_Bool cancelled,
									 int32* nohtml,
									 int32* htmlok)
{
	return CastCompositionPane(composepane)->ResultsRecipients(cancelled,
															   nohtml,
															   htmlok);
}

extern "C" XP_Bool MSG_GetHTMLMarkup(MSG_Pane * composepane) {
    return CastCompositionPane(composepane)->GetHTMLMarkup();
}

extern "C" XP_Bool MSG_DeliveryInProgress(MSG_Pane * composepane) {
    if (!composepane || MSG_COMPOSITIONPANE != MSG_GetPaneType(composepane))
        return FALSE;
    return CastCompositionPane(composepane)->DeliveryInProgress();
}

extern "C" void MSG_SetHTMLMarkup(MSG_Pane * composepane, XP_Bool flag) {
    CastCompositionPane(composepane)->SetHTMLMarkup(flag);
}

extern "C" const char *MSG_GetMessageIdFromState(void *state)
{
	if (state)
	{
		MSG_SendMimeDeliveryState *deliveryState =
			(MSG_SendMimeDeliveryState *) state;
		return deliveryState->m_fields->GetMessageId();
	}
	return NULL;
}

extern "C" XP_Bool MSG_IsSaveDraftDeliveryState(void *state)
{
	if (state)
		return (((MSG_SendMimeDeliveryState *) state)->m_deliver_mode ==
				MSG_SaveAsDraft);
	return FALSE;
}

extern "C" int MSG_SetPreloadedAttachments ( MSG_Pane *composepane,
											 MWContext *context,
											 void *attachmentData,
											 void *attachments,
											 int attachments_count )
{
  return ConvertMsgErrToMKErr ( CastCompositionPane(
								  composepane)->SetPreloadedAttachments (
									context, 
									(MSG_AttachmentData  *) attachmentData,
									(MSG_AttachedFile *) attachments,
									attachments_count) );
}

extern "C" MSG_Prefs* MSG_CreatePrefs() {
  return new MSG_Prefs();
}

extern "C" void MSG_DestroyPrefs(MSG_Prefs* prefs) {
  delete prefs;
}

extern "C" XP_Bool
MSG_GetNoInlineAttachments(MSG_Prefs* prefs)
{
	return prefs->GetNoInlineAttachments();
}

extern "C" XP_Bool MSG_GetAutoQuoteReply(MSG_Prefs* prefs) {
  return prefs->GetAutoQuoteReply();
}

extern MSG_Pane*
MSG_GetParentPane(MSG_Pane* progresspane)
{
	return progresspane->GetParentPane();
}


#ifdef XP_UNIX
extern "C" MSG_Pane*
MSG_MailDocument (MWContext *old_context)
{
  // For backwards compatability.
  return MSG_MailDocumentURL(old_context,NULL);
}

extern "C" MSG_Pane*
MSG_MailDocumentURL (MWContext *old_context,const char *url)
{
	// Don't allow a compose window to be created if the user hasn't 
	// specified an email address
	const char *real_addr = FE_UsersMailAddress();
	if (MISC_ValidateReturnAddress(old_context, real_addr) < 0)
		return NULL;

	MSG_CompositionFields* fields = new MSG_CompositionFields();
	if (!fields) return NULL;	// Out of memory.

  /* If url is not specified, grab current history entry. */
  if (!url) {
	  History_entry *h =
		  (old_context ? SHIST_GetCurrent (&old_context->hist) : 0);
	  if (h && h->address && *h->address) {
		  url = h->address;
	  }
  }
#if 1 /* Do this if we want to attach the target of Mail Document by default */

	if (url) {
		fields->SetHeader(MSG_ATTACHMENTS_HEADER_MASK, url);
	}
#endif

	if (old_context && old_context->title) {
		fields->SetHeader(MSG_SUBJECT_HEADER_MASK, old_context->title);
	}

	if (url) {
		fields->SetBody(url);
	}

	XP_Bool prefBool = FALSE;
	PREF_GetBoolPref("mail.attach_vcard",&prefBool);
	fields->SetAttachVCard(prefBool);

	MSG_CompositionPane* comppane =	(MSG_CompositionPane*) 
	  FE_CreateCompositionPane(old_context, fields, NULL, MSG_DEFAULT);
	if (!comppane) {
		delete fields;
		return NULL;
	}
	
	HG42420
	XP_ASSERT(comppane->GetPaneType() == MSG_COMPOSITIONPANE);
	return comppane;
}

extern "C" MSG_Pane*
MSG_Mail (MWContext *old_context)
{
	MSG_CompositionFields* fields = new MSG_CompositionFields();
	if (!fields) return NULL;	// Out of memory.

	XP_Bool prefBool = FALSE;
	PREF_GetBoolPref("mail.attach_vcard",&prefBool);
	fields->SetAttachVCard(prefBool);

	MSG_CompositionPane* comppane =	(MSG_CompositionPane*) 
	  FE_CreateCompositionPane(old_context, fields, NULL, MSG_DEFAULT);
	if (!comppane) {
		delete fields;
		return NULL;
	}
	
	HG52965
	XP_ASSERT(comppane->GetPaneType() == MSG_COMPOSITIONPANE);
	return comppane;
}

extern "C" void
MSG_ResetUUEncode(MSG_Pane *pane)
{
	CastCompositionPane(pane)->m_confirmed_uuencode_p = FALSE;
}

extern "C" MSG_CompositionFields*
MSG_CreateCompositionFields (
					const char *from,
					const char *reply_to,
					const char *to,
					const char *cc,
					const char *bcc,
					const char *fcc,
					const char *newsgroups,
					const char *followup_to,
					const char *organization,
					const char *subject,
					const char *references,
					const char *other_random_headers,
					const char *priority,
					const char *attachment,
					const char *newspost_url
					)
{
	MSG_CompositionFields* fields = new MSG_CompositionFields();

	fields->SetFrom(from);
	fields->SetReplyTo(reply_to);
	fields->SetTo(to);
	fields->SetCc(cc);
	fields->SetBcc(bcc);
	fields->SetFcc(fcc);
	fields->SetNewsgroups(newsgroups);
	fields->SetFollowupTo(followup_to);
	fields->SetOrganization(organization);
	fields->SetSubject(subject);
	fields->SetReferences(references);
	fields->SetOtherRandomHeaders(other_random_headers);
	fields->SetAttachments(attachment);
	fields->SetNewspostUrl(newspost_url);
	fields->SetPriority(priority);
	return fields;
}

extern "C" void
MSG_DestroyCompositionFields(MSG_CompositionFields *fields)
{
	delete fields;
}

#endif //XP_UNIX

extern "C" void
MSG_SetCompFieldsReceiptType(MSG_CompositionFields *fields,
							 int32 type)
{
	fields->SetReturnReceiptType(type);
}

extern "C" int32
MSG_GetCompFieldsReceiptType(MSG_CompositionFields *fields)
{
	return fields->GetReturnReceiptType();
}

extern "C" int
MSG_SetCompFieldsBoolHeader(MSG_CompositionFields *fields,
							MSG_BOOL_HEADER_SET header,
							XP_Bool bValue)
{
	return fields->SetBoolHeader(header, bValue);
}

extern "C" XP_Bool
MSG_GetCompFieldsBoolHeader(MSG_CompositionFields *fields,
							MSG_BOOL_HEADER_SET header)
{
	return fields->GetBoolHeader(header);
}

extern "C" XP_Bool
MSG_GetForcePlainText(MSG_CompositionFields* fields)
{
	return fields->GetForcePlainText();
}

#ifdef XP_UNIX
extern "C" MSG_Pane*
MSG_ComposeMessage (MWContext *old_context,
					const char *from,
					const char *reply_to,
					const char *to,
					const char *cc,
					const char *bcc,
					const char *fcc,
					const char *newsgroups,
					const char *followup_to,
					const char *organization,
					const char *subject,
					const char *references,
					const char *other_random_headers,
					const char *priority,
					const char *attachment,
					const char *newspost_url,
					const char *body,
					XP_Bool force_plain_text,
					const char* html_part
					)
{
	// Don't allow a compose window to be created if the user hasn't 
	// specified an email address
	const char *real_addr = FE_UsersMailAddress();
	if (MISC_ValidateReturnAddress(old_context, real_addr) < 0)
		return NULL;
	

	MSG_CompositionFields* fields =
		MSG_CreateCompositionFields(from, reply_to, to, cc, bcc,
									fcc, newsgroups, followup_to,
									organization, subject, references,
									other_random_headers, priority, attachment,
									newspost_url);

	fields->SetForcePlainText(force_plain_text);
	fields->SetHTMLPart(html_part);
	fields->SetDefaultBody(body);

	XP_Bool prefBool = FALSE;
	PREF_GetBoolPref("mail.attach_vcard",&prefBool);
	fields->SetAttachVCard(prefBool);

	MSG_CompositionPane* comppane =	(MSG_CompositionPane*) 
	  FE_CreateCompositionPane(old_context, fields, NULL, MSG_DEFAULT);
	if (!comppane) {
		delete fields;
		return NULL;
	}
	
	XP_ASSERT(comppane->GetPaneType() == MSG_COMPOSITIONPANE);
	return comppane;
}

#endif //XP_UNIX
extern "C" XP_Bool
MSG_ShouldAutoQuote(MSG_Pane* comppane)
{
	return CastCompositionPane(comppane)->ShouldAutoQuote();
}

extern "C" const char*
MSG_GetCompHeader(MSG_Pane* comppane, MSG_HEADER_SET header)
{
	return CastCompositionPane(comppane)->GetCompHeader(header);
}


extern "C" int
MSG_SetCompHeader(MSG_Pane* comppane, MSG_HEADER_SET header, const char* value)
{
	return CastCompositionPane(comppane)->SetCompHeader(header, value);
}


extern "C" XP_Bool
MSG_GetCompBoolHeader(MSG_Pane* comppane, MSG_BOOL_HEADER_SET header)
{
	return CastCompositionPane(comppane)->GetCompBoolHeader(header);
}


extern "C" int
MSG_SetCompBoolHeader(MSG_Pane* comppane, MSG_BOOL_HEADER_SET header, XP_Bool bValue)
{
	return CastCompositionPane(comppane)->SetCompBoolHeader(header, bValue);
}


extern "C" const char*
MSG_GetCompBody(MSG_Pane* comppane)
{
	return CastCompositionPane(comppane)->GetCompBody();
}


extern "C" int
MSG_SetCompBody(MSG_Pane* comppane, const char* value)
{
	return CastCompositionPane(comppane)->SetCompBody(value);
}



extern "C" void
MSG_QuoteMessage(MSG_Pane* comppane,
				 int (*func)(void* closure, const char* data),
				 void* closure)
{
	CastCompositionPane(comppane)->QuoteMessage(func, closure);
}


extern "C" int
MSG_SanityCheck(MSG_Pane* comppane, int skippast)
{
	return CastCompositionPane(comppane)->SanityCheck(skippast);
}




extern "C" const char*
MSG_GetAssociatedURL(MSG_Pane* comppane)
{
  return CastCompositionPane(comppane)->GetDefaultURL();
}


extern "C" void
MSG_MailCompositionAllConnectionsComplete(MSG_Pane* comppane)
{
  CastCompositionPane(comppane)->MailCompositionAllConnectionsComplete();
}


extern "C" int
MSG_PastePlaintextQuotation(MSG_Pane* comppane, const char* string)
{
	return CastCompositionPane(comppane)->PastePlaintextQuotation(string);
}

extern "C" char* 
MSG_UpdateHeaderContents(MSG_Pane* comppane,
						 MSG_HEADER_SET header,
						 const char* value)
{
  return CastCompositionPane(comppane)->UpdateHeaderContents(header, value);
}



extern "C" int 
MSG_SetAttachmentList(MSG_Pane* comppane,
					  struct MSG_AttachmentData* list)
{
  return CastCompositionPane(comppane)->SetAttachmentList(list);
}


extern "C" const struct MSG_AttachmentData*
MSG_GetAttachmentList(MSG_Pane* comppane)
{
  return CastCompositionPane(comppane)->GetAttachmentList();
}


extern "C" MSG_HEADER_SET MSG_GetInterestingHeaders(MSG_Pane* comppane)
{
	return CastCompositionPane(comppane)->GetInterestingHeaders();
}








extern "C" XP_Bool MSG_IsDuplicatePost(MSG_Pane* comppane) {
	// if we're sending from the outbox, we don't have a compostion pane, so guess NO.
	return (comppane->GetPaneType() == MSG_COMPOSITIONPANE) 
		? CastCompositionPane(comppane)->IsDuplicatePost()
		: FALSE;
}


extern "C" void
MSG_ClearCompositionMessageID(MSG_Pane* comppane)
{
	if (comppane->GetPaneType() == MSG_COMPOSITIONPANE)
		CastCompositionPane(comppane)->ClearCompositionMessageID();
}


extern "C" const char*
MSG_GetCompositionMessageID(MSG_Pane* comppane)
{
	return (comppane->GetPaneType() == MSG_COMPOSITIONPANE)
		? CastCompositionPane(comppane)->GetCompositionMessageID()
		: 0;
}

/* What are we going to do about error messages and codes? Internally, we'd
 like a nice error range system, but we need to export errors too... ###
 */
extern "C"
int ConvertMsgErrToMKErr(MsgERR err)
{
	switch (err)
	{
	case eSUCCESS:
		return 0;
	case eOUT_OF_MEMORY:
		return MK_OUT_OF_MEMORY;
	case eID_NOT_FOUND:
		return MK_MSG_ID_NOT_IN_FOLDER;
	case eUNKNOWN:
		return -1;
	}
	// Well, most likely, someone returned a negative number that
	// got cast somewhere into a MsgERR.  If so, just return that value.
	if (int(err) < 0) return int(err);
	// Punt, and return the generic unknown error.
	return -1;
}

extern "C" 
int MSG_RetrieveStandardHeaders(MSG_Pane * pane, MSG_HeaderEntry ** return_list)
{
  XP_ASSERT(pane && pane->GetPaneType() == MSG_COMPOSITIONPANE);
  return CastCompositionPane(pane)->RetrieveStandardHeaders(return_list);
}

extern "C"
void MSG_SetHeaderEntries(MSG_Pane * pane,MSG_HeaderEntry * in_list,int count)
{
  XP_ASSERT(pane && pane->GetPaneType() == MSG_COMPOSITIONPANE);
  CastCompositionPane(pane)->SetHeaderEntries(in_list,count);
}

extern "C"
void MSG_ClearComposeHeaders(MSG_Pane * pane)
{
  XP_ASSERT(pane && pane->GetPaneType() == MSG_COMPOSITIONPANE);
  CastCompositionPane(pane)->ClearComposeHeaders();
}

extern "C"
int MSG_ProcessBackground(URL_Struct* urlstruct)
{
	return msg_Background::ProcessBackground(urlstruct);
}

extern "C" XP_Bool MSG_RequestForReturnReceipt(MSG_Pane *pane)
{
	return pane->GetRequestForReturnReceipt();
}

extern "C" XP_Bool MSG_SendingMDNInProgress(MSG_Pane *pane)
{
	return pane->GetSendingMDNInProgress();
}

//
// NET_IsOffline() is declared in net.h, but libnet doesn't define it
// publically anywhere.  There's one in network/protocols/nntp/mknews.c
// but it's declared MODULE_PRIVATE and we can't see it from here,
// at least not in MOZ_MAIL_COMPOSE mode.
//
#ifndef MOZ_MAIL_NEWS
XP_Bool NET_IsOffline() { return FALSE; }
#endif /* MOZ_MAIL_NEWS */