← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/wireshark/gutsy-security

« back to all changes in this revision

Viewing changes to gtk/capture_if_details_dlg.c

  • Committer: Bazaar Package Importer
  • Author(s): Frederic Peters
  • Date: 2007-04-01 08:58:40 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070401085840-or3qhrpv8alt1bwg
Tags: 0.99.5-1
* New upstream release.
* debian/patches/09_idl2wrs.dpatch: updated to patch idl2wrs.sh.in.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk/capture_if_details_dlg.c
1
1
/* capture_if_details_dlg.c
2
2
 * Routines for capture interface details window (only Win32!)
3
3
 *
4
 
 * $Id: capture_if_details_dlg.c 19568 2006-10-17 01:29:55Z ulfl $
 
4
 * $Id: capture_if_details_dlg.c 20624 2007-01-30 17:14:37Z gerald $
5
5
 *
6
6
 * Wireshark - Network traffic analyzer
7
7
 * By Gerald Combs <gerald@wireshark.org>
71
71
#define ETH_SS_PAD2SIZE   (ETH_SS_MAXSIZE - (sizeof (eth_sa_family_t) + \
72
72
                              ETH_SS_PAD1SIZE + ETH_SS_ALIGNSIZE))
73
73
 
 
74
/* sockaddr_storage problem with different MSVC versions
 
75
 * - MSVC 6   (1200) doesn't define this
 
76
 * - MSVC 7   (1300) does
 
77
 * - MSVC 7.1 (1310) does
 
78
 * - MSVC 8   (1400) does */
 
79
/* we might need to tweak this #if, see version_info for _MSC_VER values */
 
80
#if _MSC_VER < 1300
74
81
struct sockaddr_storage {
75
82
    eth_sa_family_t  __ss_family;     /* address family */
76
83
    /* Following fields are implementation specific */
86
93
              /* __ss_pad1, __ss_align fields is 112 */
87
94
};
88
95
/* ... copied from RFC2553 */
 
96
#endif /* _MSC_VER */
89
97
#endif
90
98
 
91
99
 
106
114
 *
107
115
 * ndiswrapper (various NDIS related definitions)
108
116
 *  http://cvs.sourceforge.net/viewcvs.py/ndiswrapper/ndiswrapper/driver/
109
 
 *  
 
117
 *
110
118
 * ReactOS (various NDIS related definitions)
111
119
 *  http://www.reactos.org/generated/doxygen/d2/d6d/ndis_8h-source.html
112
120
 *
358
366
    ULONG    UdpChecksum:1;
359
367
    ULONG    IpChecksum:1;
360
368
  } V4Transmit;
361
 
 
 
369
 
362
370
  struct
363
371
  {
364
372
    ULONG    IpOptionsSupported:1;
367
375
    ULONG    UdpChecksum:1;
368
376
    ULONG    IpChecksum:1;
369
377
  } V4Receive;
370
 
 
 
378
 
371
379
  struct
372
380
  {
373
381
    ULONG    IpOptionsSupported:1;
375
383
    ULONG    TcpChecksum:1;
376
384
    ULONG    UdpChecksum:1;
377
385
  } V6Transmit;
378
 
 
 
386
 
379
387
  struct
380
388
  {
381
389
    ULONG    IpOptionsSupported:1;
746
754
    { 0xFF10000e, "Unknown 0xFF10000e (unused)" },
747
755
    { 0xFF10000f, "Unknown 0xFF10000f (unused)" },
748
756
    /* continued by a lot more 0xFF... values */
749
 
    
 
757
 
750
758
    { 0, NULL }
751
759
};
752
760
 
756
764
 
757
765
 
758
766
static void
759
 
supported_list(LPADAPTER adapter) 
 
