putty-source/unix/utils/make_spr_sw_abort_errno.c

/*
 * Constructor function for a SeatPromptResult of the 'software abort'
 * category, whose error message includes the translation of an OS
 * error code.
 */

#include "putty.h"

static void spr_errno_errfn(SeatPromptResult spr, BinarySink *bs)
{
    put_fmt(bs, "%s: %s", spr.errdata_lit, strerror(spr.errdata_u));
}

SeatPromptResult make_spr_sw_abort_errno(const char *prefix, int errno_value)
{
    SeatPromptResult spr;
    spr.kind = SPRK_SW_ABORT;
    spr.errfn = spr_errno_errfn;
    spr.errdata_lit = prefix;
    spr.errdata_u = errno_value;
    return spr;
}
Richer data type for interactive prompt results. All the seat functions that request an interactive prompt of some kind to the user - both the main seat_get_userpass_input and the various confirmation dialogs for things like host keys - were using a simple int return value, with the general semantics of 0 = "fail", 1 = "proceed" (and in the case of seat_get_userpass_input, answers to the prompts were provided), and -1 = "request in progress, wait for a callback". In this commit I change all those functions' return types to a new struct called SeatPromptResult, whose primary field is an enum replacing those simple integer values. The main purpose is that the enum has not three but _four_ values: the "fail" result has been split into 'user abort' and 'software abort'. The distinction is that a user abort occurs as a result of an interactive UI action, such as the user clicking 'cancel' in a dialog box or hitting ^D or ^C at a terminal password prompt - and therefore, there's no need to display an error message telling the user that the interactive operation has failed, because the user already knows, because they _did_ it. 'Software abort' is from any other cause, where PuTTY is the first to know there was a problem, and has to tell the user. We already had this 'user abort' vs 'software abort' distinction in other parts of the code - the SSH backend has separate termination functions which protocol layers can call. But we assumed that any failure from an interactive prompt request fell into the 'user abort' category, which is not true. A couple of examples: if you configure a host key fingerprint in your saved session via the SSH > Host keys pane, and the server presents a host key that doesn't match it, then verify_ssh_host_key would report that the user had aborted the connection, and feel no need to tell the user what had gone wrong! Similarly, if a password provided on the command line was not accepted, then (after I fixed the semantics of that in the previous commit) the same wrong handling would occur. So now, those Seat prompt functions too can communicate whether the user or the software originated a connection abort. And in the latter case, we also provide an error message to present to the user. Result: in those two example cases (and others), error messages should no longer go missing. Implementation note: to avoid the hassle of having the error message in a SeatPromptResult being a dynamically allocated string (and hence, every recipient of one must always check whether it's non-NULL and free it on every exit path, plus being careful about copying the struct around), I've instead arranged that the structure contains a function pointer and a couple of parameters, so that the string form of the message can be constructed on demand. That way, the only users who need to free it are the ones who actually _asked_ for it in the first place, which is a much smaller set. (This is one of the rare occasions that I regret not having C++'s extra features available in this code base - a unique_ptr or shared_ptr to a string would have been just the thing here, and the compiler would have done all the hard work for me of remembering where to insert the frees!) 2021-12-28 17:52:00 +00:00			`/*`
			`* Constructor function for a SeatPromptResult of the 'software abort'`
			`* category, whose error message includes the translation of an OS`
			`* error code.`
			`*/`

			`#include "putty.h"`

			`static void spr_errno_errfn(SeatPromptResult spr, BinarySink *bs)`
			`{`
			`put_fmt(bs, "%s: %s", spr.errdata_lit, strerror(spr.errdata_u));`
			`}`

			`SeatPromptResult make_spr_sw_abort_errno(const char *prefix, int errno_value)`
			`{`
			`SeatPromptResult spr;`
			`spr.kind = SPRK_SW_ABORT;`
			`spr.errfn = spr_errno_errfn;`
			`spr.errdata_lit = prefix;`
			`spr.errdata_u = errno_value;`
			`return spr;`
			`}`