src/protocol/auth/dialogs.c

   1 /* HTTP Auth dialog stuff */
   2
   3 #ifdef HAVE_CONFIG_H
   4 #include "config.h"
   5 #endif
   6
   7 #include <string.h>
   8
   9 #include "elinks.h"
  10
  11 #include "bfu/dialog.h"
  12 #include "document/forms.h"
  13 #include "formhist/formhist.h"
  14 #include "intl/gettext/libintl.h"
  15 #include "main/object.h"
  16 #include "protocol/auth/auth.h"
  17 #include "protocol/auth/dialogs.h"
  18 #include "protocol/uri.h"
  19 #include "session/location.h"
  20 #include "session/session.h"
  21 #include "session/task.h"
  22 #include "terminal/terminal.h"
  23 #include "util/color.h"
  24 #include "util/lists.h"
  25 #include "util/memory.h"
  26 #include "util/snprintf.h"
  27 #include "util/string.h"
  28 #include "viewer/text/form.h"
  29
  30
  31 static void
  32 auth_ok(void *data)
  33 {
  34         struct dialog *dlg = data;
  35         struct auth_entry *entry = dlg->udata2;
  36         struct session *ses = dlg->udata;
  37
  38         entry->blocked = 0;
  39         entry->valid = auth_entry_has_userinfo(entry);
  40
  41 #ifdef CONFIG_FORMHIST
  42         if (get_opt_bool("document.browse.forms.show_formhist", ses)) {
  43                 unsigned char *url = get_uri_string(entry->uri, URI_HTTP_AUTH);
  44
  45                 if (url) {
  46                         struct form form = {
  47                                 .action = url,
  48                         };
  49                         INIT_LIST_OF(struct submitted_value, submit);
  50                         struct submitted_value *user, *password;
  51
  52                         user = init_submitted_value("user", entry->user, FC_TEXT, NULL, 0);
  53                         if (user) {
  54                                 add_to_list(submit, user);
  55                         }
  56                         password = init_submitted_value("password", entry->password, FC_PASSWORD, NULL, 0);
  57                         if (password) {
  58                                 add_to_list(submit, password);
  59                         }
  60
  61                         memorize_form(ses, &submit, &form);
  62                         done_submitted_value_list(&submit);
  63                         mem_free(url);
  64                 }
  65         }
  66 #endif
  67
  68         if (entry->valid && have_location(ses)) {
  69                 struct location *loc = cur_loc(ses);
  70                 struct uri *uri = loc->vs.uri;
  71
  72                 /* Make a 'fake' redirect to a URI without user/password so that
  73                  * the user/password from the URI will not override what the
  74                  * user just entered in the dialog. */
  75                 if ((uri->userlen && strlcmp(entry->user, -1, uri->user, uri->userlen))
  76                     || (uri->password && strlcmp(entry->password, -1, uri->password, uri->passwordlen))) {
  77
  78                         uri = get_composed_uri(uri, URI_HTTP_AUTH | URI_DATA | URI_POST);
  79                         if (uri) {
  80                                 goto_uri_frame(ses, uri, NULL, CACHE_MODE_INCREMENT);
  81                                 done_uri(uri);
  82                                 return;
  83                         }
  84                 }
  85         }
  86
  87         reload(ses, CACHE_MODE_INCREMENT);
  88 }
  89
  90 static void
  91 auth_cancel(void *data)
  92 {
  93         struct auth_entry *entry = data;
  94
  95         entry->blocked = 0;
  96         del_auth_entry(entry);
  97 }
  98
  99 /* TODO: Take auth_entry from data. --jonas */
 100 void
 101 do_auth_dialog(struct session *ses, void *data)
 102 {
 103         /* [gettext_accelerator_context(do_auth_dialog)] */
 104         struct dialog *dlg;
 105         struct dialog_data *dlg_data;
 106         struct terminal *term = ses->tab->term;
 107         struct auth_entry *a = get_invalid_auth_entry();
 108         unsigned char sticker[MAX_STR_LEN], *text;
 109         int sticker_len;
 110
 111         if (!a || a->blocked) return;
 112
 113         text = get_uri_string(a->uri, URI_HTTP_AUTH);
 114         if (!text) return;
 115
 116 #ifdef CONFIG_FORMHIST
 117         {
 118                 unsigned char *user = get_form_history_value(text, "user");
 119                 unsigned char *password = get_form_history_value(text, "password");
 120
 121                 if (user) {
 122                         strncpy(a->user, user, AUTH_USER_MAXLEN - 1);
 123                 }
 124                 if (password) {
 125                         strncpy(a->password, password, AUTH_PASSWORD_MAXLEN - 1);
 126                 }
 127         }
 128 #endif
 129
 130         sticker_len = snprintf(sticker, sizeof(sticker),
 131                                _("Authentication required for %s at %s", term),
 132                                a->realm, text);
 133         mem_free(text);
 134         if (sticker_len < 0 || sticker_len > MAX_STR_LEN) return;
 135
 136 #define AUTH_WIDGETS_COUNT 5
 137         /* + 1 to leave room for the '\0'. */
 138         dlg = calloc_dialog(AUTH_WIDGETS_COUNT, sticker_len + 1);
 139         if (!dlg) return;
 140
 141         a->blocked = 1;
 142
 143         /* This function is used for at least HTTP and FTP, so don't
 144          * name the protocol here.  Consider also what an FTP server
 145          * behind an HTTP proxy should be called.  */
 146         dlg->title = _("Authentication required", term);
 147         dlg->layouter = generic_dialog_layouter;
 148
 149         text = get_dialog_offset(dlg, AUTH_WIDGETS_COUNT);
 150         memcpy(text, sticker, sticker_len); /* calloc_dialog has stored '\0' */
 151
 152         dlg->udata = (void *) ses;
 153         dlg->udata2 = a;
 154
 155         add_dlg_text(dlg, text, ALIGN_LEFT, 0);
 156         add_dlg_field_float(dlg, _("Login", term), 0, 0, NULL, AUTH_USER_MAXLEN, a->user, NULL);
 157         add_dlg_field_float_pass(dlg, _("Password", term), 0, 0, NULL, AUTH_PASSWORD_MAXLEN, a->password);
 158
 159         add_dlg_ok_button(dlg, _("~OK", term), B_ENTER, auth_ok, dlg);
 160         add_dlg_ok_button(dlg, _("~Cancel", term), B_ESC, auth_cancel, a);
 161
 162         add_dlg_end(dlg, AUTH_WIDGETS_COUNT);
 163
 164         dlg_data = do_dialog(term, dlg, getml(dlg, (void *) NULL));
 165         /* When there's some username, but no password, automagically jump to
 166          * the password. */
 167         if (dlg_data && a->user[0] && !a->password[0])
 168                 select_widget_by_id(dlg_data, 1);
 169 }
 170
 171
 172 static void
 173 lock_auth_entry(struct listbox_item *item)
 174 {
 175         object_lock((struct auth_entry *) item->udata);
 176 }
 177
 178 static void
 179 unlock_auth_entry(struct listbox_item *item)
 180 {
 181         object_unlock((struct auth_entry *) item->udata);
 182 }
 183
 184 static int
 185 is_auth_entry_used(struct listbox_item *item)
 186 {
 187         return is_object_used((struct auth_entry *) item->udata);
 188 }
 189
 190 static unsigned char *
 191 get_auth_entry_text(struct listbox_item *item, struct terminal *term)
 192 {
 193         struct auth_entry *auth_entry = item->udata;
 194
 195         return get_uri_string(auth_entry->uri, URI_HTTP_AUTH);
 196 }
 197
 198 static unsigned char *
 199 get_auth_entry_info(struct listbox_item *item, struct terminal *term)
 200 {
 201         struct auth_entry *auth_entry = item->udata;
 202         struct string info;
 203
 204         if (item->type == BI_FOLDER) return NULL;
 205         if (!init_string(&info)) return NULL;
 206
 207         add_format_to_string(&info, "%s: ", _("URL", term));
 208         add_uri_to_string(&info, auth_entry->uri, URI_HTTP_AUTH);
 209
 210         add_format_to_string(&info, "\n%s: ", _("Realm", term));
 211         if (auth_entry->realm) {
 212                 int len = strlen(auth_entry->realm);
 213                 int maxlen = 512; /* Max. number of chars displayed for realm. */
 214
 215                 if (len < maxlen)
 216                         add_bytes_to_string(&info, auth_entry->realm, len);
 217                 else {
 218                         add_bytes_to_string(&info, auth_entry->realm, maxlen);
 219                         add_to_string(&info, "...");
 220                 }
 221         } else {
 222                 add_to_string(&info, _("none", term));
 223         }
 224
 225         add_format_to_string(&info, "\n%s: %s\n", _("State", term),
 226                 auth_entry->valid ? _("valid", term) : _("invalid", term));
 227
 228         return info.source;
 229 }
 230
 231 static struct uri *
 232 get_auth_entry_uri(struct listbox_item *item)
 233 {
 234         struct auth_entry *auth_entry = item->udata;
 235
 236         return get_composed_uri(auth_entry->uri, URI_HTTP_AUTH);
 237 }
 238
 239 static struct listbox_item *
 240 get_auth_entry_root(struct listbox_item *box_item)
 241 {
 242         return NULL;
 243 }
 244
 245 static int
 246 can_delete_auth_entry(struct listbox_item *item)
 247 {
 248         return 1;
 249 }
 250
 251 static void
 252 delete_auth_entry(struct listbox_item *item, int last)
 253 {
 254         struct auth_entry *auth_entry = item->udata;
 255
 256         assert(!is_object_used(auth_entry));
 257
 258         del_auth_entry(auth_entry);
 259 }
 260
 261 static struct listbox_ops_messages http_auth_messages = {
 262         /* cant_delete_item */
 263         N_("Sorry, but auth entry \"%s\" cannot be deleted."),
 264         /* cant_delete_used_item */
 265         N_("Sorry, but auth entry \"%s\" is being used by something else."),
 266         /* cant_delete_folder */
 267         NULL,
 268         /* cant_delete_used_folder */
 269         NULL,
 270         /* delete_marked_items_title */
 271         N_("Delete marked auth entries"),
 272         /* delete_marked_items */
 273         N_("Delete marked auth entries?"),
 274         /* delete_folder_title */
 275         NULL,
 276         /* delete_folder */
 277         NULL,
 278         /* delete_item_title */
 279         N_("Delete auth entry"),
 280         /* delete_item; xgettext:c-format */
 281         N_("Delete this auth entry?"),
 282         /* clear_all_items_title */
 283         N_("Clear all auth entries"),
 284         /* clear_all_items_title */
 285         N_("Do you really want to remove all auth entries?"),
 286 };
 287
 288 static const struct listbox_ops auth_listbox_ops = {
 289         lock_auth_entry,
 290         unlock_auth_entry,
 291         is_auth_entry_used,
 292         get_auth_entry_text,
 293         get_auth_entry_info,
 294         get_auth_entry_uri,
 295         get_auth_entry_root,
 296         NULL,
 297         can_delete_auth_entry,
 298         delete_auth_entry,
 299         NULL,
 300         &http_auth_messages,
 301 };
 302
 303 static const struct hierbox_browser_button auth_buttons[] = {
 304         /* [gettext_accelerator_context(.auth_buttons)] */
 305         { N_("~Goto"),   push_hierbox_goto_button,   1 },
 306         { N_("~Info"),   push_hierbox_info_button,   1 },
 307         { N_("~Delete"), push_hierbox_delete_button, 1 },
 308         { N_("C~lear"),  push_hierbox_clear_button,  1 },
 309 };
 310
 311 struct_hierbox_browser(
 312         auth_browser,
 313         N_("Authentication manager"),
 314         auth_buttons,
 315         &auth_listbox_ops
 316 );
 317
 318 void
 319 auth_manager(struct session *ses)
 320 {
 321         hierbox_browser(&auth_browser, ses);
 322 }