ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/Windows/ether_windows.cpp
(Generate patch)

Comparing BasiliskII/src/Windows/ether_windows.cpp (file contents):
Revision 1.6 by gbeauche, 2006-04-29T10:57:56Z vs.
Revision 1.8 by gbeauche, 2006-05-01T10:42:00Z

# Line 20 | Line 20
20   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21   */
22  
23 + #include "sysdeps.h"
24 +
25   #include <process.h>
26   #include <windowsx.h>
27 + #include <winioctl.h>
28   #include <ctype.h>
29  
27 #include "sysdeps.h"
30   #include "cpu_emulation.h"
31   #include "main.h"
32   #include "macos_util.h"
# Line 58 | Line 60 | enum {
60          NET_IF_B2ETHER,
61          NET_IF_ROUTER,
62          NET_IF_SLIRP,
63 +        NET_IF_TAP,
64          NET_IF_FAKE,
65   };
66  
67 + // TAP-Win32 constants
68 + #define TAP_VERSION_MIN_MAJOR 7
69 + #define TAP_VERSION_MIN_MINOR 1
70 +
71 + #define TAP_CONTROL_CODE(request, method) \
72 +                CTL_CODE (FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
73 +
74 + #define TAP_IOCTL_GET_MAC                               TAP_CONTROL_CODE (1, METHOD_BUFFERED)
75 + #define TAP_IOCTL_GET_VERSION                   TAP_CONTROL_CODE (2, METHOD_BUFFERED)
76 + #define TAP_IOCTL_GET_MTU                               TAP_CONTROL_CODE (3, METHOD_BUFFERED)
77 + #define TAP_IOCTL_GET_INFO                              TAP_CONTROL_CODE (4, METHOD_BUFFERED)
78 + #define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE (5, METHOD_BUFFERED)
79 + #define TAP_IOCTL_SET_MEDIA_STATUS              TAP_CONTROL_CODE (6, METHOD_BUFFERED)
80 + #define TAP_IOCTL_CONFIG_DHCP_MASQ              TAP_CONTROL_CODE (7, METHOD_BUFFERED)
81 + #define TAP_IOCTL_GET_LOG_LINE                  TAP_CONTROL_CODE (8, METHOD_BUFFERED)
82 + #define TAP_IOCTL_CONFIG_DHCP_SET_OPT   TAP_CONTROL_CODE (9, METHOD_BUFFERED)
83 +
84 + #define OLD_TAP_CONTROL_CODE(request, method) \
85 +                CTL_CODE (FILE_DEVICE_PHYSICAL_NETCARD | 8000, request, method, FILE_ANY_ACCESS)
86 +
87 + #define OLD_TAP_IOCTL_GET_VERSION               OLD_TAP_CONTROL_CODE (3, METHOD_BUFFERED)
88 +
89   // Options
90   bool ether_use_permanent = true;
91   static int16 ether_multi_mode = ETHER_MULTICAST_MAC;
# Line 70 | Line 95 | HANDLE ether_th;
95   unsigned int ether_tid;
96   HANDLE ether_th1;
97   HANDLE ether_th2;
98 < static int net_if_type = -1;                            // Ethernet device type
98 > static int net_if_type = -1;    // Ethernet device type
99   #ifdef SHEEPSHAVER
100 < static bool net_open = false;                           // Flag: initialization succeeded, network device open
101 < uint8 ether_addr[6];                                            // Our Ethernet address
100 > static bool net_open = false;   // Flag: initialization succeeded, network device open
101 > uint8 ether_addr[6];                    // Our Ethernet address
102   #endif
103  
104   // These are protected by queue_csection
# Line 143 | Line 168 | static HANDLE int_sig2 = 0;
168   static HANDLE int_send_now = 0;
169  
170   // Prototypes
171 + static LPADAPTER tap_open_adapter(const char *dev_name);
172 + static void tap_close_adapter(LPADAPTER fd);
173 + static bool tap_check_version(LPADAPTER fd);
174 + static bool tap_set_status(LPADAPTER fd, ULONG status);
175 + static bool tap_get_mac(LPADAPTER fd, LPBYTE addr);
176 + static bool tap_receive_packet(LPADAPTER fd, LPPACKET lpPacket, BOOLEAN Sync);
177 + static bool tap_send_packet(LPADAPTER fd, LPPACKET lpPacket, BOOLEAN Sync, BOOLEAN recycle);
178   static WINAPI unsigned int slirp_receive_func(void *arg);
179   static WINAPI unsigned int ether_thread_feed_int(void *arg);
180   static WINAPI unsigned int ether_thread_get_packets_nt(void *arg);
# Line 198 | Line 230 | bool ether_init(void)
230  
231          // Determine Ethernet device type
232          net_if_type = -1;
233 <        if (strcmp(name, "router") == 0)
233 >        if (PrefsFindBool("routerenabled") || strcmp(name, "router") == 0)
234                  net_if_type = NET_IF_ROUTER;
235          else if (strcmp(name, "slirp") == 0)
236                  net_if_type = NET_IF_SLIRP;
237 +        else if (strcmp(name, "tap") == 0)
238 +                net_if_type = NET_IF_TAP;
239          else
240                  net_if_type = NET_IF_B2ETHER;
241  
# Line 225 | Line 259 | bool ether_init(void)
259          switch (net_if_type) {
260          case NET_IF_B2ETHER:
261                  dev_name = PrefsFindString("etherguid");
262 +                if (dev_name == NULL || strcmp(name, "b2ether") != 0)
263 +                        dev_name = name;
264 +                break;
265 +        case NET_IF_TAP:
266 +                dev_name = PrefsFindString("etherguid");
267                  break;
268          }
269          if (net_if_type == NET_IF_B2ETHER) {
# Line 261 | Line 300 | bool ether_init(void)
300                          D(bug("Fake ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
301                  }
302          }
303 +        else if (net_if_type == NET_IF_TAP) {
304 +                if (dev_name == NULL) {
305 +                        WarningAlert("No ethernet device GUID specified. Ethernet is not available.");
306 +                        goto open_error;
307 +                }
308 +
309 +                fd = tap_open_adapter(dev_name);
310 +                if (!fd) {
311 +                        sprintf(str, "Could not open ethernet adapter %s.", dev_name);
312 +                        WarningAlert(str);
313 +                        goto open_error;
314 +                }
315 +
316 +                if (!tap_check_version(fd)) {
317 +                        sprintf(str, "Minimal TAP-Win32 version supported is %d.%d.", TAP_VERSION_MIN_MAJOR, TAP_VERSION_MIN_MINOR);
318 +                        WarningAlert(str);
319 +                        goto open_error;
320 +                }
321 +
322 +                if (!tap_set_status(fd, true)) {
323 +                        sprintf(str, "Could not set media status to connected.");
324 +                        WarningAlert(str);
325 +                        goto open_error;
326 +                }
327 +
328 +                if (!tap_get_mac(fd, ether_addr)) {
329 +                        sprintf(str, "Could not get hardware address of device %s. Ethernet is not available.", dev_name);
330 +                        WarningAlert(str);
331 +                        goto open_error;
332 +                }
333 +                D(bug("Real ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
334 +
335 +                const char *ether_fake_address;
336 +                ether_fake_address = PrefsFindString("etherfakeaddress");
337 +                if (ether_fake_address && strlen(ether_fake_address) == 12) {
338 +                        char sm[10];
339 +                        strcpy( sm, "0x00" );
340 +                        for( int i=0; i<6; i++ ) {
341 +                                sm[2] = ether_fake_address[i*2];
342 +                                sm[3] = ether_fake_address[i*2+1];
343 +                                ether_addr[i] = (uint8)strtoul(sm,0,0);
344 +                        }
345 +                }
346 + #if 1
347 +                /*
348 +                  If we bridge the underlying ethernet connection and the TAP
349 +                  device altogether, we have to use a fake address.
350 +                 */
351 +                else {
352 +                        ether_addr[0] = 0x52;
353 +                        ether_addr[1] = 0x54;
354 +                        ether_addr[2] = 0x00;
355 +                }
356 + #endif
357 +                D(bug("Fake ethernet address %02x %02x %02x %02x %02x %02x\n", ether_addr[0], ether_addr[1], ether_addr[2], ether_addr[3], ether_addr[4], ether_addr[5]));
358 +        }
359          else if (net_if_type == NET_IF_SLIRP) {
360                  ether_addr[0] = 0x52;
361                  ether_addr[1] = 0x54;
# Line 337 | Line 432 | bool ether_init(void)
432          thread_active = true;
433  
434          unsigned int dummy;
435 <        ether_th2 = (HANDLE)_beginthreadex( 0, 0,
436 <                net_if_type == NET_IF_SLIRP ? slirp_receive_func : ether_thread_get_packets_nt,
437 <                0, 0, &dummy );
435 >        unsigned int (WINAPI *receive_func)(void *);
436 >        switch (net_if_type) {
437 >        case NET_IF_SLIRP:
438 >          receive_func = slirp_receive_func;
439 >          break;
440 >        default:
441 >          receive_func = ether_thread_get_packets_nt;
442 >          break;
443 >        }
444 >        ether_th2 = (HANDLE)_beginthreadex( 0, 0, receive_func, 0, 0, &dummy );
445          ether_th1 = (HANDLE)_beginthreadex( 0, 0, ether_thread_write_packets, 0, 0, &dummy );
446  
447          // Everything OK
# Line 363 | Line 465 | bool ether_init(void)
465                  int_send_now = 0;
466                  thread_active = false;
467          }
468 <        if(net_if_type == NET_IF_B2ETHER) {
469 <                PacketCloseAdapter(fd);
468 >        if (fd) {
469 >                switch (net_if_type) {
470 >                case NET_IF_B2ETHER:
471 >                        PacketCloseAdapter(fd);
472 >                        break;
473 >                case NET_IF_TAP:
474 >                        tap_close_adapter(fd);
475 >                        break;
476 >                }
477 >                fd = 0;
478          }
369        fd = 0;
479          return false;
480   }
481  
# Line 437 | Line 546 | void ether_exit(void)
546          }
547  
548          // Close ethernet device
549 <        if(fd) {
550 <                PacketCloseAdapter(fd);
549 >        if (fd) {
550 >                switch (net_if_type) {
551 >                case NET_IF_B2ETHER:
552 >                        PacketCloseAdapter(fd);
553 >                        break;
554 >                case NET_IF_TAP:
555 >                        tap_close_adapter(fd);
556 >                        break;
557 >                }
558                  fd = 0;
559          }
560  
# Line 904 | Line 1020 | static unsigned int ether_thread_write_p
1020                                          // already recycled if async
1021                                  }
1022                                  break;
1023 +                        case NET_IF_TAP:
1024 +                                if (!tap_send_packet(fd, Packet, FALSE, TRUE)) {
1025 +                                        // already recycled if async
1026 +                                }
1027 +                                break;
1028                          case NET_IF_SLIRP:
1029                                  slirp_input((uint8 *)Packet->Buffer, Packet->Length);
1030                                  Packet->bIoComplete = TRUE;
# Line 1060 | Line 1181 | static bool set_wait_request(void)
1181  
1182  
1183   /*
1184 + *  TAP-Win32 glue
1185 + */
1186 +
1187 + static LPADAPTER tap_open_adapter(const char *dev_name)
1188 + {
1189 +        fd = (LPADAPTER)GlobalAllocPtr(GMEM_MOVEABLE | GMEM_ZEROINIT, sizeof(*fd));
1190 +        if (fd == NULL)
1191 +                return NULL;
1192 +
1193 +        char dev_path[MAX_PATH];
1194 +        snprintf(dev_path, sizeof(dev_path),
1195 +                         "\\\\.\\Global\\%s.tap", dev_name);
1196 +
1197 +        HANDLE handle = CreateFile(
1198 +                dev_path,
1199 +                GENERIC_READ | GENERIC_WRITE,
1200 +                0,
1201 +                NULL,
1202 +                OPEN_EXISTING,
1203 +                FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED,
1204 +                NULL);
1205 +        if (handle == NULL || handle == INVALID_HANDLE_VALUE)
1206 +                return NULL;
1207 +
1208 +        fd->hFile = handle;
1209 +        return fd;
1210 + }
1211 +
1212 + static void tap_close_adapter(LPADAPTER fd)
1213 + {
1214 +        if (fd) {
1215 +                if (fd->hFile) {
1216 +                        tap_set_status(fd, false);
1217 +                        CloseHandle(fd->hFile);
1218 +                }
1219 +                GlobalFreePtr(fd);
1220 +        }
1221 + }
1222 +
1223 + static bool tap_check_version(LPADAPTER fd)
1224 + {
1225 +        ULONG len;
1226 +        ULONG info[3] = { 0, };
1227 +
1228 +        if (!DeviceIoControl(fd->hFile, TAP_IOCTL_GET_VERSION,
1229 +                                                 &info, sizeof(info),
1230 +                                                 &info, sizeof(info), &len, NULL)
1231 +                && !DeviceIoControl(fd->hFile, OLD_TAP_IOCTL_GET_VERSION,
1232 +                                                        &info, sizeof(info),
1233 +                                                        &info, sizeof(info), &len, NULL))
1234 +                return false;
1235 +
1236 +        if (info[0] > TAP_VERSION_MIN_MAJOR)
1237 +                return true;
1238 +        if (info[0] == TAP_VERSION_MIN_MAJOR && info[1] >= TAP_VERSION_MIN_MINOR)
1239 +                return true;
1240 +
1241 +        return false;
1242 + }
1243 +
1244 + static bool tap_set_status(LPADAPTER fd, ULONG status)
1245 + {
1246 +        DWORD len = 0;
1247 +        return DeviceIoControl(fd->hFile, TAP_IOCTL_SET_MEDIA_STATUS,
1248 +                                                   &status, sizeof (status),
1249 +                                                   &status, sizeof (status), &len, NULL);
1250 + }
1251 +
1252 + static bool tap_get_mac(LPADAPTER fd, LPBYTE addr)
1253 + {
1254 +        DWORD len = 0;
1255 +        return DeviceIoControl(fd->hFile, TAP_IOCTL_GET_MAC,
1256 +                                                   addr, 6,
1257 +                                                   addr, 6, &len, NULL);
1258 +                                                  
1259 + }
1260 +
1261 + static VOID CALLBACK tap_write_completion(
1262 +        DWORD dwErrorCode,
1263 +        DWORD dwNumberOfBytesTransfered,
1264 +        LPOVERLAPPED lpOverLapped
1265 +        )
1266 + {
1267 +        LPPACKET lpPacket = CONTAINING_RECORD(lpOverLapped, PACKET, OverLapped);
1268 +
1269 +        lpPacket->bIoComplete = TRUE;
1270 +        recycle_write_packet(lpPacket);
1271 + }
1272 +
1273 + static bool tap_send_packet(
1274 +        LPADAPTER fd,
1275 +        LPPACKET lpPacket,
1276 +        BOOLEAN Sync,
1277 +        BOOLEAN RecyclingAllowed)
1278 + {
1279 +        BOOLEAN Result;
1280 +
1281 +        lpPacket->OverLapped.Offset = 0;
1282 +        lpPacket->OverLapped.OffsetHigh = 0;
1283 +        lpPacket->bIoComplete = FALSE;
1284 +
1285 +        if (Sync) {
1286 +                Result = WriteFile(fd->hFile,
1287 +                                                   lpPacket->Buffer,
1288 +                                                   lpPacket->Length,
1289 +                                                   &lpPacket->BytesReceived,
1290 +                                                   &lpPacket->OverLapped);
1291 +                if (Result) {
1292 +                        GetOverlappedResult(fd->hFile,
1293 +                                                                &lpPacket->OverLapped,
1294 +                                                                &lpPacket->BytesReceived,
1295 +                                                                TRUE);
1296 +                }
1297 +                lpPacket->bIoComplete = TRUE;
1298 +                if (RecyclingAllowed)
1299 +                        PacketFreePacket(lpPacket);
1300 +        }
1301 +        else {
1302 +                Result = WriteFileEx(fd->hFile,
1303 +                                                         lpPacket->Buffer,
1304 +                                                         lpPacket->Length,
1305 +                                                         &lpPacket->OverLapped,
1306 +                                                         tap_write_completion);
1307 +
1308 +                if (!Result && RecyclingAllowed)
1309 +                        recycle_write_packet(lpPacket);
1310 +        }
1311 +
1312 +        return Result;
1313 + }
1314 +
1315 + static bool tap_receive_packet(LPADAPTER fd, LPPACKET lpPacket, BOOLEAN Sync)
1316 + {
1317 +        BOOLEAN Result;
1318 +
1319 +        lpPacket->OverLapped.Offset = 0;
1320 +        lpPacket->OverLapped.OffsetHigh = 0;
1321 +        lpPacket->bIoComplete = FALSE;
1322 +
1323 +        if (Sync) {
1324 +                Result = ReadFile(fd->hFile,
1325 +                                                  lpPacket->Buffer,
1326 +                                                  lpPacket->Length,
1327 +                                                  &lpPacket->BytesReceived,
1328 +                                                  &lpPacket->OverLapped);
1329 +                if (Result) {
1330 +                        Result = GetOverlappedResult(fd->hFile,
1331 +                                                                                 &lpPacket->OverLapped,
1332 +                                                                                 &lpPacket->BytesReceived,
1333 +                                                                                 TRUE);
1334 +                        if (Result)
1335 +                                lpPacket->bIoComplete = TRUE;
1336 +                        else
1337 +                                lpPacket->free = TRUE;
1338 +                }
1339 +        }
1340 +        else {
1341 +                Result = ReadFileEx(fd->hFile,
1342 +                                                        lpPacket->Buffer,
1343 +                                                        lpPacket->Length,
1344 +                                                        &lpPacket->OverLapped,
1345 +                                                        packet_read_completion);
1346 +
1347 +                if (!Result)
1348 +                        lpPacket->BytesReceived = 0;
1349 +        }
1350 +
1351 +        return Result;
1352 + }
1353 +
1354 +
1355 + /*
1356   *  SLIRP output buffer glue
1357   */
1358  
# Line 1073 | Line 1366 | void slirp_output(const uint8 *packet, i
1366          enqueue_packet(packet, len);
1367   }
1368  
1369 < unsigned int slirp_receive_func(void *arg)
1369 > static unsigned int slirp_receive_func(void *arg)
1370   {
1371          D(bug("slirp_receive_func\n"));
1372          thread_active_2 = true;
# Line 1151 | Line 1444 | VOID CALLBACK packet_read_completion(
1444                                          break;
1445                                  }
1446                          }
1447 +                        // XXX drop packets that are not for us
1448 +                        if (net_if_type == NET_IF_TAP) {
1449 +                                if (memcmp((LPBYTE)lpPacket->Buffer, ether_addr, 6) != 0)
1450 +                                        dwNumberOfBytesTransfered = 0;
1451 +                        }
1452                          if(dwNumberOfBytesTransfered) {
1453                                  if(net_if_type != NET_IF_ROUTER || !router_read_packet((uint8 *)lpPacket->Buffer, dwNumberOfBytesTransfered)) {
1454                                          enqueue_packet( (LPBYTE)lpPacket->Buffer, dwNumberOfBytesTransfered );
# Line 1223 | Line 1521 | static unsigned int ether_thread_get_pac
1521          // Obey the golden rules; keep the reads pending.
1522          while(thread_active) {
1523  
1524 <                if(net_if_type == NET_IF_B2ETHER) {
1524 >                if(net_if_type == NET_IF_B2ETHER || net_if_type == NET_IF_TAP) {
1525                          D(bug("Pending reads\n"));
1526                          for( i=0; thread_active && i<PACKET_POOL_COUNT; i++ ) {
1527                                  if(packets[i]->free) {
1528                                          packets[i]->free = FALSE;
1529 <                                        if(PacketReceivePacket(fd,packets[i],FALSE)) {
1529 >                                        BOOLEAN Result;
1530 >                                        switch (net_if_type) {
1531 >                                        case NET_IF_B2ETHER:
1532 >                                                Result = PacketReceivePacket(fd, packets[i], FALSE);
1533 >                                                break;
1534 >                                        case NET_IF_TAP:
1535 >                                                Result = tap_receive_packet(fd, packets[i], FALSE);
1536 >                                                break;
1537 >                                        }
1538 >                                        if (Result) {
1539                                                  if(packets[i]->bIoComplete) {
1540                                                          D(bug("Early io completion...\n"));
1541                                                          packet_read_completion(

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines