Imported Upstream version 0.3.3 - merge fix
[anytun.git] / src / win32 / tunDevice.cpp
1 /*
2  *  anytun
3  *
4  *  The secure anycast tunneling protocol (satp) defines a protocol used
5  *  for communication between any combination of unicast and anycast
6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
8  *  ethernet, ip, arp ...). satp directly includes cryptography and
9  *  message authentication based on the methodes used by SRTP.  It is
10  *  intended to deliver a generic, scaleable and secure solution for
11  *  tunneling and relaying of packets of any protocol.
12  *
13  *
14  *  Copyright (C) 2007-2009 Othmar Gsenger, Erwin Nindl, 
15  *                          Christian Pointner <satp@wirdorange.org>
16  *
17  *  This file is part of Anytun.
18  *
19  *  Anytun is free software: you can redistribute it and/or modify
20  *  it under the terms of the GNU General Public License as published by
21  *  the Free Software Foundation, either version 3 of the License, or
22  *  any later version.
23  *
24  *  Anytun is distributed in the hope that it will be useful,
25  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
26  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
27  *  GNU General Public License for more details.
28  *
29  *  You should have received a copy of the GNU General Public License
30  *  along with anytun.  If not, see <http://www.gnu.org/licenses/>.
31  */
32
33 #include <string.h>
34 #include <sstream>
35 #include <windows.h>
36 #include <winioctl.h>
37
38 #include "../endian.h"
39 #include "../tunDevice.h"
40 #include "../threadUtils.hpp"
41 #include "../log.h"
42 #include "../anytunError.h"
43
44 #include "registryKey.h"
45 #include "common.h"
46
47 #define MIN_TAP_VER_MAJOR 8
48 #define MIN_TAP_VER_MINOR 2
49
50 TunDevice::TunDevice(std::string dev_name, std::string dev_type, std::string ifcfg_addr, u_int16_t ifcfg_prefix) : conf_(dev_name, dev_type, ifcfg_addr, ifcfg_prefix, 1400)
51 {
52   if(conf_.type_ != TYPE_TUN && conf_.type_ != TYPE_TAP)
53     AnytunError::throwErr() << "unable to recognize type of device (tun or tap)";
54
55   handle_ = INVALID_HANDLE_VALUE;
56   if(!getAdapter(dev_name))
57     AnytunError::throwErr() << "can't find any suitable device";
58
59   if(handle_ == INVALID_HANDLE_VALUE) {
60     std::stringstream tapname;
61           tapname << USERMODEDEVICEDIR << actual_node_ << TAPSUFFIX;
62     handle_ = CreateFileA(tapname.str().c_str(), GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
63     if(handle_ == INVALID_HANDLE_VALUE)
64       AnytunError::throwErr() << "Unable to open device: " << actual_node_ << " (" << actual_name_ << "): " << AnytunErrno(GetLastError());
65   }
66
67   DWORD err;
68   u_long info[3];
69   info[0] = info[1] = info[2] = 0;
70   err = performIoControl(TAP_IOCTL_GET_VERSION, info, sizeof(info), info, sizeof(info));
71   if(err != ERROR_SUCCESS) {
72     CloseHandle(handle_);
73     AnytunError::throwErr() << "Unable to get device version: " << AnytunErrno(err);
74   }
75   cLog.msg(Log::PRIO_NOTICE) << "Windows TAP Driver Version " << info[0] << "." << info[1] << " " << (info[2] ? "(DEBUG)" : "");
76   if(!(info[0] > MIN_TAP_VER_MAJOR || (info[0] == MIN_TAP_VER_MAJOR && info[1] >= MIN_TAP_VER_MINOR))) {
77     CloseHandle(handle_);
78     AnytunError::throwErr() << "need a higher Version of TAP Driver (at least " << MIN_TAP_VER_MAJOR << "." << MIN_TAP_VER_MINOR << ")";
79   }
80
81   if(conf_.type_ == TYPE_TUN) {
82     u_long ep[3];
83     ep[0] = htonl(conf_.addr_.getNetworkAddressV4().to_ulong());
84     ep[1] = htonl(conf_.addr_.getNetworkAddressV4().to_ulong() & conf_.netmask_.getNetworkAddressV4().to_ulong());
85     ep[2] = htonl(conf_.netmask_.getNetworkAddressV4().to_ulong());
86     err = performIoControl(TAP_IOCTL_CONFIG_TUN, ep, sizeof(ep), ep, sizeof(ep));
87     if(err != ERROR_SUCCESS) {
88       CloseHandle(handle_);
89       AnytunError::throwErr() << "Unable to set device tun mode: " << AnytunErrno(err);
90     }
91   }
92
93   if(ifcfg_addr != "")
94     do_ifconfig();
95
96   int status = true;
97   err = performIoControl(TAP_IOCTL_SET_MEDIA_STATUS, &status, sizeof(status), &status, sizeof(status));
98   if(err != ERROR_SUCCESS) {
99     CloseHandle(handle_);
100     AnytunError::throwErr() << "Unable to set device media status: " << AnytunErrno(err);
101         }
102
103   roverlapped_.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
104   woverlapped_.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
105 }
106
107 bool TunDevice::getAdapter(std::string const& dev_name)
108 {
109   RegistryKey akey;
110   DWORD err = akey.open(HKEY_LOCAL_MACHINE, ADAPTER_KEY, KEY_ENUMERATE_SUB_KEYS);
111   if(err != ERROR_SUCCESS)
112     AnytunError::throwErr() << "Unable to open registry key (HKLM\\" << ADAPTER_KEY << "): " << AnytunErrno(err);
113   
114   bool found = false;
115   for(int i=0; ; ++i) {
116     RegistryKey ckey;
117     DWORD err = akey.getSubKey(i, ckey, KEY_QUERY_VALUE);
118     if(err == ERROR_NO_MORE_ITEMS)
119       break;
120     if(err != ERROR_SUCCESS)
121       continue;
122
123     try {
124           if(ckey["ComponentId"] != TAP_COMPONENT_ID)
125         continue;
126       actual_node_ = ckey["NetCfgInstanceId"];
127
128       RegistryKey nkey;
129       std::stringstream keyname;
130       keyname << NETWORK_CONNECTIONS_KEY << "\\" << actual_node_ << "\\Connection";
131       err = nkey.open(HKEY_LOCAL_MACHINE, keyname.str().c_str(), KEY_QUERY_VALUE);;
132       if(err != ERROR_SUCCESS)
133         continue;
134           
135           actual_name_ = nkey["Name"];
136         } catch(AnytunErrno&) { continue; }
137
138     if(dev_name != "") {
139       if(dev_name == actual_name_) {
140         found = true;
141         break;
142       }
143     }
144     else {
145       std::stringstream tapname;
146       tapname << USERMODEDEVICEDIR << actual_node_ << TAPSUFFIX;
147       handle_ = CreateFileA(tapname.str().c_str(), GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
148       if(handle_ == INVALID_HANDLE_VALUE)
149         continue;
150       found = true;
151       break;
152     }
153   }
154   if(!found) {
155     actual_node_ = "";
156     actual_name_ = "";
157   }
158   return found;
159 }
160
161 DWORD TunDevice::performIoControl(DWORD controlCode, LPVOID inBuffer, DWORD inBufferSize, LPVOID outBuffer, DWORD outBufferSize)
162 {
163   OVERLAPPED overlapped;
164   overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
165   overlapped.Offset = 0;
166         overlapped.OffsetHigh = 0;
167   
168   DWORD len;
169   if(!DeviceIoControl(handle_, controlCode, inBuffer, inBufferSize, outBuffer, outBufferSize, &len, &overlapped)) {
170     DWORD err = GetLastError();
171     if(err == ERROR_IO_PENDING) {
172       WaitForSingleObject(overlapped.hEvent, INFINITE);
173       if(!GetOverlappedResult(handle_, &overlapped, &len, FALSE))
174         return GetLastError();
175     }
176     else
177       return GetLastError();
178   }
179   return ERROR_SUCCESS;
180 }
181
182
183 TunDevice::~TunDevice()
184 {
185   if(handle_ != INVALID_HANDLE_VALUE)
186     CloseHandle(handle_);
187   if(roverlapped_.hEvent != INVALID_HANDLE_VALUE)
188     CloseHandle(roverlapped_.hEvent);
189   if(woverlapped_.hEvent != INVALID_HANDLE_VALUE)
190     CloseHandle(woverlapped_.hEvent);
191 }
192
193 int TunDevice::fix_return(int ret, size_t pi_length) const
194 {
195 // nothing to be done here
196         return 0;
197 }
198
199 int TunDevice::read(u_int8_t* buf, u_int32_t len)
200 {
201   DWORD lenout;
202   roverlapped_.Offset = 0;
203         roverlapped_.OffsetHigh = 0;
204   ResetEvent(roverlapped_.hEvent);
205   
206   if(!ReadFile(handle_, buf, len, &lenout, &roverlapped_)) {
207     DWORD err = GetLastError();
208     if(err == ERROR_IO_PENDING) {
209       WaitForSingleObject(roverlapped_.hEvent, INFINITE);
210       if(!GetOverlappedResult(handle_, &roverlapped_, &lenout, FALSE)) {
211         cLog.msg(Log::PRIO_ERROR) << "Error while trying to get overlapped result: " << AnytunErrno(GetLastError());
212         return -1;
213       }
214     }
215     else {
216       cLog.msg(Log::PRIO_ERROR) << "Error while reading from device: " << AnytunErrno(GetLastError());
217       return -1;
218     }
219   }
220   return lenout;
221 }
222
223 int TunDevice::write(u_int8_t* buf, u_int32_t len)
224 {
225   DWORD lenout;
226   woverlapped_.Offset = 0;
227         woverlapped_.OffsetHigh = 0;
228   ResetEvent(woverlapped_.hEvent);
229
230         if(!WriteFile(handle_, buf, len, &lenout, &woverlapped_)) {
231     DWORD err = GetLastError();
232     if(err == ERROR_IO_PENDING) {
233       WaitForSingleObject(woverlapped_.hEvent, INFINITE);
234       if(!GetOverlappedResult(handle_, &woverlapped_, &lenout, FALSE)) {
235         cLog.msg(Log::PRIO_ERROR) << "Error while trying to get overlapped result: " << AnytunErrno(GetLastError());
236         return -1;
237       }
238     }
239     else {
240       cLog.msg(Log::PRIO_ERROR) << "Error while writing to device: " << AnytunErrno(GetLastError());
241       return -1;
242     }
243   }
244   return lenout;        
245 }
246
247 void TunDevice::init_post()
248 {
249 // nothing to be done here
250 }
251
252 void TunDevice::do_ifconfig()
253 {
254   u_long ep[4];
255   ep[0] = htonl(conf_.addr_.getNetworkAddressV4().to_ulong());
256   ep[1] = htonl(conf_.netmask_.getNetworkAddressV4().to_ulong());
257   ep[2] = htonl(conf_.addr_.getNetworkAddressV4().to_ulong() & conf_.netmask_.getNetworkAddressV4().to_ulong());
258   ep[3] = 365 * 24 * 3600;  // lease time in seconds
259   DWORD err = performIoControl(TAP_IOCTL_CONFIG_DHCP_MASQ, ep, sizeof(ep), ep, sizeof(ep));
260   if(err != ERROR_SUCCESS) {
261     CloseHandle(handle_);
262     AnytunError::throwErr() << "Unable to set device dhcp masq mode: " << AnytunErrno(err);
263         }
264
265   u_long mtu;
266   err = performIoControl(TAP_IOCTL_GET_MTU, &mtu, sizeof(mtu), &mtu, sizeof(mtu));
267   if(err != ERROR_SUCCESS) {
268     CloseHandle(handle_);
269     AnytunError::throwErr() << "Unable to get device mtu: " << AnytunErrno(err);
270         }
271   conf_.mtu_ = static_cast<u_int16_t>(mtu);
272 }
273
274 void TunDevice::waitUntilReady()
275 {
276 // nothing to be done here
277 }