Protocols

/* Copyright 1997 Acorn Computers Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/***************************************************/
/* File   : Protocols.c                            */
/*                                                 */
/* Purpose: Handle some common protocol stuff,     */
/*          such as inter-application data         */
/*          transfer.                              */
/*                                                 */
/*          Function naming convention is as usual */
/*          a source leafname derived prefix, then */
/*          a code based on the protocol being     */
/*          dealt with:                            */
/*                                                 */
/*          _atats_  App To App Transfer, Save     */
/*          _atatl_  App To App Transfer, Load     */
/*          _pp_     Printer Protocol              */
/*          _auh_    Acorn URI Handler             */
/*          _ih_     Interactive Help              */
/*          _aub_    ANT URL Broadcast             */
/*          _multi_  Message is used in more than  */
/*                   one message protocol scheme   */
/*          _util_   A utility function not        */
/*                   directly connected with a     */
/*                   specific protocol.            */
/*                                                 */
/*          This is followed by the direction, so  */
/*          to speak - i.e. '_got_' for got a      */
/*          message, '_send_' for sending a        */
/*          message. Alternatively, a prefix       */
/*          '_bounced' is used for messages which  */
/*          return as a UserMessage_Acknowledge    */
/*          event.                                 */
/*                                                 */
/*          Because the Plug-In message protocol   */
/*          is such a large and self-contained     */
/*          entity, this is kept separate, in      */
/*          PlugIn.c.                              */
/*                                                 */
/* Author : A.D.Hodgkinson                         */
/*                                                 */
/* History: 29-Aug-97: Created.                    */
/*                                                 */
/*          06-Sep-97: Significant rewriting to    */
/*                     stop various clashes and    */
/*                     increase flexibility.       */
/***************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "swis.h"
#include "kernel.h"

#include "URI.h" /* URI handler API, in URILib:h */

#include "wimp.h"
#include "wimplib.h"
#include "event.h"

#include "toolbox.h"

#include "svcprint.h"
#include "Global.h"
#include "MiscDefs.h"
#include "Utils.h"

#include "Browser.h"
#include "FetchPage.h"
#include "Filetypes.h"
#include "History.h"
#include "Hotlist.h"
#include "Images.h"
#include "MimeMap.h"
#include "Printing.h"
#include "Save.h"
#include "SaveDraw.h"
#include "SaveFile.h"
#include "SaveObject.h"
#include "SaveText.h"
#include "Toolbars.h"
#include "URLutils.h"
#include "Windows.h"

#include "Protocols.h"

/* Conditional includes */

#ifdef TRACE
  #include "Trace.h"
#endif

/* Local definitions */

#define RTB_Size 4096 /* RAM transfer buffer size, in bytes */

/* Local variables */

/* Need to retain information across function calls about the */
/* different processes going on. Since an object save could   */
/* be in progress whilst other saves go on above it, all of   */
/* the remembered items have to be independent. Consequently, */
/* a lot of separate statics are needed.                      */

/* View source - broadcast loading */

static int            data_open_reference                = 0;

/* Saving the page source */

static int            save_source_reference              = 0;
static int            save_source_transmitted            = 0;
static browser_data * save_source_browser                = NULL;

/* Exporting the page as text */

static int            save_as_text_reference             = 0;
static browser_data * save_as_text_browser               = NULL;

/* Exporting the page as Draw */

static int            save_as_draw_reference             = 0;
static browser_data * save_as_draw_browser               = NULL;
static int            save_as_draw_backgrounds           = 0;

/* Saving a link */

static int            save_link_reference                = 0;
static int            save_link_transmitted              = 0;
static browser_data * save_link_browser                  = NULL;
static HStream      * save_link_token                    = NULL;
static int            save_link_as_url                   = 0;

/* Saving the current location */

static int            save_location_reference            = 0;
static int            save_location_transmitted          = 0;
static browser_data * save_location_browser              = NULL;
static int            save_location_as_url               = 0;

#ifndef REMOTE_HOTLIST

  /* Saving a hotlist item */

  static int            save_hotlist_entry_reference     = 0;
  static int            save_hotlist_entry_transmitted   = 0;
  static hotlist_item * save_hotlist_entry_item          = NULL;
  static int            save_hotlist_entry_as_url        = 0;

  /* Saving a hotlist selection */

  static int            save_hotlist_selection_reference   = 0;
  static int            save_hotlist_selection_transmitted = 0;

  /* Saving the entire hotlist */

  static int            save_entire_hotlist_reference      = 0;
  static int            save_entire_hotlist_transmitted    = 0;

#endif

/* Saving the History */

static int            save_history_reference             = 0;
static browser_data * save_history_browser               = NULL;

/* Saving an object through the fetcher */

static int            save_object_reference              = 0;
static int            save_object_transmitted            = 0;
static browser_data * save_object_browser                = NULL;
static int            save_object_through_scrap          = 0;

/* Exporting an image as a sprite */

static int            save_image_reference               = 0;
static int            save_image_transmitted             = 0;
static browser_data * save_image_browser                 = NULL;
static HStream      * save_image_token                   = NULL;
static int            save_image_as_original             = 0;

/* Loading data. For RAM transfer, buffers must be */
/* visible to all functions so they can be freed   */
/* in the event of a transfer failure.             */

static WimpMessage  * pending_data_save_ack              = NULL;
static char         * data_save_suggested_leafname       = NULL;

static void         * rtb                                = NULL;
static int            ram_fetch_reference                = 0;

static char         * ram_load_uri_buffer                = NULL;
static int            ram_load_buffer_size               = 0;
static int            ram_load_started                   = 0;

/* Printing */

static int            print_save_reference               = 0;

/* Static function prototypes */

static _kernel_oserror * protocols_atats_got_data_save_ack (WimpMessage * m);
static _kernel_oserror * protocols_pp_got_data_save_ack    (WimpMessage * m);

static void              protocols_util_update_reference   (int old_ref, int new_ref);

/*************************************************/
/* protocols_atats_send_data_open()              */
/*                                               */
/* Broadcasts a Message_DataOpen for the given   */
/* filetype and given pathname.                  */
/*                                               */
/* Parameters: The filetype to use;              */
/*                                               */
/*             Pointer to a null-terminated      */
/*             pathname to use.                  */
/*************************************************/

_kernel_oserror * protocols_atats_send_data_open(int filetype, char * pathname)
{
  WimpMessage dop;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_send_data_open: Called\n");
  #endif

  /* Fill in the header */

  dop.hdr.your_ref    = 0;
  dop.hdr.action_code = Wimp_MDataOpen;

  /* Fill in the message body */

  dop.data.data_open.window_handle = 0;
  dop.data.data_open.x             = 0;
  dop.data.data_open.y             = 0;
  dop.data.data_open.file_type     = filetype;

  StrNCpy0(dop.data.data_open.path_name, pathname);

  dop.hdr.size = (int) WordAlign(strlen(dop.data.data_open.path_name) + 45); /* (44 for stuff up to the pathname, plus 1 for terminator) */

  /* Send the message */

  RetError(wimp_send_message(Wimp_EUserMessageRecorded, &dop, 0, 0, NULL));

  /* Record my_ref in case it bounces */

  data_open_reference = dop.hdr.my_ref;

  return NULL;
}

/*************************************************/
/* protocols_atats_data_open_bounced()           */
/*                                               */
/* For a View Source function, the browser       */
/* broadcasts a Message_DataOpen. If this        */
/* bounces, attempt to start an editor instead,  */
/* with the pathname specified in the message.   */
/*                                               */
/* See PRM 3-265.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_atats_data_open_bounced(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_data_open_bounced: Called\n");
  #endif

  if (m->hdr.my_ref == data_open_reference)
  {
    _kernel_oserror * e;
    char            * combuf;
    char            * comstart = "If \"Alias$@RunType_FFF\" <> \"\" Then @RunType_FFF ";
    int               len;

    data_open_reference = 0;

    /* Want to run '@RunType_FFF' with the given pathname as a parameter;  */
    /* need to assemble this command string. Work out how long it will be. */

    len = strlen(comstart) + strlen(m->data.data_open.path_name) + 1;

    /* Allocate space for it (complain if this fails). */

    combuf = malloc(len);

    if (!combuf) return make_no_memory_error(9);

    /* Assemble the string */

    strcpy(combuf, comstart);
    strcat(combuf, m->data.data_open.path_name);

    /* Execute the command */

    e = _swix(Wimp_StartTask,
              _IN(0),

              combuf);

    /* Free the command buffer and return the value the _swix call gave back */

    free(combuf);
    combuf = NULL;

    return e;
  }

  #ifdef TRACE

    else
    {
      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Message reference %x not recognised in protocols_atats_data_open_bounced",
              m->hdr.your_ref);

      return &erb;
    }

  #endif

  return NULL;
}

/*************************************************/
/* protocols_atats_send_data_save()              */
/*                                               */
/* Send out a Message_DataSave to initiate       */
/* saving of data to another applicaion.         */
/*                                               */
/* See PRM 3-250 to 3-252.                       */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the save (or NULL);   */
/*                                               */
/*             Pointer to an item that will vary */
/*             depending on what is being saved  */
/*             - e.g. an HStream struct, a       */
/*             hotlist item, or NULL... full     */
/*             details by the definition of the  */
/*             protocols_saving enumeration in   */
/*             Protocols.h;                      */
/*                                               */
/*             Pointer to a null terminated      */
/*             leafname to use;                  */
/*                                               */
/*             If possible, the estimated size   */
/*             of the data, else -1;             */
/*                                               */
/*             Filetype to quote;                */
/*                                               */
/*             A protocols_saving value to say   */
/*             what is being saved (see          */
/*             Protocols.h);                     */
/*                                               */
/*             A WimpGetPointerInfo block        */
/*             pointer, from which the window    */
/*             and icon handle to send to, and   */
/*             x and y coords to send to, are    */
/*             read.                             */
/*************************************************/

