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

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8);

933

990

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is %d-%d characters (%d-%d bits).",WEP_KEY_MIN_CHAR_SIZE,WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MIN_BIT_SIZE,WEP_KEY_MAX_BIT_SIZE);

991

934

992

g_string_free(new_type_string,TRUE);

935

993

g_string_free(new_key_string, TRUE);

936

994

g_string_free(new_ssid_string,TRUE);

937

995

938

996

g_free(type_entered);

939

997

g_free(key_entered );

940

998

g_free(ssid_entered);

944

1002

if((new_key_string->len % 2) != 0)

945

1003

{

946

1004

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even.");

947

1005

948

1006

g_string_free(new_type_string,TRUE);

949

1007

g_string_free(new_key_string, TRUE);

950

1008

g_string_free(new_ssid_string,TRUE);

951

1009

952

1010

g_free(type_entered);

953

1011

g_free(key_entered );

954

1012

g_free(ssid_entered);

960

1018

if(!g_ascii_isxdigit(new_key_string->str[i]))

961

1019

{

962

1020

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be a hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");

963

1021

964

1022

g_string_free(new_type_string,TRUE);

965

1023

g_string_free(new_key_string, TRUE);

966

1024

g_string_free(new_ssid_string,TRUE);

967

1025

968

1026

g_free(type_entered);

969

1027

g_free(key_entered );

970

1028

g_free(ssid_entered);

972

1030

}

973

1031

}

974

1032

975

/* If so... Modify key */

1033

/* If so... add key */

976

1034

airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str);

977

1035

978

airpcap_if_selected->saved = FALSE;

1036

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

979

1037

}

980

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_KEY_STRING) == 0) /* WPA Key */

1038

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */

981

1039

{

982

1040

/* XXX - Perform some WPA related input fields check */

983

1041

/* If everything is ok, modify the entry int he list */

984

1042

985

airpcap_if_selected->saved = FALSE;

1043

if( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE))

1044

{

1045

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA key size out of range!\nValid key size range is %d-%d ASCII characters (%d-%d bits).",WPA_KEY_MIN_CHAR_SIZE,WPA_KEY_MAX_CHAR_SIZE,WPA_KEY_MIN_BIT_SIZE,WPA_KEY_MAX_BIT_SIZE);

1046

1047

g_string_free(new_type_string,TRUE);

1048

g_string_free(new_key_string, TRUE);

1049

g_string_free(new_ssid_string,TRUE);

1050

1051

g_free(type_entered);

1052

g_free(key_entered );

1053

g_free(ssid_entered);

1054

return;

1055

}

1056

1057

1058

* XXX - Maybe we need some check on the characters? I'm not sure if only stabdard ASCII are ok...

1059

1060

if( ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((new_ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE))

1061

{

1062

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"SSID key size out of range!\nValid SSID size range is %d-%d ASCII characters (%d-%d bits).",WPA_SSID_MIN_CHAR_SIZE,WPA_SSID_MAX_CHAR_SIZE,WPA_SSID_MIN_BIT_SIZE,WPA_SSID_MAX_BIT_SIZE);

1063

1064

g_string_free(new_type_string,TRUE);

1065

g_string_free(new_key_string, TRUE);

1066

g_string_free(new_ssid_string,TRUE);

1067

1068

g_free(type_entered);

1069

g_free(key_entered );

1070

g_free(ssid_entered);

1071

return;

1072

}

1073

1074

/* If so... add key */

1075

airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str);

1076

1077

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

986

1078

}

987

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA2_KEY_STRING) == 0) /* WPA2 Key */

1079

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */

988

1080

{

989

/* XXX - Perform some WPA2 related input fields check */

1081

/* XXX - Perform some WPA_BIN related input fields check */

990

1082

/* If everything is ok, modify the entry int he list */

991

1083

992

airpcap_if_selected->saved = FALSE;

1084

if( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE))

1085

{

1086

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA PSK/PMK key size is wrong!\nValid key size is %d characters (%d bits).",WPA_PSK_KEY_CHAR_SIZE,WPA_PSK_KEY_BIT_SIZE);

1087

1088

g_string_free(new_type_string,TRUE);

1089

g_string_free(new_key_string, TRUE);

1090

g_string_free(new_ssid_string,TRUE);

1091

1092

g_free(type_entered);

1093

g_free(key_entered );

1094

g_free(ssid_entered);

1095

return;

1096

}

1097

1098

for(i = 0; i < new_key_string->len; i++)

1099

{

1100

if(!g_ascii_isxdigit(new_key_string->str[i]))

1101

{

1102

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");

1103

1104

g_string_free(new_type_string,TRUE);

1105

g_string_free(new_key_string, TRUE);

1106

g_string_free(new_ssid_string,TRUE);

1107

1108

g_free(type_entered);

1109

g_free(key_entered );

1110

g_free(ssid_entered);

1111

return;

1112

}

1113

}

1114

1115

/* If so... add key */

1116

airpcap_add_key_to_list(key_ls, new_type_string->str, new_key_string->str, new_ssid_string->str);

1117

1118

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

993

1119

}

994

1120

else /* Should never happen!!! */

995

{

996

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");

1121

{

1122

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");

997

1123

}

998

1124

999

1125

g_string_free(new_type_string,TRUE);

1002

1128

1003

1129

g_free(type_entered);

1004

1130

g_free(key_entered );

1005

g_free(ssid_entered);

1131

g_free(ssid_entered);

1006

1132

1007

1133

window_destroy(GTK_WIDGET(data));

1008

1134

return;

1017

1143

GtkWidget *type_cm,

1018

1144

*key_en,

1019

1145

*ssid_en;

1020

1146

1021

1147

GtkWidget *key_ls;

1022

1148

1023

GString *new_type_string,

1024

*new_key_string,

1149

GString *new_type_string,

1150

*new_key_string,

1025

1151

*new_ssid_string;

1026

1152

1027

1153

gchar *type_entered = NULL;

1066

1192

/* Check which type of key the user has entered */

1067

1193

if(g_strcasecmp(new_type_string->str,AIRPCAP_WEP_KEY_STRING) == 0) /* WEP key */

1068

1194

{

1069

1070

if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < 2))

1195

1196

if( ((new_key_string->len) > WEP_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WEP_KEY_MIN_CHAR_SIZE))

1071

1197

