automaticconfigurator.java

jxta_src_2.41b jxta 2.41b 最新版源码 from www.jxta.org

        
        // Create new param docs that contain the updated adv
        http = (XMLDocument) StructuredDocumentFactory.newStructuredDocument( MimeMediaType.XMLUTF8, "Parm");
        XMLDocument httAdvDoc = (XMLDocument) httpAdv.getDocument(MimeMediaType.XMLUTF8);
        StructuredDocumentUtils.copyElements(http, http, httAdvDoc);
        if (httpDisabled) {
            http.appendChild(http.createElement("isOff"));
        }
        advertisement.putServiceParam(PeerGroup.httpProtoClassID, http);
        
        // Check the TCP Message Transport parameters.
        XMLDocument tcp  = (XMLDocument) advertisement.getServiceParam(PeerGroup.tcpProtoClassID);
        TCPAdv  tcpAdv = null;
        boolean tcpDisabled = false;
        
        if (tcp != null) {
            try {
                tcpDisabled = tcp.getChildren("isOff").hasMoreElements();
                
                XMLElement param = null;
                
                Enumeration tcpChilds = tcp.getChildren(TransportAdvertisement.getAdvertisementType());
                
                // get the TransportAdv
                if( tcpChilds.hasMoreElements() ) {
                    param = (XMLElement) tcpChilds.nextElement();
                }
                
                if ( null != param ) {
                    tcpAdv = (TCPAdv) AdvertisementFactory.newAdvertisement(param);
                    
                    if( !tcpDisabled ) {
                        String intf = tcpAdv.getInterfaceAddress();
                        
                        if( (null != intf) && !isValidInetAddress(intf) ) {
                            reconf = true;
                            
                            if (LOG.isEnabledFor(Level.INFO)) {
                                LOG.info("Reconfig requested - invalid interface address");
                            }
                        }
                    }
                }
            } catch (RuntimeException advTrouble) {
                if( LOG.isEnabledFor(Level.WARN) ) {
                    LOG.warn( "TCP advertisement corrupted", advTrouble );
                }
                
                tcpAdv = null;
            }
        }
        
        if (tcpAdv == null) {
            if( LOG.isEnabledFor(Level.INFO) ) {
                LOG.info( "TCP advertisement missing, making a new one." );
            }
            
            int port = 0;
            // get the port from a property
            String tcpPort = System.getProperty("jxta.tcp.port");
            if (tcpPort != null) {
                try {
                    int propertyPort = Integer.parseInt( tcpPort );
                    if( (propertyPort < 65536) && ( propertyPort >= 0 ) )
                        port = propertyPort;
                    else {
                        if( LOG.isEnabledFor(Level.WARN) ) {
                            LOG.warn( "Property 'jxta.tcp.port' is not a valid port number : " + propertyPort );
                        }
                    }
                } catch ( NumberFormatException ignored ) {
                    if( LOG.isEnabledFor(Level.WARN) ) {
                        LOG.warn( "Property 'jxta.tcp.port' was not an integer : " + tcpPort );
                    }
                }
            }
            
            tcpAdv = (TCPAdv) AdvertisementFactory.newAdvertisement( TCPAdv.getAdvertisementType() );
            
            tcpAdv.setProtocol( "tcp" );
            tcpAdv.setPort( port );
            tcpAdv.setMulticastAddr( "224.0.1.85" );
            tcpAdv.setMulticastPort( 1234 );
            tcpAdv.setMulticastSize( 16384 );
            tcpAdv.setMulticastState( true );
        }
        
        tcp = (XMLDocument) StructuredDocumentFactory.newStructuredDocument(MimeMediaType.XMLUTF8, "Parm");
        
        StructuredDocumentUtils.copyElements( tcp, tcp, (XMLDocument) tcpAdv.getDocument(MimeMediaType.XMLUTF8));
        if (tcpDisabled) {
            tcp.appendChild(tcp.createElement("isOff"));
        }
        advertisement.putServiceParam(PeerGroup.tcpProtoClassID, tcp);
        
        // Check the relay config
        RelayConfigAdv relayConfig = null;
        try {
            XMLElement param = (XMLElement) advertisement.getServiceParam(PeerGroup.relayProtoClassID);
            
            if (param != null) {
                // XXX 20041027 backwards compatibility
                param.addAttribute( "type", RelayConfigAdv.getAdvertisementType() );
                
                relayConfig = (RelayConfigAdv) AdvertisementFactory.newAdvertisement( param );
            }
        } catch (Exception failure) {
            if (LOG.isEnabledFor(Level.WARN)) {
                LOG.warn("Problem reading relay configuration", failure);
            }
        }
        
        if( null == relayConfig ) {
            if( LOG.isEnabledFor(Level.INFO) ) {
                LOG.info( "Relay Config advertisement missing, making a new one." );
            }
            
            // restore default values.
            relayConfig = (RelayConfigAdv) AdvertisementFactory.newAdvertisement( RelayConfigAdv.getAdvertisementType() );
            
            // Enable relay if any transport doesn't support incoming.
            if( !tcpAdv.isServerEnabled() || !httpAdv.isServerEnabled() ) {
                relayConfig.setClientEnabled(true);
            }
        }
        
        if( (0 == relayConfig.getSeedingURIs().length) && (0 == relayConfig.getSeedRelays().length) && !relayConfig.isServerEnabled() ) {
            // add the default relay seeding peer.
            relayConfig.addSeedingURI( "http://rdv.jxtahosts.net/cgi-bin/relays.cgi?2" );
        }
        
        XMLDocument relayDoc = (XMLDocument) relayConfig.getDocument(MimeMediaType.XMLUTF8);
        
        advertisement.putServiceParam(PeerGroup.relayProtoClassID, relayDoc );
        
        // Check Rendezvous Configuration
        RdvConfigAdv rdvAdv = null;
        try {
            XMLElement param = (XMLElement) advertisement.getServiceParam(PeerGroup.rendezvousClassID);
            
            if (param != null) {
                // XXX 20041027 backwards compatibility
                param.addAttribute( "type", RdvConfigAdv.getAdvertisementType() );
                
                rdvAdv = (RdvConfigAdv) AdvertisementFactory.newAdvertisement( param );
            }
        } catch (Exception failure) {
            if (LOG.isEnabledFor(Level.WARN)) {
                LOG.warn("Problem reading rendezvous configuration", failure);
            }
        }
        
        if( null == rdvAdv ) {
            if( LOG.isEnabledFor(Level.INFO) ) {
                LOG.info( "Rdv Config advertisement missing, making a new one." );
            }
            
            // restore default values.
            rdvAdv = (RdvConfigAdv) AdvertisementFactory.newAdvertisement( RdvConfigAdv.getAdvertisementType() );
        }
        
        if( (0 == rdvAdv.getSeedingURIs().length) &&
                (0 == rdvAdv.getSeedRendezvous().length) &&
                (RdvConfigAdv.RendezVousConfiguration.RENDEZVOUS != rdvAdv.getConfiguration()) &&
                (RdvConfigAdv.RendezVousConfiguration.AD_HOC != rdvAdv.getConfiguration()) &&
                !relayConfig.isClientEnabled() ) {
            // add the default rendezvous seeding peer if we don't know of any rendezvous, aren't a rendezvous ourselves, aren't in ad-hoc mode or using a relay.
            rdvAdv.addSeedingURI( "http://rdv.jxtahosts.net/cgi-bin/rendezvous.cgi?2" );
        }
        
        XMLDocument rdvDoc = (XMLDocument) rdvAdv.getDocument(MimeMediaType.XMLUTF8);
        
        advertisement.putServiceParam(PeerGroup.rendezvousClassID, rdvDoc );
        
        // if no proxy param section, disable it.
        XMLDocument proxy = (XMLDocument) advertisement.getServiceParam(PeerGroup.proxyClassID);
        
        if( null == proxy ) {
            if( LOG.isEnabledFor(Level.INFO) ) {
                LOG.info( "Proxy config advertisement missing, making a new one." );
            }
            
            proxy = (XMLDocument) StructuredDocumentFactory.newStructuredDocument( MimeMediaType.XMLUTF8, "Parm");
            proxy.appendChild(proxy.createElement("isOff"));
            advertisement.putServiceParam(PeerGroup.proxyClassID, proxy);
        }
        
        // Check the PSE Configuration
        PSEConfigAdv pseConfig = null;
        try {
            XMLElement param = (XMLElement) advertisement.getServiceParam(PeerGroup.membershipClassID);
            
            if (param != null) {
                // XXX 20041027 backwards compatibility
                param.addAttribute( "type", PSEConfigAdv.getAdvertisementType() );
                
                pseConfig = (PSEConfigAdv) AdvertisementFactory.newAdvertisement( param );
            }
        } catch (Exception failure) {
            if (LOG.isEnabledFor(Level.WARN)) {
                LOG.warn("Problem reading pse configuration", failure);
            }
        }
        
        if( null == pseConfig ) {
            if( LOG.isEnabledFor(Level.INFO) ) {
                LOG.info( "PSE Config advertisement missing, making a new one." );
            }
            
            // restore default values.
            pseConfig = (PSEConfigAdv) AdvertisementFactory.newAdvertisement( PSEConfigAdv.getAdvertisementType() );
            XMLDocument pseDoc = (XMLDocument) pseConfig.getDocument(MimeMediaType.XMLUTF8);
            advertisement.putServiceParam(PeerGroup.membershipClassID, pseDoc );
        }
        
        // If we did not modify anything of importance or see anything wrong,
        // leave the adv alone.
        
        return reconf;
    }
    
    private boolean isValidInetAddress(String ia) {
        boolean found = false;
        boolean loopback = false;
        
        InetAddress[] ias;
        
        try {
            ias = InetAddress.getAllByName(ia);
        } catch( java.net.UnknownHostException notfound ) {
            return false;
        }
        
        for (Iterator la = IPUtils.getAllLocalAddresses(); la.hasNext() && ! found; ) {
            for (int i = 0; i < ias.length; i++) {
                found |= ias[i].equals((InetAddress)la.next());
            }
        }
        
        loopback = true;
        
        for (int i = 0; i < ias.length; i++) {
            loopback &= ias[i].isLoopbackAddress();
        }
        
        return found || loopback;
    }
}