_kernel_oserror * protocols_atats_send_data_save(browser_data * b, void * extra, char * leaf, int estimated_size, int filetype,
                                                 protocols_saving saving, WimpGetPointerInfoBlock * info)
{
  WimpMessage m;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_send_data_save: Called\n");
  #endif

  /* Fill in the header */

  m.hdr.sender      = task_handle;
  m.hdr.your_ref    = 0;
  m.hdr.action_code = Wimp_MDataSave;

  /* Fill in the message body */

  m.data.data_save.destination_window = info->window_handle;
  m.data.data_save.destination_icon   = info->icon_handle;
  m.data.data_save.destination_x      = info->x;
  m.data.data_save.destination_y      = info->y;
  m.data.data_save.estimated_size     = estimated_size;
  m.data.data_save.file_type          = filetype;

  /* Copy in the leafname and work out the message size */

  StrNCpy0(m.data.data_save.leaf_name, leaf);

  m.hdr.size = (int) WordAlign(strlen(m.data.data_save.leaf_name) + 45);

  /* Send it */

  RetError(wimp_send_message(Wimp_EUserMessage,
                             &m,
                             info->window_handle,
                             info->icon_handle,
                             NULL));

  /* Remember various details */

  switch (saving)
  {
    /* Save the document source */

    case protocols_saving_document_source:
    {
      save_source_reference              = m.hdr.my_ref;
      save_source_transmitted            = 0;
      save_source_browser                = b;
    }
    break;

    /* Export the document as text */

    case protocols_saving_document_as_text:
    {
      save_as_text_reference             = m.hdr.my_ref;
      save_as_text_browser               = b;
    }
    break;

    /* Export the document as text */

    case protocols_saving_document_as_draw:
    {
      save_as_draw_reference             = m.hdr.my_ref;
      save_as_draw_browser               = b;
      save_as_draw_backgrounds           = savefile_alternative_selected();
    }
    break;

    /* Save a link as a URI file */

    case protocols_saving_link:
    {
      save_link_reference                = m.hdr.my_ref;
      save_link_transmitted              = 0;
      save_link_browser                  = b;
      save_link_token                    = (HStream *) extra;
      save_link_as_url                   = savefile_alternative_selected();
    }
    break;

    /* Save the current location as a URI file */

    case protocols_saving_frame_location:
    {
      save_location_reference            = m.hdr.my_ref;
      save_location_transmitted          = 0;
      save_location_browser              = b;
      save_location_as_url               = savefile_alternative_selected();
    }
    break;

    #ifndef REMOTE_HOTLIST

      /* Save a hotlist item as a URI file */

      case protocols_saving_hotlist_entry:
      {
        save_hotlist_entry_reference       = m.hdr.my_ref;
        save_hotlist_entry_transmitted     = 0;
        save_hotlist_entry_item            = (hotlist_item *) extra;
        save_hotlist_entry_as_url          = filetype == FileType_URI ? 0 : 1;
      }
      break;

      /* Save a selection of hotlist items as an HTML file */

      case protocols_saving_hotlist_selection:
      {
        save_hotlist_selection_reference   = m.hdr.my_ref;
        save_hotlist_selection_transmitted = 0;
      }
      break;

      /* Save the entire hotlist as an HTML file */

      case protocols_saving_entire_hotlist:
      {
        save_entire_hotlist_reference      = m.hdr.my_ref;
        save_entire_hotlist_transmitted    = 0;
      }
      break;

    #endif

    /* Save an object through the fetcher */

    case protocols_saving_object:
    {
      save_object_reference              = m.hdr.my_ref;
      save_object_transmitted            = 0;
      save_object_browser                = b;
      save_object_through_scrap          = 0;
    }
    break;

    /* Save an image as a sprite */

    case protocols_saving_image_sprite:
    {
      save_image_reference               = m.hdr.my_ref;
      save_image_transmitted             = 0;
      save_image_browser                 = b;
      save_image_token                   = (HStream *) extra;
      save_image_as_original             = savefile_alternative_selected();
    }
    break;

    /* Saving the local or global history */

    case protocols_saving_local_history:
    {
      save_history_reference             = m.hdr.my_ref;
      save_history_browser               = b;
    }
    break;

    case protocols_saving_global_history:
    {
      save_history_reference             = m.hdr.my_ref;
      save_history_browser               = NULL;
    }
    break;
  }

  /* Finished */

  return NULL;
}

/*************************************************/
/* protocols_atats_data_save_bounced()           */
/*                                               */
/* Deals with a Message_DataSave bouncing.       */
/*                                               */
/* See PRM 3-252.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_atats_data_save_bounced(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_data_save_bounced: Called\n");
  #endif

  /* We have nothing to do here at present; this */
  /* is only here to be complete.                */

  return NULL;
}

/*************************************************/
/* protocols_atats_got_ram_fetch()               */
/*                                               */
/* After the browser sends a Message_DataSave to */
/* an application, it may reply with             */
/* Message_RAMFetch rather than                  */
/* Message_DataSaveAck if it can handle RAM      */
/* transfer. In that case, we should see if we   */
/* can do RAM transfer for this filetype         */
/* ourselves, and if so, transfer data.          */
/*                                               */
/* See PRM 3-255 and 256.                        */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the Message_RAMFetch. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_atats_got_ram_fetch(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_got_ram_fetch: Called\n");
  #endif

  /* Only the transfer methods by which RAM saving is currently */
  /* supported are listed in the switch. For others, we just do */
  /* nothing. The other application will see its message bounce */
  /* and should send Message_DataSaveAck to continue the save   */
  /* through a temporary file on disc. If not, no loss - from   */
  /* the user's perspective, nothing will have happened.        */
  /*                                                            */
  /* Note all the functions called in the switch statement call */
  /* Protocols.c back again with requests to send a reply of    */
  /* Message_RAMTransmit if they're successful.                 */
  /*                                                            */
  /* Stop press. C can't cope - you can't have a non-constant   */
  /* in a case statement. Good grief. So, this nice elegant     */
  /* case statement gets degraded into a grotty if...else       */
  /* ladder. Yuk, yuk, yuk, yuk, yuk. I *hate* this language.   */

  if (m->hdr.your_ref && m->hdr.your_ref == save_source_reference)
  {
    /* Save document source */

    if (
         is_known_browser(save_source_browser)
       )
       return save_transfer_source(save_source_browser,
                                   &save_source_transmitted,
                                   m);
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_link_reference)
  {
    if (is_known_browser(save_link_browser))
    {
      if (save_link_token)
      {
        /* Save a link as a URI file */

        return save_transfer_uri(save_link_token->anchor,
                                 NULL,
                                 save_link_as_url,
                                 &save_link_transmitted,
                                 m);
      }
      else
      {
        /* Save the current location as a URI file */

        char * url   = browser_current_url  (save_link_browser);
        char * title = browser_current_title(save_link_browser);

        if (!url) url = " ";

        return save_transfer_uri(url,
                                 title,
                                 save_link_as_url,
                                 &save_link_transmitted,
                                 m);
      }
    }
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_location_reference)
  {
    /* Save the current location as a URI file */

    if (is_known_browser(save_location_browser))
    {
      char * title = browser_current_title(save_location_browser);

      return save_transfer_uri(browser_current_url(save_location_browser),
                               title,
                               save_location_as_url,
                               &save_location_transmitted,
                               m);
    }
  }

  #ifndef REMOTE_HOTLIST

    else if (m->hdr.your_ref && m->hdr.your_ref == save_hotlist_entry_reference)
    {
      /* Save a hotlist item as a URI file */

      if (
           save_hotlist_entry_item
         )
         return save_transfer_uri(save_hotlist_entry_item->data.url,
                                  save_hotlist_entry_item->name,
                                  save_hotlist_entry_as_url,
                                  &save_hotlist_entry_transmitted,
                                  m);
    }

  #endif

  return NULL;
}

/*************************************************/
/* protocols_atats_send_ram_transmit()           */
/*                                               */
/* Send out a Message_RAMTransmit in response to */
/* a Message_RAMFetch from another application,  */
/* as part of an ongoing dialogue for RAM        */
/* transfer.                                     */
/*                                               */
/* See PRM 3-255 and 256.                        */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the Message_RAMFetch. The     */
/*             contents will be modified and     */
/*             used in a reply;                  */
/*                                               */
/*             The number of bytes written to    */
/*             the buffer given in the           */
/*             Message_RAMFetch;                 */
/*                                               */
/*             1 if this is the last message in  */
/*             the transfer (so it won't be sent */
/*             UserMessageRecorded and raise an  */
/*             error when it doesn't get         */
/*             acknowledged...).                 */
/*************************************************/

_kernel_oserror * protocols_atats_send_ram_transmit(WimpMessage * m, int transmitted, int last)
{
  int old_ref = m->hdr.your_ref;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_send_ram_transmit: Called\n");
  #endif

  /* Fill in the parts that need changing */

  m->hdr.your_ref             = m->hdr.my_ref;
  m->hdr.action_code          = Wimp_MRAMTransmit;

  m->data.ram_transmit.nbytes = transmitted;

  #ifdef TRACE

    /* Show the contents of the transmission buffer */

    if (tl & (1u<<28))
    {
      void * local = malloc(m->data.ram_transmit.nbytes);

      if (local)
      {
        if (
             !wimp_transfer_block(m->hdr.sender,
                                  m->data.ram_transmit.buffer,
                                  task_handle,
                                  local,
                                  m->data.ram_transmit.nbytes)
           )
        {
          trace_dump_buffer(m->data.ram_transmit.buffer,
                            m->data.ram_transmit.nbytes,
                            1);
        }
        else Printf("\n(Cannot dump transmission buffer - error from Wimp_TransferBlock)\n\n");
      }
      else
      {
        Printf("\n(Cannot dump transmission buffer - not enough memory for local copy)\n\n");
      }
    }

  #endif

  /* Send the reply */

  RetError(wimp_send_message(last ? Wimp_EUserMessage : Wimp_EUserMessageRecorded,
                             m,
                             m->hdr.sender,
                             0,
                             NULL));

  /* Update the records of my_ref for subsequent replies and bounces */

  protocols_util_update_reference(old_ref, m->hdr.my_ref);

  /* If this is the last item, may need to do some tidying up */
  /* (don't do this before sending the message, as here we    */
  /* close the menu tree - if the window we were sending to   */
  /* was in a menu... Well, things Go Wrong.                  */

  if (last)
  {
    #ifndef REMOTE_HOTLIST
      if (m->hdr.my_ref == save_hotlist_entry_reference) RetError(hotlist_clear_selection());
    #endif

    if (
         m->hdr.my_ref == save_source_reference        ||
         m->hdr.my_ref == save_link_reference          ||
         m->hdr.my_ref == save_location_reference

         #ifndef REMOTE_HOTLIST
           || m->hdr.my_ref == save_hotlist_entry_reference
         #endif
       )
    {
      _swix(Wimp_CreateMenu,
            _IN(1),

            -1);
    }
  }

  /* Finished */

  return NULL;
}

/*************************************************/
/* protocols_atats_ram_transmit_bounced()        */
/*                                               */
/* If a RAMTransmit is not acknowledged, we      */
/* should abort file transfer and raise an       */
/* error.                                        */
/*                                               */
/* See PRM 3-255 and 256.                        */
/*                                               */
/* Parameters Pointer to the WimpMessage struct  */
/*            for the received message.          */
/*************************************************/

_kernel_oserror * protocols_atats_ram_transmit_bounced(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_ram_transmit_bounced: Called\n");
  #endif

  /* There's no tidying up to do; just raise an error. */

  erb.errnum = Utils_Error_Custom_Message;

  StrNCpy0(erb.errmess,
           lookup_token("RecvDied:Data transfer failed - receiver died.",
                        0,
                        0));

  return &erb;
}

/*************************************************/
/* protocols_atats_got_data_save_ack()           */
/*                                               */
/* Once we've sent out Message_DataSave we could */
/* get Message_RAMFetch back and proceed with    */
/* RAM transfer. Or the other task could respond */
/* with a Message_DataSaveAck, for transfer via  */
/* a temporary file on disc. This can also       */
/* happen if the other application responds with */
/* a Message_RAMFetch but we decide we can't do  */
/* RAM transfer for that particular object;      */
/* the application sees its Message_RAMFetch     */
/* bounce and drops back to Message_DataSaveAck  */
/* instead.                                      */
/*                                               */
/* See PRM 3-250, 251 and 253.                   */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

