1 /*
2  * This file Copyright (C) 2007-2014 Mnemosyne LLC
3  *
4  * It may be used under the GNU GPL versions 2 or 3
5  * or any future license endorsed by Mnemosyne LLC.
6  *
7  */
8 
9 #include <errno.h>
10 #include <time.h>
11 #include <inttypes.h>
12 
13 #include <event2/util.h> /* evutil_inet_ntop() */
14 
15 #define ENABLE_STRNATPMPERR
16 #include "natpmp.h"
17 
18 #include "transmission.h"
19 #include "natpmp_local.h"
20 #include "log.h"
21 #include "net.h" /* tr_netCloseSocket */
22 #include "port-forwarding.h"
23 #include "utils.h"
24 
25 #define LIFETIME_SECS 3600
26 #define COMMAND_WAIT_SECS 8
27 
getKey(void)28 static char const* getKey(void)
29 {
30     return _("Port Forwarding (NAT-PMP)");
31 }
32 
33 typedef enum
34 {
35     TR_NATPMP_IDLE,
36     TR_NATPMP_ERR,
37     TR_NATPMP_DISCOVER,
38     TR_NATPMP_RECV_PUB,
39     TR_NATPMP_SEND_MAP,
40     TR_NATPMP_RECV_MAP,
41     TR_NATPMP_SEND_UNMAP,
42     TR_NATPMP_RECV_UNMAP
43 }
44 tr_natpmp_state;
45 
46 struct tr_natpmp
47 {
48     bool has_discovered;
49     bool is_mapped;
50 
51     tr_port public_port;
52     tr_port private_port;
53 
54     time_t renew_time;
55     time_t command_time;
56     tr_natpmp_state state;
57     natpmp_t natpmp;
58 };
59 
60 /**
61 ***
62 **/
63 
logVal(char const * func,int ret)64 static void logVal(char const* func, int ret)
65 {
66     if (ret == NATPMP_TRYAGAIN)
67     {
68         return;
69     }
70 
71     if (ret >= 0)
72     {
73         tr_logAddNamedInfo(getKey(), _("%s succeeded (%d)"), func, ret);
74     }
75     else
76     {
77         tr_logAddNamedDbg(getKey(), "%s failed. Natpmp returned %d (%s); errno is %d (%s)", func, ret, strnatpmperr(ret), errno,
78             tr_strerror(errno));
79     }
80 }
81 
tr_natpmpInit(void)82 struct tr_natpmp* tr_natpmpInit(void)
83 {
84     struct tr_natpmp* nat;
85 
86     nat = tr_new0(struct tr_natpmp, 1);
87     nat->state = TR_NATPMP_DISCOVER;
88     nat->public_port = 0;
89     nat->private_port = 0;
90     nat->natpmp.s = TR_BAD_SOCKET; /* socket */
91     return nat;
92 }
93 
tr_natpmpClose(tr_natpmp * nat)94 void tr_natpmpClose(tr_natpmp* nat)
95 {
96     if (nat != NULL)
97     {
98         closenatpmp(&nat->natpmp);
99         tr_free(nat);
100     }
101 }
102 
canSendCommand(struct tr_natpmp const * nat)103 static bool canSendCommand(struct tr_natpmp const* nat)
104 {
105     return tr_time() >= nat->command_time;
106 }
107 
setCommandTime(struct tr_natpmp * nat)108 static void setCommandTime(struct tr_natpmp* nat)
109 {
110     nat->command_time = tr_time() + COMMAND_WAIT_SECS;
111 }
112 
tr_natpmpPulse(struct tr_natpmp * nat,tr_port private_port,bool is_enabled,tr_port * public_port)113 int tr_natpmpPulse(struct tr_natpmp* nat, tr_port private_port, bool is_enabled, tr_port* public_port)
114 {
115     int ret;
116 
117     if (is_enabled && nat->state == TR_NATPMP_DISCOVER)
118     {
119         int val = initnatpmp(&nat->natpmp, 0, 0);
120         logVal("initnatpmp", val);
121         val = sendpublicaddressrequest(&nat->natpmp);
122         logVal("sendpublicaddressrequest", val);
123         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_PUB;
124         nat->has_discovered = true;
125         setCommandTime(nat);
126     }
127 
128     if (nat->state == TR_NATPMP_RECV_PUB && canSendCommand(nat))
129     {
130         natpmpresp_t response;
131         int const val = readnatpmpresponseorretry(&nat->natpmp, &response);
132         logVal("readnatpmpresponseorretry", val);
133 
134         if (val >= 0)
135         {
136             char str[128];
137             evutil_inet_ntop(AF_INET, &response.pnu.publicaddress.addr, str, sizeof(str));
138             tr_logAddNamedInfo(getKey(), _("Found public address \"%s\""), str);
139             nat->state = TR_NATPMP_IDLE;
140         }
141         else if (val != NATPMP_TRYAGAIN)
142         {
143             nat->state = TR_NATPMP_ERR;
144         }
145     }
146 
147     if (nat->state == TR_NATPMP_IDLE || nat->state == TR_NATPMP_ERR)
148     {
149         if (nat->is_mapped && (!is_enabled || nat->private_port != private_port))
150         {
151             nat->state = TR_NATPMP_SEND_UNMAP;
152         }
153     }
154 
155     if (nat->state == TR_NATPMP_SEND_UNMAP && canSendCommand(nat))
156     {
157         int const val = sendnewportmappingrequest(&nat->natpmp, NATPMP_PROTOCOL_TCP, nat->private_port, nat->public_port, 0);
158         logVal("sendnewportmappingrequest", val);
159         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_UNMAP;
160         setCommandTime(nat);
161     }
162 
163     if (nat->state == TR_NATPMP_RECV_UNMAP)
164     {
165         natpmpresp_t resp;
166         int const val = readnatpmpresponseorretry(&nat->natpmp, &resp);
167         logVal("readnatpmpresponseorretry", val);
168 
169         if (val >= 0)
170         {
171             int const private_port = resp.pnu.newportmapping.privateport;
172 
173             tr_logAddNamedInfo(getKey(), _("no longer forwarding port %d"), private_port);
174 
175             if (nat->private_port == private_port)
176             {
177                 nat->private_port = 0;
178                 nat->public_port = 0;
179                 nat->state = TR_NATPMP_IDLE;
180                 nat->is_mapped = false;
181             }
182         }
183         else if (val != NATPMP_TRYAGAIN)
184         {
185             nat->state = TR_NATPMP_ERR;
186         }
187     }
188 
189     if (nat->state == TR_NATPMP_IDLE)
190     {
191         if (is_enabled && !nat->is_mapped && nat->has_discovered)
192         {
193             nat->state = TR_NATPMP_SEND_MAP;
194         }
195         else if (nat->is_mapped && tr_time() >= nat->renew_time)
196         {
197             nat->state = TR_NATPMP_SEND_MAP;
198         }
199     }
200 
201     if (nat->state == TR_NATPMP_SEND_MAP && canSendCommand(nat))
202     {
203         int const val = sendnewportmappingrequest(&nat->natpmp, NATPMP_PROTOCOL_TCP, private_port, private_port, LIFETIME_SECS);
204         logVal("sendnewportmappingrequest", val);
205         nat->state = val < 0 ? TR_NATPMP_ERR : TR_NATPMP_RECV_MAP;
206         setCommandTime(nat);
207     }
208 
209     if (nat->state == TR_NATPMP_RECV_MAP)
210     {
211         natpmpresp_t resp;
212         int const val = readnatpmpresponseorretry(&nat->natpmp, &resp);
213         logVal("readnatpmpresponseorretry", val);
214 
215         if (val >= 0)
216         {
217             nat->state = TR_NATPMP_IDLE;
218             nat->is_mapped = true;
219             nat->renew_time = tr_time() + (resp.pnu.newportmapping.lifetime / 2);
220             nat->private_port = resp.pnu.newportmapping.privateport;
221             nat->public_port = resp.pnu.newportmapping.mappedpublicport;
222             tr_logAddNamedInfo(getKey(), _("Port %d forwarded successfully"), nat->private_port);
223         }
224         else if (val != NATPMP_TRYAGAIN)
225         {
226             nat->state = TR_NATPMP_ERR;
227         }
228     }
229 
230     switch (nat->state)
231     {
232     case TR_NATPMP_IDLE:
233         *public_port = nat->public_port;
234         return nat->is_mapped ? TR_PORT_MAPPED : TR_PORT_UNMAPPED;
235         break;
236 
237     case TR_NATPMP_DISCOVER:
238         ret = TR_PORT_UNMAPPED;
239         break;
240 
241     case TR_NATPMP_RECV_PUB:
242     case TR_NATPMP_SEND_MAP:
243     case TR_NATPMP_RECV_MAP:
244         ret = TR_PORT_MAPPING;
245         break;
246 
247     case TR_NATPMP_SEND_UNMAP:
248     case TR_NATPMP_RECV_UNMAP:
249         ret = TR_PORT_UNMAPPING;
250         break;
251 
252     default:
253         ret = TR_PORT_ERROR;
254         break;
255     }
256 
257     return ret;
258 }
259