In a web browser that supports having multiple tabs, such as Firefox, do different tabs that go to different website domains use a dedicated port for each domain?.
Or does the browser use a single port for managing all tabs and therefore all domains?.
Each connection to a website uses a different socket with default destination TCP port 80 for plain HTTP and 443 for HTTPS. For the socket to be unique, the combination of the source IP address, source TCP port, destination IP address and destination TCP port must be different.
If you have multiple connections to the same website (assuming the website uses only 1 IP address) from the same computer, a different source TCP port must be used. This way, each connection is unique.
However, it should be noted that as of HTTP 1.1, all connections are persistent for a given period of time (unless declared otherwise). This means that the same connection can be reused by your browser if multiple resources from the same website are requested (e.g. css/js files). This also applies if you have multiple instances of the same website in your browser.
If you are on Windows, the netstat -no -p TCP command will show you all active TCP sockets and their corresponding process ID, including those of your browser:
If you are on Unix/Linux (Debian in this case), you can use the netstat -ntp or ss -t command:
Yes, they do.
Here is an example, showing my current Firefox connections (I have 9 open tabs) on Windows 7:
Notes:
You can see that the local ports are all different.
The remote ports are usually 80 (HTTP), 443 (HTTPS) or 8080 (HTTP Alternate).
HTTP on List of TCP and UDP port numbers for some of them.The full process of rendering a web page is described below. See in particular steps 5, 6, 13 and 15 (which are in bold):
In general rendering a single web page uses multiple connections, not all of which will be to the same remote address.
This is because web pages often include resources hosted elsewhere (javascript files, etc).
Multiple connections to the same website (eg stackoverflow.com) also have different local ports (because they are separate connections in different tabs rendering different pages).
Note:
Have you ever thought about what happens when you surf the web? It’s not as simple as it seems:
- You type an URL into address bar in your preferred browser.
- The browser parses the URL to find the protocol, host, port, and path.
- It forms a HTTP request (that was most likely the protocol)
- To reach the host, it first needs to translate the human readable host into an IP number, and it does this by doing a DNS lookup on the host
- Then a socket needs to be opened from the user’s computer to that IP number, on the port specified (most often port 80)
- When a connection is open, the HTTP request is sent to the host
- The host forwards the request to the server software (most often Apache) configured to listen on the specified port
- The server inspects the request (most often only the path), and launches the server plugin needed to handle the request (corresponding to the server language you use, PHP, Java, .NET, Python?)
- The plugin gets access to the full request, and starts to prepare a HTTP response.
- To construct the response a database is (most likely) accessed. A database search is made, based on parameters in the path (or data) of the request
- Data from the database, together with other information the plugin decides to add, is combined into a long string of text (probably HTML).
- The plugin combines that data with some meta data (in the form of HTTP headers), and sends the HTTP response back to the browser.
- The browser receives the response, and parses the HTML (which with 95% probability is broken) in the response
- A DOM tree is built out of the broken HTML
- New requests are made to the server for each new resource that is found in the HTML source (typically images, style sheets, and JavaScript files). Go back to step 3 and repeat for each resource.
- Stylesheets are parsed, and the rendering information in each gets attached to the matching node in the DOM tree
- Javascript is parsed and executed, and DOM nodes are moved and style information is updated accordingly
- The browser renders the page on the screen according to the DOM tree and the style information for each node
- You see the page on the screen
- You get annoyed the whole process was too slow.
As regards tabs to different websites, there is nothing in TCP that requires the local port to be different, as long as the tuple {local IP, local port, target IP, target port} is unique. For tabs to the same website, the situation is much more complex.
The browser, like any other piece of client software, uses a different local port per outgoing connection to the same target. In general it will form multiple connections to any given website, to fetch embedded resources such as images, CSS, JavaScript, etc. It will also pool those connections for possible reuse.
It isn't possible to say whether different tabs to the same website, will use distinct connections, because (a) there usually isn't a single connection per tab anyway, and (b) depending on the timing and authentication, connections may be reused between tabs; and as it isn't possible to identity the connections it therefore isn't possible to identify the local ports either.
First, a browser may use any of these strategies for connections:
You don't have a way of knowing which strategy a browser will use, although using a pool of connections (and re-using connections) is a reasonable assumption.
Second, the way TCP works, you have a source port, and a destination port for every connection. The pair of source and destination address/port defines the connection.
You always[1] use a well-known port (such as 80 or 443) to connect to the server (to which it listens on its advertized address), but the other port is randomly chosen. Thus, depending on from which side you look at a connection, it either has one or many possible ports.
Thus, the same tab may (and usually will) use several different ports on its end, but in principle different tabs might (if connections are pooled and different resources in different tabs are loaded from the same server) use the same port.
Since the question explicitly mentions outgoing, in the "normal" case, the port numbers would be the same regardless which tab they're in, or one of two possible ports (80 and 443). Although of course it is possible to explicitly ask for a different port (like 8080) in an URL. That's kind of rare, though.
I tested this on MacOS 12.3.1 with browsers: Chrome 109.0.5414.119 Safari 15.4 (17613.1.17.1.13)
I opened 2 tabs and browsed to a simple local server I ran with Python. The server has 2 workers.
The results are:
Use case 1 - Browse to http://127.0.0.1:5000/
Chrome
2 tabs requesting the same url, e.g. 127.0.0.1:5000/?value=1, are running sequentially. When the 1st tab ends, the 2nd starts. This means that the 2 tabs both complete after 10 seconds. It doesn't matter if the tabs are in the same or different windows.
The same port is used by both tabs.
If the tabs are accessing different urls, 127.0.0.1:5000/?value=1 or 127.0.0.1:5000/?value=2, the tabs are running with different ports and in parallel, completing after 5 seconds.
Safari
2 tabs requesting the same url are running in parallel using different ports. It doesn't matter if the tabs are in the same or different windows. It doesn't matter if the tabs are accessing the same url. The tabs are running with different ports and in parallel, completing after 5 seconds.
The FastAPI, Uvicorn server
import asyncio
from fastapi import FastAPI
import uvicorn
from datetime import datetime
app = FastAPI()
class MyClass:
value: str = 'a'
@app.get("/")
async def root(value: int):
MyClass.value = MyClass.value + 'b'
start = datetime.now().strftime("%H:%M:%S")
await asyncio.sleep(5)
end = datetime.now().strftime("%H:%M:%S")
return {
"start": start,
"end": end,
"value": value
}
@app.get("/root2")
async def root2():
MyClass.value = MyClass.value + 'c'
start = datetime.now().strftime("%H:%M:%S")
await asyncio.sleep(5)
end = datetime.now().strftime("%H:%M:%S")
return {
"start": start,
"end": end,
"value": MyClass.value
}
if name == "main":
uvicorn.run("main:app", host="127.0.0.1", port=5000, log_level="info", workers=2)