static _kernel_oserror * protocols_atats_got_data_save_ack(WimpMessage * m)
{
  _kernel_oserror * e    = NULL;
  int               ok   = 0; /* 0 = problem, 1 = OK, send DataLoad, 2 = OK, but don't send DataLoad */
  char            * path = m->data.data_save_ack.leaf_name; /* (Daft structure definition - it's a path, not a leaf...) */

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_got_data_save_ack: Called\n");
  #endif

  /* First, save the file. Yes, it's another nasty if...else ladder */
  /* because C can't handle it as a switch statement...             */

  if (m->hdr.your_ref && m->hdr.your_ref == save_source_reference)
  {
    /* Save the document source */

    if (is_known_browser(save_source_browser))
    {
      e = save_save_source(path, save_source_browser);
      if (!e) ok = 1;
    }
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_as_text_reference)
  {
    /* Export the document as text */

    if (is_known_browser(save_as_text_browser))
    {
      e = savetext_save_text(save_as_text_browser, path);
      if (!e) ok = 1;
    }
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_as_draw_reference)
  {
    /* Export the document as Draw */

    if (is_known_browser(save_as_draw_browser))
    {
      e = savedraw_save_draw(save_as_draw_browser, path, save_as_draw_backgrounds);
      if (!e) ok = 1;
    }
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_link_reference)
  {
    if (is_known_browser(save_link_browser))
    {
      if (save_link_token)
      {
        /* Save a link as a URI file */

        e = save_save_uri(path, save_link_token->anchor, NULL, save_link_as_url);
        if (!e) ok = 1;
      }
      else
      {
        char * url   = browser_current_url  (save_link_browser);
        char * title = browser_current_title(save_link_browser);

        /* Save the current location as a URI file */

        if (!url) url = " ";

        e = save_save_uri(path, url, title, 0);
        if (!e) ok = 1;
      }
    }
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_location_reference)
  {
    /* Save the current location as a URI file */

    if (is_known_browser(save_location_browser))
    {
      char * title = browser_current_title(save_location_browser);

      e = save_save_uri(path, browser_current_url(save_location_browser), title, save_location_as_url);
      if (!e) ok = 1;
    }
  }

  #ifndef REMOTE_HOTLIST

    else if (m->hdr.your_ref && m->hdr.your_ref == save_hotlist_entry_reference)
    {
      /* Save a hotlist item as a URI file */

      if (save_hotlist_entry_item)
      {
        e = save_save_uri(path, save_hotlist_entry_item->data.url, save_hotlist_entry_item->name, save_hotlist_entry_as_url);

        if (!e)
        {
          ok = 1;
          e = hotlist_clear_selection();
        }
      }
    }
    else if (m->hdr.your_ref && m->hdr.your_ref == save_hotlist_selection_reference)
    {
      /* Save a hotlist selection as an HTML file */

      e = hotlist_save_hotlist(path, NULL, 1);

      if (!e)
      {
        ok = 1;
        e = hotlist_clear_selection();
      }
    }
    else if (m->hdr.your_ref && m->hdr.your_ref == save_entire_hotlist_reference)
    {
      /* Save the whole hotlist */

      e = hotlist_save_hotlist(path, NULL, 0);
      if (!e) ok = 1;
    }

  #endif

  else if (m->hdr.your_ref && m->hdr.your_ref == save_history_reference)
  {
    /* Save the local or global history */

    if (is_known_browser(save_history_browser))
    {
      e = history_save_as_html(path, save_history_browser);
      if (!e) ok = 1;
    }
    else
    {
      e = history_save_as_html(path, NULL);
      if (!e) ok = 1;
    }
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_object_reference)
  {
    if (is_known_browser(save_object_browser))
    {
      /* First, hide the Save Object dialogue */

      e = saveobject_close(save_object_browser);

      if (!e)
      {
        /* If this is through scrap, use a different filename */

        if (m->data.data_save_ack.estimated_size == -1)
        {
          /* Need to store the Message_DataLoad for later */

          save_object_browser->pending_data_load = malloc(sizeof(WimpMessage));
          if (!save_object_browser->pending_data_load) return make_no_memory_error(13);

          #ifdef TRACE
            malloccount += sizeof(WimpMessage);
            if (tl & (1u<<13)) Printf("** malloccount (protocols_atats_got_data_save_ack): \0211%d\0217\n",malloccount);
          #endif

          *save_object_browser->pending_data_load = *m;

          /* Change the filename to something unique and */
          /* update the message length                   */

          protocols_util_make_unique_name(save_object_browser->pending_data_load->data.data_load.leaf_name,
                                          sizeof(save_object_browser->pending_data_load->data.data_load.leaf_name));

          save_object_browser->pending_data_load->hdr.size = (int) WordAlign(strlen(save_object_browser->pending_data_load->data.data_load.leaf_name) + 45);

          /* Exit through the save routine */

          return save_save_object(save_object_browser->pending_data_load->data.data_load.leaf_name,
                                  save_object_browser);
        }

        /* Otherwise, save as normal */

        else
        {
          e = save_save_object(path, save_object_browser);
          if (!e) ok = 1;
        }
      }
    }
  }
  else if (m->hdr.your_ref && m->hdr.your_ref == save_image_reference)
  {
    if (is_known_browser(save_image_browser))
    {
      if (!save_image_as_original)
      {
        /* Save as a sprite */

        e = image_export_sprite(path, save_image_browser, save_image_token);
        if (!e) ok = 1;
      }
      else
      {
        /* Save original image - similar to Save Object code. So, */
        /* if this is through scrap, use a different filename.    */

        if (m->data.data_save_ack.estimated_size == -1)
        {
          WimpMessage * pending;

          /* Need to store the Message_DataLoad for later */

          pending = malloc(sizeof(WimpMessage));
          if (!pending) return make_no_memory_error(13);

          #ifdef TRACE
            malloccount += sizeof(WimpMessage);
            if (tl & (1u<<13)) Printf("** malloccount (protocols_atats_got_data_save_ack): \0211%d\0217\n",malloccount);
          #endif

          *pending = *m;

          /* Change the filename to something unique and */
          /* update the message length                   */

          protocols_util_make_unique_name(pending->data.data_load.leaf_name,
                                          sizeof(pending->data.data_load.leaf_name));

          pending->hdr.size = (int) WordAlign(strlen(pending->data.data_load.leaf_name) + 45);

          /* Exit through the save routine */

          e = image_export_original(pending->data.data_load.leaf_name,
                                    save_image_browser,
                                    save_image_token);

          if (!e)
          {
            save_image_browser                    = last_browser;
            save_image_browser->pending_data_load = pending;
            ok                                    = 2;
          }
        }

        /* Otherwise, save as normal */

        else
        {
          e = image_export_original(path,
                                    save_image_browser,
                                    save_image_token);

          if (!e)
          {
            save_image_browser = last_browser;
            ok                 = 2;
          }
        }
      }
    }
  }

  /* If everything is OK, send out a Message_DataLoad in reply */

  if (ok && !e)
  {
    if (ok == 1) e = protocols_atats_send_data_load(m);

    /* Don't close the menu before sending the message, as if the item we are */
    /* sending to is within a menu tree, an Illegal Window Handle error may   */
    /* be raised.                                                             */

    _swix(Wimp_CreateMenu,
          _IN(1),

          -1);
  }

  /* Finished */

  return e;
}

/*************************************************/
/* protocols_atats_send_data_load()              */
/*                                               */
/* Send out a Message_DataLoad in response to a  */
/* Message_DataSaveAck from another application, */
/* as part of an ongoing dialogue for file       */
/* transfer.                                     */
/*                                               */
/* See PRM 3-251 and 253.                        */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the Message_DataSaveAck. The  */
/*             contents will be modified and     */
/*             used in the reply.                */
/*************************************************/

_kernel_oserror * protocols_atats_send_data_load(WimpMessage * m)
{
  int old_ref = m->hdr.your_ref;
  int found   = 0;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_send_data_load: Called\n");
  #endif

  /* Fill in the parts that need changing */

  m->hdr.your_ref    = m->hdr.my_ref;
  m->hdr.action_code = Wimp_MDataLoad;

  /* Find out the file size and type */

  RetError(_swix(OS_File,
                 _INR(0,1) | _OUT(0) | _OUT(4) | _OUT(6),

                 23, /* Read catalogue info for named, stamped object */
                 m->data.data_save_ack.leaf_name,

                 &found,
                 &m->data.data_load.estimated_size,
                 &m->data.data_load.file_type));

  if (found != 1)
  {
    /* Object not found - woo, weird (but it happens!) */

    #ifdef TRACE
      {
        erb.errnum = Utils_Error_Custom_Message;

        StrNCpy0(erb.errmess,
                 "Can't find the file I'm supposed to tell someone else to load in protocols_atats_send_data_load");

        show_error_ret(&erb);
      }
    #endif

    return NULL;
  }

  /* Send the reply */

  RetError(wimp_send_message(Wimp_EUserMessageRecorded,
                             m,
                             m->data.data_save_ack.destination_window,
                             m->data.data_save_ack.destination_icon,
                             NULL));

  /* Update the records of my_ref for subsequent replies and bounces */

  protocols_util_update_reference(old_ref, m->hdr.my_ref);

  /* Finished */

  return NULL;
}

/*************************************************/
/* protocols_atats_data_load_bounced()           */
/*                                               */
/* Called if a Message_DataLoad bounces. Need to */
/* delete any scrap files written and report an  */
/* appropriate error.                            */
/*                                               */
/* See PRM 3-253, 254.                           */
/*                                               */
/* Parameters Pointer to the WimpMessage struct  */
/*            for the received message.          */
/*************************************************/

_kernel_oserror * protocols_atats_data_load_bounced(WimpMessage * m)
{
  int scrap_was_opened = 0;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_data_load_bounced: Called\n");
  #endif

  /* Do we recognise this message? If so, deal with it, otherwise */
  /* ignore it (or raise a warning in TRACE builds).              */

  if (
       m->hdr.my_ref == save_source_reference              ||
       m->hdr.my_ref == save_as_text_reference             ||
       m->hdr.my_ref == save_as_draw_reference             ||
       m->hdr.my_ref == save_link_reference                ||
       m->hdr.my_ref == save_location_reference            ||

       #ifndef REMOTE_HOTLIST

         m->hdr.my_ref == save_hotlist_entry_reference     ||
         m->hdr.my_ref == save_hotlist_selection_reference ||
         m->hdr.my_ref == save_entire_hotlist_reference    ||

       #endif

       m->hdr.my_ref == save_object_reference              ||
       m->hdr.my_ref == save_image_reference               ||
       m->hdr.my_ref == save_history_reference
     )
  {
    /* Not interested in any errors here - just get rid of scrap if we can */

    if (
         !strcmp(m->data.data_load.leaf_name,
                 Save_ScrapFile)
       )
    {
      /* Special case - if saving an object (Shift+Click on a link */
      /* or whatever) through scrap, so the send of a pending      */
      /* Message_DataLoad led to this bounce, don't delete the     */
      /* scrap file as it's the only copy of the data that we      */
      /* have. Instead, open the scrap directory. Otherwise, do as */
      /* PRM 3-254 and delete the scrap file.                      */

      if (!save_object_through_scrap) remove (m->data.data_load.leaf_name);
      else
      {
        char * combuf;
        int    comlen;
        char   new_name[Limits_OS_Pathname];

        save_object_through_scrap = 0;

        /* The first thing we need to do is change the filename away */
        /* from Scrap, or it could get overwritten when someone else */
        /* does a transfer.                                          */

        protocols_util_make_unique_name(new_name, sizeof(new_name));

        comlen = strlen("Rename ")                   +
                 strlen(m->data.data_load.leaf_name) +
                 1                                   + /* Space between the two names */
                 strlen(new_name)                    +
                 1;                                    /* Terminating byte */

        /* Allocate space for the Rename command; if it fails, fine */
        /* - just don't rename.                                     */

        combuf = malloc(comlen);

        if (combuf)
        {
          sprintf(combuf,
                  "%s%s%c%s",
                  "Rename ",
                  m->data.data_load.leaf_name,
                  ' ',
                  new_name);

          /* Execute the command */

          _swix(Wimp_StartTask,
                _IN(0),
                combuf);

          /* Free the buffer */

          free(combuf);
          combuf = NULL;
        }

        /* Try and allocate a buffer for the Filer_OpenDir command. */
        /* If this fails, let it do so silently.                    */

        comlen = strlen("Filer_OpenDir ") + strlen(Save_ScrapDir) + 1;
        combuf = malloc(comlen);

        if (combuf)
        {
          /* Copy in the command */

          strcpy(combuf, "Filer_OpenDir ");
          strcat(combuf, Save_ScrapDir);

          /* Execute it - if there was no error, flag that Scrap was opened */

          if (
               !_swix(Wimp_StartTask,
                      _IN(0),

                      combuf)
             )
             scrap_was_opened = 1;

          /* Free the temporary buffer */

          free(combuf);
        }
      }
    }

    /* Report an appropriate message */

    erb.errnum = Utils_Error_Custom_Message;


    if (!scrap_was_opened)
    {
      StrNCpy0(erb.errmess,
               lookup_token("RecvDied:Data transfer failed - receiver died.",
                            0,
                            0));
    }
    else
    {
      StrNCpy0(erb.errmess,
               lookup_token("RecvDiedKept:Data transfer failed - receiver died. The temporary file has been kept on disc so the fetched data can be recovered.",
                            0,
                            0));
    }

    return &erb;
  }

  #ifdef TRACE

    /* In TRACE builds, raise a warning if we don't recognise the message */

    else
    {
      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Message reference %x not recognised in protocols_atats_data_load_bounced",
              m->hdr.your_ref);

      return &erb;
    }

  #endif

  return NULL;
}