767
supported_list(LPADAPTER adapter)
760
768
{
761
769
    unsigned char       values[10000];
762
770
    int                 length;
778
786
 
779
787
 
780
788
static gboolean
781
 
supported_query_oid(LPADAPTER adapter, guint32 oid) 
 
789
supported_query_oid(LPADAPTER adapter, guint32 oid)
782
790
{
783
791
    unsigned char       values[10000];
784
792
    int                 length;
785
793
 
786
 
    
 
794
 
787
795
    length = sizeof(values);
788
796
    if (wpcap_packet_request(adapter, OID_GEN_SUPPORTED_LIST, FALSE /* !set */, values, &length)) {
789
797
        guint32 *value = (guint32 *) values;
811
819
    GtkWidget *val_lb;
812
820
 
813
821
static GtkWidget *
814
 
add_meter_to_table(GtkWidget *list, guint *row, gchar *title, 
815
 
                 int value, gchar *value_title, 
 
822
add_meter_to_table(GtkWidget *list, guint *row, gchar *title,
 
823
                 int value, gchar *value_title,
816
824
                 int min, int max,
817
825
                 int yellow_level,
818
826
                 GList *scale)
1157
1165
            /* MAC */
1158
1166
            memcpy(mac, &bssid_item->mac, sizeof(mac));
1159
1167
            g_snprintf(mac_buff, DETAILS_STR_MAX, "%02X:%02X:%02X:%02X:%02X:%02X",
1160
 
                mac[0], mac[1], mac[2], 
 
1168
                mac[0], mac[1], mac[2],
1161
1169
                mac[3], mac[4], mac[5]);
1162
1170
 
1163
1171
            /* Vendor */
1226
1234
                    len-=2;
1227
1235
 
1228
1236
#ifdef DEBUG_IE
1229
 
                    g_warning("ID: %s (%u) Len: %u", 
 
1237
                    g_warning("ID: %s (%u) Len: %u",
1230
1238
                        val_to_str(id, ie_id_vals, "0x%x"), id, el_len);
1231
1239
#endif
1232
1240
 
1233
1241
                    if (id != 0 && id != 1 && id != 3 && id != 5 && id != 42 && id != 50 && id != 221) {
1234
1242
                        hex(iep, el_len);
1235
1243
                    }
1236
 
                    
 
1244
 
1237
1245
                    /* WPA2 (RSN) */
1238
1246
                    if (id == 48) {
1239
1247
                        privacy_wpa2 = TRUE;
1247
1255
                        /* include information from epan/packet-ieee80211.c dissect_vendor_ie_wpawme() */
1248
1256
                        manuf_name = get_manuf_name_if_known(iep);
1249
1257
                        if(manuf_name != NULL) {
1250
 
                            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X (%s) Type: %02X", 
 
1258
                            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X (%s) Type: %02X",
1251
1259
                                *(iep), *(iep+1), *(iep+2), manuf_name, *(iep+3));
1252
1260
                        } else {
1253
 
                            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X Type: %02X", 
 
1261
                            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X Type: %02X",
1254
1262
                                *(iep), *(iep+1), *(iep+2), *(iep+3));
1255
1263
                        }
1256
1264
 
1262
1270
                        hex(iep, el_len);
1263
1271
#endif
1264
1272
                    }
1265
 
                    
 
1273
 
1266
1274
                    iep += el_len;
1267
1275
                    len -= el_len;
1268
1276
                }
1287
1295
                g_snprintf(privacy_buff, DETAILS_STR_MAX, "None");
1288
1296
            }
1289
1297
 
1290
 
            simple_list_append(list, 
 
1298
            simple_list_append(list,
1291
1299
                0, ssid_buff,
1292
1300
                1, mac_buff,
1293
1301
                2, vendor_buff,
1294
1302
                3, privacy_buff,
1295
1303
                4, rssi_buff,
1296
1304
                5, nettype_buff,
1297
 
                6, infra_buff, 
1298
 
                7, freq_buff, 
 
1305
                6, infra_buff,
 
1306
                7, freq_buff,
1299
1307
                8, Rates->str,
1300
1308
                -1);
1301
1309
 
1342
1350
        manuf_name = get_manuf_name_if_known(values);
1343
1351
        if(manuf_name != NULL) {
1344
1352
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X:%02X:%02X:%02X (%s)",
1345
 
                values[0], values[1], values[2], 
 
1353
                values[0], values[1], values[2],
1346
1354
                values[3], values[4], values[5],
1347
1355
                manuf_name);
1348
1356
        } else {
1349
1357
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X:%02X:%02X:%02X",
1350
 
                values[0], values[1], values[2], 
 
1358
                values[0], values[1], values[2],
1351
1359
                values[3], values[4], values[5]);
1352
1360
        }
1353
1361
        entries++;
1358
1366
 
1359
1367
    /* Network type in use */