{

1072

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WEP key size out of range!\nValid key size range is 2-%d characters (8-%d bits).",WEP_KEY_MAX_CHAR_SIZE,WEP_KEY_MAX_SIZE*8);

1073

1198

1199

1074

1200

g_string_free(new_type_string,TRUE);

1075

1201

g_string_free(new_key_string, TRUE);

1076

1202

g_string_free(new_ssid_string,TRUE);

1077

1203

1078

1204

g_free(type_entered);

1079

1205

g_free(key_entered );

1080

1206

g_free(ssid_entered);

1084

1210

if((new_key_string->len % 2) != 0)

1085

1211

{

1086

1212

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nThe number of characters must be even.");

1087

1213

1088

1214

g_string_free(new_type_string,TRUE);

1089

1215

g_string_free(new_key_string, TRUE);

1090

1216

g_string_free(new_ssid_string,TRUE);

1091

1217

1092

1218

g_free(type_entered);

1093

1219

g_free(key_entered );

1094

1220

g_free(ssid_entered);

1100

1226

if(!g_ascii_isxdigit(new_key_string->str[i]))

1101

1227

{

1102

1228

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WEP key!\nA WEP key must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");

1103

1229

1104

1230

g_string_free(new_type_string,TRUE);

1105

1231

g_string_free(new_key_string, TRUE);

1106

1232

g_string_free(new_ssid_string,TRUE);

1107

1233

1108

1234

g_free(type_entered);

1109

1235

g_free(key_entered );

1110

1236

g_free(ssid_entered);

1115

1241

/* If so... Modify key */

1116

1242

airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str);

1117

1243

1118

airpcap_if_selected->saved = FALSE;

1244

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

1119

1245

}

1120

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_KEY_STRING) == 0) /* WPA Key */

1246

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_PWD_KEY_STRING) == 0) /* WPA Key */

1121

1247

{

1122

1248

/* XXX - Perform some WPA related input fields check */

1123

1249

/* If everything is ok, modify the entry int he list */

1124

1250

1125

airpcap_if_selected->saved = FALSE;

1126

}

1127

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA2_KEY_STRING) == 0) /* WPA2 Key */

1128

{

1129

/* XXX - Perform some WPA2 related input fields check */

1251

if( ((new_key_string->len) > WPA_KEY_MAX_CHAR_SIZE) || ((new_key_string->len) < WPA_KEY_MIN_CHAR_SIZE))

1252

{

1253

1254

1255

g_string_free(new_type_string,TRUE);

1256

g_string_free(new_key_string, TRUE);

1257

g_string_free(new_ssid_string,TRUE);

1258

1259

g_free(type_entered);

1260

g_free(key_entered );

1261

g_free(ssid_entered);

1262

return;

1263

}

1264

1265

1266

* XXX - Maybe we need some check on the characters? I'm not sure if only stabdard ASCII are ok...

1267

1268

if( ((new_ssid_string->len) > WPA_SSID_MAX_CHAR_SIZE) || ((new_ssid_string->len) < WPA_SSID_MIN_CHAR_SIZE))

1269

{

1270

1271

1272

g_string_free(new_type_string,TRUE);

1273

g_string_free(new_key_string, TRUE);

1274

g_string_free(new_ssid_string,TRUE);

1275

1276

g_free(type_entered);

1277

g_free(key_entered );

1278

g_free(ssid_entered);

1279

return;

1280

}

1281

1282

/* If so... Modify key */

1283

airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str);

1284

1285

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

1286

}

1287

else if(g_strcasecmp(new_type_string->str,AIRPCAP_WPA_BIN_KEY_STRING) == 0) /* WPA_BIN Key */

1288

{

1289

/* XXX - Perform some WPA_BIN related input fields check */

1130

1290

/* If everything is ok, modify the entry int he list */

1131

1291

1132

airpcap_if_selected->saved = FALSE;

1292

if( ((new_key_string->len) != WPA_PSK_KEY_CHAR_SIZE))

1293

{

1294

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"WPA PSK/PMK key size is wrong!\nValid key size is %d characters (%d bits).",WPA_PSK_KEY_CHAR_SIZE,WPA_PSK_KEY_BIT_SIZE);

1295

1296

g_string_free(new_type_string,TRUE);

1297

g_string_free(new_key_string, TRUE);

1298

g_string_free(new_ssid_string,TRUE);

1299

1300

g_free(type_entered);

1301

g_free(key_entered );

1302

g_free(ssid_entered);

1303

return;

1304

}

1305

1306

for(i = 0; i < new_key_string->len; i++)

1307

{

1308

if(!g_ascii_isxdigit(new_key_string->str[i]))

1309

{

1310

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Invalid WPA PSK/PMK key!\nKey must be an hexadecimal number.\nThe valid characters are: 0123456789ABCDEF.");

1311

1312

g_string_free(new_type_string,TRUE);

1313

g_string_free(new_key_string, TRUE);

1314

g_string_free(new_ssid_string,TRUE);

1315

1316

g_free(type_entered);

1317

g_free(key_entered );

1318

g_free(ssid_entered);

1319

return;

1320

}

1321

}

1322

1323

/* If so... Modify key */

1324

airpcap_modify_key_in_list(key_ls, r, new_type_string->str, new_key_string->str, new_ssid_string->str);

1325

1326

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

1133

1327

}

1134

1328

else /* Should never happen!!! */

1135

{

1136

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");

1329

{

1330

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Unknown error in the key \"Type\" field!");

1137

1331

}

1138

1332

1139

1333

g_string_free(new_type_string,TRUE);

1142

1336

1143

1337

g_free(type_entered);

1144

1338

g_free(key_entered );

1145

g_free(ssid_entered);

1339

g_free(ssid_entered);

1146

1340

1147

1341

window_destroy(GTK_WIDGET(data));

1148

1342

return;

1200

1394

1201

1395

if(keys_in_list >= MAX_ENCRYPTION_KEYS) /* Check if we have already reached the maximum number of allowed keys... */

1202

1396

{

1203

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Maximum number (%d) of decryption keys reached! You cannot add another key!\n",MAX_ENCRYPTION_KEYS);

1397

simple_dialog(ESD_TYPE_ERROR,ESD_BTN_OK,"Maximum number (%d) of decryption keys reached! You cannot add another key!\n",MAX_ENCRYPTION_KEYS);

1204

1398

return;

1205

1399

}

1206

1400

1207

1401

/* Gray out the Advanced Wireless Setting window */

1208

1402

gtk_widget_set_sensitive(airpcap_advanced_w,FALSE);

1209

1403

1210

/* Pop-up a new window */

1404

/* Pop-up a new window */

1211

1405