/*************************************************/
/* protocols_atats_got_data_load_ack()           */
/*                                               */
/* Deals with a Message_DataLoadAck - completion */
/* of app to app transfer from the browser.      */
/*                                               */
/* See PRM 3-250, 251, 254.                      */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_atats_got_data_load_ack(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atats_got_data_load_ack: Called\n");
  #endif

  /* We have nothing to do here at present; this */
  /* is only here to be complete.                */

  return NULL;
}

/*************************************************/
/* protocols_atats_send_any_pendings()           */
/*                                               */
/* Sends any pending messages related to the     */
/* given browser, in the context of application  */
/* to application saving.                        */
/*                                               */
/* Parameters: Pointer to a browser_data struct  */
/*             relevant to the pending messages, */
/*             if any.                           */
/*************************************************/

_kernel_oserror * protocols_atats_send_any_pendings(browser_data * b)
{
  _kernel_oserror * e = NULL;

  if (!b || !is_known_browser(b)) return NULL;

  /* Pending Message_DataLoad - an object has been saved */
  /* through the fetcher to a temporary file.            */

  if (b->pending_data_load)
  {
    char * combuf;
    int    comlen;
    int    type;

    b->pending_data_load->hdr.my_ref = 0;

    /* Update the other state variables */

    save_object_reference     = b->pending_data_load->hdr.your_ref;
    save_object_transmitted   = 0;
    save_object_browser       = b;
    save_object_through_scrap = 1;

    /* Delete scrap if present, rename the file we've written to */
    /* ScrapFile, and alter the message back to using this       */
    /* filename.                                                 */

    remove(Save_ScrapFile);

    /* Does Scrap still exist? The above may have failed because */
    /* Save_ScrapFile was in use elsewhere. If so, then leave    */
    /* the filename as-is.                                       */

    type = 1;

    _swix(OS_File,
          _INR(0,1) | _OUT(0),

          17, /* Read catalogue info for object */
          Save_ScrapFile,

          &type);

    if (!type)
    {
      /* Allocate space for the buffer */

      comlen = strlen("Rename ")                                      +
               strlen(b->pending_data_load->data.data_load.leaf_name) +
               1                                                      + /* The space between the two names */
               strlen(Save_ScrapFile)                                 +
               1;                                                       /* Terminating byte */

      combuf = malloc(comlen);

      /* If we can't allocate space, as with the case of the scrap */
      /* file being undeletable, stick with the existing filename. */

      if (combuf)
      {
        /* We can allocate space, so build the command string. */

        sprintf(combuf,
                "%s%s%c%s",
                "Rename ",
                b->pending_data_load->data.data_load.leaf_name,
                ' ',
                Save_ScrapFile);

        /* Do it. If the command fails, use the original filename. */

        if (
             !_swix(Wimp_StartTask,
                    _IN(0),

                    combuf)
           )
        {
          /* The command worked, so change the message appropriately. */

          StrNCpy0(b->pending_data_load->data.data_load.leaf_name, Save_ScrapFile);

          b->pending_data_load->hdr.size = (int) WordAlign(strlen(Save_ScrapFile) + 45);
        }

        /* Free the command buffer */

        free(combuf);
      }
    }

    /* At last, send the message */

    e = protocols_atats_send_data_load(b->pending_data_load);

    /* We don't need the message block in the browser_data structure */
    /* any more, so free it.                                         */

    free(b->pending_data_load);
    b->pending_data_load = NULL;
  }

  return e;
}

/*************************************************/
/* protocols_atatl_got_data_open()               */
/*                                               */
/* Handle reception of a Message_DataOpen - we   */
/* may want to load a given file. It is an       */
/* application to application related the        */
/* consideration as we are transfering data      */
/* from the Filer, in a sense.                   */
/*                                               */
/* See PRM 3-265.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_atatl_got_data_open(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atatl_got_data_open: Called\n");
  #endif

  /* Don't load it if we're the originator */

  if (m->hdr.sender == task_handle) return NULL;

  /* Don't want to load a text or data file from double-clicking, */
  /* only by dragging to a window or the icon bar icon. Similarly */
  /* ANT's URL files should only be loaded if dragged on, and the */
  /* same is true of URI files if we are using the URI handler.   */
  /* Since there is no native TIFF support, drop that out too.    */

  if (
       m->data.data_open.file_type == FileType_TEXT ||
       m->data.data_open.file_type == FileType_DATA ||
       m->data.data_open.file_type == FileType_DOS  || /* (Equivalent to FileType_DATA for PC files, so to speak) */
       m->data.data_open.file_type == FileType_TIFF ||
       m->data.data_open.file_type == FileType_URL  ||
       (
         m->data.data_open.file_type == FileType_URI &&
         uri_module_present
       )
     )
     return NULL;

  /* Now treat as a DataLoad message to avoid duplicating load code. */

  m->data.data_load.destination_window = 0; /* Force a new window to open */
  m->data.data_load.destination_icon   = -1;
  m->data.data_load.estimated_size     = 0;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atatl_got_data_open: Exitting through protocols_atatl_got_data_load\n");
  #endif

  return protocols_atatl_got_data_load(m);
}

/*************************************************/
/* protocols_atatl_got_data_load()               */
/*                                               */
/* Deals with a Message_DataLoad - if we can     */
/* handle the file, load it.                     */
/*                                               */
/* See PRM 3-253.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_atatl_got_data_load(WimpMessage * m)
{
  int         filetype = m->data.data_load.file_type;
  ComponentId c;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atatl_got_data_load: Called\n");
  #endif

  /* Was the URL writable targetted? In this case, if it was a text file, */
  /* assume it contained a URL - modify the Wimp Message block to contain */
  /* an ANT URL file filetype.                                            */

  RetError(window_wimp_to_toolbox(0,
                                  m->data.data_save.destination_window,
                                  m->data.data_save.destination_icon,
                                  NULL,
                                  &c));

  if (c == URLBarWrit && filetype == FileType_TEXT) filetype = FileType_URL;

  /* If we've got a Data or DOS filetype, can we get anything */
  /* more from the filename?                                  */

  if (
       filetype == FileType_DATA ||
       filetype == FileType_DOS
     )
  {
    char * ext = strrchr(m->data.data_load.leaf_name, '/'); /* Since under RISC OS, filename extensions will start with '/' */

    if (ext)
    {
      ext++;

      if (mimemap_extension_to_riscos(ext, &filetype)) filetype = FileType_DATA;
    }
  }

  /* Proceed only if it's a filetype we can handle */

  if (
       filetype == FileType_HTML ||
       filetype == FileType_TEXT ||
       filetype == FileType_GIF  ||
       filetype == FileType_JPEG ||
       filetype == FileType_PNG  ||
       filetype == FileType_TIFF ||
       filetype == FileType_URL  ||
       filetype == FileType_URI
     )
  {
    char url  [Limits_URL];
    char title[Limits_Title];

    int  apptoapp = m->hdr.your_ref ? 1 : 0; /* your_ref is zero if from filer, else filled in for app to app */

    #ifdef TRACE
      if (tl & (1u<<28)) Printf("protocols_atatl_got_data_load: Can handle this filetype (0x%03x)\n", filetype);
    #endif

    /* Multiuser builds, if not logged in, just acknowledge */
    /* the message to stop (e.g.) another browser being     */
    /* launched by the Filer, then complain.                */

    #ifndef SINGLE_USER

      #ifdef TRACE
        if (tl & (1u<<28)) Printf("protocols_atatl_got_data_load: Not logged in\n");
      #endif

      if (!logged_in)
      {
        show_error_ret(protocols_atatl_send_data_load_ack(m));

        erb.errnum = Utils_Error_Custom_Message;

        StrNCpy0(erb.errmess,
                 lookup_token("MustLogIn:The browser cannot fetch Web pages until you log in.",
                              0,
                              0));

        show_error_ret(&erb);

        return NULL;
      }

    #endif

    /* Process the file */

    if (
         filetype != FileType_URI &&
         filetype != FileType_URL
       )
    {
      /* Not a URI or URL file, so text, HTML, image... */

      StrNCpy0(url, m->data.data_load.leaf_name);
      urlutils_pathname_to_url(url, sizeof(url));

      /* For text and HTML, we can use an internal URL scheme */
      /* to allow the fetcher to load the scrap file and then */
      /* remove it, as it should. For other types, the main   */
      /* fetcher modules must be used; so we can't get rid    */
      /* of the scrap file. If something else trashes it,     */
      /* tough.                                               */

      if (
           apptoapp &&
           (
             filetype == FileType_TEXT ||
             filetype == FileType_HTML
           )
         )
      {
        StrNCpy0(url, Internal_URL ForScrapFile ":");

        /* Append the application suggested leafname */

        if (!data_save_suggested_leafname || !*data_save_suggested_leafname)
        {
          if (strlen(url) + 9 <= sizeof(url)) strcat(url, "HTMLfile");
        }
        else
        {
          if (strlen(url) + strlen(data_save_suggested_leafname) + 1 <= sizeof(url)) strcat(url, data_save_suggested_leafname);
        }

        /* Don't need a leafname record now */

        if (data_save_suggested_leafname)
        {
          free(data_save_suggested_leafname);
          data_save_suggested_leafname = NULL;
        }
      }
    }
    else
    {
      urlutils_load_uri_file(url, sizeof(url), title, sizeof(title), m->data.data_load.leaf_name);

      /* Delete scrap if used - we've finished with the */
      /* file now, certainly.                           */

      if (apptoapp) remove(m->data.data_load.leaf_name);
    }

    /* Take appropriate action */

    if (m->data.data_load.destination_window <= 0)
    {
      /* Load file to icon bar - i.e. open a new window. */

      ChkError(windows_create_browser(url, NULL, NULL, NULL, Windows_CreateBrowser_Normal));
    }

    #ifndef REMOTE_HOTLIST

      else
      {
        int handled = 0;

        /* We allow two places for loading - a browser window (or bits of it), */
        /* and for URI / URL files, the hotlist window. Check the latter.      */

        if (
             filetype == FileType_URI ||
             filetype == FileType_URL
           )
        {
          ObjectId this;

          /* If we can get the window object ID... */

          if (
               !window_wimp_to_toolbox(0,
                                       m->data.data_load.destination_window,
                                       -1,
                                       &this,
                                       NULL)
             )
          {
            /* ...and it matches that of the hotlist, add the item. */

            if (this == hotlist_return_window_id())
            {
              char * leaf = NULL;

              /* If we have a title for the URL, use it, else try other methods... */

              if (!*title)
              {
                /* For the description, use the source leafname, unless this */
                /* is from another app (your_ref is non-zero), in which case */
                /* use the URL, as <Wimp$Scrap> isn't very friendly or       */
                /* unique.                                                   */

                if (!m->hdr.your_ref) leaf = strrchr(m->data.data_load.leaf_name, '.');

                if (!leaf) leaf = url;
                else       leaf ++;
              }

              ChkError(hotlist_add_position(m->data.data_load.destination_x,
                                            m->data.data_load.destination_y,
                                            *title ? title : leaf,
                                            url));

              handled = 1;
            }
          }
        }

        /* We can also load HTML files, in a fashion, to the hotlist. */

        if (filetype == FileType_HTML)
        {
          ObjectId this;

          /* If we can get the window object ID... */

          if (
               !window_wimp_to_toolbox(0,
                                       m->data.data_load.destination_window,
                                       -1,
                                       &this,
                                       NULL)
             )
          {
            /* ...and it matches that of the hotlist, add the item. */

            if (this == hotlist_return_window_id())
            {
              char * path = m->data.data_load.leaf_name;

              ChkError(hotlist_add_html_file(m->data.data_load.destination_x,
                                             m->data.data_load.destination_y,
                                             path));

              handled = 1;
            }
          }
        }

        /* If not handled yet, deal with the file */

        if (!handled)
        {
          browser_data * b = NULL;

          /* Otherwise, load file to a browser window. Need to find */
          /* its browser_data structure for this.                   */

          utils_browser_from_window(m->data.data_load.destination_window, &b);

          if (b && !b->small_fetch) ChkError(fetchpage_new(b, url, 1, 0));
        }
      }

    #endif

    ChkError(protocols_atatl_send_data_load_ack(m));
  }

  return NULL;
}

