docs: protected void handleCreateProxySubscription(SubscriptionMessage createMessage,
        Transaction transaction) throws SIResourceException
    {
      if (tc.isEntryEnabled())
        SibTr.entry(tc, "handleCreateProxySubscription", 
          new Object[] { createMessage, transaction });
          
      // Flag for securing foreign proxy subs
      boolean foreignAllowed = true;
      // Userid to be stored when securing foreign proxy subs
        String MESubUserId = null;
      // Flag to indicate whether a proxy sub originated from
      // a foreign bus where the home bus is secured.
      boolean foreignSecuredProxy = false;
      
      // Get the iterators that we require for this method
      final Iterator topics = createMessage.getTopics().iterator();
      final Iterator topicSpaces = createMessage.getTopicSpaces().iterator();
      final Iterator topicSpaceMappings = createMessage.getTopicSpaceMappings().iterator();
  
  
      // Get the Me name and ME uuid
      final byte[] meUUIDArr = createMessage.getMEUUID();
      final SIBUuid8 meUUID = new SIBUuid8(meUUIDArr);
  
      // Get the bus that this message arrived from
      final String busId = createMessage.getBusName();
  
      // Get the Neighbour from the above details
      Neighbour neighbour = iNeighbours.getNeighbour(meUUID);
      
      // If the neighbour is null, then simply return.
      if (neighbour == null)
      { 
        if (tc.isEntryEnabled()) 
          SibTr.exit(tc, "handleCreateProxySubscription", "Unknown neighbour");   
        return;
      }
      
      boolean okToForward = false;
  
      // If the length of the buses are more than one 
      // then that indicates that this subscription is in more then one bus.
      // This subscription is then required to be forwarded onto all Neighbours in 
      // the other buses.
      if (iNeighbours.getAllBuses().length > 1)
      {
        okToForward = true;
  
        // Reset the list of add subscriptions.
        iAddTopics.clear();
        iAddTopicSpaces.clear();
        iAddTopicSpaceMappings.clear();
      }
  
      // Iterate through the parameters stored in the Message
      while (topics.hasNext())
      {
        // Get the parameters for this iteration
        final String topic = (String) topics.next();
        //as we are receiving this from a remote ME, the foreign topic
        //space name is actually our own topic space name.
        String topicSpaceName = (String) topicSpaceMappings.next();
        //see defect 267686:
        //This will be the topic space uuid if the subscription is coming
        //from another ME on the same bus. Otherwise it will be the foreign
        //topic space name from this ME's perspective.
        String foreignTopicSpaceName = (String)topicSpaces.next();
        
        //the uuid for our local topic space
        SIBUuid12 localTopicSpaceUuid = null;
  
        foreignAllowed = true;
        MESubUserId = null;
        foreignSecuredProxy = false;
        
        // If this message originated from a foreign bus then convert the
        // topicSpaceName to a uuid
        if (!busId.equals(iProxyHandler.getMessageProcessor().getMessagingEngineBus()))
        {
          DestinationHandler topicSpace = null;
          try
          { 
            topicSpace =  
              iDestinationManager.getDestination(topicSpaceName, false);
          } 
          catch (SIException e)
          {
            // No FFDC code needed
            if (tc.isDebugEnabled())
              SibTr.debug(tc, "Destination not found " + topicSpaceName);
          }
                        
          if (topicSpace == null)
          {
            // We do not register temporary proxies for foreign buses.
            // Instead the situation is handled with the request message code.  
            // So we ignore the message
            if (tc.isEntryEnabled())
              SibTr.exit(tc, "handleCreateProxySubscription", "Topic Space " + topicSpaceName + " not found");
  
            return;
          }
          
          // Check whether bus security is enabled 
          if (iProxyHandler.getMessageProcessor().isBusSecure()) 
          {
            try 
            {
              if(createMessage.isSecurityUseridSentBySystem())
               {
                // Message is from a foreign bus but still retains
                // SIBServerSubject. This implies that no link inbound
                // userid was set and we'll allow processing to continue
                // without the necessity of access checks.              
              }
              else
              {
                // Get the userid against which to check access.
                // This userid will also be stored in the MESubscription
                MESubUserId = createMessage.getSecurityUserid(); 
                                  
                // Check authority to produce to destination
                foreignAllowed =
                  checkDestinationAccess(topicSpace,
                                         topic,
                                         MESubUserId);
                foreignSecuredProxy = foreignAllowed;
              }
            } 
            catch (SIException e) 
            {
              // No FFDC code needed
              if (tc.isDebugEnabled())
                SibTr.debug(tc, "Caught exception " + e);
              foreignAllowed = false;
            }
          }
          
          if (foreignAllowed)
          {
            //we have located our local dest handler for
            //our local topic space for this subscription, so we can 
            //obtain the uuid
            localTopicSpaceUuid = topicSpace.getUuid();
          } 
        } 
        else
        {
          //see defect 267686:
          //we are on the same bus as the subscribing ME - this means that
          //the foreignTopicSpace is actually the local topic space's uuid
          localTopicSpaceUuid = new SIBUuid12(foreignTopicSpaceName);
        }
  
        if (foreignAllowed) 
        {
          // Tell the Neighbour to create the proxy subscription if
          // required.
  
          final MESubscription sub = 
            neighbour.proxyRegistered(localTopicSpaceUuid,
                                      topicSpaceName, 
                                      topic,
                                      foreignTopicSpaceName,
                                      transaction,
                                      foreignSecuredProxy,
                                      MESubUserId);
                                      
          // If this was registered, then add to the list of registered subscriptions,
          // but we only need to do this if we can forward this onto other Neighbours.
          if (sub!=null)
          {
            // Create the PubSubHandler and assign it to the match space
            final boolean created =
              iNeighbours.createProxy(
                neighbour,
                iDestinationManager.getDestinationInternal(localTopicSpaceUuid, false),
                sub,
                localTopicSpaceUuid,
                topic,
                false);
  
            // Only if the pubsub output handler is created, run through the
            // proxy created code.
            if (created && okToForward)
            {
              iAddTopics.add(topic);
              iAddTopicSpaces.add(localTopicSpaceUuid);
              iAddTopicSpaceMappings.add(foreignTopicSpaceName);
            }
          }
        }
      }
  
      // Forward onto other Neighbours if this is a new proxy
      // and there are other Neighbours that require this change.
      if (okToForward && iAddTopics.size() > 0)
      {
        iProxyHandler.subscribeEvent(iAddTopicSpaces, iAddTopics, busId, transaction);
      }
  
      if (tc.isEntryEnabled())
        SibTr.exit(tc, "handleCreateProxySubscription");
    }