add_key_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

1212

1406

gtk_widget_set_name (add_key_window, "add_key_window");

1213

1407

gtk_container_set_border_width (GTK_CONTAINER (add_key_window), 5);

1251

1445

(GtkAttachOptions) (GTK_FILL),

1252

1446

(GtkAttachOptions) (0), 0, 0);

1253

1447

#if GTK_MAJOR_VERSION >= 2

1254

gtk_widget_set_size_request (add_type_cm, 63, -1);

1448

gtk_widget_set_size_request (add_type_cm, 83, -1);

1255

1449

#else

1256

gtk_widget_set_usize (add_type_cm, 63, -1);

1450

gtk_widget_set_usize (add_type_cm, 83, -1);

1257

1451

#endif

1258

1452

add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING);

1259

1453

1260

/* XXX - DEcomment only when WPA and WPA2 will be ready */

1261

1262

add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_KEY_STRING);

1263

add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA2_KEY_STRING);*/

1454

/* XXX - DEcomment only when WPA and WPA_BIN will be ready */

1455

#ifdef HAVE_AIRPDCAP

1456

add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING);

1457

add_type_cm_items = g_list_append (add_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING);

1458

#endif

1264

1459

gtk_combo_set_popdown_strings (GTK_COMBO (add_type_cm),

1265

1460

add_type_cm_items);

1266

1461

g_list_free (add_type_cm_items);

1285

1480

add_ssid_te = gtk_entry_new ();

1286

1481

gtk_widget_set_name (add_ssid_te, "add_ssid_te");

1287

1482

gtk_widget_set_sensitive(add_ssid_te,FALSE);

1288

/* XXX - Decomment only when WPA and WPA2 will be ready */

1289

/* gtk_widget_show (add_ssid_te); */

1483

/* XXX - Decomment only when WPA and WPA_BIN will be ready */

1484

gtk_widget_show (add_ssid_te);

1290

1485

gtk_table_attach (GTK_TABLE (add_tb), add_ssid_te, 2, 3, 1, 2,

1291

1486

(GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);

1292

1487

1300

1495

1301

1496

add_key_lb = gtk_label_new ("Key");

1302

1497

gtk_widget_set_name (add_key_lb, "add_key_lb");

1303

gtk_widget_show (add_key_lb);

1498

gtk_widget_show (add_key_lb);

1304

1499

gtk_table_attach (GTK_TABLE (add_tb), add_key_lb, 1, 2, 0, 1,

1305

1500

(GtkAttachOptions) (GTK_FILL),

1306

1501

(GtkAttachOptions) (0), 0, 0);

1307

1502

gtk_label_set_justify (GTK_LABEL (add_key_lb), GTK_JUSTIFY_CENTER);

1308

1503

1309

add_ssid_lb = gtk_label_new ("SSID");

1504

add_ssid_lb = gtk_label_new ("");

1310

1505

gtk_widget_set_name (add_ssid_lb, "add_ssid_lb");

1311

/* XXX - Decomment only when WPA and WPA2 will be ready */

1312

/* gtk_widget_show (add_ssid_lb); */

1506

/* XXX - Decomment only when WPA and WPA_BIN will be ready */

1507

gtk_widget_show (add_ssid_lb);

1313

1508

gtk_table_attach (GTK_TABLE (add_tb), add_ssid_lb, 2, 3, 0, 1,

1314

1509

(GtkAttachOptions) (GTK_FILL),

1315

1510

(GtkAttachOptions) (0), 0, 0);

1324

1519

GTK_BUTTONBOX_END);

1325

1520

1326

1521

#if GTK_MAJOR_VERISON >= 2

1327

ok_bt = gtk_button_new_with_mnemonic ("Ok");

1522

ok_bt = gtk_button_new_with_mnemonic ("OK");

1328

1523

#else

1329

ok_bt = gtk_button_new_with_label ("Ok");

1524

ok_bt = gtk_button_new_with_label ("OK");

1330

1525

#endif

1331

1526

gtk_widget_set_name (ok_bt, "ok_bt");

1332

1527

gtk_widget_show (ok_bt);

1354

1549

#endif

1355

1550

1356

1551

/* Add callbacks */

1357

SIGNAL_CONNECT(ok_bt, "clicked", add_key, add_key_window );

1552

SIGNAL_CONNECT(ok_bt, "clicked", on_add_key_ok_bt_clicked, add_key_window );

1358

1553

SIGNAL_CONNECT(cancel_bt, "clicked", window_cancel_button_cb, add_key_window );

1359

1554

SIGNAL_CONNECT(add_type_en, "changed",on_add_type_en_changed, add_key_window);

1360

1555

SIGNAL_CONNECT(add_key_window, "delete_event",window_delete_event_cb, add_key_window);

1366

1561

OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_TYPE_KEY,add_type_cm);

1367

1562

OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_KEY,add_key_te);

1368

1563

OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_KEY,add_ssid_te);

1564

OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_KEY_LABEL_KEY,add_key_lb);

1565

OBJECT_SET_DATA(add_key_window,AIRPCAP_ADVANCED_ADD_KEY_SSID_LABEL_KEY,add_ssid_lb);

1369

1566

1370

1567

gtk_widget_show(add_key_window);

1371

1568

}

1431

1628

key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);

1432

1629

selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);

1433

1630

1434

1435

* Better to store the selected_item data in two new variables, because maybe some

1631

1632

* Better to store the selected_item data in two new variables, because maybe some

1436

1633

* select_row signal will be emitted somewhere...

1437

1634

1438

1635

r = selected_item->row;

1450

1647

if( r < (keys_in_list-1) )

1451

1648

gtk_clist_select_row(GTK_CLIST(key_ls),r,c);

1452

1649

else

1453

gtk_clist_select_row(GTK_CLIST(key_ls),r-1,c);

1650

gtk_clist_select_row(GTK_CLIST(key_ls),r-1,c);

1454

1651

1455

1652

/* Need to save config... */

1456

airpcap_if_selected->saved = FALSE;

1653

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

1457

1654

}

1458

1655

1459

1656

1511

1708

gtk_clist_get_text(GTK_CLIST(key_ls),r,0,&row_type);

1512

1709

gtk_clist_get_text(GTK_CLIST(key_ls),r,1,&row_key);

1513

1710

gtk_clist_get_text(GTK_CLIST(key_ls),r,2,&row_ssid);

1514

1711

1515

1712

/* Gray out the Advanced Wireless Setting window */

1516

1713