/*************************************************/
/* protocols_atatl_send_data_load_ack()          */
/*                                               */
/* In response to a Message_DataLoad, reply with */
/* a Message_DataLoadAck.                        */
/*                                               */
/* See PRM 3-252 and 254.                        */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_atatl_send_data_load_ack(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atatl_send_data_load_ack: Called\n");
  #endif

  m->hdr.your_ref    = m->hdr.my_ref;
  m->hdr.action_code = Wimp_MDataLoadAck;

  return wimp_send_message(Wimp_EUserMessage, m, m->hdr.sender, 0, NULL);
}

/*************************************************/
/* protocols_atatl_got_data_save()               */
/*                                               */
/* Handle reception of a Message_DataSave - load */
/* data from another application. Handles RAM    */
/* transfer for some filetypes.                  */
/*                                               */
/* See PRM 3-252, 253, 255 and 256.              */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_atatl_got_data_save(WimpMessage * m)
{
  _kernel_oserror * e        = NULL;
  int               filetype = m->data.data_save.file_type;
  int               ram      = 0;
  WimpMessage     * reply;
  ComponentId       c;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atatl_got_data_save: Called\n");
  #endif

  /* Was the URL writable targetted? In this case, if it was a text file, */
  /* assume it contained a URL - modify the Wimp Message block to contain */
  /* an ANT URL file filetype.                                            */

  RetError(window_wimp_to_toolbox(0,
                                  m->data.data_save.destination_window,
                                  m->data.data_save.destination_icon,
                                  NULL,
                                  &c));

  if (c == URLBarWrit && filetype == FileType_TEXT) filetype = FileType_URL;

  /* Can we do RAM transfer for this file type? */

  if (
       filetype == FileType_URI ||
       filetype == FileType_URL
     )
     ram = 1;

  /* Can't do anything if <Wimp$Scrap> isn't defined and we want to */
  /* use it for file transfer. Note that the checking function will */
  /* raise an appropriate error in passing ('<Wimp$Scrap> not       */
  /* defined', for example).                                        */

  if (!ram && utils_check_scrap()) return NULL;

  /* Free any allocated data left over from previous calls */

  if (pending_data_save_ack)
  {
    #ifdef TRACE
      if (tl & (1u<<28)) Printf("protocols_atatl_got_data_save: Freeing old pending Acknowledge block\n");
    #endif

    free(pending_data_save_ack);
    pending_data_save_ack = NULL;
  }

  if (data_save_suggested_leafname)
  {
    #ifdef TRACE
      if (tl & (1u<<28)) Printf("protocols_atatl_got_data_save: Freeing old suggested leafname block\n");
    #endif

    free(data_save_suggested_leafname);
    data_save_suggested_leafname = NULL;
  }

  /* Record the leafname. Thus, when the Message_DataLoad comes along  */
  /* or the RAM transfer is finished, we can use this recorded leaf in */
  /* some meaningful place (such as the URL bar). Otherwise, we have   */
  /* no record (only e.g. '<Wimp$Scrap>' in a Message_DataLoad) and    */
  /* things get a bit more ugly at the front-end.                      */

  if (*m->data.data_save.leaf_name)
  {
    /* Allocate the block */

    data_save_suggested_leafname = malloc(strlen(m->data.data_save_ack.leaf_name) + 1);

    /* Do nothing if this should fail; assuming we managed  */
    /* to load the file, allow the load routines to default */
    /* down to a general alternative in the absence of this */
    /* record.                                              */

    if (data_save_suggested_leafname) strcpy(data_save_suggested_leafname, m->data.data_save_ack.leaf_name);
  }

  /* Deal with RAM transfer - send out a RAMFetch. If this */
  /* bounces, we'll need to drop back to scrap files.      */

  if (ram)
  {
    /* First, we may need to use file transfer so fill in */
    /* a pending DataSaveAck block for later use.         */

    pending_data_save_ack = malloc(sizeof(WimpMessage));

    if (!pending_data_save_ack) return make_no_memory_error(11);

    #ifdef TRACE
      if (tl & (1u<<28)) Printf("protocols_atatl_got_data_save: Allocated new pending Acknowledge block\n");
    #endif

    reply = pending_data_save_ack;
  }
  else
  {
    /* Otherwise, just point back to the existing message and modify */
    /* its contents for a reply in the normal fashion.               */

    reply = m;
  }

  /* Fill it in */

  *reply = *m;

  reply->hdr.your_ref    = m->hdr.my_ref;
  reply->hdr.action_code = Wimp_MDataSaveAck;

  reply->data.data_save_ack.estimated_size = -1;

  /* Write the filename for Scrap to the message block */
  /* and update the size field in the header.          */

  StrNCpy0(reply->data.data_save_ack.leaf_name, Save_ScrapFile);

  reply->hdr.size = (int) WordAlign(strlen(Save_ScrapFile) + 45); /* (44 for stuff up to the pathname, plus 1 for terminator) */

  /* For RAM transfer, send a Message_RAMFetch */

  if (ram)
  {
    WimpMessage * raf = m;

    /* Free any existing RAM transfer buffer and allocate a new one */

    if (rtb) free(rtb);
    rtb = malloc(RTB_Size);

    /* If the allocation fails, drop through to a scrap file method */

    if (rtb)
    {
      /* Fill in the message details */

      #ifdef TRACE
        malloccount += RTB_Size;
        if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_got_data_save): \0211%d\0217\n",malloccount);
      #endif

      raf->hdr.size                   = 28;
      raf->hdr.your_ref               = m->hdr.my_ref;
      raf->hdr.action_code            = Wimp_MRAMFetch;

      raf->data.ram_fetch.buffer      = rtb;
      raf->data.ram_fetch.buffer_size = RTB_Size;

      /* Send it */

      #ifdef TRACE
        if (tl & (1u<<28)) Printf("protocols_atatl_got_data_save: Sending Message_RAMFetch in response\n");
      #endif

      RetError(wimp_send_message(Wimp_EUserMessageRecorded,
                                 raf,
                                 m->hdr.sender,
                                 0,
                                 NULL));

      /* Remember my_ref in case it bounces */

      ram_fetch_reference = raf->hdr.my_ref;

      /* Flag that we've not started transfer of actual data yet */

      ram_load_started = 0;
    }
    else ram = 0; /* So that the Message_DataSaveAck goes out instead */
  }

  /* Otherwise send a Message_DataSaveAck reply */

  if (!ram) /* Must use this as the RAM transfer code will set 'ram' to 0 if it can't claim a transfer buffer */
  {
    RetError(wimp_send_message(Wimp_EUserMessage, /* Not interested in it bouncing */
                               reply,
                               m->hdr.sender,
                               0,
                               NULL));
  }

  return e;
}

/*************************************************/
/* protocols_atatl_ram_fetch_bounced()           */
/*                                               */
/* Following getting a Message_DataSave,         */
/* protocols_atatl_got_data_save may send out a  */
/* Message_RAMFetch. If this bounces, this       */
/* function is called. If the bounce is indeed   */
/* due to the RAMFetch we sent, then send out    */
/* a Message_DataSaveAck instead, to try and use */
/* scrap file transfer. This is stored in the    */
/* 'pending' block by the same function that     */
/* sends the Message_RAMFetch.                   */
/*                                               */
/* Alternatively, a Message_RAMFetch being sent  */
/* in reply to a Message_RAMTransmit *during*    */
/* RAM transfer could bounce, and this function  */
/* would be called. In that case, we should      */
/* abort data transfer. The other end is meant   */
/* to raise an error (which is odd, since it     */
/* seems likely that it will have died - since   */
/* it's sending, the changes of running out of   */
/* memory at that end are slim).                 */
/*                                               */
/* See PRM 3-255.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_atatl_ram_fetch_bounced(WimpMessage * m)
{
  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atatl_ram_fetch_bounced: Called\n");
  #endif

  if (m->hdr.my_ref == ram_fetch_reference)
  {
    if (!ram_load_started && pending_data_save_ack)
    {
      /* The bounce is from the first Message_RAMFetch, so try using */
      /* scrap file transfer instead.                                */

      _kernel_oserror * e;

      #ifdef TRACE
        if (tl & (1u<<28)) Printf("protocols_atatl_ram_fetch_bounced: Recognised bounce for a new transfer - using Scrap instead\n");
      #endif

      /* Before doing this, make sure Scrap is present - the call */
      /* will raise an error if not, before returning here        */

      if (utils_check_scrap()) return NULL;

      /* Send the pending message */

      e = wimp_send_message(Wimp_EUserMessage,
                            pending_data_save_ack,
                            pending_data_save_ack->hdr.sender,
                            0,
                            NULL);

      /* Free the block and return any error that may have been generated */

      free(pending_data_save_ack);
      pending_data_save_ack = NULL;

      return e;
    }
    else
    {
      #ifdef TRACE
        if (tl & (1u<<28)) Printf("protocols_atatl_ram_fetch_bounced: Recognised bounce for an ongoing transfer - aborting\n");
      #endif

      /* The bounce is from an ongoing RAM transfer, so abort that */
      /* transfer - free any in-use buffers.                       */

      if (ram_load_uri_buffer)
      {
        free(ram_load_uri_buffer);
        ram_load_uri_buffer = NULL;

        #ifdef TRACE
          malloccount -= ram_load_buffer_size;
          if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_ram_fetch_bounced): \0212%d\0217\n",malloccount);
        #endif
      }

      ram_load_buffer_size = 0;

      if (rtb)
      {
        free(rtb);
        rtb = NULL;

        #ifdef TRACE
          malloccount -= RTB_Size;
          if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_ram_fetch_bounced): \0212%d\0217\n",malloccount);
        #endif
      }

      /* Free the pending Message_DataSaveAck block, if present */

      if (pending_data_save_ack)
      {
        free(pending_data_save_ack);
        pending_data_save_ack = 0;
      }
    }
  }

  return NULL;
}

