Changeset 164:cb9a746904ad in mediastreamer2


Ignore:
Timestamp:
Nov 10, 2008 5:41:30 PM (5 years ago)
Author:
jehan <jehan@…>
Branch:
default
Message:

debug stun servers

git-svn-id: ​svn+ssh://svn.savannah.nongnu.org/linphone/trunk@167 3f6dc0c8-ddfe-455d-9043-3cd528dc4637

Location:
p2pproxy
Files:
1 added
2 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • p2pproxy/src/org/linphone/p2pproxy/api/P2pProxyResourceManagement.java

    r110 r164  
    3131    
    3232   public void revokeSipProxy(String aProxy) throws P2pProxyException; 
     33    
     34   public void revokeMediaServer(String aMediaServer) throws P2pProxyException; 
    3335   /** 
    3436    * return 2 adresses where to contact media server (stun/rtprelay) 

  • p2pproxy/src/org/linphone/p2pproxy/core/JxtaNetworkManager.java

    r120 r164  
    2222import java.io.File; 
    2323import java.io.IOException; 
     24import java.net.InetAddress; 
    2425import java.net.URI; 
    2526import java.net.URISyntaxException; 
    … …  
    133134      if (!lNetworkConfigurator.exists()) { 
    134135         lNetworkConfigurator.setPeerID(IDFactory.newPeerID(PeerGroupID.defaultNetPeerGroupID)); 
     136         lNetworkConfigurator.setName(InetAddress.getLocalHost().toString()+" "+aProperties.getProperty(TCP_LISTENING_PORT)); 
    135137         lNetworkConfigurator.setDescription("p2p proxy instance"); 
    136138         lNetworkConfigurator.save(); 
    … …  
    369371          for (Advertisement lAdv: aList) { 
    370372                  if (lAdv.equals(lNewAdv)) { 
    371                           if (mLog.isDebugEnabled()) mLog.debug("adv ["+lNewAdv.getID()+"]already gathered"); 
     373                          if (mLog.isInfoEnabled()) mLog.info("adv ["+lNewAdv.getID()+"]already gathered"); 
     374                          if (mLog.isDebugEnabled()) mLog.debug(lNewAdv); 
    372375                          lNewAdv = null; 
    373376                          break; 

  • p2pproxy/src/org/linphone/p2pproxy/core/P2pProxyMain.java

    r156 r164  
    4242import org.linphone.p2pproxy.api.P2pProxyResourceManagement; 
    4343import org.linphone.p2pproxy.api.P2pProxyUserAlreadyExistException; 
    44 import org.linphone.p2pproxy.core.media.rtprelay.RtpRelayService; 
     44import org.linphone.p2pproxy.core.media.MediaResourceService; 
    4545import org.linphone.p2pproxy.core.sipproxy.SipProxyRegistrar; 
    4646import org.zoolu.sip.provider.SipStack; 
    … …  
    8585                   mConfigHomeDir=System.getProperty("user.home")+"/.p2pproxy"; 
    8686                   int lsipPort=5040; 
    87                    int lMediaPort=16000; 
     87                   int lMediaPort=MediaResourceService.AUDIO_VIDEO_LOCAL_PORT_DEFAULT_VALUE; 
     88                   int lP2pPort = 9701; 
    8889                   JxtaNetworkManager.Mode lMode = JxtaNetworkManager.Mode.auto; 
    89                    boolean lEnableHttp = false; 
    9090                   // setup logging 
    9191 
    … …  
    123123                           mLog.warn("cannot register MBean",e); 
    124124                   }          
    125                    String lSocksHost = null; 
    126                    String lSocksPort = null; 
    127                    //         if (args.length <= 0) { 
    128 //                 usage(); 
    129 //                 System.exit(1); 
    130 //                 } 
     125         
    131126                   // get other params 
    132127                   for (int i=0; i < args.length; i=i+2) {   
    133128                           String argument = args[i]; 
    134                            if (argument.equals("-jxta")) { 
     129                           if (argument.equals("-jxta") || argument.equals("-home")) { 
    135130                                   mConfigHomeDir = args[i + 1]; 
    136131                                   //nop 
    … …  
    141136                           } else if (argument.equals("-media")) { 
    142137                  lMediaPort = Integer.parseInt(args[i + 1]); 
    143                   System.out.println("media detected[" + lsipPort + "]"); 
    144                   mConfigurator.setProperty(RtpRelayService.AUDIO_VIDEO_LOCAL_PORT, Integer.toString(lMediaPort)); 
     138                  System.out.println("media detected[" + lMediaPort + "]"); 
     139                  mConfigurator.setProperty(MediaResourceService.AUDIO_VIDEO_LOCAL_PORT, Integer.toString(lMediaPort)); 
     140              } else if (argument.equals("-p2p")) { 
     141                  lP2pPort = Integer.parseInt(args[i + 1]); 
     142                  System.out.println("p2p port detected[" + lP2pPort + "]"); 
     143                  mConfigurator.setProperty(JxtaNetworkManager.TCP_LISTENING_PORT, Integer.toString(lP2pPort)); 
    145144              } else if (argument.equals("-relay")) { 
    146145                                   lMode = JxtaNetworkManager.Mode.relay; 
    … …  
    170169                                   mConfigurator.setProperty(JxtaNetworkManager.SEEDING_RELAY, args[i + 1]); 
    171170                                   System.out.println("seeding relay detected[" + args[i + 1] + "]"); 
     171                           }  else if (argument.equals("-seeding")) { 
     172                                   mConfigurator.setProperty(JxtaNetworkManager.SEEDING_RDV, args[i + 1]); 
     173                                   mConfigurator.setProperty(JxtaNetworkManager.SEEDING_RELAY, args[i + 1]); 
     174                                   System.out.println("seeding  detected[" + args[i + 1] + "]"); 
    172175                           } 
    173176                           else if (argument.equals("-public-address")) { 
    174177                                   mConfigurator.setProperty(JxtaNetworkManager.HTTP_LISTENING_PUBLIC_ADDRESS,args[i + 1]+":9700"); 
    175                                    mConfigurator.setProperty(JxtaNetworkManager.TCP_LISTENING_PUBLIC_ADDRESS,args[i + 1]+":9701"); 
    176                    mConfigurator.setProperty(RtpRelayService.AUDIO_VIDEO_PUBLIC_URI,"udp://"+args[i + 1]+":"+lMediaPort); 
     178                                   mConfigurator.setProperty(JxtaNetworkManager.TCP_LISTENING_PUBLIC_ADDRESS,args[i + 1]+":"+lP2pPort); 
     179                   mConfigurator.setProperty(MediaResourceService.AUDIO_VIDEO_PUBLIC_URI,"udp://"+args[i + 1]+":"+lMediaPort); 
    177180                   mConfigurator.setProperty(SipProxyRegistrar.REGISTRAR_PUBLIC_ADDRESS,args[i + 1]); 
    178181                   System.out.println("public address detected[" + args[i + 1] + "]"); 
    179                            }             
    180                            else if (argument.equals("-socks-url")) { 
    181                                    try { 
    182                                       URI lSocksUrl = new URI(args[i + 1]); 
    183                                            lSocksHost = lSocksUrl.getHost(); 
    184                                            lSocksPort = Integer.toString(lSocksUrl.getPort()); 
    185                                    }catch (Exception e) { 
    186                                            mLog.warn("enable to get socks proxy from env",e); 
    187                                    } 
    188                                    System.out.println("socks serveur detected[" + args[i + 1] + "]"); 
    189                            } else if (argument.equals("-enable-http-client")) { 
    190                                    lEnableHttp = true; 
    191                                    mConfigurator.setProperty(JxtaNetworkManager.ENABLE_HTTP_CLIENT, "true"); 
    192                                    System.out.println("enable-http mode detected"); 
    193                                    i--; 
    194182                           }             
    195183                           else 
    … …  
    200188                           } 
    201189                   } 
    202                    String lProxyUrlString = null; 
    203                    String lProxyHost = null; 
    204                    String lProxyPort = null; 
    205                    //configure http proxy  
    206                    if ((lProxyUrlString = System.getenv("http_proxy")) != null) { 
    207                            //get from env 
    208                            try { 
    209                                    URL lProxyUrl = new URL(lProxyUrlString); 
    210                                    lProxyHost = lProxyUrl.getHost(); 
    211                                    lProxyPort = Integer.toString(lProxyUrl.getPort()); 
    212                            }catch (Exception e) { 
    213                                    mLog.warn("enable do get http proxy from env",e); 
    214                            } 
    215                    } 
    216                    //check from config  
    217                    if (lProxyHost != null || (lProxyHost = mConfigurator.getProperty("http.proxyHost")) != null)  { 
    218                            System.setProperty("http.proxyHost", lProxyHost); 
    219                    } 
    220                    if (lProxyPort != null || (lProxyPort = mConfigurator.getProperty("http.proxyPort")) != null) { 
    221                            System.setProperty("http.proxyPort", lProxyPort); 
    222                    } 
    223                    //configure socks proxy 
    224                    if ((lProxyUrlString = System.getenv("socks_proxy")) != null) { 
    225                            //get from env 
    226  
    227                    } 
    228                    //check from config  
    229                    if (lSocksHost != null || (lSocksHost = mConfigurator.getProperty("socksProxyHost")) != null)  { 
    230                            System.setProperty("socksProxyHost", lSocksHost); 
    231                    } 
    232                    if (lSocksPort != null || (lSocksPort = mConfigurator.getProperty("socksProxyPort")) != null) { 
    233                            System.setProperty("socksProxyPort", lSocksPort); 
    234                    } 
    235  
    236                    //check from env 
    237190 
    238191                   File lJxtaDirectory = new File (mConfigHomeDir); 
    … …  
    352305   private static void usage() { 
    353306      System.out.println("p2pproxy"); 
    354       System.out.println("-jxta : directory where configuration/cache is located  (including jxta cache.default is $HOME/.p2pproxy"); 
     307      System.out.println("-home : directory where configuration/cache is located  (including jxta cache.default is $HOME/.p2pproxy"); 
    355308      System.out.println("-sip : udp proxy port, default 5060"); 
    356309      System.out.println("-media : udp relay/stun port, default 16000"); 
     310      System.out.println("-p2p : p2p tcp port, default 9701"); 
    357311      System.out.println("-relay : super peer mode"); 
    358312      System.out.println("-edge-only : edge mode"); 
    359313      System.out.println("-seeding-server : seeding server mode"); 
    360314      System.out.println("-auto-config : automatically choose edge or relay (default mode)"); 
    361       System.out.println("-seeding-rdv : list of boostrap rdv separated by | (ex tcp://127.0.0.1:9701|http://127.0.0.2:9700)"); 
    362       System.out.println("-seeding-relay : list of boostrap relay separated by |(ex tcp://127.0.0.1:9701|http://127.0.0.2:9700)"); 
     315      System.out.println("-seeding : list of boostrap rdv separated by | (ex tcp://127.0.0.1:9701|http://127.0.0.2:9700)"); 
    363316      System.out.println("-public-address : ip as exported to peers (ex myPublicAddress.no-ip.org)"); 
    364       System.out.println("-socks-url : tcp://ip:port for socks server (ex tcp://socks.com:1080)"); 
    365       System.out.println("-enable-http-client : enable http transport for client (default = false)"); 
    366    } 
    367    public String getHttpProxy() { 
    368       return System.getProperty("http.proxyHost", "not-set")+":"+System.getProperty("http.proxyPort", "not-set"); 
    369    } 
    370  
    371    public void setHttpProxy(String aProxyHost, String aProxyPort, String aUserName, String aPassword) { 
    372       System.setProperty("http.proxyHost",aProxyHost); 
    373       System.setProperty("http.proxyPort",aProxyPort); 
    374  
    375    } 
    376 public String getSocksServer() { 
    377     return System.getProperty("socksProxyHost", "not-set")+":"+System.getProperty("socksProxyPort", "not-set"); 
    378 } 
    379 public void setSocksServer(String aSocksHost, String aSocksPort, String aUserName, String aPassword) { 
    380     System.setProperty("socksProxyHost",aSocksHost); 
    381     System.setProperty("socksProxyPort",aSocksPort); 
    382 } 
     317   } 
    383318   
    384319public void loadTraceConfigFile() throws P2pProxyException { 
    … …  
    515450   }    
    516451} 
    517  
     452public static int revokeMediaServer(String aServer) { 
     453           try { 
     454              isReady(); 
     455              mP2pProxyManagement.revokeMediaServer(aServer); 
     456              return P2pProxylauncherConstants.P2PPROXY_NO_ERROR; 
     457           } catch (P2pProxyException e) { 
     458              return P2pProxylauncherConstants.P2PPROXY_NOT_CONNECTED; 
     459           }    
     460        } 
    518461public static void stop() { 
    519462   mExit = true; 

  • p2pproxy/src/org/linphone/p2pproxy/core/P2pProxyMainMBean.java

    r0 r164  
    2424 
    2525public interface P2pProxyMainMBean { 
    26    public void setHttpProxy(String aProxyHost,String aProxyPort,String aUserName,String aPassword); 
    27    public String getHttpProxy(); 
    28    public void setSocksServer(String aSocksHost,String aSocksPort,String aUserName,String aPassword); 
    29    public String getSocksServer(); 
     26  
    3027   /** 
    3128    * reload traces from file 

  • p2pproxy/src/org/linphone/p2pproxy/core/P2pProxyManagementImpl.java

    r84 r164  
    2020package org.linphone.p2pproxy.core; 
    2121 
    22 import java.io.IOException; 
    2322import java.net.InetAddress; 
    2423import java.net.InetSocketAddress; 
    2524import java.net.SocketException; 
    26 import java.net.URI; 
    2725import java.net.UnknownHostException; 
    28 import java.util.Map; 
    2926 
    3027import org.apache.log4j.Logger; 
    3128import org.linphone.p2pproxy.api.P2pProxyException; 
    3229import org.linphone.p2pproxy.api.P2pProxyManagement; 
    33 import org.linphone.p2pproxy.core.media.rtprelay.MediaType; 
    34 import org.linphone.p2pproxy.core.media.rtprelay.RtpRelayServiceClient; 
     30 
    3531import org.linphone.p2pproxy.core.rdvautoconfig.PeerInfoServiceClient; 
    36 import org.linphone.p2pproxy.core.sipproxy.NetworkResourceAdvertisement; 
    3732 
    3833public abstract class P2pProxyManagementImpl extends P2pProxyResourceManagementImpl implements ServiceProvider,P2pProxyManagement { 

  • p2pproxy/src/org/linphone/p2pproxy/core/P2pProxyResourceManagementImpl.java

    r156 r164  
    5656     } 
    5757} 
     58public void revokeMediaServer(String aMediaServer) throws P2pProxyException { 
     59    try { 
     60        List<NetworkResourceAdvertisement> lMediaResourceAdvertisement = (List<NetworkResourceAdvertisement>) (mJxtaNetworkManager.getAdvertisementList(null,MediaResourceService.ADV_NAME, true)); 
     61        for (NetworkResourceAdvertisement lMediaResource:lMediaResourceAdvertisement) { 
     62            if (lMediaResource.getAddress().equals("udp://"+aMediaServer)) { 
     63                mJxtaNetworkManager.getPeerGroup().getDiscoveryService().flushAdvertisement(lMediaResource); 
     64            mLog.info(aMediaServer +" revoked"); 
     65            } 
     66                 
     67        } 
     68     } catch (Exception e) { 
     69        throw new P2pProxyException(e); 
     70     }   
     71         
     72} 
    5873 
    5974} 

  • p2pproxy/src/org/linphone/p2pproxy/core/media/MediaResourceService.java

    r156 r164  
    2020package org.linphone.p2pproxy.core.media; 
    2121 
     22import java.net.InetAddress; 
    2223import java.net.InetSocketAddress; 
    2324import java.net.SocketException; 
    … …  
    3839import org.linphone.p2pproxy.core.media.rtprelay.RtpRelayServer; 
    3940import org.linphone.p2pproxy.core.media.rtprelay.RtpRelayServerConfig; 
    40 import org.linphone.p2pproxy.core.media.rtprelay.RtpRelayService; 
    4141import org.linphone.p2pproxy.core.sipproxy.NetworkResourceAdvertisement; 
    4242import org.linphone.p2pproxy.core.stun.StunServer; 
    … …  
    4444public class MediaResourceService implements ServiceProvider { 
    4545   private final static Logger mLog = Logger.getLogger(MediaResourceService.class);    
     46   public final static String AUDIO_VIDEO_LOCAL_PORT="org.linphone.p2pproxy.udp-media-relay.audio-video.port"; 
     47   public final static int AUDIO_VIDEO_LOCAL_PORT_DEFAULT_VALUE=16000; 
     48   public final static String AUDIO_VIDEO_PUBLIC_URI="org.linphone.p2pproxy.udp-media-relay.audio-video.public-uri"; 
     49 
    4650   private GenericUdpSession mUdpSessionForStunRtp; 
    4751   private  RtpRelayServer mRtpRelayServer; 
    … …  
    5559   TimerTask mPublishTask; 
    5660   public MediaResourceService(Configurator aConfigurator, JxtaNetworkManager aJxtaNetworkManager) throws SocketException, UnknownHostException { 
    57       URI lAudioVideoPublicUri = URI.create(aConfigurator.getProperty(RtpRelayService.AUDIO_VIDEO_PUBLIC_URI,RtpRelayService.getDefaultAudioVideoPublicUri())); 
    58       int lAudioVideoLocalPort = Integer.valueOf(aConfigurator.getProperty(RtpRelayService.AUDIO_VIDEO_LOCAL_PORT,String.valueOf(lAudioVideoPublicUri.getPort()))); 
     61           
     62          int lAudioVideoLocalPort = Integer.valueOf(aConfigurator.getProperty(MediaResourceService.AUDIO_VIDEO_LOCAL_PORT,String.valueOf(AUDIO_VIDEO_LOCAL_PORT_DEFAULT_VALUE))); 
     63      URI lAudioVideoPublicUri = URI.create(aConfigurator.getProperty(MediaResourceService.AUDIO_VIDEO_PUBLIC_URI,"udp://"+InetAddress.getLocalHost().getHostAddress()+":"+lAudioVideoLocalPort)); 
    5964      mConfig = new RtpRelayServerConfig(new InetSocketAddress(lAudioVideoPublicUri.getHost(),lAudioVideoPublicUri.getPort()) 
    6065                                          ,new InetSocketAddress(lAudioVideoLocalPort)); 
    … …  
    7580                                   mStunRtpServerAdvertisement = (NetworkResourceAdvertisement) AdvertisementFactory.newAdvertisement(NetworkResourceAdvertisement.getAdvertisementType()); 
    7681                                   mStunRtpServerAdvertisement.setAddress("udp://"+mConfig.getAudioVideoPublicSocketAddress().getAddress().getHostAddress()+":"+mConfig.getAudioVideoPublicSocketAddress().getPort()); 
    77                                    mStunRtpServerAdvertisement.setID(IDFactory.newCodatID(mJxtaNetworkManager.getPeerGroup().getPeerGroupID(), mStunRtpServerAdvertisement.getAddress().toString().getBytes())); 
     82                                   mStunRtpServerAdvertisement.setID(IDFactory.newCodatID(mJxtaNetworkManager.getPeerGroup().getPeerGroupID()/*, mStunRtpServerAdvertisement.getAddress().getBytes("US-ASCII")*/)); 
    7883                                   mStunRtpServerAdvertisement.setName(ADV_NAME); 
    7984                                   mJxtaNetworkManager.getPeerGroup().getDiscoveryService().publish(mStunRtpServerAdvertisement,ADV_LIFE_TIME,ADV_LIFE_TIME/2); 

  • p2pproxy/src/org/linphone/p2pproxy/core/rdvautoconfig/AutoConfigService.java

    r0 r164  
    4040import org.linphone.p2pproxy.core.JxtaNetworkManager; 
    4141import org.linphone.p2pproxy.core.ServiceProvider; 
    42 import org.linphone.p2pproxy.core.media.rtprelay.RtpRelayService; 
     42import org.linphone.p2pproxy.core.media.MediaResourceService; 
     43 
    4344 
    4445public class AutoConfigService implements ServiceProvider { 
    … …  
    132133   } 
    133134   public boolean startUdpProxyIfPossible() { 
    134       int lAudioVideoPort = Integer.parseInt(mProperties.getProperty(RtpRelayService.AUDIO_VIDEO_LOCAL_PORT,"16000")); 
     135      int lAudioVideoPort = Integer.parseInt(mProperties.getProperty(MediaResourceService.AUDIO_VIDEO_LOCAL_PORT,"16000")); 
    135136      InetSocketAddress  lSocketAddress=null; 
    136137      try { 

  • p2pproxy/src/org/linphone/p2pproxy/core/sipproxy/SipProxyRegistrar.java

    r126 r164  
    395395           if (mProxyRegistrationAdvertisement == null) {    
    396396           mProxyRegistrationAdvertisement = (NetworkResourceAdvertisement) AdvertisementFactory.newAdvertisement(NetworkResourceAdvertisement.getAdvertisementType()); 
    397               mProxyRegistrationAdvertisement.setID(IDFactory.newCodatID(mJxtaNetworkManager.getPeerGroup().getPeerGroupID(), mSuperPeerProxy.getSipProxyRegistrarAddress().toString().getBytes())); 
     397              mProxyRegistrationAdvertisement.setID(IDFactory.newCodatID(mJxtaNetworkManager.getPeerGroup().getPeerGroupID()/*, mSuperPeerProxy.getSipProxyRegistrarAddress().getBytes("US-ASCII")*/)); 
    398398              mProxyRegistrationAdvertisement.setAddress(mSuperPeerProxy.getSipProxyRegistrarAddress()); 
    399399              mProxyRegistrationAdvertisement.setName(ADV_NAME); 

  • p2pproxy/src/org/linphone/p2pproxy/core/stun/StunClient.java

    r156 r164  
    2424import java.net.DatagramSocket; 
    2525import java.net.InetSocketAddress; 
     26import java.net.PortUnreachableException; 
    2627import java.net.SocketException; 
    2728import java.net.SocketTimeoutException; 
    … …  
    3536import org.linphone.p2pproxy.core.P2pProxyAdvertisementNotFoundException; 
    3637import org.linphone.p2pproxy.core.media.MediaResourceService; 
     38import org.linphone.p2pproxy.core.media.MediaResoureUnreachableException; 
    3739import org.linphone.p2pproxy.core.sipproxy.NetworkResourceAdvertisement; 
    3840import de.javawi.jstun.attribute.ChangeRequest; 
    … …  
    8688   } 
    8789    
    88    public AddressInfo computeAddressInfo(DatagramSocket lLocalSocket) throws P2pProxyException { 
     90   public AddressInfo computeAddressInfo(DatagramSocket lLocalSocket) throws PortUnreachableException, P2pProxyException { 
    8991      AddressInfo lAddressInfo = new AddressInfo((InetSocketAddress) lLocalSocket.getLocalSocketAddress());  
    90            try { 
     92      InetSocketAddress lCurrentMediaServerAddress = null;  
     93      try { 
    9194              DiscoveryInfo lDiscoveryInfo = new DiscoveryInfo((InetSocketAddress) lLocalSocket.getLocalSocketAddress());  
    9295              //1 bind request  
    93                    bindRequest(lDiscoveryInfo,lLocalSocket,lLocalSocket,null, mStunServerList.get(0)); 
     96              bindRequest(lDiscoveryInfo,lLocalSocket,lLocalSocket,null,lCurrentMediaServerAddress = mStunServerList.get(0)); 
    9497                   //2 bind request 
    9598                   if (mStunServerList.size() > 1) { 
    9699                   //open new socket 
    97100                   DatagramSocket lDatagramSocket = new DatagramSocket(); 
    98                    bindRequest(lDiscoveryInfo,lDatagramSocket, lLocalSocket, lDiscoveryInfo.getPublicSocketAddress(),mStunServerList.get(1)); 
     101                   bindRequest(lDiscoveryInfo,lDatagramSocket, lLocalSocket, lDiscoveryInfo.getPublicSocketAddress(),lCurrentMediaServerAddress = mStunServerList.get(1)); 
    99102                   lDatagramSocket.close(); 
    100103                   } 
    … …  
    103106                   lAddressInfo.setPublicAddress(lDiscoveryInfo.getPublicSocketAddress()); 
    104107                    
     108        } catch (PortUnreachableException pex) { 
     109                MediaResoureUnreachableException lExeption = new MediaResoureUnreachableException(pex); 
     110                lExeption.setRourceAddress(lCurrentMediaServerAddress.getAddress().getHostAddress()+":"+lCurrentMediaServerAddress.getPort()); 
     111                throw lExeption; 
    105112        } catch (Exception e) { 
    106113                throw new P2pProxyException(e); 
    … …  
    108115           return lAddressInfo; 
    109116   } 
    110         private void bindRequest(DiscoveryInfo aDiscoveryInfo,DatagramSocket aLocalSocket, DatagramSocket aResponseSocket,InetSocketAddress aResponseAddress, InetSocketAddress aStunAddress) throws UtilityException, SocketException, UnknownHostException, IOException, MessageAttributeParsingException, MessageHeaderParsingException, P2pProxyException { 
    111                 int timeSinceFirstTransmission = 0; 
    112                 int lSoTimeOut = SO_TIME_OUT; 
    113                 while (true) { 
    114                         try { 
    115                                 aLocalSocket.setReuseAddress(true); 
    116                                 aLocalSocket.connect(aStunAddress); 
    117                                 aLocalSocket.setSoTimeout(lSoTimeOut); 
    118                                  
    119                                 MessageHeader sendMH = new MessageHeader(MessageHeader.MessageHeaderType.BindingRequest); 
    120                                 sendMH.generateTransactionID(); 
    121                                  
    122                                 ChangeRequest changeRequest = new ChangeRequest(); 
    123                                 sendMH.addMessageAttribute(changeRequest); 
    124                                 if (!((InetSocketAddress)aLocalSocket.getLocalSocketAddress()).equals((InetSocketAddress)aResponseSocket.getLocalSocketAddress()) && aResponseAddress != null) { 
    125                                         // add response address 
    126                                         ResponseAddress lResponseAddress = new ResponseAddress(); 
    127                                         lResponseAddress.setAddress(new Address(aResponseAddress.getAddress().getHostAddress())); 
    128                                         try { 
    129                                                 lResponseAddress.setPort(aResponseAddress.getPort()); 
    130                                                 sendMH.addMessageAttribute(lResponseAddress); 
    131                                         } catch (MessageAttributeException e) { 
    132                                                 mLog.info("Cannot set Response address ["+lResponseAddress+"]"); 
    133                                         } 
    134                                 } 
    135                                  
    136                                 byte[] data = sendMH.getBytes(); 
    137                                 DatagramPacket send = new DatagramPacket(data, data.length); 
    138                                 aLocalSocket.send(send); 
    139                                                          
    140                                 MessageHeader receiveMH = new MessageHeader(); 
    141                                 while (!(receiveMH.equalTransactionID(sendMH))) { 
    142                                         DatagramPacket receive = new DatagramPacket(new byte[200], 200); 
    143                                         aResponseSocket.receive(receive); 
    144                                         receiveMH = MessageHeader.parseHeader(receive.getData()); 
    145                                         receiveMH.parseAttributes(receive.getData()); 
    146                                 } 
    147                                  
    148                                 MappedAddress lMappedAddress = (MappedAddress) receiveMH.getMessageAttribute(MessageAttribute.MessageAttributeType.MappedAddress); 
    149                                 ErrorCode ec = (ErrorCode) receiveMH.getMessageAttribute(MessageAttribute.MessageAttributeType.ErrorCode); 
    150                                 if (ec != null) { 
     117   private void bindRequest(DiscoveryInfo aDiscoveryInfo,DatagramSocket aLocalSocket, DatagramSocket aResponseSocket,InetSocketAddress aResponseAddress, InetSocketAddress aStunAddress) throws UtilityException, SocketException, UnknownHostException, IOException, MessageAttributeParsingException, MessageHeaderParsingException, P2pProxyException { 
     118           int timeSinceFirstTransmission = 0; 
     119           int lSoTimeOut = SO_TIME_OUT; 
     120           while (true) { 
     121                   try { 
     122                           aLocalSocket.setReuseAddress(true); 
     123                           aLocalSocket.connect(aStunAddress); 
     124                           aLocalSocket.setSoTimeout(lSoTimeOut); 
     125 
     126                           MessageHeader sendMH = new MessageHeader(MessageHeader.MessageHeaderType.BindingRequest); 
     127                           sendMH.generateTransactionID(); 
     128 
     129                           ChangeRequest changeRequest = new ChangeRequest(); 
     130                           sendMH.addMessageAttribute(changeRequest); 
     131                           if (!((InetSocketAddress)aLocalSocket.getLocalSocketAddress()).equals((InetSocketAddress)aResponseSocket.getLocalSocketAddress()) && aResponseAddress != null) { 
     132                                   // add response address 
     133                                   ResponseAddress lResponseAddress = new ResponseAddress(); 
     134                                   lResponseAddress.setAddress(new Address(aResponseAddress.getAddress().getHostAddress())); 
     135                                   try { 
     136                                           lResponseAddress.setPort(aResponseAddress.getPort()); 
     137                                           sendMH.addMessageAttribute(lResponseAddress); 
     138                                   } catch (MessageAttributeException e) { 
     139                                           mLog.info("Cannot set Response address ["+lResponseAddress+"]"); 
     140                                   } 
     141                           } 
     142 
     143                           byte[] data = sendMH.getBytes(); 
     144                           DatagramPacket send = new DatagramPacket(data, data.length); 
     145                           aLocalSocket.send(send); 
     146 
     147                           MessageHeader receiveMH = new MessageHeader(); 
     148                           while (!(receiveMH.equalTransactionID(sendMH))) { 
     149                                   DatagramPacket receive = new DatagramPacket(new byte[200], 200); 
     150                                   aResponseSocket.receive(receive); 
     151                                   receiveMH = MessageHeader.parseHeader(receive.getData()); 
     152                                   receiveMH.parseAttributes(receive.getData()); 
     153                           } 
     154 
     155                           MappedAddress lMappedAddress = (MappedAddress) receiveMH.getMessageAttribute(MessageAttribute.MessageAttributeType.MappedAddress); 
     156                           ErrorCode ec = (ErrorCode) receiveMH.getMessageAttribute(MessageAttribute.MessageAttributeType.ErrorCode); 
     157                           if (ec != null) { 
    151158                                   aDiscoveryInfo.setError(ec.getResponseCode(), ec.getReason()); 
    152                                         throw new P2pProxyException("Message header contains an Errorcode message attribute. ["+ec+"]"); 
    153                                 } 
    154                                 if ((lMappedAddress == null)) { 
    155                                         throw new P2pProxyException("Response does not contain a Mapped Address message attribute."); 
    156                                          
    157                                 } else { 
    158                                         if (aLocalSocket.getLocalSocketAddress().equals(aResponseSocket.getLocalSocketAddress())) { 
     159                                   throw new P2pProxyException("Message header contains an Errorcode message attribute. ["+ec+"]"); 
     160                           } 
     161                           if ((lMappedAddress == null)) { 
     162                                   throw new P2pProxyException("Response does not contain a Mapped Address message attribute."); 
     163 
     164                           } else { 
     165                                   if (aLocalSocket.getLocalSocketAddress().equals(aResponseSocket.getLocalSocketAddress())) { 
    159166                                           aDiscoveryInfo.setPublicSocketAddress(new InetSocketAddress(lMappedAddress.getAddress().getInetAddress(),lMappedAddress.getPort())); 
    160                                         } else { 
     167                                   } else { 
    161168                                           aDiscoveryInfo.setFullCone(); 
    162                                         } 
    163                                         } 
    164                                         return; 
    165                                  
    166                         } catch (SocketTimeoutException ste) { 
    167                                 if (timeSinceFirstTransmission < 7900) { 
    168                                         if (mLog.isInfoEnabled()) mLog.info("Socket timeout while receiving the response."); 
    169                                         timeSinceFirstTransmission += lSoTimeOut; 
    170                                         int timeoutAddValue = (timeSinceFirstTransmission * 2); 
    171                                         if (timeoutAddValue > 1600) timeoutAddValue = 1600; 
    172                                         lSoTimeOut = timeoutAddValue; 
    173                                 } else { 
    174                                         // node is not capable of udp communication 
    175                                         if (mLog.isInfoEnabled()) mLog.info("Socket timeout while receiving the response. Maximum retry limit exceed. Give up."); 
    176                                         if (aLocalSocket.getLocalSocketAddress().equals(aResponseSocket.getLocalSocketAddress())) { 
     169                                   } 
     170                           } 
     171                           return; 
     172 
     173                   } catch (PortUnreachableException pex ) { 
     174                           throw pex; 
     175                   } 
     176                   catch (SocketTimeoutException ste) { 
     177                           if (timeSinceFirstTransmission < 7900) { 
     178                                   if (mLog.isInfoEnabled()) mLog.info("Socket timeout while receiving the response."); 
     179                                   timeSinceFirstTransmission += lSoTimeOut; 
     180                                   int timeoutAddValue = (timeSinceFirstTransmission * 2); 
     181                                   if (timeoutAddValue > 1600) timeoutAddValue = 1600; 
     182                                   lSoTimeOut = timeoutAddValue; 
     183                           } else { 
     184                                   // node is not capable of udp communication 
     185                                   if (mLog.isInfoEnabled()) mLog.info("Socket timeout while receiving the response. Maximum retry limit exceed. Give up."); 
     186                                   if (aLocalSocket.getLocalSocketAddress().equals(aResponseSocket.getLocalSocketAddress())) { 
    177187                                           aDiscoveryInfo.setBlockedUDP(); 
    178                                         } else { 
     188                                   } else { 
    179189                                           aDiscoveryInfo.setSymmetric(); 
    180                                         } 
    181                                         if (mLog.isInfoEnabled()) mLog.info("Node is not capable of UDP communication."); 
    182                                         return ; 
    183                                 } 
    184                         }  
    185                 } 
    186         } 
     190                                   } 
     191                                   if (mLog.isInfoEnabled()) mLog.info("Node is not capable of UDP communication."); 
     192                                   return ; 
     193                           } 
     194                   }  
     195           } 
     196   } 
    187197} 

  • p2pproxy/test-src/org/linphone/p2pproxy/test/utils/UserInstance.java

    r156 r164  
    2424import java.net.DatagramSocket; 
    2525import java.net.InetAddress; 
     26import java.net.PortUnreachableException; 
    2627import java.net.URI; 
    2728import java.util.Timer; 
    … …  
    3233import org.linphone.p2pproxy.api.P2pProxyResourceManagement; 
    3334import org.linphone.p2pproxy.core.P2pProxyMain; 
     35import org.linphone.p2pproxy.core.media.MediaResoureUnreachableException; 
    3436import org.linphone.p2pproxy.core.stun.AddressInfo; 
    3537import org.linphone.p2pproxy.core.stun.StunClient; 
    … …  
    5961                final String[] lParam = {"-jxta" ,"userinstance-"+lUserNameUri.getSchemeSpecificPart() 
    6062                                ,"-edge-only" 
    61                                 ,"-seeding-rdv", "tcp://82.67.74.86:9701" 
    62                                 ,"-seeding-relay", "tcp://82.67.74.86:9701"}; 
     63                                ,"-seeding", "tcp://91.121.81.212:9701|tcp://91.121.81.212:9702"}; 
    6364                lSocket.close(); 
    6465 
    … …  
    114115                                         
    115116                                        mStunClient =  new StunClient(lMediaServer); 
    116                                         AddressInfo lAudioAddressInfo = mStunClient.computeAddressInfo(mAudioSocket); 
    117                                         mLog.info("audio socket info ["+lAudioAddressInfo+"]"); 
     117                                        try { 
     118                                                AddressInfo lAudioAddressInfo = mStunClient.computeAddressInfo(mAudioSocket); 
     119                                                mLog.info("audio socket info ["+lAudioAddressInfo+"]"); 
     120                                        }catch (MediaResoureUnreachableException pex) { 
     121                                                mLog.error("cannot reach media server, flushing ["+pex.getResourceAddress()+"]",pex); 
     122                                                P2pProxyMain.revokeMediaServer(pex.getResourceAddress()); 
     123                                        } 
     124                                         
    118125                                        mSipClient.register(REGISTRATION_PERIOD,userName); 
    119126                                        mIsRegistered = true; 
    120                                 } catch(Exception e) { 
     127                                }        
     128                                        catch(Exception e) { 
    121129                                        mLog.error("cannot register user["+userName+"]",e); 
    122130                                } finally { 
Note: See TracChangeset for help on using the changeset viewer.