gtk_widget_set_sensitive(airpcap_advanced_w,FALSE);

1517

1518

/* Pop-up a new window */

1714

1715

/* Pop-up a new window */

1519

1716

edit_key_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

1520

1717

gtk_widget_set_name (edit_key_window, "edit_key_window");

1521

1718

gtk_container_set_border_width (GTK_CONTAINER (edit_key_window), 5);

1525

1722

#else

1526

1723

gtk_window_set_policy(GTK_WINDOW(edit_key_window), FALSE, FALSE, TRUE);

1527

1724

#endif

1528

1725

1529

1726

main_v_box = gtk_vbox_new (FALSE, 0);

1530

1727

gtk_widget_set_name (main_v_box, "main_v_box");

1531

1728

gtk_widget_show (main_v_box);

1532

1729

gtk_container_add (GTK_CONTAINER (edit_key_window), main_v_box);

1533

1730

1534

1731

edit_frame = gtk_frame_new (NULL);

1535

1732

gtk_widget_set_name (edit_frame, "edit_frame");

1536

1733

gtk_widget_show (edit_frame);

1537

1734

gtk_box_pack_start (GTK_BOX (main_v_box), edit_frame, TRUE, TRUE, 0);

1538

1735

1539

1736

edit_frame_al = gtk_alignment_new (0.5, 0.5, 1, 1);

1540

1737

gtk_widget_set_name (edit_frame_al, "edit_frame_al");

1541

1738

gtk_widget_show (edit_frame_al);

1545

1742

#else

1546

1743

gtk_alignment_set (GTK_ALIGNMENT (edit_frame_al), 0, 0, 12, 0);

1547

1744

#endif

1548

1745

1549

1746

edit_tb = gtk_table_new (2, 3, FALSE);

1550

1747

gtk_widget_set_name (edit_tb, "edit_tb");

1551

1748

gtk_container_set_border_width(GTK_CONTAINER(edit_tb),5);

1552

1749

gtk_widget_show (edit_tb);

1553

1750

gtk_container_add (GTK_CONTAINER (edit_frame_al), edit_tb);

1554

1751

1555

1752

edit_type_cm = gtk_combo_new ();

1556

1753

gtk_widget_set_name (edit_type_cm, "edit_type_cm");

1557

1754

gtk_widget_show (edit_type_cm);

1559

1756

(GtkAttachOptions) (GTK_FILL),

1560

1757

(GtkAttachOptions) (0), 0, 0);

1561

1758

#if GTK_MAJOR_VERSION >= 2

1562

gtk_widget_set_size_request (edit_type_cm, 63, -1);

1759

gtk_widget_set_size_request (edit_type_cm, 83, -1);

1563

1760

#else

1564

gtk_widget_set_usize (edit_type_cm, 63, -1);

1761

gtk_widget_set_usize (edit_type_cm, 83, -1);

1565

1762

#endif

1566

1763

edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WEP_KEY_STRING);

1567

/* XXX - Decomment only when WPA and WPA2 support will be ready!!! */

1568

/* edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_KEY_STRING);

1569

edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA2_KEY_STRING);*/

1764

/* XXX - Decomment only when WPA and WPA_BIN support will be ready!!! */

1765

#ifdef HAVE_AIRPDCAP

1766

edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_PWD_KEY_STRING);

1767

edit_type_cm_items = g_list_append (edit_type_cm_items, (gpointer) AIRPCAP_WPA_BIN_KEY_STRING);

1768

#endif

1570

1769

gtk_combo_set_popdown_strings (GTK_COMBO (edit_type_cm),

1571

1770

edit_type_cm_items);

1572

1771

g_list_free (edit_type_cm_items);

1573

1772

1574

1773

edit_type_en = GTK_COMBO (edit_type_cm)->entry;

1575

1774

gtk_widget_set_name (edit_type_en, "edit_type_en");

1576

1775

/* Set current type */

1577

1776

gtk_entry_set_text(GTK_ENTRY(edit_type_en),row_type);

1578

1777

gtk_editable_set_editable (GTK_EDITABLE (edit_type_en), FALSE);

1579

1778

gtk_widget_show (edit_type_en);

1580

1779

1581

1780

edit_key_te = gtk_entry_new ();

1582

1781

gtk_widget_set_name (edit_key_te, "edit_key_te");

1583

1782

/* Set current key */

1590

1789

#else

1591

1790

gtk_widget_set_usize (edit_key_te, 178, -1);

1592

1791

#endif

1593

1792

1594

1793

edit_ssid_te = gtk_entry_new ();

1595

1794

gtk_widget_set_name (edit_ssid_te, "edit_ssid_te");

1596

1795

1604

1803

gtk_widget_set_sensitive(edit_ssid_te,TRUE);

1605

1804

gtk_entry_set_text(GTK_ENTRY(edit_ssid_te),row_ssid);

1606

1805

}

1607

1806

1608

1807

/* XXX - Decomment only when WPA and WPA@ will be ready */

1609

/* gtk_widget_show (edit_ssid_te); */

1808

#ifdef HAVE_AIRPDCAP

1809

gtk_widget_show (edit_ssid_te);

1810

#endif

1610

1811

gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_te, 2, 3, 1, 2,

1611

1812

(GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0);

1612

1813

1613

1814

edit_type_lb = gtk_label_new ("Type");

1614

1815

gtk_widget_set_name (edit_type_lb, "edit_type_lb");

1615

1816

gtk_widget_show (edit_type_lb);

1617

1818

(GtkAttachOptions) (GTK_FILL),

1618

1819

(GtkAttachOptions) (0), 0, 0);

1619

1820

gtk_label_set_justify (GTK_LABEL (edit_type_lb), GTK_JUSTIFY_CENTER);

1620

1821

1621

1822

edit_key_lb = gtk_label_new ("Key");

1622

1823

gtk_widget_set_name (edit_key_lb, "edit_key_lb");

1623

1824

gtk_widget_show (edit_key_lb);

1625

1826

(GtkAttachOptions) (GTK_FILL),

1626

1827

(GtkAttachOptions) (0), 0, 0);

1627

1828

gtk_label_set_justify (GTK_LABEL (edit_key_lb), GTK_JUSTIFY_CENTER);

1628

1629

edit_ssid_lb = gtk_label_new ("SSID");

1829

1830

edit_ssid_lb = gtk_label_new ("");

1630

1831

gtk_widget_set_name (edit_ssid_lb, "edit_ssid_lb");

1631

/* XXX - Decomment only when WPA and WPA2 will be ready */