/*************************************************/
/* protocols_atatl_got_ram_transmit()            */
/*                                               */
/* Deals with a Message_RAMTransmit - we have    */
/* some data in the 'rtb' buffer.                */
/*                                               */
/* See PRM 3-255, 256.                           */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_atatl_got_ram_transmit(WimpMessage * m)
{
  _kernel_oserror * e        = NULL;
  int               ok       = 1;
  int               finished = 0;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_atatl_got_ram_transmit: Called with %d bytes to receive\n", m->data.ram_transmit.nbytes);
  #endif

  /* Flag that transfer is in progress */

  ram_load_started = 1;

  /* Flag if we've finished, too */

  if (m->data.ram_transmit.nbytes < RTB_Size) finished = 1;
  else if (m->data.ram_transmit.nbytes > RTB_Size) m->data.ram_transmit.nbytes = RTB_Size; /* You *never* know...! */

  /* We should know where the buffer is */

  #ifdef TRACE

    if (m->data.ram_transmit.buffer != rtb)
    {
      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Expected to get buffer %p but got %p instead, in protocols_atatl_got_ram_transmit",
              rtb,
              m->data.ram_transmit.buffer);

      e  = &erb;
      ok = 0;
    }

  #else

    if (m->data.ram_transmit.buffer != rtb) ok = 0;

  #endif

  /* The action here depends on the type of file being transferred; */
  /* we know from here on in that the 'rtb' buffer is the buffer    */
  /* that has been filled in (see above), so we can use this rather */
  /* than the more cumbersome 'm->data.ram_transmit.buffer'.        */

  if (ok && pending_data_save_ack)
  {
    ComponentId c;
    int         filetype = pending_data_save_ack->data.data_save_ack.file_type;

    /* Was this dragged to the URL writable, and thus should be */
    /* treated as an ANT URL file (if text)?                    */

    RetError(window_wimp_to_toolbox(0,
                                    pending_data_save_ack->data.data_save_ack.destination_window,
                                    pending_data_save_ack->data.data_save_ack.destination_icon,
                                    NULL,
                                    &c));

    if (c == URLBarWrit && filetype == FileType_TEXT) filetype = FileType_URL;

    switch (filetype)
    {
      /* For URI / URL files, copy data from the file transfer */
      /* buffer (which may deliver the file in several small   */
      /* chunks) to a cumulative file buffer, and then process */
      /* that whole thing when finished.                       */

      case FileType_URL: /* Same as for URI files, so no 'break' */
      case FileType_URI:
      {
        int first = 0;

        /* Only proceed with transfer if there are some bytes to get  */
        /* (otherwise, this was the last message with the final chunk */
        /* of data having exactly filled the buffer last time - so    */
        /* act upon the buffer contents now, without trying to        */
        /* transfer zero bytes first).                                */

        if (m->data.ram_transmit.nbytes)
        {
          /* Allocate or extend the local buffer to take in the URI file */

          if (!ram_load_uri_buffer)
          {
            /* Note we allocate 1 byte more than needed to allow a terminator to */
            /* be inserted after the URL string when the transfer has ended;     */
            /* this is because a URI file may end simply by EOF, it does not     */
            /* need a terminator (and in any case, that terminator may be a      */
            /* control char such as ASCII 10 or 13, which C would not treat as a */
            /* string terminator).                                               */

            ram_load_uri_buffer = malloc(m->data.ram_transmit.nbytes + 1);
            first               = 1;

            /* Complain if the allocation fails */

            if (!ram_load_uri_buffer)
            {
              e = make_no_memory_error(7);

              ok = 0;
            }

            #ifdef TRACE

              else
              {
                malloccount += m->data.ram_transmit.nbytes + 1;
                if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_got_ram_transmit): \0211%d\0217\n",malloccount);
              }

            #endif
          }
          else
          {
            void * local;

            /* realloc to a new size */

            local = realloc(ram_load_uri_buffer, ram_load_buffer_size + m->data.ram_transmit.nbytes);

            if (!local)
            {
              /* If the allocation fails, free the whole thing */

              free(ram_load_uri_buffer);
              ram_load_uri_buffer = NULL;

              #ifdef TRACE
                malloccount -= ram_load_buffer_size;
                if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_got_ram_transmit): \0212%d\0217\n",malloccount);
              #endif

              ram_load_buffer_size = 0;

              e = make_no_memory_error(7);

              ok = 0;
            }

            /* Otherwise record a possibly new buffer address */

            else
            {
              ram_load_uri_buffer = local;

              #ifdef TRACE
                malloccount += m->data.ram_transmit.nbytes;
                if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_got_ram_transmit): \0211%d\0217\n",malloccount);
              #endif
            }
          }

          if (ok)
          {
            /* Copy the data from the file transfer buffer into */
            /* the cumulative URI file buffer                   */

            memcpy(ram_load_uri_buffer + ram_load_buffer_size - !first,
                   rtb,
                   m->data.ram_transmit.nbytes);

            /* Increment the buffer size counter, remembering to add 1 if this */
            /* is the first time we've allocated data, to allow room for a     */
            /* string terminator when the transfer finishes.                   */

            ram_load_buffer_size += m->data.ram_transmit.nbytes + !!first;

            /* If tracing the process of the transfer, show the buffer contents */
            /* (but don't bother showing the uninitialised last byte).          */

            #ifdef TRACE
              if (tl & (1u<<28)) trace_dump_buffer(ram_load_uri_buffer,
                                                   ram_load_buffer_size - 1,
                                                   2);
            #endif
          }
        }

        /* If the transfer has finished, fetch the URL */

        if (finished)
        {
          /* Remember we allocated 1 byte more than needed at the start, */
          /* so that this terminator could be inserted. This is required */
          /* for URL files, and won't hurt for URI files.                */

          ram_load_uri_buffer[ram_load_buffer_size - 1] = 0;

          /* This is capable of dealing with URI or URL files */

          urlutils_extract_uri(ram_load_uri_buffer, ram_load_buffer_size);

          if (pending_data_save_ack->data.data_save_ack.destination_window <= 0)
          {
            /* The original Message_DataSave was for no specific window */

            e = windows_create_browser(ram_load_uri_buffer, NULL, NULL, NULL, Windows_CreateBrowser_Normal);
          }

          #ifndef REMOTE_HOTLIST

            else
            {
              /* As with DataLoad, this can go to a Hotlist window or a browser; */
              /* the hotlist is the simpler case, check that first.              */

              ObjectId this;
              int      handled = 0;

              /* If we can get the window object ID... */

              if (
                   !window_wimp_to_toolbox(0,
                                           pending_data_save_ack->data.data_save_ack.destination_window,
                                           -1,
                                           &this,
                                           NULL)
                 )
              {
                /* ...and it matches that of the hotlist, add the item. */

                if (this == hotlist_return_window_id())
                {
                  /* Use the title, if we have one */

                  if (*(ram_load_uri_buffer + strlen(ram_load_uri_buffer) + 1))
                  {
                    ChkError(hotlist_add_position(pending_data_save_ack->data.data_save_ack.destination_x,
                                                  pending_data_save_ack->data.data_save_ack.destination_y,
                                                  ram_load_uri_buffer + strlen(ram_load_uri_buffer) + 1,
                                                  ram_load_uri_buffer));
                  }
                  else
                  {
                    ChkError(hotlist_add_position(pending_data_save_ack->data.data_save_ack.destination_x,
                                                  pending_data_save_ack->data.data_save_ack.destination_y,
                                                  ram_load_uri_buffer,
                                                  ram_load_uri_buffer));
                  }

                  handled = 1;
                }
              }

              if (!handled)
              {
                browser_data * b;

                /* The message was for a specific window, so find out which one */

                utils_browser_from_window(pending_data_save_ack->data.data_save_ack.destination_window, &b);

                if (b && !b->small_fetch) e = fetchpage_new(b, ram_load_uri_buffer, 1, 0);
              }
            }

          #endif

          free (ram_load_uri_buffer);
          ram_load_uri_buffer = NULL;

          #ifdef TRACE
            malloccount -= ram_load_buffer_size;
            if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_got_ram_transmit): \0212%d\0217\n",malloccount);
          #endif

          ram_load_buffer_size = 0;

          if (!e) ok = 0;
        }
      }
      break;

      default:
      {
        /* If we don't recognise the filetype, something is very wrong... */

        #ifdef TRACE

          erb.errnum = Utils_Error_Custom_Normal;
          sprintf(erb.errmess,
                  "Unrecognised filetype 0x%03x (%x) in protocols_atatl_got_ram_transmit",
                  pending_data_save_ack->data.data_save_ack.file_type,
                  pending_data_save_ack->data.data_save_ack.file_type);

          e  = &erb;
          ok = 0;

        #else

          ok = 0;

        #endif
      }
      break;
    }
  }

  if (ok && !finished)
  {
    /* If things are OK still, send a RAMFetch to get the  */
    /* next chunk, provided that there is more to get.     */
    /*                                                     */
    /* If things are not OK, no reply is given, thereby    */
    /* abandoning the transfer (PRM 3-256).                */

    WimpMessage * raf = m;

    raf->hdr.size        = 28;
    raf->hdr.your_ref    = m->hdr.my_ref;
    raf->hdr.action_code = Wimp_MRAMFetch;

    #ifdef TRACE
      if (tl & (1u<<28)) Printf("protocols_atatl_got_ram_transmit: Sending RAMFetch in reply\n");
    #endif

    e = wimp_send_message(Wimp_EUserMessageRecorded,
                          raf,
                          m->hdr.sender,
                          0,
                          NULL);

    ram_fetch_reference = m->hdr.my_ref;
  }

  /* Either we've finished or there was an error higher up */

  if (finished || !ok)
  {
    /* Free the RAM transfer buffer, if required. */

    if (rtb) free(rtb);
    rtb = NULL;

    #ifdef TRACE
      malloccount -= RTB_Size;
      if (tl & (1u<<13)) Printf("** malloccount (protocols_atatl_got_ram_transmit): \0212%d\0217\n",malloccount);
    #endif

    /* Free any pending Message_DataSaveAck */

    if (pending_data_save_ack)
    {
      #ifdef TRACE
        if (tl & (1u<<28)) Printf("protocols_atatl_got_ram_transmit: Freeing old pending Acknowledge block\n");
      #endif

      free(pending_data_save_ack);
      pending_data_save_ack = NULL;
    }
  }

  return e;
}

/*************************************************/
/* protocols_pp_send_print_save()                */
/*                                               */
/* First stage of the Print Protocol - broadcast */
/* a Message_PrintSave.                          */
/*                                               */
/* See PRM 3-259, 262.                           */
/*************************************************/

_kernel_oserror * protocols_pp_send_print_save(void)
{
  WimpMessage m;

  /* Fill in the header */

  m.hdr.your_ref    = 0;
  m.hdr.action_code = Browser_Message_PrintSave;

  /* Fill in the body */

  m.data.data_save.destination_window = 0;
  m.data.data_save.destination_icon   = 0;
  m.data.data_save.destination_x      = 0;
  m.data.data_save.destination_y      = 0;
  m.data.data_save.estimated_size     = 4096;
  m.data.data_save.file_type          = FileType_POUT;

  StrNCpy0(m.data.data_save.leaf_name,
           lookup_token("PrintName:WebPage",0,0));

  /* Work out the message size */

  m.hdr.size = (strlen(m.data.data_save.leaf_name) + 44);
  if (m.hdr.size & 3) m.hdr.size = (m.hdr.size & ~3) + 4;

  /* Send the message */

  RetError(wimp_send_message(Wimp_EUserMessageRecorded,
                             &m,
                             0,
                             0,
                             NULL));

  /* A Message_DataSaveAck returns, so to distinguish this from */
  /* any other Message_DataSaveAck, remember my_ref and check   */
  /* it against the returned your_ref in future.                */

  print_save_reference = m.hdr.my_ref;

  return NULL;
}

/*************************************************/
/* protocols_pp_print_save_bounced()             */
/*                                               */
/* If a Message_PrintSave bounces, the browser   */
/* tried to use the printer protocol to do a     */
/* print job but the printer wasn't loaded. In   */
/* that case, print directly to the 'printer:'   */
/* device.                                       */
/*                                               */
/* See PRM 3-259 for details of where this fits  */
/* into the protocol, or 3-262 for the message   */
/* structure.                                    */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_pp_print_save_bounced(WimpMessage * m)
{
  if (m->hdr.my_ref && m->hdr.my_ref == print_save_reference)
  {
    print_save_reference = 0;

    /* Go for it. */

    print_print(NULL);
  }

  #ifdef TRACE

    else
    {
      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Message reference %x not recognised in protocols_pp_print_save_bounced",
              m->hdr.your_ref);

      return &erb;
    }

  #endif

  return NULL;
}

