*/
#include <assert.h>
+#include <stdarg.h>
#include <ctype.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#endif
#include "putty.h"
+#include "storage.h"
#include "dialog.h"
#include "tree234.h"
dp->byctrl = newtree234(uctrl_cmp_byctrl);
dp->bywidget = newtree234(uctrl_cmp_bywidget);
dp->coloursel_result.ok = FALSE;
+ dp->treeitems = NULL;
+ dp->window = dp->cancelbutton = dp->currtreeitem = NULL;
}
static void dlg_cleanup(struct dlgparam *dp)
{
struct dlgparam *dp = (struct dlgparam *)dlg;
struct uctrl *uc = dlg_find_byctrl(dp, ctrl);
+ /*
+ * This is an internal allocation routine, so it's allowed to
+ * use smalloc directly.
+ */
uc->privdata = smalloc(size);
uc->privdata_needs_free = FALSE;
return uc->privdata;
void dlg_listbox_add(union control *ctrl, void *dlg, char const *text)
{
- dlg_listbox_addwithindex(ctrl, dlg, text, 0);
+ dlg_listbox_addwithid(ctrl, dlg, text, 0);
}
/*
* strings in any listbox then you MUST not assign them different
* IDs and expect to get meaningful results back.
*/
-void dlg_listbox_addwithindex(union control *ctrl, void *dlg,
- char const *text, int id)
+void dlg_listbox_addwithid(union control *ctrl, void *dlg,
+ char const *text, int id)
{
struct dlgparam *dp = (struct dlgparam *)dlg;
struct uctrl *uc = dlg_find_byctrl(dp, ctrl);
assert(ncols <=
(uc->ctrl->listbox.ncols ? uc->ctrl->listbox.ncols : 1));
- percents = smalloc(ncols * sizeof(gint));
+ percents = snewn(ncols, gint);
percents[ncols-1] = 100;
for (i = 0; i < ncols-1; i++) {
percents[i] = uc->ctrl->listbox.percentages[i];
{
struct dlgparam *dp = (struct dlgparam *)dlg;
dp->retval = value;
- gtk_main_quit();
+ gtk_widget_destroy(dp->window);
}
void dlg_refresh(union control *ctrl, void *dlg)
event->keyval==GDK_Page_Up || event->keyval==GDK_KP_Page_Up)
? 2 : 1;
int i, n;
- GtkWidget *thisitem;
GList *children, *chead;
chead = children = gtk_container_children(GTK_CONTAINER(list));
static int listitem_single_key(GtkWidget *item, GdkEventKey *event,
gpointer data)
{
- listitem_key(item, event, data, FALSE);
+ return listitem_key(item, event, data, FALSE);
}
static int listitem_multi_key(GtkWidget *item, GdkEventKey *event,
gpointer data)
{
- listitem_key(item, event, data, TRUE);
+ return listitem_key(item, event, data, TRUE);
}
static int listitem_button(GtkWidget *item, GdkEventButton *event,
{
struct dlgparam *dp = (struct dlgparam *)data;
struct uctrl *uc = dlg_find_bywidget(dp, GTK_WIDGET(list));
+ if (!uc) return;
uc->ctrl->generic.handler(uc->ctrl, dp, dp->data, EVENT_SELCHANGE);
}
static void filesel_ok(GtkButton *button, gpointer data)
{
- struct dlgparam *dp = (struct dlgparam *)data;
+ /* struct dlgparam *dp = (struct dlgparam *)data; */
gpointer filesel = gtk_object_get_data(GTK_OBJECT(button), "user-data");
struct uctrl *uc = gtk_object_get_data(GTK_OBJECT(filesel), "user-data");
char *name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel));
static void fontsel_ok(GtkButton *button, gpointer data)
{
- struct dlgparam *dp = (struct dlgparam *)data;
+ /* struct dlgparam *dp = (struct dlgparam *)data; */
gpointer fontsel = gtk_object_get_data(GTK_OBJECT(button), "user-data");
struct uctrl *uc = gtk_object_get_data(GTK_OBJECT(fontsel), "user-data");
char *name = gtk_font_selection_dialog_get_font_name
continue; /* no actual control created */
}
- uc = smalloc(sizeof(struct uctrl));
+ uc = snew(struct uctrl);
uc->ctrl = ctrl;
uc->privdata = NULL;
uc->privdata_needs_free = FALSE;
group = NULL;
uc->nbuttons = ctrl->radio.nbuttons;
- uc->buttons = smalloc(uc->nbuttons * sizeof(GtkWidget *));
+ uc->buttons = snewn(uc->nbuttons, GtkWidget *);
for (i = 0; i < ctrl->radio.nbuttons; i++) {
GtkWidget *b;
{
GtkWidget *w = dp->treeitems[i];
int vis = TRUE;
- while (w && GTK_IS_TREE_ITEM(w) || GTK_IS_TREE(w)) {
+ while (w && (GTK_IS_TREE_ITEM(w) || GTK_IS_TREE(w))) {
if (!GTK_WIDGET_VISIBLE(w)) {
vis = FALSE;
break;
gtk_signal_emit_stop_by_name(GTK_OBJECT(widget),
"key_press_event");
if (j >= 0) {
- gint return_val;
gtk_signal_emit_by_name(GTK_OBJECT(dp->treeitems[j]), "toggle");
gtk_widget_grab_focus(dp->treeitems[j]);
}
}
}
-int do_config_box(const char *title)
+int do_config_box(const char *title, Config *cfg)
{
GtkWidget *window, *hbox, *vbox, *cols, *label,
*tree, *treescroll, *panels, *panelvbox;
char *path;
GtkTreeItem *treeitemlevels[8];
GtkTree *treelevels[8];
- Config cfg;
struct dlgparam dp;
struct sesslist sl;
struct Shortcuts scs;
struct selparam *selparams = NULL;
int nselparams = 0, selparamsize = 0;
- do_defaults(NULL, &cfg);
-
dlg_init(&dp);
{
gtk_widget_unref(listitem);
}
- sl.nsessions = 0;
+ get_sesslist(&sl, TRUE);
for (index = 0; index < lenof(scs.sc); index++) {
scs.sc[index].action = SHORTCUT_EMPTY;
if (nselparams >= selparamsize) {
selparamsize += 16;
- selparams = srealloc(selparams,
- selparamsize * sizeof(*selparams));
+ selparams = sresize(selparams, selparamsize,
+ struct selparam);
}
selparams[nselparams].dp = &dp;
selparams[nselparams].panels = PANELS(panels);
}
dp.ntreeitems = nselparams;
- dp.treeitems = smalloc(dp.ntreeitems * sizeof(GtkWidget *));
+ dp.treeitems = snewn(dp.ntreeitems, GtkWidget *);
for (index = 0; index < nselparams; index++) {
gtk_signal_connect(GTK_OBJECT(selparams[index].treeitem), "select",
dp.treeitems[index] = selparams[index].treeitem;
}
- dp.data = &cfg;
+ dp.data = cfg;
dlg_refresh(NULL, &dp);
dp.shortcuts = &selparams[0].shortcuts;
gtk_main();
+ get_sesslist(&sl, FALSE);
dlg_cleanup(&dp);
sfree(selparams);
return dp.retval;
}
-/* ======================================================================
- * Below here is a stub main program which allows the dialog box
- * code to be compiled and tested with a minimal amount of the rest
- * of PuTTY.
- */
+static void messagebox_handler(union control *ctrl, void *dlg,
+ void *data, int event)
+{
+ if (event == EVENT_ACTION)
+ dlg_end(dlg, ctrl->generic.context.i);
+}
+int messagebox(GtkWidget *parentwin, char *title, char *msg, int minwid, ...)
+{
+ GtkWidget *window, *w0, *w1;
+ struct controlbox *ctrlbox;
+ struct controlset *s0, *s1;
+ union control *c;
+ struct dlgparam dp;
+ struct Shortcuts scs;
+ int index, ncols;
+ va_list ap;
-#ifdef TESTMODE
+ dlg_init(&dp);
-/* Compile command for testing:
+ for (index = 0; index < lenof(scs.sc); index++) {
+ scs.sc[index].action = SHORTCUT_EMPTY;
+ }
-gcc -g -o gtkdlg gtk{dlg,cols,panel}.c ../{config,dialog,settings}.c \
-../{misc,tree234,be_none}.c ux{store,misc,print,cfg}.c \
--I. -I.. -I../charset -DTESTMODE `gtk-config --cflags --libs`
+ ctrlbox = ctrl_new_box();
- */
+ ncols = 0;
+ va_start(ap, minwid);
+ while (va_arg(ap, char *) != NULL) {
+ ncols++;
+ (void) va_arg(ap, int); /* shortcut */
+ (void) va_arg(ap, int); /* normal/default/cancel */
+ (void) va_arg(ap, int); /* end value */
+ }
+ va_end(ap);
-void modalfatalbox(char *p, ...)
-{
- va_list ap;
- fprintf(stderr, "FATAL ERROR: ");
- va_start(ap, p);
- vfprintf(stderr, p, ap);
+ s0 = ctrl_getset(ctrlbox, "", "", "");
+ c = ctrl_columns(s0, 2, 50, 50);
+ c->columns.ncols = s0->ncolumns = ncols;
+ c->columns.percentages = sresize(c->columns.percentages, ncols, int);
+ for (index = 0; index < ncols; index++)
+ c->columns.percentages[index] = (index+1)*100/ncols - index*100/ncols;
+ va_start(ap, minwid);
+ index = 0;
+ while (1) {
+ char *title = va_arg(ap, char *);
+ int shortcut, type, value;
+ if (title == NULL)
+ break;
+ shortcut = va_arg(ap, int);
+ type = va_arg(ap, int);
+ value = va_arg(ap, int);
+ c = ctrl_pushbutton(s0, title, shortcut, HELPCTX(no_help),
+ messagebox_handler, I(value));
+ c->generic.column = index++;
+ if (type > 0)
+ c->button.isdefault = TRUE;
+ else if (type < 0)
+ c->button.iscancel = TRUE;
+ }
va_end(ap);
- fputc('\n', stderr);
- exit(1);
-}
-char *cp_name(int codepage)
-{
- return (codepage == 123 ? "testing123" :
- codepage == 234 ? "testing234" :
- codepage == 345 ? "testing345" :
- "unknown");
-}
+ s1 = ctrl_getset(ctrlbox, "x", "", "");
+ ctrl_text(s1, msg, HELPCTX(no_help));
-char *cp_enumerate(int index)
-{
- return (index == 0 ? "testing123" :
- index == 1 ? "testing234" :
- NULL);
-}
+ window = gtk_dialog_new();
+ gtk_window_set_title(GTK_WINDOW(window), title);
+ w0 = layout_ctrls(&dp, &scs, s0, 0, GTK_WINDOW(window));
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area),
+ w0, TRUE, TRUE, 0);
+ gtk_widget_show(w0);
+ w1 = layout_ctrls(&dp, &scs, s1, 0, GTK_WINDOW(window));
+ gtk_container_set_border_width(GTK_CONTAINER(w1), 10);
+ gtk_widget_set_usize(w1, minwid+20, -1);
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox),
+ w1, TRUE, TRUE, 0);
+ gtk_widget_show(w1);
-int decode_codepage(char *cp_name)
-{
- return (!strcmp(cp_name, "testing123") ? 123 :
- !strcmp(cp_name, "testing234") ? 234 :
- !strcmp(cp_name, "testing345") ? 345 :
- -2);
-}
+ dp.shortcuts = &scs;
+ dp.lastfocus = NULL;
+ dp.retval = 0;
+ dp.window = window;
-struct printer_enum_tag { int dummy; } printer_test;
+ gtk_window_set_modal(GTK_WINDOW(window), TRUE);
+ if (parentwin) {
+ gint x, y, w, h, dx, dy;
+ gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_NONE);
+ gdk_window_get_origin(parentwin->window, &x, &y);
+ gdk_window_get_size(parentwin->window, &w, &h);
+ dx = x + w/4;
+ dy = y + h/4;
+ gtk_widget_set_uposition(GTK_WIDGET(window), dx, dy);
+ gtk_window_set_transient_for(GTK_WINDOW(window),
+ GTK_WINDOW(parentwin));
+ } else
+ gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
+ gtk_widget_show(window);
-printer_enum *printer_start_enum(int *nprinters_ptr) {
- *nprinters_ptr = 2;
- return &printer_test;
-}
-char *printer_get_name(printer_enum *pe, int i) {
- return (i==0 ? "lpr" : i==1 ? "lpr -Pfoobar" : NULL);
-}
-void printer_finish_enum(printer_enum *pe) { }
+ gtk_signal_connect(GTK_OBJECT(window), "destroy",
+ GTK_SIGNAL_FUNC(window_destroy), NULL);
+ gtk_signal_connect(GTK_OBJECT(window), "key_press_event",
+ GTK_SIGNAL_FUNC(win_key_press), &dp);
-char *platform_default_s(const char *name)
-{
- return NULL;
+ gtk_main();
+
+ dlg_cleanup(&dp);
+ ctrl_free_box(ctrlbox);
+
+ return dp.retval;
}
-int platform_default_i(const char *name, int def)
-{
- return def;
+static int string_width(char *text)
+{
+ GtkWidget *label = gtk_label_new(text);
+ GtkRequisition req;
+ gtk_widget_size_request(label, &req);
+ gtk_widget_unref(label);
+ return req.width;
+}
+
+void verify_ssh_host_key(void *frontend, char *host, int port, char *keytype,
+ char *keystr, char *fingerprint)
+{
+ static const char absenttxt[] =
+ "The server's host key is not cached. You have no guarantee "
+ "that the server is the computer you think it is.\n"
+ "The server's key fingerprint is:\n"
+ "%s\n"
+ "If you trust this host, press \"Accept\" to add the key to "
+ "PuTTY's cache and carry on connecting.\n"
+ "If you want to carry on connecting just once, without "
+ "adding the key to the cache, press \"Connect Once\".\n"
+ "If you do not trust this host, press \"Cancel\" to abandon the "
+ "connection.";
+ static const char wrongtxt[] =
+ "WARNING - POTENTIAL SECURITY BREACH!\n"
+ "The server's host key does not match the one PuTTY has "
+ "cached. This means that either the server administrator "
+ "has changed the host key, or you have actually connected "
+ "to another computer pretending to be the server.\n"
+ "The new key fingerprint is:\n"
+ "%s\n"
+ "If you were expecting this change and trust the new key, "
+ "press \"Accept\" to update PuTTY's cache and continue connecting.\n"
+ "If you want to carry on connecting but without updating "
+ "the cache, press \"Connect Once\".\n"
+ "If you want to abandon the connection completely, press "
+ "\"Cancel\" to cancel. Pressing \"Cancel\" is the ONLY guaranteed "
+ "safe choice.";
+ char *text;
+ int ret;
+
+ /*
+ * Verify the key.
+ */
+ ret = verify_host_key(host, port, keytype, keystr);
+
+ if (ret == 0) /* success - key matched OK */
+ return;
+
+ text = dupprintf((ret == 2 ? wrongtxt : absenttxt), fingerprint);
+
+ ret = messagebox(GTK_WIDGET(get_window(frontend)),
+ "PuTTY Security Alert", text,
+ string_width(fingerprint),
+ "Accept", 'a', 0, 2,
+ "Connect Once", 'o', 0, 1,
+ "Cancel", 'c', -1, 0,
+ NULL);
+
+ sfree(text);
+
+ if (ret == 0)
+ cleanup_exit(0);
+ else if (ret == 2)
+ store_host_key(host, port, keytype, keystr);
}
-FontSpec platform_default_fontspec(const char *name)
-{
- FontSpec ret;
- if (!strcmp(name, "Font"))
- strcpy(ret.name, "fixed");
- else
- *ret.name = '\0';
- return ret;
+/*
+ * Ask whether the selected cipher is acceptable (since it was
+ * below the configured 'warn' threshold).
+ * cs: 0 = both ways, 1 = client->server, 2 = server->client
+ */
+void askcipher(void *frontend, char *ciphername, int cs)
+{
+ static const char msg[] =
+ "The first %scipher supported by the server is "
+ "%s, which is below the configured warning threshold.\n"
+ "Continue with connection?";
+ char *text;
+ int ret;
+
+ text = dupprintf(msg, (cs == 0) ? "" :
+ (cs == 1) ? "client-to-server " : "server-to-client ",
+ ciphername);
+ ret = messagebox(GTK_WIDGET(get_window(frontend)),
+ "PuTTY Security Alert", text,
+ string_width("Continue with connection?"),
+ "Yes", 'y', 0, 1,
+ "No", 'n', 0, 0,
+ NULL);
+ sfree(text);
+
+ if (ret) {
+ return;
+ } else {
+ cleanup_exit(0);
+ }
}
-Filename platform_default_filename(const char *name)
+void old_keyfile_warning(void)
{
- Filename ret;
- if (!strcmp(name, "LogFileName"))
- strcpy(ret.path, "putty.log");
- else
- *ret.path = '\0';
- return ret;
+ /*
+ * This should never happen on Unix. We hope.
+ */
}
-char *x_get_default(const char *key)
+void fatal_message_box(void *window, char *msg)
{
- return NULL;
+ messagebox(window, "PuTTY Fatal Error", msg,
+ string_width("REASONABLY LONG LINE OF TEXT FOR BASIC SANITY"),
+ "OK", 'o', 1, 1, NULL);
}
-int main(int argc, char **argv)
+void fatalbox(char *p, ...)
{
- gtk_init(&argc, &argv);
- printf("returned %d\n", do_config_box("PuTTY Configuration"));
- return 0;
+ va_list ap;
+ char *msg;
+ va_start(ap, p);
+ msg = dupvprintf(p, ap);
+ va_end(ap);
+ fatal_message_box(NULL, msg);
+ sfree(msg);
+ cleanup_exit(1);
}
-
-#endif
projects / u / mdw / putty / blobdiff