1632

/* gtk_widget_show (edit_ssid_lb); */

1832

/* XXX - Decomment only when WPA and WPA_BIN will be ready */

1833

gtk_widget_show (edit_ssid_lb);

1633

1834

gtk_table_attach (GTK_TABLE (edit_tb), edit_ssid_lb, 2, 3, 0, 1,

1634

1835

(GtkAttachOptions) (GTK_FILL),

1635

1836

(GtkAttachOptions) (0), 0, 0);

1636

1837

gtk_label_set_justify (GTK_LABEL (edit_ssid_lb), GTK_JUSTIFY_CENTER);

1637

1838

1638

1839

low_h_button_box = gtk_hbutton_box_new ();

1639

1840

gtk_widget_set_name (low_h_button_box, "low_h_button_box");

1640

1841

gtk_container_set_border_width (GTK_CONTAINER (low_h_button_box), 5);

1642

1843

gtk_box_pack_end (GTK_BOX (main_v_box), low_h_button_box, FALSE, FALSE, 0);

1643

1844

gtk_button_box_set_layout (GTK_BUTTON_BOX (low_h_button_box),

1644

1845

GTK_BUTTONBOX_END);

1645

1846

1646

1847

#if GTK_MAJOR_VERISON >= 2

1647

ok_bt = gtk_button_new_with_mnemonic ("Ok");

1848

ok_bt = gtk_button_new_with_mnemonic ("OK");

1648

1849

#else

1649

ok_bt = gtk_button_new_with_label ("Ok");

1850

ok_bt = gtk_button_new_with_label ("OK");

1650

1851

#endif

1651

1852

gtk_widget_set_name (ok_bt, "ok_bt");

1652

1853

gtk_widget_show (ok_bt);

1653

1854

gtk_container_add (GTK_CONTAINER (low_h_button_box), ok_bt);

1654

1855

GTK_WIDGET_SET_FLAGS (ok_bt, GTK_CAN_DEFAULT);

1655

1856

1656

1857

#if GTK_MAJOR_VERISON >= 2

1657

1858

cancel_bt = gtk_button_new_with_mnemonic ("Cancel");

1658

1859

#else

1662

1863

gtk_widget_show (cancel_bt);

1663

1864

gtk_container_add (GTK_CONTAINER (low_h_button_box), cancel_bt);

1664

1865

GTK_WIDGET_SET_FLAGS (cancel_bt, GTK_CAN_DEFAULT);

1665

1866

1666

1867

edit_frame_lb = gtk_label_new ("<b>Modify Selected Key</b>");

1667

1868

gtk_widget_set_name (edit_frame_lb, "edit_frame_lb");

1668

1869

gtk_widget_show (edit_frame_lb);

1672

1873

#else

1673

1874

gtk_frame_set_label (GTK_FRAME (edit_frame), "Modify Selected Key");

1674

1875

#endif

1675

1876

1676

1877

/* Add callbacks */

1677

1878

SIGNAL_CONNECT(ok_bt, "clicked", on_edit_key_ok_bt_clicked, edit_key_window );

1678

1879

SIGNAL_CONNECT(cancel_bt, "clicked", window_cancel_button_cb, edit_key_window );

1679

1880

SIGNAL_CONNECT(edit_type_en, "changed",on_edit_type_en_changed, edit_key_window);

1680

1881

SIGNAL_CONNECT(edit_key_window, "delete_event",window_delete_event_cb, edit_key_window);

1681

1882

SIGNAL_CONNECT(edit_key_window, "destroy",on_edit_key_w_destroy, data);

1682

1883

1683

1884

/* Add widget data */

1684

1885

OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_LIST_KEY,key_ls);

1685

1886

OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SELECTED_KEY,selected_item);

1686

1887

OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_TYPE_KEY,edit_type_cm);

1687

1888

OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_KEY,edit_key_te);

1688

1889

OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_KEY,edit_ssid_te);

1689

1890

OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_KEY_LABEL_KEY,edit_key_lb);

1891

OBJECT_SET_DATA(edit_key_window,AIRPCAP_ADVANCED_EDIT_KEY_SSID_LABEL_KEY,edit_ssid_lb);

1892

1690

1893

gtk_widget_show(edit_key_window);

1691

1894

}

1692

1895

}

1715

1918

key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);

1716

1919

selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);

1717

1920

1718

1719

* Better to store the selected_item data in two new variables, because maybe some

1921

1922

* Better to store the selected_item data in two new variables, because maybe some

1720

1923

* select_row signal will be emitted somewhere...

1721

1924

1722

1925

r = selected_item->row;

1733

1936

/* Move up selected key */

1734

1937

gtk_clist_swap_rows (GTK_CLIST(key_ls),r-1,r);

1735

1938

1736

1939

1737

1940

* Re-select the just moved key... so the user can keep pressing 'Move Key Up'

1738

1941

* without re-select the row...

1739

1942

1740

1943

gtk_clist_select_row (GTK_CLIST(key_ls),r-1,c);

1741

1944

1742

1945

/* Need to save config... */

1743

airpcap_if_selected->saved = FALSE;

1946

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

1744

1947

}

1745

1948

1746

1949

1767

1970

key_ls = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_KEYLIST_KEY);

1768

1971

selected_item = OBJECT_GET_DATA(airpcap_advanced_w,AIRPCAP_ADVANCED_SELECTED_KEY_LIST_ITEM_KEY);

1769

1972

1770

1771

* Better to store the selected_item data in two new variables, because maybe some

1973

1974

* Better to store the selected_item data in two new variables, because maybe some

1772

1975

* select_row signal will be emitted somewhere...

1773

1976

1774

1977

r = selected_item->row;

1785

1988

/* Move down selected key */

1786

1989

gtk_clist_swap_rows (GTK_CLIST(key_ls),r,r+1);

1787

1990

1788

1991

1789

1992

* Re-select the just moved key... so the user can keep pressing 'Move Key Down'

1790

1993

* without re-select the row...

1791

1994

1792

1995

gtk_clist_select_row (GTK_CLIST(key_ls),r+1,c);

1793

1996

1794

1997

/* Need to save config... */

1795

airpcap_if_selected->saved = FALSE;

1998

if(airpcap_if_selected != NULL) airpcap_if_selected->saved = FALSE;

1796

1999

}

1797

2000

1798

2001

/* Turns the decryption on or off */

1805

2008

1806

2009

decryption_en = GTK_ENTRY(w);

1807

2010

2011

2012