/*************************************************/
/* protocols_pp_got_print_error()                */
/*                                               */
/* Handle reception of a Message_PrintError -    */
/* report an error from the printer driver.      */
/*                                               */
/* See PRM 3-262.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_pp_got_print_error(WimpMessage * m)
{
  if (m->hdr.size == 20)
  {
    /* RISC OS 2 printer manager's PrintBusy response */

    erb.errnum = Utils_Error_Custom_Message;

    StrNCpy0(erb.errmess,
             lookup_token("PrintBusy:The printer is currently busy.",
                          0,
                          0));

    show_error_ret(&erb);
  }

  /* RISC OS 3 !Printers-generated specific error response */

  else show_error_ret((_kernel_oserror *) &m->data);

  return NULL;
}

/*************************************************/
/* protocols_pp_got_data_save_ack()              */
/*                                               */
/* Handle reception of a Message_DataSaveAck     */
/* where the your_ref field shows that it has    */
/* been sent in relation to a print job. Only    */
/* call in those circumstances...                */
/*                                               */
/* See PRM 3-259 / 3-260 for details of where    */
/* this fits into the protocol, or PRM 3-253     */
/* for details on the message structure.         */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

static _kernel_oserror * protocols_pp_got_data_save_ack(WimpMessage * m)
{
  _kernel_oserror * e;
  WimpMessage     * dl = m;
  int               file_size;

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_pp_got_data_save_ack: Called\n");
  #endif

  /* Print to a file in the !Printers-given file, then send */
  /* a DataLoad to the printer manager to tell it to put    */
  /* the file into the print queue.                         */

  print_save_reference = 0;

  print_print(m->data.data_save.leaf_name);

  e = _swix(OS_File,
        _INR(0,1) | _OUT(4),

        23, /* Read catalogue info */
        m->data.data_save.leaf_name,

        &file_size);

  if (e) return e;

  dl->hdr.size        = 64;
  dl->hdr.your_ref    = m->hdr.my_ref;
  dl->hdr.action_code = Wimp_MDataLoad;

  dl->data.data_load.estimated_size = file_size;
  dl->data.data_load.file_type      = FileType_POUT;

  e = _swix(OS_File,
            _INR(0,2),

            18, /* Set filetype of named object */
            m->data.data_save_ack.leaf_name,
            FileType_POUT);

  strcpy(dl->data.data_load.leaf_name, m->data.data_save_ack.leaf_name);

  /* Send the DataLoad - a UserMessage, not UserMessageRecorded, */
  /* so it can't bounce back.                                    */

  #ifdef TRACE
    if (tl & (1u<<28)) Printf("protocols_pp_got_data_save_ack: Sending Message_DataLoad in response\n");
  #endif

  return wimp_send_message(Wimp_EUserMessage,
                           dl,
                           m->hdr.sender,
                           0,
                           NULL);
}

/*************************************************/
/* protocols_pp_got_print_type_odd()             */
/*                                               */
/* Handle reception of a Message_PrintTypeOdd.   */
/*                                               */
/* If this is sent directly to the task, we can  */
/* print immediately to 'printer:'.              */
/*                                               */
/* The use of an Alias$PrintType_FF4 system      */
/* variable makes it unnecessary to deal with    */
/* the case of a broadcast PrintTypeOdd. This    */
/* happens when a queued PrintOut file that the  */
/* browser has been asked to print rises to the  */
/* top of !Printers' queue. Bizarrely, !Printers */
/* doesn't recognise the filetype and raises the */
/* message. We allow this to fall back to the    */
/* system variable, which copies the PrintOut    */
/* file to the 'printer:' device.                */
/*                                               */
/* This is a hole in an otherwise workable, if   */
/* cumbersome, protocol.                         */
/*                                               */
/* See PRM 3-263.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_pp_got_print_type_odd(WimpMessage * m)
{
  WimpMessage * ptk = m;

  if (m->hdr.your_ref && m->hdr.your_ref == print_save_reference)
  {
    /* The printer manager sent PrintTypeOdd as a reply to this */
    /* task (not a broadcast), so go ahead and print.           */

    print_save_reference = 0;

    /* Send PrintTypeKnown */

    ptk->hdr.size        = 20;
    ptk->hdr.your_ref    = m->hdr.my_ref;
    ptk->hdr.action_code = Browser_Message_PrintTypeKnown;

    RetError(wimp_send_message(Wimp_EUserMessage,
                               ptk,
                               m->hdr.sender,
                               0,
                               NULL));

    print_print(NULL);
  }

  #ifdef TRACE

    else if (m->hdr.your_ref)
    {
      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Message reference %x unrecognised in protocols_pp_got_print_type_odd",
              m->hdr.your_ref);

      return &erb;
    }

  #endif

// Commented out as the Alias$@PrintType_FF4 system variable does this job
// anyway, and if we don't claim this message then anything else which may
// have a better idea of what to do at least gets a chance to try.
//
// This currently doesn't work, incidentally; the conditions on the 'if'
// are wrong (print_save_ref has probably been set to 0, but I never
// got the chance to properly debug this before removing it due to time
// constraints...).
//
//   else if (print_save_ref && m->data.data_save.file_type == FileType_POUT)
//   {
//     /* If the printer doesn't understand PrintOut files, then */
//     /* it may be broken (!) / PostScript. So reply, and copy  */
//     /* the file to the printer device directly.               */
//
//     print_save_ref = 0;
//
//     ptk->hdr.size        = 20;
//     ptk->hdr.your_ref    = m->hdr.my_ref;
//     ptk->hdr.action_code = Browser_Message_PrintTypeKnown;
//
//     ChkError(wimp_send_message(Wimp_EUserMessage, ptk, m->hdr.sender, 0, NULL));
//
//     _swix(OS_FSControl,
//           _INR(0,3),
//
//           26,
//           m->data.data_save.leaf_name,
//           "printer:",
//           2); /* Flags - 'Force' set, but no others. */
//   }

  return NULL;
}

/*************************************************/
/* protocols_auh_got_process()                   */
/*                                               */
/* Handle reception of a URI_MProcess - process  */
/* a URI from the URI handler, replying if we    */
/* can handle the URI.                           */
/*                                               */
/* See 1307,260/FS.                              */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_auh_got_process(WimpMessage * m)
{
  URIProcessMessage * uri    = (URIProcessMessage *) &m->data;
  int                 ok;
  unsigned int        sender = m->hdr.sender;

  /* Can we handle this URI? */

  ok = urlutils_check_protocols(uri->uri);

  #ifdef TRACE
    if (tl & (1u<<21)) Printf("protocols_auh_got_process: URI_MProcess '%s', ok = %d\n",uri->uri,ok);
  #endif

  /* If so, reply to the message and possibly start a fetch */

  if (ok)
  {
    #ifndef SINGLE_USER

      if (logged_in)
      {

    #endif

    /* Only fetch if the flags bits don't say we're to just */
    /* check the URI could be handled.                      */

    if (!uri->flags.bits.check)
    {
      uri_queue * entry = urlutils_find_queue_entry(uri->uri_handle);

      if (entry)
      {
        RetError(fetchpage_postprocess_uri(entry->b,
                                           uri  ->uri,
                                           entry->flags & URIQueue_RecordInHistory ? 1 : 0));

        /* Don't remove it from the queue of uri_queue structures yet - */
        /* wait for the ReturnResult message for that.                  */
      }

      else RetError(windows_create_browser(uri->uri, NULL, NULL, NULL, Windows_CreateBrowser_Normal));
    }

    #ifndef SINGLE_USER

      }
      else
      {
        erb.errnum = Utils_Error_Custom_Message;

        StrNCpy0(erb.errmess,
                 lookup_token("MustLogIn:The browser cannot fetch Web pages until you log in.",
                              0,
                              0));

        show_error_ret(&erb);
      }

    #endif

    /* Now reply, saying that we've handled the message */

    m->hdr.sender      = task_handle;
    m->hdr.your_ref    = m->hdr.my_ref;
    m->hdr.action_code = URI_MProcessAck;

    RetError(wimp_send_message(Wimp_EUserMessage,
                               m,
                               sender,
                               0,
                               NULL));
  }

  return NULL;
}

/*************************************************/
/* protocols_auh_got_return_result()             */
/*                                               */
/* Handle reception of a URI_MReturnResult -     */
/* the URI handler is reporting what happened to */
/* a URI we dispatched through it.               */
/*                                               */
/* See 1307,260/FS.                              */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_auh_got_return_result(WimpMessage * m)
{
  URIReturnResultMessage * uri = (URIReturnResultMessage *) &m->data;

  #ifdef TRACE
    if (tl & (1u<<21)) Printf("protocols_auh_got_return_result: URI_MReturnResult, not_claimed = %d\n",uri->flags.bits.not_claimed);
  #endif

  /* Remove the entry from the queue */

  RetError(urlutils_remove_from_queue(uri->uri_handle));

  /* If the URI was not claimed by anyone, give an appropriate error */

  if (uri->flags.bits.not_claimed)
  {
    erb.errnum = Utils_Error_Custom_Message;

    StrNCpy0(erb.errmess,
             lookup_token("CannotFetch:The browser does not have a method of fetching the requested site.",
                          0,0));

    show_error_ret(&erb);
  }

  return NULL;
}

/*************************************************/
/* protocols_auh_got_dying()                     */
/*                                               */
/* Handle reception of a URI_MDying - the URI    */
/* handler is closing down.                      */
/*                                               */
/* See 1307,260/FS.                              */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_auh_got_dying(WimpMessage * m)
{
  /* If the URI handler is dying, don't try and use it anymore... */

  uri_module_present = 0;

  return NULL;
}

/*************************************************/
/* protocols_ih_send_help_request()              */
/*                                               */
/* Sends out HelpRequest messages for the item   */
/* the mouse pointer is currently over, every    */
/* 20 centiseconds or so.                        */
/*                                               */
/* Parameters are as standard for a Wimp NULL    */
/* event handler.                                */
/*************************************************/

int protocols_ih_send_help_request(int eventcode, WimpPollBlock * block, IdBlock * idb, void * handle)
{
  int        time_now;
  static int last_time   = 0;
  static int last_window = 0;
  static int last_icon   = 0;

  /* Only proceed if the Controls say to do so */

  if (controls.claim_help)
  {
    /* Don't sent out requests too often */

    _swix(OS_ReadMonotonicTime, _OUT(0), &time_now);

    if (time_now - last_time > 20)
    {
      WimpGetPointerInfoBlock i;
      WimpMessage             m;

      last_time = time_now;

      ChkError(wimp_get_pointer_info(&i));

      /* Don't send a request if the pointer isn't over a */
      /* browser-owned window.                            */

      if (task_handle == task_from_window(i.window_handle))
      {
        /* Don't send out multiple requests for the same window/icon. */

        if (i.icon_handle != last_icon || i.window_handle != last_window)
        {
          last_icon   = i.icon_handle;
          last_window = i.window_handle;
        }
        else return 0;

        /* Build the message block and send the request */

        m.hdr.size        = 40;
        m.hdr.sender      = task_handle;
        m.hdr.my_ref      = 0;
        m.hdr.your_ref    = 0;
        m.hdr.action_code = Wimp_MHelpRequest;

        m.data.help_request.mouse_x       = i.x;
        m.data.help_request.mouse_y       = i.y;
        m.data.help_request.buttons       = i.button_state;
        m.data.help_request.window_handle = i.window_handle;
        m.data.help_request.icon_handle   = i.icon_handle;

        ChkError(wimp_send_message(Wimp_EUserMessageRecorded,
                                   &m,
                                   i.window_handle,
                                   i.icon_handle,
                                   NULL));
      }
    }
  }

  return 0;
}

