nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-07-02 03:52:49 -05:00
Code Issues Projects Releases Wiki Activity

Rename 'ret' variables passed from allocation to return.

Browse Source 
I mentioned recently (in commit 9e7d4c53d8) message that I'm no
longer fond of the variable name 'ret', because it's used in two quite
different contexts: it's the return value from a subroutine you just
called (e.g. 'int ret = read(fd, buf, len);' and then check for error
or EOF), or it's the value you're preparing to return from the
_containing_ routine (maybe by assigning it a default value and then
conditionally modifying it, or by starting at NULL and reallocating,
or setting it just before using the 'goto out' cleanup idiom). In the
past I've occasionally made mistakes by forgetting which meaning the
variable had, or accidentally conflating both uses.

If all else fails, I now prefer 'retd' (short for 'returned') in the
former situation, and 'toret' (obviously, the value 'to return') in
the latter case. But even better is to pick a name that actually says
something more specific about what the thing actually is.

One particular bad habit throughout this codebase is to have a set of
functions that deal with some object type (say 'Foo'), all *but one*
of which take a 'Foo *foo' parameter, but the foo_new() function
starts with 'Foo *ret = snew(Foo)'. If all the rest of them think the
canonical name for the ambient Foo is 'foo', so should foo_new()!

So here's a no-brainer start on cutting down on the uses of 'ret': I
looked for all the cases where it was being assigned the result of an
allocation, and renamed the variable to be a description of the thing
being allocated. In the case of a new() function belonging to a
family, I picked the same name as the rest of the functions in its own
family, for consistency. In other cases I picked something sensible.

One case where it _does_ make sense not to use your usual name for the
variable type is when you're cloning an existing object. In that case,
_neither_ of the Foo objects involved should be called 'foo', because
it's ambiguous! They should be named so you can see which is which. In
the two cases I found here, I've called them 'orig' and 'copy'.

As in the previous refactoring, many thanks to clang-rename for the
help.
This commit is contained in:
Simon Tatham
2022-09-13 14:53:36 +01:00
parent 6cf6682c54
commit 20f818af12
19 changed files with 508 additions and 511 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
windows/named-pipe-server.c
View File