* This callback is called twice: when the current text is canceled ("")

2013

* and then when the 'new text' is added ("new text"). We don't really

2014

* care about the first time, and we just return.

2015

2016

if(g_strcasecmp(gtk_entry_get_text(decryption_en),"") == 0)

2017

return;

2018

1808

2019

if(g_strcasecmp(gtk_entry_get_text(decryption_en),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK) == 0)

1809

2020

{

1810

2021

set_wireshark_decryption(TRUE);

1831

2042

void

1832

2043

update_decryption_mode_cm(GtkWidget *w)

1833

2044

{

1834

/* Wireshark decryption is on */

2045

2046

* This ensures that the entry tet changes... the callback will return immediately, but

2047

* at least next time packets will be redissected...

2048

2049

gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),"");

2050

2051

/* Wireshark decryption is on */

1835

2052

if(wireshark_decryption_on())

1836

2053

{

1837

2054

gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);

1848

2065

{

1849

2066

gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(w)->entry),AIRPCAP_DECRYPTION_TYPE_STRING_NONE);

1850

2067

}

1851

return;

2068

2069

return;

2070

}

2071

2072

2073

* Creates the list of available decryption modes, depending on the adapters found

2074

2075

void

2076

update_decryption_mode_list(GtkWidget *w)

2077

{

2078

GList *enable_decryption_cb_items = NULL;

2079

GtkWidget *entry;

2080

gchar *current_text;

2081

2082

if(w == NULL)

2083

return;

2084

2085

entry = GTK_COMBO(w)->entry;

2086

current_text = NULL;

2087

2088

2089

* XXX - Retrieve the current 'decryption mode'. It would be better just block the

2090

* signal handler, but it doesn't work... one of these days I'll try to figure otu why...

2091

2092

current_text = g_strdup(gtk_entry_get_text(GTK_ENTRY(entry)));

2093

2094

enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_NONE);

2095

enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);

2096

2097

if(airpcap_if_list != NULL)

2098

{

2099

enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);

2100

}

2101

else

2102

{

2103

/* The last decryption mode was 'Driver', but no more AirPcap adapter are found */

2104

if(g_strcasecmp(current_text,AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP) == 0)

2105

{

2106

if(current_text != NULL) g_free(current_text);

2107

2108

current_text = g_strdup(AIRPCAP_DECRYPTION_TYPE_STRING_NONE);

2109

}

2110

}

2111

2112

gtk_signal_handler_block_by_data(GTK_OBJECT(entry),(gpointer)airpcap_tb);

2113

gtk_combo_set_popdown_strings (GTK_COMBO (w), enable_decryption_cb_items);

2114

/* The 'changed' callback will be called twice */

2115

gtk_entry_set_text(GTK_ENTRY(entry),current_text);

2116

gtk_signal_handler_unblock_by_data(GTK_OBJECT(entry),(gpointer)airpcap_tb);

2117

2118

if(current_text != NULL) g_free(current_text);

2119

2120

g_list_free (enable_decryption_cb_items);

1852

2121

}

1853

2122

1854

2123

/* Called to create the airpcap settings' window */

1927

2196

"Advanced Wireless Settings");

1928

2197

gtk_window_set_position (GTK_WINDOW (airpcap_advanced_w),

1929

2198

GTK_WIN_POS_CENTER);

1930

2199

1931

2200

#if GTK_MAJOR_VERSION >= 2

1932

2201

gtk_window_set_resizable (GTK_WINDOW (airpcap_advanced_w), FALSE);

1933

2202

gtk_window_set_type_hint (GTK_WINDOW (airpcap_advanced_w), GDK_WINDOW_TYPE_HINT_DIALOG);

1978

2247

interface_name_lb = gtk_label_new("No airpcap interface found!");

1979

2248

gtk_widget_set_sensitive(main_box,FALSE);

1980

2249

}

1981

2250

1982

2251

gtk_widget_set_name (interface_name_lb, "interface_name_lb");

1983

2252

gtk_widget_show (interface_name_lb);

1984

2253

gtk_box_pack_start (GTK_BOX (interface_sub_h_box), interface_name_lb, TRUE,

2013

2282

gtk_label_set_use_markup (GTK_LABEL (interface_frame_lb), TRUE);

2014

2283

#else

2015

2284

gtk_frame_set_label(GTK_FRAME(interface_fr),"Interface");

2016

#endif

2285

#endif

2017

2286

2018

2287

basic_parameters_fr = gtk_frame_new (NULL);

2019

2288

gtk_widget_set_name (basic_parameters_fr, "basic_parameters_fr");

2082

2351

{

2083

2352

airpcap_update_channel_combo(GTK_WIDGET(channel_cm), airpcap_if_selected);

2084

2353

}

2085

2354

2086

2355

g_list_free (channel_cm_items);

2087

2356

2088

2357

channel_en = GTK_COMBO (channel_cm)->entry;

2102

2371

g_list_append (capture_type_cm_items, (gpointer) AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);

2103

2372

gtk_combo_set_popdown_strings (GTK_COMBO (capture_type_cm),

2104

2373

capture_type_cm_items);

2105

2374

2106

2375

/* Current interface value */

2107

2376

capture_s = NULL;

2108

2377

if(airpcap_if_selected != NULL)

2110

2379

if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11)

2111

2380

capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_ONLY);

2112

2381

else if(airpcap_if_selected->linkType == AIRPCAP_LT_802_11_PLUS_RADIO)

2113

capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);

2382

capture_s = g_strdup_printf("%s",AIRPCAP_LINK_TYPE_NAME_802_11_PLUS_RADIO);

2114

2383

if(capture_s != NULL) gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(capture_type_cm)->entry), capture_s);

2115

2384

}

2116

2385

g_free(capture_s);

2136

2405

else

2137

2406

gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(fcs_ck),FALSE);

2138

2407

}

2139

2408

2140

2409

gtk_widget_show (fcs_ck);

2141

2410

gtk_table_attach (GTK_TABLE (basic_parameters_tb), fcs_ck, 2, 3, 0, 1,

2142

2411

(GtkAttachOptions) (GTK_FILL),

2185

2454

{

2186

2455

airpcap_validation_type_combo_set_by_type(fcs_filter_cm,airpcap_if_selected->CrcValidationOn);

2187

2456

}

2188

2457

2189

2458

gtk_widget_show (fcs_filter_en);

2190

2459

2191

2460

basic_parameters_frame_lb = gtk_label_new ("<b>Basic Parameters</b>");

2350

2619

if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)