/*************************************************/
/* protocols_ih_help_request_bounced()           */
/*                                               */
/* If a Message_HelpRequest comes in as a        */
/* UserMessage_Acknowledge, then the browser     */
/* tried to send out such a message and it       */
/* bounced - there is no help on that item.      */
/* In this case, if we're displaing help items   */
/* in the status bar, return to a non-help       */
/* status string.                                */
/*                                               */
/* See PRM 3-244 for details of the message or   */
/* protocols_ih_send_help_request for the        */
/* message origin.                               */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_ih_help_request_bounced(WimpMessage * m)
{
  if (controls.claim_help)
  {
    WimpGetPointerInfoBlock   i;
    browser_data            * b = NULL;
    ObjectId                  o, a = -1;

    RetError(wimp_get_pointer_info(&i));
    RetError(window_wimp_to_toolbox(0, i.window_handle, i.icon_handle, &o, NULL));

    /* If we can get an ancestor, the pointer is over e.g. a toolbar */
    /* - otherwise, assume it is over a browser window.              */

    toolbox_get_ancestor(0, o, &a, NULL);

    if (a)
    {
      toolbox_get_client_handle(0, a, (void *) &b);
    }
    else toolbox_get_client_handle(0, o, (void *) &b);

    /* If we haven't got a valid client handle, exit */

    if (!is_known_browser(b)) return NULL;

    /* Update the status line */

    if (b->status_help != NULL)
    {
      b->status_help = NULL;
      RetError(toolbars_cancel_status(b, Toolbars_Status_Help));
    }
  }

  return NULL;
}

/*************************************************/
/* protocols_ih_got_help_reply()                 */
/*                                               */
/* On receiving a Message_HelpReply, we may want */
/* to display the Help text in the status bar.   */
/*                                               */
/* See PRM 3-245.                                */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_ih_got_help_reply(WimpMessage * m)
{
  static char last_help[Limits_StatusBarStatus];

  /* Don't do anything if the Controls say not to. */

  if (controls.claim_help)
  {
    WimpGetPointerInfoBlock   i;
    browser_data            * b = NULL;
    ObjectId                  o, a = 0;

    RetError(wimp_get_pointer_info(&i));
    RetError(window_wimp_to_toolbox(0, i.window_handle, i.icon_handle, &o, NULL));

    /* If we can get an ancestor, the pointer is over e.g. a toolbar */
    /* - otherwise, assume it is over a browser window.              */

    toolbox_get_ancestor(0, o, &a, NULL);

    if (a)
    {
      toolbox_get_client_handle(0, a, (void *) &b);
    }
    else toolbox_get_client_handle(0, o, (void *) &b);

    /* If we haven't got a valid client handle, exit. */

    if (!is_known_browser(b)) return NULL;

    /* If this is a small fetch window, don't display anything either */

    if (b->small_fetch) return NULL;

    /* If the text is empty, there was no help for that item, */
    /* so restore the old status display, if there was a      */
    /* help display already there.                            */

    if (!*m->data.help_reply.text)
    {
      if (b->status_help != NULL)
      {
        b->status_help = NULL;
        RetError(toolbars_cancel_status(b, Toolbars_Status_Help));
      }
    }
    else
    {
      /* Otherwise update the status bar with the help text, */
      /* if the text has changed.                            */

      if (
           !b->status_help ||
           (
             b->status_help                                  &&
             strcmp(b->status_help, m->data.help_reply.text)
           )
         )
      {
        StrNCpy0(last_help, m->data.help_reply.text);
        b->status_help = last_help;
        RetError(toolbars_update_status(b, Toolbars_Status_Help));
      }
    }
  }

  return NULL;
}

/*************************************************/
/* protocols_aub_got_open_url()                  */
/*                                               */
/* Handle ANT Open URL broadcasts.               */
/*                                               */
/* See http://www.ant.co.uk/support/tech/        */
/* notes/url.html (15 Sep 1997).                 */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message. The     */
/*             contents will be modified and     */
/*             used in a reply.                  */
/*************************************************/

_kernel_oserror * protocols_aub_got_open_url(WimpMessage * m)
{
  ant_open_url * open = (ant_open_url *) &m->data;
  int            ok   = 0;
  char         * url;
  char         * target;

  /* If 'tag' is non-NULL, the data is a URL string */

  if (open->tag) url = (char *) open, target = NULL;

  /* Otherwise, it's indirected */

  else
  {
    char * file;
    char * mimetype;

    /* Entries are either NULL, an offset into the  */
    /* message block (but we have to ensure that it */
    /* is a valid offset), or a pointer. This       */
    /* protocol sucks, big time.                    */

    if (!open->file.offset) file = NULL;
    else if (open->file.offset < 0x1800000)
    {
      if (open->file.offset >= sizeof(m->data.bytes)) file = NULL;
      else file = ((char *) open) + open->file.offset;
    }
    else file = open->file.ptr;

    if (!open->mimetype.offset) mimetype = NULL;
    else if (open->mimetype.offset < 0x1800000)
    {
      if (open->mimetype.offset >= sizeof(m->data.bytes)) mimetype = NULL;
      else mimetype = ((char *) open) + open->mimetype.offset;
    }
    else mimetype = open->mimetype.ptr;

    /* Can't handle file or mimetype requests */

    if (!file && !mimetype)
    {
      if (!open->url.offset) url = NULL;
      else if (open->url.offset < 0x1800000)
      {
        if (open->url.offset >= sizeof(m->data.bytes)) url = NULL;
        else url = ((char *) open) + open->url.offset;
      }
      else url = open->url.ptr;

      if (!open->target.offset) target = NULL;
      else if (open->target.offset < 0x1800000)
      {
        if (open->target.offset >= sizeof(m->data.bytes)) target = NULL;
        else target = ((char *) open) + open->target.offset;
      }
      else target = open->target.ptr;
    }
    else url = NULL, target = NULL;
  }

  /* Check the protocol - can we handle this? */

  if (url) ok = urlutils_check_protocols(url);

  /* If so, do so */

  if (ok)
  {
    /* Send out the URL */

    RetError(windows_create_browser(url,
                                    NULL,
                                    NULL,
                                    target,
                                    Windows_CreateBrowser_Normal));

    /* Acknowledge the message */

    m->hdr.your_ref = m->hdr.my_ref;

    return wimp_send_message(Wimp_EUserMessageAcknowledge,
                             m,
                             m->hdr.sender,
                             0,
                             NULL);
  }

  return NULL;
}

/*************************************************/
/* protocols_multi_got_data_save_ack()           */
/*                                               */
/* Got a DataSaveAck - this could be part of the */
/* print protocol, or standard file transfer     */
/* between applications.                         */
/*                                               */
/* Parameters: Pointer to the WimpMessage struct */
/*             for the received message.         */
/*************************************************/

_kernel_oserror * protocols_multi_got_data_save_ack(WimpMessage * m)
{
  if (m->hdr.your_ref && m->hdr.your_ref == print_save_reference) return protocols_pp_got_data_save_ack(m);
  else                                                            return protocols_atats_got_data_save_ack(m);
}

/*************************************************/
/* protocols_util_update_reference()             */
/*                                               */
/* When a message is sent out as part of an      */
/* ongoing conversation, this function should be */
/* called after Wimp_SendMessage to update the   */
/* internal records of known my_ref numbers.     */
/*                                               */
/* Parameters: The value of the your_ref field   */
/*             in the *original* message, before */
/*             a reply was generated (so you     */
/*             will need to remember this before */
/*             setting your_ref to my_ref prior  */
/*             to replying);                     */
/*                                               */
/*             The value of the my_ref field     */
/*             filled in by the Wimp after       */
/*             Wimp_SendMessage was called to    */
/*             send the reply.                   */
/*************************************************/

static void protocols_util_update_reference(int old_ref, int new_ref)
{
  /* This would look really great as a switch statement. But hey, */
  /* I'm sure C is really an excellent language. Really.          */

  if      (old_ref == save_source_reference)              save_source_reference            = new_ref;
  else if (old_ref == save_as_text_reference)             save_as_text_reference           = new_ref;
  else if (old_ref == save_as_draw_reference)             save_as_draw_reference           = new_ref;
  else if (old_ref == save_link_reference)                save_link_reference              = new_ref;
  else if (old_ref == save_location_reference)            save_location_reference          = new_ref;

  #ifndef REMOTE_HOTLIST

    else if (old_ref == save_hotlist_entry_reference)     save_hotlist_entry_reference     = new_ref;
    else if (old_ref == save_hotlist_selection_reference) save_hotlist_selection_reference = new_ref;
    else if (old_ref == save_entire_hotlist_reference)    save_entire_hotlist_reference    = new_ref;

  #endif

  else if (old_ref == save_object_reference)              save_object_reference            = new_ref;
  else if (old_ref == save_image_reference)               save_image_reference             = new_ref;
  else if (old_ref == save_history_reference)             save_history_reference           = new_ref;
  else if (old_ref == print_save_reference)               print_save_reference             = new_ref;

  #ifdef TRACE

    else
    {
      erb.errnum = Utils_Error_Custom_Normal;

      sprintf(erb.errmess,
              "Old message reference %x not recognised in protocols_util_update_reference (has a new save method been created, but not added to this function?)",
              old_ref);

      show_error_ret(&erb);
    }

  #endif
}

/*************************************************/
/* protocols_util_make_unique_name()             */
/*                                               */
/* Generates a browser-unique pathname in the    */
/* given buffer, based on Wimp$ScrapDir. This is */
/* hopefully system-unique as the function       */
/* keeps going until it can't find a file under  */
/* the name it has constructed.                  */
/*                                               */
/* Parameters: Pointer to the buffer;            */
/*                                               */
/*             Size of the buffer.               */
/*                                               */
/* Assumes:    Well it won't crash if you give   */
/*             it a NULL buffer pointer or a     */
/*             buffer size of less than 2 bytes, */
/*             but there's not exactly a huge    */
/*             amount of worth in calling the    */
/*             function under those conditions!  */
/*************************************************/

void protocols_util_make_unique_name(char * buffer, int buffer_size)
{
  int    filecount = 0;
  int    type;
  char * leaf;

  if (!buffer || buffer_size < 2) return;

  /* Clear the buffer first */

  memset(buffer, 0, buffer_size);

  /* Write '<Wimp$ScrapDir>.' (or whatever is defined in Save.h) */
  /* to the buffer - +9 is 8 letters for the leafname (see code  */
  /* below) plus 1 for a terminator.                             */

  if (strlen(Save_ScrapPath) + 9 <= buffer_size) strcpy(buffer, Save_ScrapPath);
  else return;

  /* Append with a unique 8 letter leafname */

  leaf = buffer + strlen(buffer);

  do
  {
    sprintf(leaf, "BTF%05x", filecount++);

    /* Can we find the file? */

    type = 1;

    _swix(OS_File,
          _INR(0,1) | _OUT(0),

          17, /* Read catalogue info for object */
          buffer,

          &type);

    /* Keep going until we run out of files (!) or find an unused name */
  }
  while (type != 0 && filecount <= 0xfffff);

  /* Woo - did we run out? */

  if (filecount > 0xfffff)
  {
    #ifdef TRACE

      erb.errnum = Utils_Error_Custom_Normal;

      StrNCpy0(erb.errmess,
               "Blimey! Ran out of filenames in protocols_util_make_unique_name. Going to try to use Save_ScrapFile instead...");

      show_error_ret(&erb);

    #endif

    *buffer = 0;

    if (strlen(Save_ScrapFile) + 1 <= buffer_size) strcpy(buffer, Save_ScrapFile);

    return;
  }

  /* Finished */

  return;
}