i am using a twilio free account and generated twilio turn servers and credentials. With these as ICEServerOptions, I am getting candidate which has only UDP connections, but I needed a TCP connection for reliable data transfer using webRTC.
Is there any way to get TCP relay/srflx connection from the twilio stun/turn servers?
If yes then please let me know how?
Thanks
MJ
As far as I am aware, Twilio by default doesn't add TURN/TCP to their configuration of Twilio Client, although they might do so in the future.
For now, you'll need to explicitly add that in, using something like the call below:
Twilio.Device.setup(token, {
"iceServers": [ { "url": "turn:global.turn.twilio.com:443?transport=tcp" } ]
});
That said, you should note the following:
WebRTC doesn't run on a reliable connection for audio and video transmission. If what you are aiming for is real time media, then UDP is your best friend. TCP is used only as a necessary evil when firewalls block UDP
Once WebRTC is able to connect its ICE candidates via UDP, it will simply stop trying and in most cases, you won't see TCP candidates connecting at all - they get lower priority because of (1)
Related
I know UDP is not a two-way communication between client & server. However, if I send a packet to clients from a server, how can I know that my packet reach it's destination?
The only way to be sure that the data you've send are received (and processed) by the server application is to let the server application explicitly acknowledge the data in a reply.
Note that contrary to a comment to your question it will not help to use TCP instead of UDP to get a more reliable transport: while your OS kernel will does its best to deliver data with TCP (instead of just trying once with UDP) it can neither guarantee the delivery (since connectivity might break) nor does it care if the server application itself has read and maybe also processed the data. The only way to know that the application has successfully read the data is to let the application itself say so.
I have been writing my own version of the 802.11 protocol with network stack. This is mostly a learning experience to see more in depth on how networks work.
My question is, is there a standard for replying to client devices that a certain protocol is unsupported?
I have an android device connecting to my custom wifi device and immediately sending a TON of requests at the DNS port of my UDP protocol. Since I would like to test out other protocols I would very much like a way for my wifi device to tell the android device that DNS is not available and get it to quite down a little.
Thanks in advance!
I don't see a possibility to send a reply that a service is not available.
I can't find anything about this case in the UDP specification.
One part of the DNS specification assumes that there are multiple DNS servers and defines how to handle communication with them. This explains part of the behavior in your network, but does not provide much information how to handle it.
4.2.1 Messages - format - UDP usage
The optimal UDP retransmission policy will vary with performance of the
Internet and the needs of the client, but the following are recommended:
The client should try other servers and server addresses
before repeating a query to a specific address of a server.
The retransmission interval should be based on prior
statistics if possible. Too aggressive retransmission can
easily slow responses for the community at large. Depending
on how well connected the client is to its expected servers,
the minimum retransmission interval should be 2-5 seconds.
7.2 Resolver Implementation - sending the queries
If a resolver gets a server error or other bizarre response
from a name server, it should remove it from SLIST, and may
wish to schedule an immediate transmission to the next
candidate server address.
According to this you could try to send garbage back to the client, but this is rather a hack, or an error, but how does an error look like? Such a solution assumes that you have knowledge about the service that you don't support.
I believe that the DNS - requests can be avoided by using DHCP. DHCP allows to specify DNS-servers as listed in the linked page. This is the usual way that I know for a DNS-resolver in a LAN to get initial DNS servers although I don't find anything about this in the DNS specification. You can give the Android - device a DNS-server with DHCP so that it does to need to try to query your device. Querying your device could be a fallback.
Additionally to DNS there is mDNS which uses multicasts in the network to send queries. This seems not to be the protocol you have to do with because it uses the special port 5353.
Not possible to stop DNS in the way you intend. However, only for your tests you can check the UDP messages and find out the names the device is looking for. Then you update the hosts file (google how to do it: http://www.howtogeek.com/140576/how-to-edit-the-hosts-file-on-android-and-block-web-sites/) and add those names with some localoop IP address. That might work for your test.
Other possibility is to change DNS server to some localloop IP address: http://xslab.com/2013/08/how-to-change-dns-settings-on-android/
Again, this is only to avoid having all the DNS messages through the wifi connection.
I have computers connected in a wifi netwrok. One of them serves as a root(lets call it server), and is directly or indirectly connected to all other computers(lets call them clients). I want to send some information from root to all nodes(information is different for each node).
Is there a way to do this without running any program on the client side(similar to PING) ?
Or the only possible way is by using sockets over client and server?
Is there a way to do this without running any program on the client side(similar to PING)?
Yes, provided that you don't care that the clients will never do anything with the information.
Seriously, without something on the client listening for and doing something with the data you send from the server, what do you expect?
Ping does not actually send any data to the client. It just roundtrips a packet.
To receive the information you need some kind of service running on the client. Sockets are needed. For minimal communication (not reliable) use UDP and for more reliable use TCP.
I would like a recommendation for a tool(sniffer that able to modify packets maybe?) that would be able to mess up the TCP packets sent/recieved between the 2 apps in various ways. The main purpose is to test the behavior of the apps when bad/invalid messages arrive. An invalid message is a valid TCP packet but the application level format is bad in some way (so this tool would operate on levels 6,7 of the OSI model and screw up messages sent by the apps)
I've played with Fiddler2 and found it quite good for http(s) packets.
This is only half an answer, but if you just want a network sniffer (no ability to modify packets) here is a review of 11 packet sniffers.
Setup proxy with netcat which will pipe input from transmitting application through your custom mangler and then to receiving application. You will need to write mangler, however.
The idea is to allow to peer processes to exchange messages (packets) over tcp as much asynchronously as possible.
The way I'd like it to work is each process to have an outbox and an inbox. The send operation is just a push on the outbox. The receive operation is just a pop on the inbox. Underlying protocol would take care of the communication details.
Is there a way to implement such mechanism using a single TCP connection?
How would that be implemented using BSD sockets and modern OO Socket APIs (like Java or C# socket API)?
Yes, it can be done with a single TCP connection. For one obvious example, (though a bit more elaborate than you really need) you could take a look at the NNTP protocol (RFC 3977). What you seem to want would be similar to retrieving and posting articles.