2351

2620

{

2352

2621

gtk_label_set_text(GTK_LABEL(toolbar_if_lb), g_strdup_printf("%s %s\t","Current Wireless Interface: #",airpcap_get_if_string_number(airpcap_if_selected)));

2353

2622

2354

2623

airpcap_update_channel_combo(GTK_WIDGET(toolbar_channel_cm),airpcap_if_selected);

2355

2624

2356

2625

airpcap_validation_type_combo_set_by_type(toolbar_wrong_crc_cm,airpcap_if_selected->CrcValidationOn);

2357

2626

}

2358

2627

2473

2742

GtkWidget *ok_bt;

2474

2743

GtkWidget *apply_bt;

2475

2744

GtkWidget *cancel_bt;

2476

2745

2477

2746

/* widgets in the toolbar */

2478

2747

GtkWidget *toolbar,

2479

2748

*toolbar_decryption_ck;

2481

2750

/* other stuff */

2482

2751

/*GList *channel_list,*capture_list;*/

2483

2752

GList *linktype_list = NULL;

2484

2753

2485

2754

/* Selected row/column structure */

2486

2755

airpcap_key_ls_selected_info_t *key_ls_selected_item;

2487

2756

key_ls_selected_item = (airpcap_key_ls_selected_info_t*)g_malloc(sizeof(airpcap_key_ls_selected_info_t));

2507

2776

/* Create the new window */

2508

2777

key_management_w = window_new(GTK_WINDOW_TOPLEVEL, "Decryption Keys Management");

2509

2778

2510

2511

2779

gtk_container_set_border_width (GTK_CONTAINER (key_management_w), 5);

2512

2780

gtk_window_set_title (GTK_WINDOW (key_management_w),

2513

2781

"Decryption Keys Management");

2514

2782

gtk_window_set_position (GTK_WINDOW (key_management_w),

2515

2783

GTK_WIN_POS_CENTER);

2516

2784

2517

2785

#if GTK_MAJOR_VERSION >= 2

2518

2786

gtk_window_set_resizable (GTK_WINDOW (key_management_w), FALSE);

2519

2787

gtk_window_set_type_hint (GTK_WINDOW (key_management_w), GDK_WINDOW_TYPE_HINT_DIALOG);

2575

2843

#else

2576

2844

gtk_widget_set_usize (enable_decryption_cb, 83, -1);

2577

2845

#endif

2578

enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_NONE);

2579

enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_WIRESHARK);

2580

enable_decryption_cb_items = g_list_append (enable_decryption_cb_items, AIRPCAP_DECRYPTION_TYPE_STRING_AIRPCAP);

2581

gtk_combo_set_popdown_strings (GTK_COMBO (enable_decryption_cb), enable_decryption_cb_items);

2582

g_list_free (enable_decryption_cb_items);

2846

update_decryption_mode_list(enable_decryption_cb);

2583

2847

2584

2848

enable_decryption_en = GTK_COMBO (enable_decryption_cb)->entry;

2585

2849

gtk_widget_set_name (enable_decryption_en, "enable_decryption_en");

2602

2866

0);

2603

2867

gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (keys_scrolled_w), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

2604

2868

2869

#ifdef HAVE_AIRPDCAP

2605

2870

key_ls = gtk_clist_new (3);

2871

#else

2872

key_ls = gtk_clist_new (2);

2873

#endif

2874

2606

2875

gtk_widget_set_name (key_ls, "key_ls");

2607

2876

gtk_widget_show (key_ls);

2608

2877

2609

2878

gtk_container_add (GTK_CONTAINER (keys_scrolled_w), key_ls);

2610

2879

gtk_clist_set_column_width (GTK_CLIST (key_ls), 0, 54);

2611

2880

gtk_clist_set_column_width (GTK_CLIST (key_ls), 1, 113);

2881

#ifdef HAVE_AIRPDCAP

2612

2882

gtk_clist_set_column_width (GTK_CLIST (key_ls), 2, 80);

2883

#endif

2613

2884

gtk_clist_column_titles_show (GTK_CLIST (key_ls));

2614

2885

gtk_clist_set_shadow_type (GTK_CLIST (key_ls), GTK_SHADOW_ETCHED_IN);

2615

2886

gtk_clist_set_column_justification(GTK_CLIST (key_ls),0,GTK_JUSTIFY_CENTER);

2627

2898

gtk_clist_set_column_widget (GTK_CLIST (key_ls), 1,

2628

2899

key_list_decryption_key_col_lb);

2629

2900

2901

#ifdef HAVE_AIRPDCAP

2630

2902

key_ls_decryption_ssid_col_lb = gtk_label_new ("SSID");

2631

2903

gtk_widget_set_name (key_ls_decryption_ssid_col_lb,

2632

2904

"key_ls_decryption_ssid_col_lb");

2633

2905

gtk_widget_show (key_ls_decryption_ssid_col_lb);

2634

2906

gtk_clist_set_column_widget (GTK_CLIST (key_ls), 2,

2635

2907

key_ls_decryption_ssid_col_lb);

2908

#endif

2636

2909

2637

/* XXX - USED ONLY BECAUSE WPA and WPA2 are note ready YET... */

2638

gtk_clist_set_column_visibility(GTK_CLIST (key_ls), 2, FALSE);

2639

2910

2640

2911

key_v_button_box = gtk_vbutton_box_new ();

2641

2912

gtk_widget_set_name (key_v_button_box, "key_v_button_box");

2721

2992

/* Connect the callbacks */

2722

2993

SIGNAL_CONNECT (key_management_w, "delete_event", window_delete_event_cb, key_management_w);

2723

2994

SIGNAL_CONNECT (key_management_w, "destroy", on_key_management_destroy, key_management_w);

2724

/*SIGNAL_CONNECT (enable_decryption_en, "changed",on_enable_decryption_en_changed, toolbar);*/

2725

2995

SIGNAL_CONNECT (add_new_key_bt, "clicked",on_add_new_key_bt_clicked, key_management_w);

2726

2996

SIGNAL_CONNECT (remove_key_bt, "clicked",on_remove_key_bt_clicked, key_management_w);

2727

2997

SIGNAL_CONNECT (edit_key_bt, "clicked",on_edit_key_bt_clicked, key_management_w);

2755

3025

OBJECT_SET_DATA (key_management_w, AIRPCAP_TOOLBAR_DECRYPTION_KEY, toolbar_decryption_ck);

2756

3026

2757

3027