1360
1368
    if (wpcap_packet_request_uint(adapter, OID_802_11_NETWORK_TYPE_IN_USE, &uint_value)) {
1361
 
        add_string_to_table(table, row, "Network type used", 
 
1369
        add_string_to_table(table, row, "Network type used",
1362
1370
            val_to_str(uint_value, win32_802_11_network_type_vals, "(0x%x)"));
1363
1371
        entries++;
1364
1372
    } else {
1367
1375
 
1368
1376
    /* Infrastructure mode */
1369
1377
    if (wpcap_packet_request_ulong(adapter, OID_802_11_INFRASTRUCTURE_MODE, &uint_value)) {
1370
 
        add_string_to_table(table, row, "Infrastructure mode", 
 
1378
        add_string_to_table(table, row, "Infrastructure mode",
1371
1379
            val_to_str(uint_value, win32_802_11_infra_mode_vals, "(0x%x)"));
1372
1380
        entries++;
1373
1381
    } else {
1376
1384
 
1377
1385
    /* Authentication mode */
1378
1386
    if (wpcap_packet_request_ulong(adapter, OID_802_11_AUTHENTICATION_MODE, &uint_value)) {
1379
 
        add_string_to_table(table, row, "Authentication mode", 
 
1387
        add_string_to_table(table, row, "Authentication mode",
1380
1388
            val_to_str(uint_value, win32_802_11_auth_mode_vals, "(0x%x)"));
1381
1389
        entries++;
1382
1390
    } else {
1385
1393
 
1386
1394
    /* Encryption (WEP) status */
1387
1395
    if (wpcap_packet_request_ulong(adapter, OID_802_11_ENCRYPTION_STATUS, &uint_value)) {
1388
 
        add_string_to_table(table, row, "Encryption status", 
 
1396
        add_string_to_table(table, row, "Encryption status",
1389
1397
            val_to_str(uint_value, win32_802_11_encryption_status_vals, "(0x%x)"));
1390
1398
        entries++;
1391
1399
    } else {
1448
1456
        }
1449
1457
        g_snprintf(string_buff, DETAILS_STR_MAX, "%ld dBm", rssi);
1450
1458
 
1451
 
        add_meter_to_table(table, row, "RSSI (Received Signal Strength Indication)", 
 
1459
        add_meter_to_table(table, row, "RSSI (Received Signal Strength Indication)",
1452
1460
            rssi+100 , string_buff, -100+100, 0+100, -80+100, scale_items);
1453
 
    
 
1461
 
1454
1462
        current = scale_items;
1455
1463
        while (current != NULL) {
1456
1464
            g_free(current->data);
1499
1507
        } else {
1500
1508
            yellow = 1;
1501
1509
        }
1502
 
        add_meter_to_table(table, row, "Link Speed", 
 
1510
        add_meter_to_table(table, row, "Link Speed",
1503
1511
                uint_value, string_buff, 0, max, yellow, rates_list);
1504
 
    
 
1512
 
1505
1513
        current = rates_list;
1506
1514
        while (current != NULL) {
1507
1515
            g_free(current->data);
1592
1600
        manuf_name = get_manuf_name_if_known(values);
1593
1601
        if(manuf_name != NULL) {
1594
1602
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X:%02X:%02X:%02X (%s)",
1595
 
                values[0], values[1], values[2], 
 
1603
                values[0], values[1], values[2],
1596
1604
                values[3], values[4], values[5],
1597
1605
                manuf_name);
1598
1606
        } else {
1599
1607
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X:%02X:%02X:%02X",
1600
 
                values[0], values[1], values[2], 
 
1608
                values[0], values[1], values[2],
1601
1609
                values[3], values[4], values[5]);
1602
1610
        }
1603
1611
        entries++;
1611
1619
        manuf_name = get_manuf_name_if_known(values);
1612
1620
        if(manuf_name != NULL) {
1613
1621
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X:%02X:%02X:%02X (%s)",
1614
 
                values[0], values[1], values[2], 
 
1622
                values[0], values[1], values[2],
1615
1623
                values[3], values[4], values[5],
1616
1624
                manuf_name);
1617
1625
        } else {
1618
1626
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X:%02X:%02X:%02X",
1619
 
                values[0], values[1], values[2], 
 
1627
                values[0], values[1], values[2],
1620
1628
                values[3], values[4], values[5]);
1621
1629
        }
1622
1630
        entries++;
1735
1743
    offload->EncapsulationFormat.Flags.FixedHeaderSize = 1;
1736
1744
    offload->EncapsulationFormat.Flags.Reserved = 0;
1737
1745
    offload->EncapsulationFormat.EncapsulationHeaderSize = 14; /* sizeof(struct ether_header) */;
1738
 
    
 
1746
 
1739
1747
    length = sizeof(values);
1740
1748
    if (wpcap_packet_request(adapter, OID_TCP_TASK_OFFLOAD, FALSE /* !set */, values, &length)) {
1741
1749
        NDIS_TASK_OFFLOAD *of;
1848
1856
                add_string_to_table(table, row, "Task", string_buff);
1849
1857
 
1850
1858
            }
1851
 
            
 
1859
 
1852
1860
            add_string_to_table(table, row, "", "");
1853
1861
 
1854
1862
            valuep += of->OffsetNextTask;
1855
1863
            length -= of->OffsetNextTask;
1856
1864
        } while(of->OffsetNextTask != 0);
1857
 
    } 
 
1865
    }
1858
1866
 
1859
1867
    if(TcpIpChecksumSupported == 0) {
1860
1868
        add_string_to_table(table, row, "TCP/IP Checksum", "");
1865
1873
        add_string_to_table(table, row, "IpSec", "");
1866
1874
        add_string_to_table(table, row, "Offload not supported", "-");
1867
1875
    }
1868
 
        
 
1876
 
1869
1877
    if(TcpLargeSendSupported == 0) {
1870
1878
        add_string_to_table(table, row, "TCP Large Send", "");
1871
1879
        add_string_to_table(table, row, "Offload not supported", "-");
1943
1951
        uint_array_size /= sizeof(unsigned int);
1944
1952
        i=0;
1945
1953
        while(uint_array_size--) {
1946
 
            add_string_to_table(table, row, "Media supported", 
 
1954
            add_string_to_table(table, row, "Media supported",
1947
1955
                val_to_str(uint_array[i], win32_802_3_medium_vals, "(0x%x)"));
1948
1956
            i++;
1949
1957
        }
1957
1965
        uint_array_size /= sizeof(unsigned int);
1958
1966
        i=0;
1959
1967
        while(uint_array_size--) {
1960
 
            add_string_to_table(table, row, "Medium in use", 
 
1968
            add_string_to_table(table, row, "Medium in use",
1961
1969
                  val_to_str(uint_array[i], win32_802_3_medium_vals, "(0x%x)"));
1962
1970
            i++;
1963
1971
        }
1967
1975
 
1968
1976
    if (wpcap_packet_request_uint(adapter, OID_GEN_PHYSICAL_MEDIUM, &physical_medium)) {
1969
1977
        entries++;
1970
 
        add_string_to_table(table, row, "Physical medium", 
 
1978
        add_string_to_table(table, row, "Physical medium",
1971
1979
            val_to_str(physical_medium, win32_802_3_physical_medium_vals, "(0x%x)"));
1972
1980
    } else {
1973
1981
        add_string_to_table(table, row, "Physical medium", "-");
1986
1994
    if (wpcap_packet_request(adapter, OID_GEN_VENDOR_DRIVER_VERSION, FALSE /* !set */, (char *) &uint_value, &length)) {
1987
1995
        entries++;
1988
1996
        /* XXX - what's the correct output format? */
1989
 
        g_snprintf(string_buff, DETAILS_STR_MAX, "%u.%u (Hex: %X.%X)", 
 
1997
        g_snprintf(string_buff, DETAILS_STR_MAX, "%u.%u (Hex: %X.%X)",
1990
1998
            (uint_value / 0x10000  ) % 0x10000,
1991
1999
             uint_value              % 0x10000,
1992
2000
            (uint_value / 0x10000  ) % 0x10000,
2001
2009
        entries++;
2002
2010
        manuf_name = get_manuf_name_if_known(values);
2003
2011
        if(manuf_name != NULL) {
2004
 
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X (%s) NIC: %02X", 
 
2012
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X (%s) NIC: %02X",
2005
2013
                values[0], values[1], values[2], manuf_name, values[3]);
2006
2014
        } else {
2007
 
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X NIC: %02X", 
 
2015
            g_snprintf(string_buff, DETAILS_STR_MAX, "%02X:%02X:%02X NIC: %02X",
2008
2016
                values[0], values[1], values[2], values[3]);
2009
2017
        }
2010
2018
    } else {
2014
2022
 
2015
2023
    if (wpcap_packet_request_uint(adapter, OID_GEN_MAC_OPTIONS, &uint_value)) {
2016
2024
        entries++;
2017
 
        g_snprintf(string_buff, DETAILS_STR_MAX, 
2018
 
            "802.1P Priority: %s, 802.1Q VLAN: %s", 
 
2025
        g_snprintf(string_buff, DETAILS_STR_MAX,
 
2026
            "802.1P Priority: %s, 802.1Q VLAN: %s",
2019
2027
            (uint_value & NDIS_MAC_OPTION_8021P_PRIORITY) ? "Supported" : "Unsupported",
2020
2028
            (uint_value & NDIS_MAC_OPTION_8021Q_VLAN) ? "Supported" : "Unsupported" );
2021
2029
    } else {
2286
2294
    /* open the network adapter */
2287
2295
    adapter = wpcap_packet_open(iface);
2288
2296
    if(adapter == NULL) {
2289
 
        simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, 
 
2297
        simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
2290
2298
            PRIMARY_TEXT_START "Could not open adapter: %s!" PRIMARY_TEXT_END
2291
2299
            "\n\nThe adapter might be removed from the system in the meantime!", iface);
2292
2300
        return;
2412
2420
    if(version == NULL) {
2413
2421
        /* couldn't even get the packet.dll version, must be a very old one or just not existing -> give up */
2414
2422
        /* (this seems to be the case for 2.3 beta and all previous releases) */
2415
 
        simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK, 
 
2423
        simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
2416
2424
            PRIMARY_TEXT_START "Couldn't obtain WinPcap packet.dll version!" PRIMARY_TEXT_END
2417
2425
            "\n\nThe WinPcap packet.dll is not installed or the version you use seems to be very old!"
2418
2426
            "\n\nPlease update/install WinPcap.");
2421
2429
 
2422
2430
    /* XXX - add more known DLL versions here */
2423
2431
    /* (all versions since the 2.3 release seems to be working (although the 2.3 beta did not) */
2424
 
    if( 
2425
 
        strcmp(version, "4.0.0.592"  ) == 0 ||       /* 4.0 beta 1 */
 
2432
    if(
 
2433
        /*
 
2434
         * 4.0 version strings:
 
2435
         * 4.0.0.703:  4.0 beta 3
 
2436
         * 4.0.0.655:  4.0 beta 2
 
2437
         * 4.0.0.592:  4.0 beta 1
 
2438
         */
 
2439
        strcmp(version, "3"          ) >  0 ||       /* 4.0 and above (including betas) */
2426
2440
        strcmp(version, "3, 2, 0, 29") == 0 ||       /* 3.2 beta 1 */
2427
2441
        strcmp(version, "3, 1, 0, 27") == 0 ||       /* 3.1 release */
2428
2442
        strcmp(version, "3, 1, 0, 24") == 0 ||       /* 3.1 beta 4 */
2431
2445
        strcmp(version, "3, 1, 0, 20") == 0 ||       /* 3.1 beta */
2432
2446
        strcmp(version, "3.0 alpha3" ) == 0 ||       /* 3.0 release or 3.0 beta (yes, both versions report alpha3!) */
2433
2447
        strcmp(version, "2.3"        ) == 0          /* 2.3 release */
2434
 
        ) {   
 
2448
        ) {
2435
2449
            version_ok = TRUE;
2436
2450
    }
2437
2451
 
2438
2452
    if(!version_ok) {
2439
2453
        /* packet.dll version not known to us, warn user but try to continue */
2440
 
        dialog = simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK | ESD_BTN_CANCEL, 
 
2454
        dialog = simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK | ESD_BTN_CANCEL,
2441
2455
            PRIMARY_TEXT_START "Unknown WinPcap version might crash or fail!" PRIMARY_TEXT_END
2442
2456
            "\n\nThe WinPcap packet.dll version \"%s\" is unknown if it supports required functions!"
2443
2457
            "\n\nOnly WinPcap versions 3.0 and 3.1 are known to work with this feature."