Hairpin NAT

對於 Router 來說，當看到封包的 ip:port 是 1.2.3.4:8001，則會將封包標頭改成 192.168.1.5:80，然後依照本機端內的 route rules 將其轉發到底下的 Web Server 去。

For   Louter     :port & nbsp;     1.2.3.4:8001, the seal will be changed to   192.168.1.5:80, followed by   roote riles    Web Server & nbsp; go.

所以假設今天外網的機器(9.8.7.6)發送了一個封包，其流向是

當 Router 收到此封包後，就會將其轉換成

So let's say today's outer web machine (9.8.7.6), sends a package that flows to
when & nbsp; router & nbsp; when you get this package, you convert it to

當 Web Server 收到此封包後，會有一個回應的封包，此封包的流向是

當此封包到達 Router 後， Router 會先查詢看看這個封包是不是經過上述規則轉換的，若是的話就將封包內容重新轉成（進來的封包轉換其 Destination, 回去的封包轉換其 Source)

When & nbsp; Web Server  receives this package, there will be a response package, which will flow to

when the package reaches & nbsp; Louter    and Router  first check to see if the package has been converted through the above-mentioned rules and, if so, re-route the contents of the package (for incoming packages to replace their Destination, return packages to convert their Source
).

這樣外網的機器 (9.8.7.6) 就可以很順利跟內網內的 Web Server 溝通了。

So the outer-net machine (9.8.7.6) can easily communicate with the inner-net & nbsp; Web Server 

上述的這個行為有些會稱 Port Forwarding，有些會稱 Virtual Server，不論怎麼稱呼，其背後的意義都相同。

Some of the above-mentioned actions are called   Port Forwarding; others & nbsp; Virtual Server, however they may be called, have the same meaning behind them.

然而在真實的環境中，我們通常不會去死記這些 IP address，我們會使用 DNS 的服務來幫這些 IP address 設定一組好記的名稱，舉例來說可以設定 webserver.com 指向 1.2.3.4。
在這種情況下，外面機器想要存取該 webserver 的流程就會是

In a real environment, however, we usually don't forget these   IP address, we use DNS services to help these   IP address  set a good list of names, for example   Webserver.com  point to   1.2.3.4.
In such a situation, the outside machine wants to access & nbsp; Webserver  the process will be:

1. 外網機器(9.8.7.6)想要存取 webserver.com，因此向 DNS server 詢問其對應的 IP address
2. DNS server 回應 webserver.com 就是 1.2.3.4，因此外網機器接下來會發送封包到 1.2.3.4
3. 封包到達 1.2.3.4 後，根據 DNAT 的規則轉送到底下真正的 web server。
4. 底下的 web server 回送封包，透過 1.2.3.4 送回到外網機器(9.8.7.6)

其流程可以用下列兩張圖來說明

The process can be described as

假設我們都已經瞭解上述的概念後，接下來我們將該外網電腦()的角色給放到同樣區網內(192.168.1.6)來看，基本上  代表的涵意就是讓內網的機器能夠遵循原本的流程去存取內網的機器。

Assuming that we all know the above concepts, then we put the role of the Extranet computer in the same area network

在這種情況下，若內網的機器想要依循上述的流程運行

In this case, if the machine on the inside of the Internet wants to follow the process described above,

1. 首先內網機器 (192.168.1.6) 透過 DNS 的服務，得到 webserver.com 指向 1.2.3.4
2. 接下來將封包送往到 1.2.3.4，遇到 DNAT 後將封包轉換
   所以假設今天內部機器(192.168.1.6)發送了一個封包，其流向是
   
   當 Router 收到此封包後，就會將其轉換成
   
3. 當 web server 收到封包後就會回應一個封包，該封包透過 Router 就會依循上述的模式回到內網的機器(192.168.1.6)。

上述的流程看起來是順利也沒有問題的，但是有時候實體網路環境中，可能這些機器(PC,Server)是接在同一台 switch 底下，譬如下列這種情況，
或是 Router 內含 Hardware L2 switch。

The processes described above seem smooth and unproblematic, but there are times when the machines (PC, Server) are attached to the same switch, for example,
    (只做DNAT，不做snat)

& nbsp; & nbsp; & nbsp;                                                    
4.當封包到達switch時，就會發現這是個同網段的封包，所以就直接幫他回傳給內網機器 192.168.1.6了
5.當內網機器收到這個封包時，就會感受到一臉困惑。
一開始送出去的封包是

所以期望收回到的封包應該是

所以當他看到不符合期望的封包標頭時，就會將其丟棄

整個流程如下圖所示

The whole process is

這邊最大的問題就是 web server 送回去的封包必須要先給 Router 將其根據 DNAT 的規則給重新反轉一次。
但是在此環境下，因為中間有一台 switch 存在，所以封包就沒有送回到 router 那邊去處理而是直接送回去給內網機器了。

The biggest problem here is   webserver  the package to be returned must first be given to   Router  the rule to reverse it according to   DNA T 
, but in this environment, because there is a   switch  there is one in the middle, the package is not returned to   rooter  it is processed over there and returned directly to the inner machine.

若要能夠處理上述的情況，我們就必須要想辦法將封包也送回到 router 端去處理，為了達到這個目的我們可以在 router 也採用 SNAT (Source NAT)
規則大概如下，只要是從某個 interface 近來的，就將此封包標頭內的 Source IP Address 變成 192.168.1.1。

To be able to deal with the above, we must find a way to return the package to   rooter & nbsp; end up in   root & nbsp; also use the SNAT (Source Nat)
rule, presumably as follows, provided it is from one & nbsp; interface & nbsp; nearest & nbsp; Source IP Address & nbsp; become & nbsp; 192.168.1.1.

1

in_interface=xxxx, source ip=192.168.1.1:xxxx