/* FIRST OF ALL, CHECK THE KEY COLLECTIONS */

2758

2759

* This will read the decryption keys from the preferences file, and will store

2760

* them into the registry...

3028

3029

* This will read the decryption keys from the preferences file, and will store

3030

* them into the registry...

2761

3031

2762

3032

if(!airpcap_check_decryption_keys(airpcap_if_list))

2763

3033

{

2769

3039

airpcap_load_decryption_keys(airpcap_if_list);

2770

3040

airpcap_fill_key_list(key_ls);

2771

3041

/* At the end, so that it appears completely all together ... */

2772

gtk_widget_show (key_management_w);

3042

gtk_widget_show (key_management_w);

2773

3043

}

2774

3044

}

2775

3045

2817

3087

}

2818

3088

2819

3089

/* Save the configuration */

2820

if( (airpcap_if_selected != NULL) )

2821

{

2822

3090

airpcap_read_and_save_decryption_keys_from_clist(key_ls,airpcap_if_selected,airpcap_if_list); /* This will save the keys for every adapter */

2823

2824

/* Update toolbar (only if airpcap_if_selected is airpcap_if_active)*/

2825

if( g_strcasecmp(airpcap_if_selected->description,airpcap_if_active->description) == 0)

2826

{

3091

3092

/* The update will make redissect al the packets... no need to do it here again */

2827

3093

update_decryption_mode_cm(toolbar_cm);

2828

}

2829

}

2830

3094

2831

3095

/* Redissect all the packets, and re-evaluate the display filter. */

2832

cf_redissect_packets(&cfile);

3096

//cf_redissect_packets(&cfile);

2833

3097

2834

3098

/* Save the preferences to preferences file!!! */

2835

3099

write_prefs_to_file();

2836

3100

2837

3101

/* If interface active is airpcap, set sensitive TRUE for airpcap toolbar */

3102

if(airpcap_if_list != NULL)

3103

{

3104

if(airpcap_if_active != NULL)

3105

{

2838

3106

if( get_airpcap_if_by_name(airpcap_if_list,airpcap_if_active->description) != NULL)

2839

3107

{

2840

3108

airpcap_set_toolbar_start_capture(airpcap_if_active);

2843

3111

{

2844

3112

airpcap_set_toolbar_stop_capture(airpcap_if_active);

2845

3113

}

3114

}

3115

}

2846

3116

2847

3117

gtk_widget_destroy(key_management_w);

2848

3118

}

2865

3135

GtkWidget *toolbar,

2866

3136

*toolbar_decryption_ck,

2867

3137

*key_management_bt;

2868

3138

2869

3139

/* Row selected structure */

2870

3140

airpcap_key_ls_selected_info_t *selected_item;

2871

3141

2890

3160

}

2891

3161

2892

3162

2893

* Dialog box that appears whenever keys are not consistent between wireshark and AirPcap

3163

* Dialog box that appears whenever keys are not consistent between wireshark and AirPcap

2894

3164

2895

3165

void

2896

3166

airpcap_keys_check_w(GtkWidget *w, gpointer data)

3061

3331

GTK_BUTTONBOX_SPREAD);

3062

3332

3063

3333

#if GTK_MAJOR_VERSION >= 2

3064

ok_bt = gtk_button_new_with_mnemonic ("Ok");

3334

ok_bt = gtk_button_new_with_mnemonic ("OK");

3065

3335

#else

3066

ok_bt = gtk_button_new_with_label ("Ok");

3336

ok_bt = gtk_button_new_with_label ("OK");

3067

3337

#endif

3068

3338

gtk_widget_set_name (ok_bt, "ok_bt");

3069

3339

gtk_widget_show (ok_bt);

3108

3378

3109

3379

key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);

3110

3380

3111

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3381

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3112

3382

and is not NULL if it was called when the Key Management widget has been clicked */

3113

3383

if(key_management_w != NULL)

3114

3384

{

3193

3463

3194

3464

/* Free the memory */

3195

3465

free_key_list(wireshark_keys);

3196

free_key_list(merged_keys);

3197

3466

3198

3467

/* Close the window */

3199

3468

gtk_widget_destroy(keys_check_w);

3200

3469

3201

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3470

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3202

3471

and is not NULL if it was called when the Key Management widget has been clicked */

3203

3472

if(key_management_w != NULL)

3204

3473

{

3259

3528

current_adapter_keys = get_airpcap_device_keys(curr_adapter);

3260

3529

n_curr_adapter_keys = g_list_length(current_adapter_keys);

3261

3530

3262

merged_list_tmp = merged_list;

3263

merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);

3531

merged_list_tmp = merged_list;

3532

merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);

3264

3533

free_key_list(merged_list_tmp);

3265

3266

n_total_keys += n_curr_adapter_keys;

3534

3535

n_total_keys += n_curr_adapter_keys;

3267

3536

}

3268

3537

3269

3538

n_merged_keys = g_list_length(merged_list);

3279

3548

3280

3549

gtk_widget_destroy(keys_check_w);

3281

3550

3282

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3551

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3283

3552

and is not NULL if it was called when the Key Management widget has been clicked */

3284

3553

if(key_management_w != NULL)

3285

3554

{

3338

3607

current_adapter_keys = get_airpcap_device_keys(curr_adapter);

3339

3608

n_curr_adapter_keys = g_list_length(current_adapter_keys);

3340

3609

3341

merged_list_tmp = merged_list;

3342

merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);

3610

merged_list_tmp = merged_list;

3611

merged_list = merge_key_list(merged_list_tmp,current_adapter_keys);

3343

3612

free_key_list(merged_list_tmp);

3344

3345

n_total_keys += n_curr_adapter_keys;

3613

3614

n_total_keys += n_curr_adapter_keys;

3346

3615

}

3347

3616

3348

3617

n_merged_keys = g_list_length(merged_list);

3358

3627

3359

3628

gtk_widget_destroy(keys_check_w);

3360

3629

3361

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3630

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3362

3631

and is not NULL if it was called when the Key Management widget has been clicked */

3363

3632

if(key_management_w != NULL)

3364

3633

{

3381

3650

3382

3651

key_management_w = OBJECT_GET_DATA(keys_check_w,AIRPCAP_CHECK_WINDOW_KEY);

3383

3652

3384

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3653

/* w may be NULL if airpcap_keys_check_w() has been called while wireshark was loading,

3385

3654

and is not NULL if it was called when the Key Management widget has been clicked */

3386

3655

if(key_management_w != NULL)

3387

3656

{

Older »