@ -201,35 +201,35 @@ static const SocketVtable NamedPipeServerSocket_sockvt = {
Socket *new_named_pipe_listener(const char *pipename, Plug *plug)
{
NamedPipeServerSocket *ret = snew(NamedPipeServerSocket);
ret->sock.vt = &NamedPipeServerSocket_sockvt;
ret->plug = plug;
ret->error = NULL;
ret->psd = NULL;
ret->pipename = dupstr(pipename);
ret->acl = NULL;
ret->callback_handle = NULL;
NamedPipeServerSocket *ps = snew(NamedPipeServerSocket);
ps->sock.vt = &NamedPipeServerSocket_sockvt;
ps->plug = plug;
ps->error = NULL;
ps->psd = NULL;
ps->pipename = dupstr(pipename);
ps->acl = NULL;
ps->callback_handle = NULL;
assert(strncmp(pipename, "\\\\.\\pipe\\", 9) == 0);
assert(strchr(pipename + 9, '\\') == NULL);
if (!make_private_security_descriptor(GENERIC_READ | GENERIC_WRITE,
&ret->psd, &ret->acl, &ret->error)) {
&ps->psd, &ps->acl, &ps->error)) {
goto cleanup;
}
if (!create_named_pipe(ret, true)) {
ret->error = dupprintf("unable to create named pipe '%s': %s",
if (!create_named_pipe(ps, true)) {
ps->error = dupprintf("unable to create named pipe '%s': %s",
pipename, win_strerror(GetLastError()));
goto cleanup;
}
memset(&ret->connect_ovl, 0, sizeof(ret->connect_ovl));
ret->connect_ovl.hEvent = CreateEvent(NULL, true, false, NULL);
ret->callback_handle = add_handle_wait(
ret->connect_ovl.hEvent, named_pipe_connect_callback, ret);
named_pipe_accept_loop(ret, false);
memset(&ps->connect_ovl, 0, sizeof(ps->connect_ovl));
ps->connect_ovl.hEvent = CreateEvent(NULL, true, false, NULL);
ps->callback_handle = add_handle_wait(
ps->connect_ovl.hEvent, named_pipe_connect_callback, ps);
named_pipe_accept_loop(ps, false);
cleanup:
return &ret->sock;
return &ps->sock;
}

214
windows/network.c
View File

@ -547,18 +547,18 @@ SockAddr *sk_namelookup(const char *host, char **canonicalname,
static SockAddr *sk_special_addr(SuperFamily superfamily, const char *name)
{
SockAddr *ret = snew(SockAddr);
ret->error = NULL;
ret->superfamily = superfamily;
SockAddr *addr = snew(SockAddr);
addr->error = NULL;
addr->superfamily = superfamily;
#ifndef NO_IPV6
ret->ais = NULL;
addr->ais = NULL;
#endif
ret->addresses = NULL;
ret->naddresses = 0;
ret->refcount = 1;
strncpy(ret->hostname, name, lenof(ret->hostname));
ret->hostname[lenof(ret->hostname)-1] = '\0';
return ret;
addr->addresses = NULL;
addr->naddresses = 0;
addr->refcount = 1;
strncpy(addr->hostname, name, lenof(addr->hostname));
addr->hostname[lenof(addr->hostname)-1] = '\0';
return addr;
}
SockAddr *sk_nonamelookup(const char *host)
@ -838,47 +838,47 @@ static Socket *sk_net_accept(accept_ctx_t ctx, Plug *plug)
{
DWORD err;
const char *errstr;
NetSocket *ret;
NetSocket *s;
/*
* Create NetSocket structure.
*/
ret = snew(NetSocket);
ret->sock.vt = &NetSocket_sockvt;
ret->error = NULL;
ret->plug = plug;
bufchain_init(&ret->output_data);
ret->writable = true; /* to start with */
ret->sending_oob = 0;
ret->outgoingeof = EOF_NO;
ret->frozen = true;
ret->frozen_readable = false;
ret->localhost_only = false; /* unused, but best init anyway */
ret->pending_error = 0;
ret->parent = ret->child = NULL;
ret->addr = NULL;
s = snew(NetSocket);
s->sock.vt = &NetSocket_sockvt;
s->error = NULL;
s->plug = plug;
bufchain_init(&s->output_data);
s->writable = true; /* to start with */
s->sending_oob = 0;
s->outgoingeof = EOF_NO;
s->frozen = true;
s->frozen_readable = false;
s->localhost_only = false; /* unused, but best init anyway */
s->pending_error = 0;
s->parent = s->child = NULL;
s->addr = NULL;
ret->s = (SOCKET)ctx.p;
s->s = (SOCKET)ctx.p;
if (ret->s == INVALID_SOCKET) {
if (s->s == INVALID_SOCKET) {
err = p_WSAGetLastError();
ret->error = winsock_error_string(err);
return &ret->sock;
s->error = winsock_error_string(err);
return &s->sock;
}
ret->oobinline = false;
s->oobinline = false;
/* Set up a select mechanism. This could be an AsyncSelect on a
* window, or an EventSelect on an event object. */
errstr = do_select(ret->s, true);
errstr = do_select(s->s, true);
if (errstr) {
ret->error = errstr;
return &ret->sock;
s->error = errstr;
return &s->sock;
}
add234(sktree, ret);
add234(sktree, s);
return &ret->sock;
return &s->sock;
}
static DWORD try_connect(NetSocket *sock)
@ -1087,48 +1087,48 @@ static DWORD try_connect(NetSocket *sock)
Socket *sk_new(SockAddr *addr, int port, bool privport, bool oobinline,
bool nodelay, bool keepalive, Plug *plug)
{
NetSocket *ret;
NetSocket *s;
DWORD err;
/*
* Create NetSocket structure.
*/
ret = snew(NetSocket);
ret->sock.vt = &NetSocket_sockvt;
ret->error = NULL;
ret->plug = plug;
bufchain_init(&ret->output_data);
ret->connected = false; /* to start with */
ret->writable = false; /* to start with */
ret->sending_oob = 0;
ret->outgoingeof = EOF_NO;
ret->frozen = false;
ret->frozen_readable = false;
ret->localhost_only = false; /* unused, but best init anyway */
ret->pending_error = 0;
ret->parent = ret->child = NULL;
ret->oobinline = oobinline;
ret->nodelay = nodelay;
ret->keepalive = keepalive;
ret->privport = privport;
ret->port = port;
ret->addr = addr;
START_STEP(ret->addr, ret->step);
ret->s = INVALID_SOCKET;
s = snew(NetSocket);
s->sock.vt = &NetSocket_sockvt;
s->error = NULL;
s->plug = plug;
bufchain_init(&s->output_data);
s->connected = false; /* to start with */
s->writable = false; /* to start with */
s->sending_oob = 0;
s->outgoingeof = EOF_NO;
s->frozen = false;
s->frozen_readable = false;
s->localhost_only = false; /* unused, but best init anyway */
s->pending_error = 0;
s->parent = s->child = NULL;
s->oobinline = oobinline;
s->nodelay = nodelay;
s->keepalive = keepalive;
s->privport = privport;
s->port = port;
s->addr = addr;
START_STEP(s->addr, s->step);
s->s = INVALID_SOCKET;
err = 0;
do {
err = try_connect(ret);
} while (err && sk_nextaddr(ret->addr, &ret->step));
err = try_connect(s);
} while (err && sk_nextaddr(s->addr, &s->step));
return &ret->sock;
return &s->sock;
}
static Socket *sk_newlistener_internal(
const char *srcaddr, int port, Plug *plug,
bool local_host_only, int orig_address_family)
{
SOCKET s;
SOCKET sk;
SOCKADDR_IN a;
#ifndef NO_IPV6
SOCKADDR_IN6 a6;
@ -1141,7 +1141,7 @@ static Socket *sk_newlistener_internal(
DWORD err;
const char *errstr;
NetSocket *ret;
NetSocket *s;
int retcode;
int address_family = orig_address_family;
@ -1149,20 +1149,20 @@ static Socket *sk_newlistener_internal(
/*
* Create NetSocket structure.
*/
ret = snew(NetSocket);
ret->sock.vt = &NetSocket_sockvt;
ret->error = NULL;
ret->plug = plug;
bufchain_init(&ret->output_data);
ret->writable = false; /* to start with */
ret->sending_oob = 0;
ret->outgoingeof = EOF_NO;
ret->frozen = false;
ret->frozen_readable = false;
ret->localhost_only = local_host_only;
ret->pending_error = 0;
ret->parent = ret->child = NULL;
ret->addr = NULL;
s = snew(NetSocket);
s->sock.vt = &NetSocket_sockvt;
s->error = NULL;
s->plug = plug;
bufchain_init(&s->output_data);
s->writable = false; /* to start with */
s->sending_oob = 0;
s->outgoingeof = EOF_NO;
s->frozen = false;
s->frozen_readable = false;
s->localhost_only = local_host_only;
s->pending_error = 0;
s->parent = s->child = NULL;
s->addr = NULL;
/*
* Our default, if passed the `don't care' value
@ -1176,25 +1176,25 @@ static Socket *sk_newlistener_internal(
/*
* Open socket.
*/
s = p_socket(address_family, SOCK_STREAM, 0);
ret->s = s;
sk = p_socket(address_family, SOCK_STREAM, 0);
s->s = sk;
if (s == INVALID_SOCKET) {
if (sk == INVALID_SOCKET) {
err = p_WSAGetLastError();
ret->error = winsock_error_string(err);
return &ret->sock;
s->error = winsock_error_string(err);
return &s->sock;
}
SetHandleInformation((HANDLE)s, HANDLE_FLAG_INHERIT, 0);
SetHandleInformation((HANDLE)sk, HANDLE_FLAG_INHERIT, 0);
ret->oobinline = false;
s->oobinline = false;
#if HAVE_AFUNIX_H
if (address_family != AF_UNIX)
#endif
{
BOOL on = true;
p_setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
p_setsockopt(sk, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
(const char *)&on, sizeof(on));
}
@ -1244,7 +1244,7 @@ static Socket *sk_newlistener_internal(
a.sin_addr.s_addr = p_inet_addr(srcaddr);
if (a.sin_addr.s_addr != INADDR_NONE) {
/* Override localhost_only with specified listen addr. */
ret->localhost_only = ipv4_is_loopback(a.sin_addr);
s->localhost_only = ipv4_is_loopback(a.sin_addr);
got_addr = true;
}
}
@ -1277,7 +1277,7 @@ static Socket *sk_newlistener_internal(
unreachable("bad address family in sk_newlistener_internal");
}
retcode = p_bind(s, bindaddr, bindsize);
retcode = p_bind(sk, bindaddr, bindsize);
if (retcode != SOCKET_ERROR) {
err = 0;
} else {
@ -1285,28 +1285,28 @@ static Socket *sk_newlistener_internal(
}
if (err) {
p_closesocket(s);
ret->error = winsock_error_string(err);
return &ret->sock;
p_closesocket(sk);
s->error = winsock_error_string(err);
return &s->sock;
}
if (p_listen(s, SOMAXCONN) == SOCKET_ERROR) {
p_closesocket(s);
ret->error = winsock_error_string(p_WSAGetLastError());
return &ret->sock;
if (p_listen(sk, SOMAXCONN) == SOCKET_ERROR) {
p_closesocket(sk);
s->error = winsock_error_string(p_WSAGetLastError());
return &s->sock;
}
/* Set up a select mechanism. This could be an AsyncSelect on a
* window, or an EventSelect on an event object. */
errstr = do_select(s, true);
errstr = do_select(sk, true);
if (errstr) {
p_closesocket(s);
ret->error = errstr;
return &ret->sock;
p_closesocket(sk);
s->error = errstr;
return &s->sock;
}
add234(sktree, ret);
add234(sktree, s);
#ifndef NO_IPV6
/*
@ -1320,8 +1320,8 @@ static Socket *sk_newlistener_internal(
if (other) {
NetSocket *ns = container_of(other, NetSocket, sock);
if (!ns->error) {
ns->parent = ret;
ret->child = ns;
ns->parent = s;
s->child = ns;
} else {
sfree(ns);
}
@ -1329,7 +1329,7 @@ static Socket *sk_newlistener_internal(
}
#endif
return &ret->sock;
return &s->sock;
}
Socket *sk_newlistener(const char *srcaddr, int port, Plug *plug,
@ -1871,9 +1871,9 @@ char *get_hostname(void)
SockAddr *platform_get_x11_unix_address(const char *display, int displaynum)
{
SockAddr *ret = snew(SockAddr);
memset(ret, 0, sizeof(SockAddr));
ret->error = "unix sockets for X11 not supported on this platform";
ret->refcount = 1;
return ret;
SockAddr *addr = snew(SockAddr);
memset(addr, 0, sizeof(SockAddr));
addr->error = "unix sockets for X11 not supported on this platform";
addr->refcount = 1;
return addr;
}

42
windows/printing.c
View File

@ -93,7 +93,7 @@ static bool printer_add_enum(int param, DWORD level, char **buffer,
printer_enum *printer_start_enum(int *nprinters_ptr)
{
printer_enum *ret = snew(printer_enum);
printer_enum *pe = snew(printer_enum);
char *buffer = NULL;
*nprinters_ptr = 0; /* default return value */
@ -110,30 +110,30 @@ printer_enum *printer_start_enum(int *nprinters_ptr)
* Bletch.
*/
if (osPlatformId != VER_PLATFORM_WIN32_NT) {
ret->enum_level = 5;
pe->enum_level = 5;
} else {
ret->enum_level = 4;
pe->enum_level = 4;
}
if (!printer_add_enum(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS,
ret->enum_level, &buffer, 0, nprinters_ptr))
pe->enum_level, &buffer, 0, nprinters_ptr))
goto error;
switch (ret->enum_level) {
switch (pe->enum_level) {
case 4:
ret->info.i4 = (LPPRINTER_INFO_4)buffer;
pe->info.i4 = (LPPRINTER_INFO_4)buffer;
break;
case 5:
ret->info.i5 = (LPPRINTER_INFO_5)buffer;
pe->info.i5 = (LPPRINTER_INFO_5)buffer;
break;
}
ret->nprinters = *nprinters_ptr;
pe->nprinters = *nprinters_ptr;
return ret;
return pe;
error:
sfree(buffer);
sfree(ret);
sfree(pe);
*nprinters_ptr = 0;
return NULL;
}
@ -171,38 +171,38 @@ void printer_finish_enum(printer_enum *pe)
printer_job *printer_start_job(char *printer)
{
printer_job *ret = snew(printer_job);
printer_job *pj = snew(printer_job);
DOC_INFO_1 docinfo;
bool jobstarted = false, pagestarted = false;
init_winfuncs();
ret->hprinter = NULL;
if (!p_OpenPrinter(printer, &ret->hprinter, NULL))
pj->hprinter = NULL;
if (!p_OpenPrinter(printer, &pj->hprinter, NULL))
goto error;
docinfo.pDocName = "PuTTY remote printer output";
docinfo.pOutputFile = NULL;
docinfo.pDatatype = "RAW";
if (!p_StartDocPrinter(ret->hprinter, 1, (LPBYTE)&docinfo))
if (!p_StartDocPrinter(pj->hprinter, 1, (LPBYTE)&docinfo))
goto error;
jobstarted = true;
if (!p_StartPagePrinter(ret->hprinter))
if (!p_StartPagePrinter(pj->hprinter))
goto error;
pagestarted = true;
return ret;
return pj;
error:
if (pagestarted)
p_EndPagePrinter(ret->hprinter);
p_EndPagePrinter(pj->hprinter);
if (jobstarted)
p_EndDocPrinter(ret->hprinter);
if (ret->hprinter)
p_ClosePrinter(ret->hprinter);
sfree(ret);
p_EndDocPrinter(pj->hprinter);
if (pj->hprinter)
p_ClosePrinter(pj->hprinter);
sfree(pj);
return NULL;
}

50
windows/sftp.c
View File

@ -104,15 +104,15 @@ RFile *open_existing_file(const char *name, uint64_t *size,
long *perms)
{
HANDLE h;
RFile *ret;
RFile *f;
h = CreateFile(name, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, 0);
if (h == INVALID_HANDLE_VALUE)
return NULL;
ret = snew(RFile);
ret->h = h;
f = snew(RFile);
f->h = h;
if (size) {
DWORD lo, hi;
@ -132,7 +132,7 @@ RFile *open_existing_file(const char *name, uint64_t *size,
if (perms)
*perms = -1;
return ret;
return f;
}
int read_from_file(RFile *f, void *buffer, int length)
@ -157,31 +157,31 @@ struct WFile {
WFile *open_new_file(const char *name, long perms)
{
HANDLE h;
WFile *ret;
WFile *f;
h = CreateFile(name, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
if (h == INVALID_HANDLE_VALUE)
return NULL;
ret = snew(WFile);
ret->h = h;
f = snew(WFile);
f->h = h;
return ret;
return f;
}
WFile *open_existing_wfile(const char *name, uint64_t *size)
{
HANDLE h;
WFile *ret;
WFile *f;
h = CreateFile(name, GENERIC_WRITE, FILE_SHARE_READ, NULL,
OPEN_EXISTING, 0, 0);
if (h == INVALID_HANDLE_VALUE)
return NULL;
ret = snew(WFile);
ret->h = h;
f = snew(WFile);
f->h = h;
if (size) {
DWORD lo, hi;
@ -189,7 +189,7 @@ WFile *open_existing_wfile(const char *name, uint64_t *size)
*size = uint64_from_words(hi, lo);
}
return ret;
return f;
}
int write_to_file(WFile *f, void *buffer, int length)
@ -277,7 +277,7 @@ DirHandle *open_directory(const char *name, const char **errmsg)
HANDLE h;
WIN32_FIND_DATA fdat;
char *findfile;
DirHandle *ret;
DirHandle *dir;
/* Enumerate files in dir `foo'. */
findfile = dupcat(name, "/*");
@ -288,10 +288,10 @@ DirHandle *open_directory(const char *name, const char **errmsg)
}
sfree(findfile);
ret = snew(DirHandle);
ret->h = h;
ret->name = dupstr(fdat.cFileName);
return ret;
dir = snew(DirHandle);
dir->h = h;
dir->name = dupstr(fdat.cFileName);
return dir;
}
char *read_filename(DirHandle *dir)
@ -384,26 +384,26 @@ WildcardMatcher *begin_wildcard_matching(const char *name)
{
HANDLE h;
WIN32_FIND_DATA fdat;
WildcardMatcher *ret;
WildcardMatcher *dir;
char *last;
h = FindFirstFile(name, &fdat);
if (h == INVALID_HANDLE_VALUE)
return NULL;
ret = snew(WildcardMatcher);
ret->h = h;
ret->srcpath = dupstr(name);
last = stripslashes(ret->srcpath, true);
dir = snew(WildcardMatcher);
dir->h = h;
dir->srcpath = dupstr(name);
last = stripslashes(dir->srcpath, true);
*last = '\0';
if (fdat.cFileName[0] == '.' &&
(fdat.cFileName[1] == '\0' ||
(fdat.cFileName[1] == '.' && fdat.cFileName[2] == '\0')))
ret->name = NULL;
dir->name = NULL;
else
ret->name = dupcat(ret->srcpath, fdat.cFileName);
dir->name = dupcat(dir->srcpath, fdat.cFileName);
return ret;
return dir;
}
char *wildcard_get_filename(WildcardMatcher *dir)

22
windows/storage.c
View File

@ -51,9 +51,9 @@ settings_w *open_settings_w(const char *sessionname, char **errmsg)
}
strbuf_free(sb);
settings_w *toret = snew(settings_w);
toret->sesskey = sesskey;
return toret;
settings_w *handle = snew(settings_w);
handle->sesskey = sesskey;
return handle;
}
void write_setting_s(settings_w *handle, const char *key, const char *value)
@ -91,9 +91,9 @@ settings_r *open_settings_r(const char *sessionname)
if (!sesskey)
return NULL;
settings_r *toret = snew(settings_r);
toret->sesskey = sesskey;
return toret;
settings_r *handle = snew(settings_r);
handle->sesskey = sesskey;
return handle;
}
char *read_setting_s(settings_r *handle, const char *key)
@ -221,13 +221,13 @@ settings_e *enum_settings_start(void)
if (!key)
return NULL;
settings_e *ret = snew(settings_e);
if (ret) {
ret->key = key;
ret->i = 0;
settings_e *e = snew(settings_e);
if (e) {
e->key = key;
e->i = 0;
}
return ret;
return e;
}
bool enum_settings_next(settings_e *e, strbuf *sb)

6
windows/utils/filename.c
View File

@ -6,9 +6,9 @@
Filename *filename_from_str(const char *str)
{
Filename *ret = snew(Filename);
ret->path = dupstr(str);
return ret;
Filename *fn = snew(Filename);
fn->path = dupstr(str);
return fn;
}
Filename *filename_copy(const Filename *fn)

6
windows/utils/request_file.c
View File

@ -60,9 +60,9 @@ bool request_file(filereq *state, OPENFILENAME *of, bool preserve, bool save)
filereq *filereq_new(void)
{
filereq *ret = snew(filereq);
ret->cwd[0] = '\0';
return ret;
filereq *state = snew(filereq);
state->cwd[0] = '\0';
return state;
}
void filereq_free(filereq *state)