至於實際上要採用 Masquerade 或是 SNAT 來決定怎麼轉換 Source IP 都可以。

As for the actual use of   Masquerade  or   SNT  to decide how to convert   Source IP 

因此，目前的設定中，Router同時會進行 SNAT 以及 DNAT，因此假設內網機器(192.168.1.6)要對 1.2.3.4:80進行存取。
接下來以下圖來解釋每個步驟中封包的變化。

Therefore, in the current setup, Router will also do   SNAT  and   DNAT, so assume that the in-network machine (192.168.1.6) is to access   1.2.3.4:80.
next to explain the change of envelopes in each step.
        ( DNAT， snat, 从192)
藍色區域
1,2: 
接下來封包會進入 router，執行 SNAT/DNAT
3,4: 

& nbsp; & nbsp; & nbsp;                                                                     > ,,

當封包到達 web server後，接下來 web server 會回傳一個封包回去
1,2: 
當封包到達 switch 時，查了一下目的地是 ,因此就會幾該封包送回到 router 去處理。
當封包到達 router 時，會根據之前的記錄瞭解該封包有使用過 SNAT 以及 DNAT，因此會將封包標頭給重新修改
3,4: 

When the package reaches & nbsp; webserver; & nbsp; returns a package to
1,2: 
when the package reaches   and   therefore several packages will be returned to   root  process.
when the package reaches   root  3,4: & nbsp;

當內網機器(192.168.1.6)收到此封包後因為與預期的相同，所以就可以正確地建立起連線並且開始傳輸。

When the inner network machine (192.168.1.6) receives the package, it is able to establish the connection correctly and start transmission because it is the same as expected.

到這邊我們已經完成了最基本的 NAT Loopback，基本上大部分的情況都可以依照這種思路來完成。
當然若是你網路中間有遇到一些 Hardware 會幫你偷偷做事情的，那你的封包可能就會被影響導致整個傳輸都出問題，這邊要特別小心。

We've already done the most basic & nbsp; NT Loopback, and most of the situation can be done along these lines. Of course, if there are some Hardware in your network that will help you to do something secretly, then your bag may be affected by the whole transfer problem, and be very careful here.

前面講了這麼多話之後，我們來看看實際操作上可能會遇到的問題。
以下列這張圖為範例

After all we've said, let's look at the practical problems that might be encountered.
uses the example of

為了簡化問題，我們假設 router 含有八個實體連接埠，其中第一個連接埠跟底下的switch有連結。

To simplify the problem, we assume & nbsp; rooter & nbsp; contains eight physical ports, the first of which is connected to the bottom of the switch.

假設這一台 Router 我們系統中有透過 Linux bridge 創建了一個 bridge br0，然後我們幫八個連接埠都接到該 br0底下，其中第一個連接埠對應到系統上的 interface 是 eth0
所以這時候大概可以看到如下面的架構

Let's say this   Louter & nbsp; there's   in our system; Linux Bridge & nbsp; there's a   Bridge br0, and then we get the & nbsp; under br0, the first port of the connection to the system is & nbsp; eth0
so you can probably see the structure of the following.

1
2
3
4
5

br0:
    eth0
    eth1
    ...
    eth8

                                                                                                                                                    从eth0收到包，又要从eth0发出

& nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp; & nbsp;                 & nbsp; & nbsp; & nbsp; & nbsp; & nsp; & nbsp; & & & nbsp; & & nbsp; & & & ; & nbsp; & nbsp; & & & ; & & ng; & bbsp; & & ng; & & n; & bbsp; & bbsp; & & & ng; & & n; & bbsp; & & & ngbsp; & & nbsp; & & nbsp; & & nbsp; & & & nbsp; & & & & ngbsp; & & & & ngbsp; & & & ngbsp; & & & & ngbsp; & ngbbsp; & & & & & ngbbsp; & ngbsp; & & ngbsp; & & ngbbsp; & & & & ngbbbbbsp; & & & & & & & & & ngbbbbbbbsp; & & & & ngbbbbsp; & & & & & & ngbbbsp; & & ngbsp; ngbsp; & & & & & & & ngbbbbbsp; & & & & & & & &

在這種情況下，剛剛上述 NAT Loopback 的封包會遇到一問題。
當內網機器的封包送到 router時，會先透過 eth0進入到系統後到達 br0，接下來進行 SNAT 以及 DNAT 的處理。
然後最後封包又要從 br0 往 eth0 出去，一切的料想都是如此美好。
然而實際上就會發現封包不見了!!
根據 Linux kernel 3.6 source code，當系統底下的 bridge 再轉發封包的時候，會呼叫到 br_forward 去處理。

In this case, the package that was just & nbsp; NAT Loopback  will have a problem.
The package of the inner net machine will be delivered to  
The package of DNA T  Span style=" Color: rgba (255, 102, 0)" before   br0 & nbsp; & nbsp; & nbsp; & & nbsp; DNA T  ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14

void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
{
	if (should_deliver(to, skb)) {
		if (skb0)
			deliver_clone(to, skb, __br_forward);
		else
			__br_forward(to, skb);
		return;
	}

	if (!skb0)
		kfree_skb(skb);
}

1
2
3
4
5
6
7

static inline int should_deliver(const struct net_bridge_port *p,
				 const struct sk_buff *skb)
{
	return (((p->flags & BR_HAIRPIN_MODE) || skb->dev !=p->dev) &&
		p->state==BR_STATE_FORWARDING);
}

上面程式碼有一個最重要的地方
skb->dev !=p->dev，如果當前封包進入的 bridge port 跟出去的 bridge port 是一樣的話，那就不會轉發，導致這個封包被丟棄了…

There's one of the most important places on the code above:
skb-> dev! =p-> dev, if the package entered in front & nbsp;