/** Downloads managment * @file */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include #include #ifdef HAVE_SYS_CYGWIN_H #include #endif #include #ifdef HAVE_FCNTL_H #include /* OS/2 needs this after sys/types.h */ #endif #include #ifdef HAVE_UNISTD_H #include #endif #include #include "elinks.h" #include "bfu/dialog.h" #include "cache/cache.h" #include "config/options.h" #include "dialogs/document.h" #include "dialogs/download.h" #include "dialogs/menu.h" #include "intl/gettext/libintl.h" #include "main/object.h" #include "mime/mime.h" #include "network/connection.h" #include "network/progress.h" #include "network/state.h" #include "osdep/osdep.h" #include "protocol/bittorrent/dialogs.h" #include "protocol/date.h" #include "protocol/protocol.h" #include "protocol/uri.h" #include "session/download.h" #include "session/history.h" #include "session/location.h" #include "session/session.h" #include "session/task.h" #include "terminal/draw.h" #include "terminal/screen.h" #include "terminal/terminal.h" #include "util/conv.h" #include "util/error.h" #include "util/file.h" #include "util/lists.h" #include "util/memlist.h" #include "util/memory.h" #include "util/string.h" #include "util/time.h" /* TODO: tp_*() should be in separate file, I guess? --pasky */ INIT_LIST_OF(struct file_download, downloads); int download_is_progressing(struct download *download) { return download && is_in_state(download->state, S_TRANS) && has_progress(download->progress); } int are_there_downloads(void) { struct file_download *file_download; foreach (file_download, downloads) if (!file_download->external_handler) return 1; return 0; } static void download_data(struct download *download, struct file_download *file_download); /*! @note If this fails, the caller is responsible of freeing @a file * and closing @a fd. */ struct file_download * init_file_download(struct uri *uri, struct session *ses, unsigned char *file, int fd) { struct file_download *file_download; file_download = mem_calloc(1, sizeof(*file_download)); if (!file_download) return NULL; /* Actually we could allow fragments in the URI and just change all the * places that compares and shows the URI, but for now it is much * easier this way. */ file_download->uri = get_composed_uri(uri, URI_BASE); if (!file_download->uri) { mem_free(file_download); return NULL; } init_download_display(file_download); file_download->file = file; file_download->handle = fd; file_download->download.callback = (download_callback_T *) download_data; file_download->download.data = file_download; file_download->ses = ses; /* The tab may be closed, but we will still want to ie. open the * handler on that terminal. */ file_download->term = ses->tab->term; object_nolock(file_download, "file_download"); /* Debugging purpose. */ add_to_list(downloads, file_download); return file_download; } void abort_download(struct file_download *file_download) { #if 0 /* When hacking to cleanup the download code, remove lots of duplicated * code and implement stuff from bug 435 we should reintroduce this * assertion. Currently it will trigger often and shows that the * download dialog code potentially could access free()d memory. */ assert(!is_object_used(file_download)); #endif done_download_display(file_download); if (file_download->ses) check_questions_queue(file_download->ses); if (file_download->dlg_data) cancel_dialog(file_download->dlg_data, NULL); cancel_download(&file_download->download, file_download->stop); if (file_download->uri) done_uri(file_download->uri); if (file_download->handle != -1) { prealloc_truncate(file_download->handle, file_download->seek); close(file_download->handle); } mem_free_if(file_download->external_handler); if (file_download->file) { if (file_download->delete) unlink(file_download->file); mem_free(file_download->file); } del_from_list(file_download); mem_free(file_download); } static void kill_downloads_to_file(unsigned char *file) { struct file_download *file_download; foreach (file_download, downloads) { if (strcmp(file_download->file, file)) continue; file_download = file_download->prev; abort_download(file_download->next); } } void abort_all_downloads(void) { while (!list_empty(downloads)) abort_download(downloads.next); } void destroy_downloads(struct session *ses) { struct file_download *file_download, *next; struct session *s; /* We are supposed to blat all downloads to external handlers belonging * to @ses, but we will refuse to do so if there is another session * bound to this terminal. That looks like the reasonable thing to do, * fulfilling the principle of least astonishment. */ foreach (s, sessions) { if (s == ses || s->tab->term != ses->tab->term) continue; foreach (file_download, downloads) { if (file_download->ses != ses) continue; file_download->ses = s; } return; } foreachsafe (file_download, next, downloads) { if (file_download->ses != ses) continue; if (!file_download->external_handler) { file_download->ses = NULL; continue; } abort_download(file_download); } } void detach_downloads_from_terminal(struct terminal *term) { struct file_download *file_download, *next; assert(term != NULL); if_assert_failed return; foreachsafe (file_download, next, downloads) { if (file_download->term != term) continue; if (!file_download->external_handler) { file_download->term = NULL; if (file_download->ses && file_download->ses->tab->term == term) file_download->ses = NULL; continue; } abort_download(file_download); } } static void download_error_dialog(struct file_download *file_download, int saved_errno) { unsigned char *emsg = (unsigned char *) strerror(saved_errno); struct session *ses = file_download->ses; struct terminal *term = file_download->term; if (!ses) return; info_box(term, MSGBOX_FREE_TEXT, N_("Download error"), ALIGN_CENTER, msg_text(term, N_("Could not create file '%s':\n%s"), file_download->file, emsg)); } static int write_cache_entry_to_file(struct cache_entry *cached, struct file_download *file_download) { struct fragment *frag; if (file_download->download.progress && file_download->download.progress->seek) { file_download->seek = file_download->download.progress->seek; file_download->download.progress->seek = 0; /* This is exclusive with the prealloc, thus we can perform * this in front of that thing safely. */ if (lseek(file_download->handle, file_download->seek, SEEK_SET) < 0) { download_error_dialog(file_download, errno); return 0; } } foreach (frag, cached->frag) { off_t remain = file_download->seek - frag->offset; int *h = &file_download->handle; ssize_t w; if (remain < 0 || frag->length <= remain) continue; #ifdef USE_OPEN_PREALLOC if (!file_download->seek && (!file_download->download.progress || file_download->download.progress->size > 0)) { close(*h); *h = open_prealloc(file_download->file, O_CREAT|O_WRONLY|O_TRUNC, 0666, file_download->download.progress ? file_download->download.progress->size : cached->length); if (*h == -1) { download_error_dialog(file_download, errno); return 0; } set_bin(*h); } #endif w = safe_write(*h, frag->data + remain, frag->length - remain); if (w == -1) { download_error_dialog(file_download, errno); return 0; } file_download->seek += w; } return 1; } static void abort_download_and_beep(struct file_download *file_download, struct terminal *term) { if (term && get_opt_int("document.download.notify_bell") + file_download->notify >= 2) { beep_terminal(term); } abort_download(file_download); } static void download_data_store(struct download *download, struct file_download *file_download) { struct terminal *term = file_download->term; assert_terminal_ptr_not_dangling(term); if_assert_failed term = file_download->term = NULL; if (!term) { /* No term here, so no beep. --Zas */ abort_download(file_download); return; } if (is_in_progress_state(download->state)) { if (file_download->dlg_data) redraw_dialog(file_download->dlg_data, 1); return; } if (!is_in_state(download->state, S_OK)) { unsigned char *url = get_uri_string(file_download->uri, URI_PUBLIC); struct connection_state state = download->state; abort_download_and_beep(file_download, term); if (!url) return; info_box(term, MSGBOX_FREE_TEXT, N_("Download error"), ALIGN_CENTER, msg_text(term, N_("Error downloading %s:\n\n%s"), url, get_state_message(state, term))); mem_free(url); return; } if (file_download->external_handler) { prealloc_truncate(file_download->handle, file_download->seek); close(file_download->handle); file_download->handle = -1; exec_on_terminal(term, file_download->external_handler, file_download->file, file_download->block ? TERM_EXEC_FG : TERM_EXEC_BG); file_download->delete = 0; abort_download_and_beep(file_download, term); return; } if (file_download->notify) { unsigned char *url = get_uri_string(file_download->uri, URI_PUBLIC); /* This is apparently a little racy. Deleting the box item will * update the download browser _after_ the notification dialog * has been drawn whereby it will be hidden. This should make * the download browser update before launcing any * notification. */ done_download_display(file_download); if (url) { info_box(term, MSGBOX_FREE_TEXT, N_("Download"), ALIGN_CENTER, msg_text(term, N_("Download complete:\n%s"), url)); mem_free(url); } } if (file_download->remotetime && get_opt_bool("document.download.set_original_time")) { struct utimbuf foo; foo.actime = foo.modtime = file_download->remotetime; utime(file_download->file, &foo); } abort_download_and_beep(file_download, term); } static void download_data(struct download *download, struct file_download *file_download) { struct cache_entry *cached = download->cached; if (!cached || is_in_queued_state(download->state)) { download_data_store(download, file_download); return; } if (cached->last_modified) file_download->remotetime = parse_date(&cached->last_modified, NULL, 0, 1); if (cached->redirect && file_download->redirect_cnt++ < MAX_REDIRECTS) { cancel_download(&file_download->download, 0); assertm(compare_uri(cached->uri, file_download->uri, 0), "Redirecting using bad base URI"); done_uri(file_download->uri); file_download->uri = get_uri_reference(cached->redirect); file_download->download.state = connection_state(S_WAIT_REDIR); if (file_download->dlg_data) redraw_dialog(file_download->dlg_data, 1); load_uri(file_download->uri, cached->uri, &file_download->download, PRI_DOWNLOAD, CACHE_MODE_NORMAL, download->progress ? download->progress->start : 0); return; } if (!write_cache_entry_to_file(cached, file_download)) { detach_connection(download, file_download->seek); abort_download(file_download); return; } detach_connection(download, file_download->seek); download_data_store(download, file_download); } /** Type of the callback function that will be called when the user * answers the question posed by lookup_unique_name(). * * @param term * The terminal on which the callback should display any windows. * Comes directly from the @a term argument of lookup_unique_name(). * * @param file * The name of the local file to which the data should be downloaded, * or NULL if the download should not begin. The callback is * responsible of doing mem_free(@a file). * * @param data * A pointer to any data that the callback cares about. * Comes directly from the @a data argument of lookup_unique_name(). * * @param resume * Whether the user chose to resume downloading an existing file. * * @relates lun_hop */ typedef void lun_callback_T(struct terminal *term, unsigned char *file, void *data, enum download_resume resume); /** The user is being asked what to do when the local file for * the download already exists. This structure is allocated by * lookup_unique_name() and freed by each lun_* function: * lun_alternate(), lun_cancel(), lun_overwrite(), and lun_resume(). */ struct lun_hop { /** The terminal in which ELinks is asking the question. * This gets passed to #callback. */ struct terminal *term; /** The name of the local file into which the data was * originally going to be downloaded, but which already * exists. In this string, "~" has already been expanded * to the home directory. The string must be freed with * mem_free(). */ unsigned char *ofile; /** An alternative file name that the user may choose instead * of #ofile. The string must be freed with mem_free(). */ unsigned char *file; /** This function will be called when the user answers. */ lun_callback_T *callback; /** A pointer to be passed to #callback. If #resume includes * ::DOWNLOAD_RESUME_ALLOWED, this must point to struct * cdf_hop because the pointer can be read by lun_resume(), * which assumes so. */ void *data; /** Whether the download can be resumed. * The ::DOWNLOAD_RESUME_SELECTED bit should be clear * because otherwise there would have been no reason to * ask the user and initialize this structure. */ enum download_resume resume; }; /** Data saved by common_download() for the common_download_do() * callback. */ struct cmdw_hop { struct session *ses; /** The URI from which the data will be downloaded. */ struct uri *download_uri; /** The name of the local file to which the data will be * downloaded. This is initially NULL, but its address is * given to create_download_file(), which arranges for the * pointer to be set before common_download_do() is called. * The string must be freed with mem_free(). */ unsigned char *real_file; }; /** Data saved by continue_download() for the continue_download_do() * callback. */ struct codw_hop { struct type_query *type_query; /** The name of the local file to which the data will be * downloaded. This is initially NULL, but its address is * given to create_download_file(), which arranges for the * pointer to be set before continue_download_do() is called. * The string must be freed with mem_free(). */ unsigned char *real_file; unsigned char *file; }; /** Data saved by create_download_file() for the create_download_file_do() * callback. */ struct cdf_hop { /** Where to save the name of the file that was actually * opened. One of the arguments of #callback is a file * descriptor for this file. @c real_file can be NULL if * #callback does not care about the name. */ unsigned char **real_file; /** If nonzero, give only the user herself access to the file * (even if the umask is looser), and create the file with * @c O_EXCL unless resuming. */ int safe; /** This function will be called when the file has been opened, * or when it is known that the file will not be opened. */ cdf_callback_T *callback; /** A pointer to be passed to #callback. */ void *data; }; /** The use chose "Save under the alternative name" when asked where * to download a file. * * lookup_unique_name() passes this function as a ::done_handler_T to * msg_box(). * * @relates lun_hop */ static void lun_alternate(void *lun_hop_) { struct lun_hop *lun_hop = lun_hop_; lun_hop->callback(lun_hop->term, lun_hop->file, lun_hop->data, lun_hop->resume); mem_free_if(lun_hop->ofile); mem_free(lun_hop); } /** The use chose "Cancel" when asked where to download a file. * * lookup_unique_name() passes this function as a ::done_handler_T to * msg_box(). * * @relates lun_hop */ static void lun_cancel(void *lun_hop_) { struct lun_hop *lun_hop = lun_hop_; lun_hop->callback(lun_hop->term, NULL, lun_hop->data, lun_hop->resume); mem_free_if(lun_hop->ofile); mem_free_if(lun_hop->file); mem_free(lun_hop); } /** The use chose "Overwrite the original file" when asked where to * download a file. * * lookup_unique_name() passes this function as a ::done_handler_T to * msg_box(). * * @relates lun_hop */ static void lun_overwrite(void *lun_hop_) { struct lun_hop *lun_hop = lun_hop_; lun_hop->callback(lun_hop->term, lun_hop->ofile, lun_hop->data, lun_hop->resume); mem_free_if(lun_hop->file); mem_free(lun_hop); } /** The user chose "Resume download of the original file" when asked * where to download a file. * * lookup_unique_name() passes this function as a ::done_handler_T to * msg_box(). * * @relates lun_hop */ static void lun_resume(void *lun_hop_) { struct lun_hop *lun_hop = lun_hop_; lun_hop->callback(lun_hop->term, lun_hop->ofile, lun_hop->data, lun_hop->resume | DOWNLOAD_RESUME_SELECTED); mem_free_if(lun_hop->file); mem_free(lun_hop); } /** If attempting to download to an existing file, perhaps ask * the user whether to resume, overwrite, or save elsewhere. * This function constructs a struct lun_hop, which will be freed * when the user answers the question. * * @param term * The terminal in which this function should show its UI. * * @param[in] ofile * A proposed name for the local file to which the data would be * downloaded. "~" here refers to the home directory. * lookup_unique_name() treats this original string as read-only. * * @param[in] resume * Indicates if the user already chose to resume downloading, * before ELinks even asked for the file name. * See ::ACT_MAIN_LINK_DOWNLOAD_RESUME. * * @param callback * Will be called when the user answers, or right away if the question * need not or cannot be asked. * * @param data * A pointer to be passed to @a callback. If @a resume includes * ::DOWNLOAD_RESUME_ALLOWED, this must point to struct cdf_hop * because the pointer can be read by lun_resume(), which assumes so. * * @relates lun_hop */ static void lookup_unique_name(struct terminal *term, unsigned char *ofile, enum download_resume resume, lun_callback_T *callback, void *data) { /* [gettext_accelerator_context(.lookup_unique_name)] */ struct lun_hop *lun_hop; unsigned char *file = NULL; int overwrite; ofile = expand_tilde(ofile); if (!ofile) goto error; /* Minor code duplication to prevent useless call to get_opt_int() * if possible. --Zas */ if (resume & DOWNLOAD_RESUME_SELECTED) { callback(term, ofile, data, resume); return; } /* !overwrite means always silently overwrite, which may be admitelly * indeed a little confusing ;-) */ overwrite = get_opt_int("document.download.overwrite"); if (!overwrite) { /* Nothing special to do... */ callback(term, ofile, data, resume); return; } /* Check if file is a directory, and use a default name if it's the * case. */ if (file_is_dir(ofile)) { info_box(term, MSGBOX_FREE_TEXT, N_("Download error"), ALIGN_CENTER, msg_text(term, N_("'%s' is a directory."), ofile)); goto error; } /* Check if the file already exists (file != ofile). */ file = get_unique_name(ofile); if (!file || overwrite == 1 || file == ofile) { /* Still nothing special to do... */ if (file != ofile) mem_free(ofile); callback(term, file, data, resume & ~DOWNLOAD_RESUME_SELECTED); return; } /* overwrite == 2 (ask) and file != ofile (=> original file already * exists) */ lun_hop = mem_calloc(1, sizeof(*lun_hop)); if (!lun_hop) goto error; lun_hop->term = term; lun_hop->ofile = ofile; lun_hop->file = (file != ofile) ? file : stracpy(ofile); lun_hop->callback = callback; lun_hop->data = data; lun_hop->resume = resume; msg_box(term, NULL, MSGBOX_FREE_TEXT, N_("File exists"), ALIGN_CENTER, msg_text(term, N_("This file already exists:\n" "%s\n\n" "The alternative filename is:\n" "%s"), empty_string_or_(lun_hop->ofile), empty_string_or_(file)), lun_hop, 4, MSG_BOX_BUTTON(N_("Sa~ve under the alternative name"), lun_alternate, B_ENTER), MSG_BOX_BUTTON(N_("~Overwrite the original file"), lun_overwrite, 0), MSG_BOX_BUTTON((resume & DOWNLOAD_RESUME_ALLOWED ? N_("~Resume download of the original file") : NULL), lun_resume, 0), MSG_BOX_BUTTON(N_("~Cancel"), lun_cancel, B_ESC)); return; error: if (file != ofile) mem_free_if(file); mem_free_if(ofile); callback(term, NULL, data, resume & ~DOWNLOAD_RESUME_SELECTED); } /** Now that the final name of the download file has been chosen, * open the file and call the ::cdf_callback_T that was originally * given to create_download_file(). * * create_download_file() passes this function as a ::lun_callback_T * to lookup_unique_name(). * * @relates cdf_hop */ static void create_download_file_do(struct terminal *term, unsigned char *file, void *data, enum download_resume resume) { struct cdf_hop *cdf_hop = data; unsigned char *wd; int h = -1; int saved_errno; #ifdef NO_FILE_SECURITY int sf = 0; #else int sf = cdf_hop->safe; #endif if (!file) goto finish; wd = get_cwd(); set_cwd(term->cwd); /* Create parent directories if needed. */ mkalldirs(file); /* O_APPEND means repositioning at the end of file before each write(), * thus ignoring seek()s and that can hide mysterious bugs. IMHO. * --pasky */ h = open(file, O_CREAT | O_WRONLY | (resume & DOWNLOAD_RESUME_SELECTED ? 0 : O_TRUNC) | (sf && !(resume & DOWNLOAD_RESUME_SELECTED) ? O_EXCL : 0), sf ? 0600 : 0666); saved_errno = errno; /* Saved in case of ... --Zas */ if (wd) { set_cwd(wd); mem_free(wd); } if (h == -1) { info_box(term, MSGBOX_FREE_TEXT, N_("Download error"), ALIGN_CENTER, msg_text(term, N_("Could not create file '%s':\n%s"), file, strerror(saved_errno))); mem_free(file); goto finish; } else { set_bin(h); if (!cdf_hop->safe) { unsigned char *download_dir = get_opt_str("document.download.directory"); int i; safe_strncpy(download_dir, file, MAX_STR_LEN); /* Find the used directory so it's available in history */ for (i = strlen(download_dir); i >= 0; i--) if (dir_sep(download_dir[i])) break; download_dir[i + 1] = 0; } } if (cdf_hop->real_file) *cdf_hop->real_file = file; else mem_free(file); finish: cdf_hop->callback(term, h, cdf_hop->data, resume); mem_free(cdf_hop); } /** Create a file to which data can be downloaded. * This function constructs a struct cdf_hop that will be freed * when @a callback returns. * * @param term * If any dialog boxes are needed, show them in this terminal. * * @param fi * A proposed name for the local file to which the data would be * downloaded. "~" here refers to the home directory. * create_download_file() treats this original string as read-only. * * @param real_file * If non-NULL, prepare to save in *@a real_file the name of the local * file that was eventually opened. @a callback must then arrange for * this string to be freed with mem_free(). * * @param safe * If nonzero, give only the user herself access to the file (even if * the umask is looser), and create the file with @c O_EXCL unless * resuming. * * @param resume * Whether the download can be resumed, and whether the user already * asked for it to be resumed. * * @param callback * This function will be called when the file has been opened, * or when it is known that the file will not be opened. * * @param data * A pointer to be passed to @a callback. * * @relates cdf_hop */ void create_download_file(struct terminal *term, unsigned char *fi, unsigned char **real_file, int safe, enum download_resume resume, cdf_callback_T *callback, void *data) { struct cdf_hop *cdf_hop = mem_calloc(1, sizeof(*cdf_hop)); unsigned char *wd; if (!cdf_hop) { callback(term, -1, data, resume & ~DOWNLOAD_RESUME_SELECTED); return; } cdf_hop->real_file = real_file; cdf_hop->safe = safe; cdf_hop->callback = callback; cdf_hop->data = data; /* FIXME: The wd bussiness is probably useless here? --pasky */ wd = get_cwd(); set_cwd(term->cwd); /* Also the tilde will be expanded here. */ lookup_unique_name(term, fi, resume, create_download_file_do, cdf_hop); if (wd) { set_cwd(wd); mem_free(wd); } } static unsigned char * get_temp_name(struct uri *uri) { struct string name; unsigned char *extension; /* FIXME * We use tempnam() here, which is unsafe (race condition), for now. * This should be changed at some time, but it needs an in-depth work * of whole download code. --Zas */ unsigned char *nm = tempnam(NULL, ELINKS_TEMPNAME_PREFIX); if (!nm) return NULL; if (!init_string(&name)) { free(nm); return NULL; } add_to_string(&name, nm); free(nm); extension = get_extension_from_uri(uri); if (extension) { add_shell_safe_to_string(&name, extension, strlen(extension)); mem_free(extension); } return name.source; } static unsigned char * subst_file(unsigned char *prog, unsigned char *file) { struct string name; /* When there is no %s in the mailcap entry, the handler program reads * data from stdin instead of a file. */ int input = 1; if (!init_string(&name)) return NULL; while (*prog) { int p; for (p = 0; prog[p] && prog[p] != '%'; p++); add_bytes_to_string(&name, prog, p); prog += p; if (*prog == '%') { input = 0; #if defined(HAVE_CYGWIN_CONV_TO_FULL_WIN32_PATH) #ifdef MAX_PATH unsigned char new_path[MAX_PATH]; #else unsigned char new_path[1024]; #endif cygwin_conv_to_full_win32_path(file, new_path); add_to_string(&name, new_path); #else add_shell_quoted_to_string(&name, file, strlen(file)); #endif prog++; } } if (input) { struct string s; if (init_string(&s)) { add_to_string(&s, "/bin/cat "); add_shell_quoted_to_string(&s, file, strlen(file)); add_to_string(&s, " | "); add_string_to_string(&s, &name); done_string(&name); return s.source; } } return name.source; } /*! common_download() passes this function as a ::cdf_callback_T to * create_download_file(). * * @relates cmdw_hop */ static void common_download_do(struct terminal *term, int fd, void *data, enum download_resume resume) { struct file_download *file_download; struct cmdw_hop *cmdw_hop = data; struct uri *download_uri = cmdw_hop->download_uri; unsigned char *file = cmdw_hop->real_file; struct session *ses = cmdw_hop->ses; struct stat buf; mem_free(cmdw_hop); if (!file || fstat(fd, &buf)) goto finish; file_download = init_file_download(download_uri, ses, file, fd); if (!file_download) goto finish; /* If init_file_download succeeds, it takes ownership of file * and fd. */ file = NULL; fd = -1; if (resume & DOWNLOAD_RESUME_SELECTED) file_download->seek = buf.st_size; display_download(ses->tab->term, file_download, ses); load_uri(file_download->uri, ses->referrer, &file_download->download, PRI_DOWNLOAD, CACHE_MODE_NORMAL, file_download->seek); finish: mem_free_if(file); if (fd != -1) close(fd); done_uri(download_uri); } /** Begin or resume downloading from session.download_uri to the * @a file specified by the user. * * This function contains the code shared between start_download() and * resume_download(). * * @relates cmdw_hop */ static void common_download(struct session *ses, unsigned char *file, enum download_resume resume) { struct cmdw_hop *cmdw_hop; if (!ses->download_uri) return; cmdw_hop = mem_calloc(1, sizeof(*cmdw_hop)); if (!cmdw_hop) return; cmdw_hop->ses = ses; cmdw_hop->download_uri = ses->download_uri; ses->download_uri = NULL; kill_downloads_to_file(file); create_download_file(ses->tab->term, file, &cmdw_hop->real_file, 0, resume, common_download_do, cmdw_hop); } /** Begin downloading from session.download_uri to the @a file * specified by the user. * * The ::ACT_MAIN_SAVE_AS, ::ACT_MAIN_SAVE_URL_AS, * ::ACT_MAIN_LINK_DOWNLOAD, and ::ACT_MAIN_LINK_DOWNLOAD_IMAGE * actions pass this function as the @c std callback to query_file(). * * @relates cmdw_hop */ void start_download(void *ses, unsigned char *file) { common_download(ses, file, DOWNLOAD_RESUME_ALLOWED); } /** Resume downloading from session.download_uri to the @a file * specified by the user. * * The ::ACT_MAIN_LINK_DOWNLOAD_RESUME action passes this function as * the @c std callback to query_file(). * * @relates cmdw_hop */ void resume_download(void *ses, unsigned char *file) { common_download(ses, file, DOWNLOAD_RESUME_ALLOWED | DOWNLOAD_RESUME_SELECTED); } /** Resume downloading a file, based on information in struct * codw_hop. This function actually starts a new download from the * current end of the file, even though a download from the beginning * is already in progress at codw_hop->type_query->download. The * caller will cancel the preexisting download after this function * returns. * * @relates codw_hop */ static void transform_codw_to_cmdw(struct terminal *term, int fd, struct codw_hop *codw_hop, enum download_resume resume) { struct type_query *type_query = codw_hop->type_query; struct cmdw_hop *cmdw_hop = mem_calloc(1, sizeof(*cmdw_hop)); if (!cmdw_hop) { close(fd); return; } cmdw_hop->ses = type_query->ses; cmdw_hop->download_uri = get_uri_reference(type_query->uri); cmdw_hop->real_file = codw_hop->real_file; codw_hop->real_file = NULL; common_download_do(term, fd, cmdw_hop, resume); } /*! continue_download() passes this function as a ::cdf_callback_T to * create_download_file(). * * @relates codw_hop */ static void continue_download_do(struct terminal *term, int fd, void *data, enum download_resume resume) { struct codw_hop *codw_hop = data; struct file_download *file_download = NULL; struct type_query *type_query; assert(codw_hop); assert(codw_hop->type_query); assert(codw_hop->type_query->uri); assert(codw_hop->type_query->ses); type_query = codw_hop->type_query; if (!codw_hop->real_file) goto cancel; if (resume & DOWNLOAD_RESUME_SELECTED) { transform_codw_to_cmdw(term, fd, codw_hop, resume); fd = -1; /* ownership transfer */ goto cancel; } file_download = init_file_download(type_query->uri, type_query->ses, codw_hop->real_file, fd); if (!file_download) goto cancel; /* If init_file_download succeeds, it takes ownership of * codw_hop->real_file and fd. */ codw_hop->real_file = NULL; fd = -1; if (type_query->external_handler) { file_download->external_handler = subst_file(type_query->external_handler, codw_hop->file); file_download->delete = 1; mem_free(codw_hop->file); mem_free_set(&type_query->external_handler, NULL); } file_download->block = !!type_query->block; /* Done here and not in init_file_download() so that the external * handler can become initialized. */ display_download(term, file_download, type_query->ses); move_download(&type_query->download, &file_download->download, PRI_DOWNLOAD); done_type_query(type_query); mem_free(codw_hop); return; cancel: mem_free_if(codw_hop->real_file); if (fd != -1) close(fd); if (type_query->external_handler) mem_free_if(codw_hop->file); tp_cancel(type_query); mem_free(codw_hop); } /** When asked what to do with a file, the user chose to download it * to a local file named @a file. * Or an external handler was selected, in which case * type_query.external_handler is non-NULL and @a file does not * matter because this function will generate a name. * * tp_save() passes this function as the @c std callback to query_file(). * * @relates codw_hop */ static void continue_download(void *data, unsigned char *file) { struct type_query *type_query = data; struct codw_hop *codw_hop = mem_calloc(1, sizeof(*codw_hop)); if (!codw_hop) { tp_cancel(type_query); return; } if (type_query->external_handler) { /* FIXME: get_temp_name() calls tempnam(). --Zas */ file = get_temp_name(type_query->uri); if (!file) { mem_free(codw_hop); tp_cancel(type_query); return; } } codw_hop->type_query = type_query; codw_hop->file = file; kill_downloads_to_file(file); create_download_file(type_query->ses->tab->term, file, &codw_hop->real_file, !!type_query->external_handler, DOWNLOAD_RESUME_ALLOWED, continue_download_do, codw_hop); } /** Prepare to ask the user what to do with a file, but don't display * the window yet. To display it, do_type_query() must be called * separately. setup_download_handler() takes care of that. * * @relates type_query */ static struct type_query * init_type_query(struct session *ses, struct download *download, struct cache_entry *cached) { struct type_query *type_query; /* There can be only one ... */ foreach (type_query, ses->type_queries) if (compare_uri(type_query->uri, ses->loading_uri, 0)) return NULL; type_query = mem_calloc(1, sizeof(*type_query)); if (!type_query) return NULL; type_query->uri = get_uri_reference(ses->loading_uri); type_query->ses = ses; type_query->target_frame = null_or_stracpy(ses->task.target.frame); type_query->cached = cached; type_query->cgi = cached->cgi; object_lock(type_query->cached); move_download(download, &type_query->download, PRI_MAIN); download->state = connection_state(S_OK); add_to_list(ses->type_queries, type_query); return type_query; } /** Cancel any download started for @a type_query, remove the structure * from the session.type_queries list, and free it. * * @relates type_query */ void done_type_query(struct type_query *type_query) { /* Unregister any active download */ cancel_download(&type_query->download, 0); object_unlock(type_query->cached); done_uri(type_query->uri); mem_free_if(type_query->external_handler); mem_free_if(type_query->target_frame); del_from_list(type_query); mem_free(type_query); } /** The user chose "Cancel" when asked what to do with a file, * or the type query was cancelled for some other reason. * * do_type_query() and bittorrent_query_callback() pass this function * as a ::done_handler_T to add_dlg_ok_button(), and tp_save() passes * this function as a @c cancel callback to query_file(). * * @relates type_query */ void tp_cancel(void *data) { struct type_query *type_query = data; /* XXX: Should we really abort? (1 vs 0 as the last param) --pasky */ cancel_download(&type_query->download, 1); done_type_query(type_query); } /** The user chose "Save" when asked what to do with a file. * Now ask her where to save the file. * * do_type_query() and bittorrent_query_callback() pass this function * as a ::done_handler_T to add_dlg_ok_button(). * * @relates type_query */ void tp_save(struct type_query *type_query) { mem_free_set(&type_query->external_handler, NULL); query_file(type_query->ses, type_query->uri, type_query, continue_download, tp_cancel, 1); } /** The user chose "Show header" when asked what to do with a file. * * do_type_query() passes this function as a ::widget_handler_T to * add_dlg_button(). Unlike with add_dlg_ok_button(), pressing this * button does not close the dialog box. This way, the user can * first examine the header and then choose what to do. * * @relates type_query */ static widget_handler_status_T tp_show_header(struct dialog_data *dlg_data, struct widget_data *widget_data) { struct type_query *type_query = widget_data->widget->data; cached_header_dialog(type_query->ses, type_query->cached); return EVENT_PROCESSED; } /** The user chose "Display" when asked what to do with a file, * or she chose "Open" and there is no external handler. * * do_type_query() and bittorrent_query_callback() pass this function * as a ::done_handler_T to add_dlg_ok_button(). * * @bug FIXME: We need to modify this function to take frame data * instead, as we want to use this function for frames as well (now, * when frame has content type text/plain, it is ignored and displayed * as HTML). * * @relates type_query */ void tp_display(struct type_query *type_query) { struct view_state *vs; struct session *ses = type_query->ses; struct uri *loading_uri = ses->loading_uri; unsigned char *target_frame = ses->task.target.frame; ses->loading_uri = type_query->uri; ses->task.target.frame = type_query->target_frame; vs = ses_forward(ses, /* type_query->frame */ 0); if (vs) vs->plain = 1; ses->loading_uri = loading_uri; ses->task.target.frame = target_frame; if (/* !type_query->frame */ 1) { struct download *old = &type_query->download; struct download *new = &cur_loc(ses)->download; new->callback = (download_callback_T *) doc_loading_callback; new->data = ses; move_download(old, new, PRI_MAIN); } display_timer(ses); done_type_query(type_query); } /** The user chose "Open" when asked what to do with a file. * Or an external handler was found and it has been configured * to run without asking. * * do_type_query() passes this function as a ::done_handler_T to * add_dlg_ok_button(). * * @relates type_query */ static void tp_open(struct type_query *type_query) { if (!type_query->external_handler || !*type_query->external_handler) { tp_display(type_query); return; } if (type_query->uri->protocol == PROTOCOL_FILE && !type_query->cgi) { unsigned char *file = get_uri_string(type_query->uri, URI_PATH); unsigned char *handler = NULL; if (file) { decode_uri(file); handler = subst_file(type_query->external_handler, file); mem_free(file); } if (handler) { exec_on_terminal(type_query->ses->tab->term, handler, "", type_query->block ? TERM_EXEC_FG : TERM_EXEC_BG); mem_free(handler); } done_type_query(type_query); return; } continue_download(type_query, ""); } /*! Ask the user what to do with a file. * * This function does not support BitTorrent downloads. * For those, query_bittorrent_dialog() must be called instead. * setup_download_handler() takes care of this. * * @relates type_query */ static void do_type_query(struct type_query *type_query, unsigned char *ct, struct mime_handler *handler) { /* [gettext_accelerator_context(.do_type_query)] */ struct string filename; unsigned char *description; unsigned char *desc_sep; unsigned char *format, *text, *title; struct dialog *dlg; #define TYPE_QUERY_WIDGETS_COUNT 8 int widgets = TYPE_QUERY_WIDGETS_COUNT; struct terminal *term = type_query->ses->tab->term; struct memory_list *ml; struct dialog_data *dlg_data; int selected_widget; mem_free_set(&type_query->external_handler, NULL); if (handler) { type_query->block = handler->block; if (!handler->ask) { type_query->external_handler = stracpy(handler->program); tp_open(type_query); return; } /* Start preparing for the type query dialog. */ description = handler->description; desc_sep = *description ? "; " : ""; title = N_("What to do?"); } else { title = N_("Unknown type"); description = ""; desc_sep = ""; } dlg = calloc_dialog(TYPE_QUERY_WIDGETS_COUNT, MAX_STR_LEN * 2); if (!dlg) return; if (init_string(&filename)) { add_mime_filename_to_string(&filename, type_query->uri); /* Let's make the filename pretty for display & save */ /* TODO: The filename can be the empty string here. See bug 396. */ #ifdef CONFIG_UTF8 if (term->utf8_cp) decode_uri_string(&filename); else #endif /* CONFIG_UTF8 */ decode_uri_string_for_display(&filename); } text = get_dialog_offset(dlg, TYPE_QUERY_WIDGETS_COUNT); /* For "default directory index pages" with wrong content-type * the filename can be NULL, e.g. http://www.spamhaus.org in bug 396. */ if (filename.length) { format = _("What would you like to do with the file '%s' (type: %s%s%s)?", term); snprintf(text, MAX_STR_LEN, format, filename.source, ct, desc_sep, description); } else { format = _("What would you like to do with the file (type: %s%s%s)?", term); snprintf(text, MAX_STR_LEN, format, ct, desc_sep, description); } done_string(&filename); dlg->title = _(title, term); dlg->layouter = generic_dialog_layouter; dlg->layout.padding_top = 1; dlg->layout.fit_datalen = 1; dlg->udata2 = type_query; add_dlg_text(dlg, text, ALIGN_LEFT, 0); /* Add input field or text widget with info about the program handler. */ if (!get_cmd_opt_bool("anonymous")) { unsigned char *field = mem_calloc(1, MAX_STR_LEN); if (!field) { mem_free(dlg); return; } if (handler && handler->program) { safe_strncpy(field, handler->program, MAX_STR_LEN); } /* xgettext:no-c-format */ add_dlg_field(dlg, _("Program ('%' will be replaced by the filename)", term), 0, 0, NULL, MAX_STR_LEN, field, NULL); type_query->external_handler = field; add_dlg_radio(dlg, _("Block the terminal", term), 0, 0, &type_query->block); selected_widget = 3; } else if (handler) { unsigned char *field = text + MAX_STR_LEN; format = _("The file will be opened with the program '%s'.", term); snprintf(field, MAX_STR_LEN, format, handler->program); add_dlg_text(dlg, field, ALIGN_LEFT, 0); type_query->external_handler = stracpy(handler->program); if (!type_query->external_handler) { mem_free(dlg); return; } widgets--; selected_widget = 2; } else { widgets -= 2; selected_widget = 1; } /* Add buttons if they are both usable and allowed. */ if (!get_cmd_opt_bool("anonymous") || handler) { add_dlg_ok_button(dlg, _("~Open", term), B_ENTER, (done_handler_T *) tp_open, type_query); } else { widgets--; } if (!get_cmd_opt_bool("anonymous")) { add_dlg_ok_button(dlg, _("Sa~ve", term), B_ENTER, (done_handler_T *) tp_save, type_query); } else { widgets--; } add_dlg_ok_button(dlg, _("~Display", term), B_ENTER, (done_handler_T *) tp_display, type_query); if (type_query->cached && type_query->cached->head) { add_dlg_button(dlg, _("Show ~header", term), B_ENTER, tp_show_header, type_query); } else { widgets--; } add_dlg_ok_button(dlg, _("~Cancel", term), B_ESC, (done_handler_T *) tp_cancel, type_query); add_dlg_end(dlg, widgets); ml = getml(dlg, (void *) NULL); if (!ml) { /* XXX: Assume that the allocated @external_handler will be * freed when releasing the @type_query. */ mem_free(dlg); return; } dlg_data = do_dialog(term, dlg, ml); /* Don't focus the text field; we want the user to be able * to select a button by typing the first letter of its label * without having to first leave the text field. */ if (dlg_data) { select_widget_by_id(dlg_data, selected_widget); } } struct { unsigned char *type; unsigned int plain:1; } static const known_types[] = { { "text/html", 0 }, { "text/plain", 1 }, { "application/xhtml+xml", 0 }, /* RFC 3236 */ #if CONFIG_DOM { "application/docbook+xml", 1 }, { "application/rss+xml", 0 }, { "application/xbel+xml", 1 }, { "application/xbel", 1 }, { "application/x-xbel", 1 }, #endif { NULL, 1 }, }; /*! @relates type_query */ int setup_download_handler(struct session *ses, struct download *loading, struct cache_entry *cached, int frame) { struct mime_handler *handler; struct view_state *vs; struct type_query *type_query; unsigned char *ctype = get_content_type(cached); int plaintext = 1; int ret = 0; int xwin, i; if (!ctype || !*ctype) goto plaintext_follow; for (i = 0; known_types[i].type; i++) { if (c_strcasecmp(ctype, known_types[i].type)) continue; plaintext = known_types[i].plain; goto plaintext_follow; } xwin = ses->tab->term->environment & ENV_XWIN; handler = get_mime_type_handler(ctype, xwin); if (!handler && strlen(ctype) >= 4 && !c_strncasecmp(ctype, "text", 4)) goto plaintext_follow; type_query = init_type_query(ses, loading, cached); if (type_query) { ret = 1; #ifdef CONFIG_BITTORRENT /* A terrible waste of a good MIME handler here, but we want * to use the type_query this is easier. */ if ((!c_strcasecmp(ctype, "application/x-bittorrent") || !c_strcasecmp(ctype, "application/x-torrent")) && !get_cmd_opt_bool("anonymous")) query_bittorrent_dialog(type_query); else #endif do_type_query(type_query, ctype, handler); } mem_free_if(handler); return ret; plaintext_follow: vs = ses_forward(ses, frame); if (vs) vs->plain = plaintext; return 0; }