nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-09 17:38:00 +00:00
Code Issues Projects Releases Wiki Activity

Rename FROMFIELD to 'container_of'.

Browse Source 
Ian Jackson points out that the Linux kernel has a macro of this name
with the same purpose, and suggests that it's a good idea to use the
same name as they do, so that at least some people reading one code
base might recognise it from the other.

I never really thought very hard about what order FROMFIELD's
parameters should go in, and therefore I'm pleasantly surprised to
find that my order agrees with the kernel's, so I don't have to
permute every call site as part of making this change :-)
This commit is contained in:
Simon Tatham 2018-10-05 23:49:08 +01:00
parent ed652a70e8
commit 9396fcc9f7
47 changed files with 410 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
agentf.c
View File

@ -174,7 +174,7 @@ Channel *agentf_new(SshChannel *c)
static void agentf_free(Channel *chan)
{
assert(chan->vt == &agentf_channelvt);
agentf *af = FROMFIELD(chan, agentf, chan);
agentf *af = container_of(chan, agentf, chan);
if (af->pending)
agent_cancel_query(af->pending);
@ -186,7 +186,7 @@ static int agentf_send(Channel *chan, int is_stderr,
const void *data, int length)
{
assert(chan->vt == &agentf_channelvt);
agentf *af = FROMFIELD(chan, agentf, chan);
agentf *af = container_of(chan, agentf, chan);
bufchain_add(&af->inbuffer, data, length);
agentf_try_forward(af);
@ -204,7 +204,7 @@ static int agentf_send(Channel *chan, int is_stderr,
static void agentf_send_eof(Channel *chan)
{
assert(chan->vt == &agentf_channelvt);
agentf *af = FROMFIELD(chan, agentf, chan);
agentf *af = container_of(chan, agentf, chan);
af->rcvd_eof = TRUE;
@ -222,7 +222,7 @@ static char *agentf_log_close_msg(Channel *chan)
static void agentf_set_input_wanted(Channel *chan, int wanted)
{
assert(chan->vt == &agentf_channelvt);
agentf *af = FROMFIELD(chan, agentf, chan);
agentf *af = container_of(chan, agentf, chan);
af->input_wanted = wanted;

2
defs.h
View File

@ -97,7 +97,7 @@ typedef struct PacketProtocolLayer PacketProtocolLayer;
/* Return a pointer to the object of structure type 'type' whose field
* with name 'field' is pointed at by 'object'. */
#define FROMFIELD(object, type, field) \
#define container_of(object, type, field) \
TYPECHECK(object == &((type *)0)->field, \
((type *)(((char *)(object)) - offsetof(type, field))))

6
errsock.c
View File

@ -18,7 +18,7 @@ typedef struct {
static Plug *sk_error_plug(Socket *s, Plug *p)
{
ErrorSocket *es = FROMFIELD(s, ErrorSocket, sock);
ErrorSocket *es = container_of(s, ErrorSocket, sock);
Plug *ret = es->plug;
if (p)
es->plug = p;
@ -27,7 +27,7 @@ static Plug *sk_error_plug(Socket *s, Plug *p)
static void sk_error_close(Socket *s)
{
ErrorSocket *es = FROMFIELD(s, ErrorSocket, sock);
ErrorSocket *es = container_of(s, ErrorSocket, sock);
sfree(es->error);
sfree(es);
@ -35,7 +35,7 @@ static void sk_error_close(Socket *s)
static const char *sk_error_socket_error(Socket *s)
{
ErrorSocket *es = FROMFIELD(s, ErrorSocket, sock);
ErrorSocket *es = container_of(s, ErrorSocket, sock);
return es->error;
}

2
import.c
View File

@ -916,7 +916,7 @@ int openssh_pem_write(const Filename *filename, struct ssh2_userkey *key,
ssh_key_alg(key->key) == &ssh_ecdsa_nistp384 ||
ssh_key_alg(key->key) == &ssh_ecdsa_nistp521) {
const unsigned char *oid;
struct ec_key *ec = FROMFIELD(key->key, struct ec_key, sshk);
struct ec_key *ec = container_of(key->key, struct ec_key, sshk);
int oidlen;
int pointlen;
strbuf *seq, *sub;

10
misc.c
View File

@ -493,7 +493,7 @@ struct strbuf_impl {
void *strbuf_append(strbuf *buf_o, size_t len)
{
struct strbuf_impl *buf = FROMFIELD(buf_o, struct strbuf_impl, visible);
struct strbuf_impl *buf = container_of(buf_o, struct strbuf_impl, visible);
char *toret;
if (buf->size < buf->visible.len + len + 1) {
buf->size = (buf->visible.len + len + 1) * 5 / 4 + 512;
@ -524,7 +524,7 @@ strbuf *strbuf_new(void)
}
void strbuf_free(strbuf *buf_o)
{
struct strbuf_impl *buf = FROMFIELD(buf_o, struct strbuf_impl, visible);
struct strbuf_impl *buf = container_of(buf_o, struct strbuf_impl, visible);
if (buf->visible.s) {
smemclr(buf->visible.s, buf->size);
sfree(buf->visible.s);
@ -533,14 +533,14 @@ void strbuf_free(strbuf *buf_o)
}
char *strbuf_to_str(strbuf *buf_o)
{
struct strbuf_impl *buf = FROMFIELD(buf_o, struct strbuf_impl, visible);
struct strbuf_impl *buf = container_of(buf_o, struct strbuf_impl, visible);
char *ret = buf->visible.s;
sfree(buf);
return ret;
}
void strbuf_catfv(strbuf *buf_o, const char *fmt, va_list ap)
{
struct strbuf_impl *buf = FROMFIELD(buf_o, struct strbuf_impl, visible);
struct strbuf_impl *buf = container_of(buf_o, struct strbuf_impl, visible);
STRBUF_SET_PTR(buf, dupvprintf_inner(buf->visible.s, buf->visible.len,
&buf->size, fmt, ap));
buf->visible.len += strlen(buf->visible.s + buf->visible.len);
@ -561,7 +561,7 @@ strbuf *strbuf_new_for_agent_query(void)
}
void strbuf_finalise_agent_query(strbuf *buf_o)
{
struct strbuf_impl *buf = FROMFIELD(buf_o, struct strbuf_impl, visible);
struct strbuf_impl *buf = container_of(buf_o, struct strbuf_impl, visible);
assert(buf->visible.len >= 5);
PUT_32BIT_MSB_FIRST(buf->visible.u, buf->visible.len - 4);
}

10
pageant.c
View File

@ -713,7 +713,7 @@ struct pageant_conn_state {
static void pageant_conn_closing(Plug *plug, const char *error_msg,
int error_code, int calling_back)
{
struct pageant_conn_state *pc = FROMFIELD(
struct pageant_conn_state *pc = container_of(
plug, struct pageant_conn_state, plug);
if (error_msg)
plog(pc->logctx, pc->logfn, "%p: error: %s", pc, error_msg);
@ -725,7 +725,7 @@ static void pageant_conn_closing(Plug *plug, const char *error_msg,
static void pageant_conn_sent(Plug *plug, int bufsize)
{
/* struct pageant_conn_state *pc = FROMFIELD(
/* struct pageant_conn_state *pc = container_of(
plug, struct pageant_conn_state, plug); */
/*
@ -747,7 +747,7 @@ static void pageant_conn_log(void *logctx, const char *fmt, va_list ap)
static void pageant_conn_receive(Plug *plug, int urgent, char *data, int len)
{
struct pageant_conn_state *pc = FROMFIELD(
struct pageant_conn_state *pc = container_of(
plug, struct pageant_conn_state, plug);
char c;
@ -807,7 +807,7 @@ struct pageant_listen_state {
static void pageant_listen_closing(Plug *plug, const char *error_msg,
int error_code, int calling_back)
{
struct pageant_listen_state *pl = FROMFIELD(
struct pageant_listen_state *pl = container_of(
plug, struct pageant_listen_state, plug);
if (error_msg)
plog(pl->logctx, pl->logfn, "listening socket: error: %s", error_msg);
@ -826,7 +826,7 @@ static const PlugVtable pageant_connection_plugvt = {
static int pageant_listen_accepting(Plug *plug,
accept_fn_t constructor, accept_ctx_t ctx)
{
struct pageant_listen_state *pl = FROMFIELD(
struct pageant_listen_state *pl = container_of(
plug, struct pageant_listen_state, plug);
struct pageant_conn_state *pc;
const char *err;

23
portfwd.c
View File

@ -124,7 +124,8 @@ static void pfd_close(struct PortForwarding *pf);
static void pfd_closing(Plug *plug, const char *error_msg, int error_code,
int calling_back)
{
struct PortForwarding *pf = FROMFIELD(plug, struct PortForwarding, plug);
struct PortForwarding *pf =
container_of(plug, struct PortForwarding, plug);
if (error_msg) {
/*
@ -205,7 +206,8 @@ static char *ipv6_to_string(ptrlen ipv6)
static void pfd_receive(Plug *plug, int urgent, char *data, int len)
{
struct PortForwarding *pf = FROMFIELD(plug, struct PortForwarding, plug);
struct PortForwarding *pf =
container_of(plug, struct PortForwarding, plug);
if (len == 0)
return;
@ -429,7 +431,8 @@ static void pfd_receive(Plug *plug, int urgent, char *data, int len)
static void pfd_sent(Plug *plug, int bufsize)
{
struct PortForwarding *pf = FROMFIELD(plug, struct PortForwarding, plug);
struct PortForwarding *pf =
container_of(plug, struct PortForwarding, plug);
if (pf->c)
sshfwd_unthrottle(pf->c, bufsize);
@ -473,7 +476,7 @@ static int pfl_accepting(Plug *p, accept_fn_t constructor, accept_ctx_t ctx)
Socket *s;
const char *err;
pl = FROMFIELD(p, struct PortListener, plug);
pl = container_of(p, struct PortListener, plug);
pf = new_portfwd_state();
pf->plug.vt = &PortForwarding_plugvt;
pf->chan.initial_fixed_window_size = 0;
@ -588,7 +591,7 @@ static void pfl_terminate(struct PortListener *pl)
static void pfd_set_input_wanted(Channel *chan, int wanted)
{
assert(chan->vt == &PortForwarding_channelvt);
PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
PortForwarding *pf = container_of(chan, PortForwarding, chan);
pf->input_wanted = wanted;
sk_set_frozen(pf->s, !pf->input_wanted);
}
@ -596,7 +599,7 @@ static void pfd_set_input_wanted(Channel *chan, int wanted)
static void pfd_chan_free(Channel *chan)
{
assert(chan->vt == &PortForwarding_channelvt);
PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
PortForwarding *pf = container_of(chan, PortForwarding, chan);
pfd_close(pf);
}
@ -606,21 +609,21 @@ static void pfd_chan_free(Channel *chan)
static int pfd_send(Channel *chan, int is_stderr, const void *data, int len)
{
assert(chan->vt == &PortForwarding_channelvt);
PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
PortForwarding *pf = container_of(chan, PortForwarding, chan);
return sk_write(pf->s, data, len);
}
static void pfd_send_eof(Channel *chan)
{
assert(chan->vt == &PortForwarding_channelvt);
PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
PortForwarding *pf = container_of(chan, PortForwarding, chan);
sk_write_eof(pf->s);
}
static void pfd_open_confirmation(Channel *chan)
{
assert(chan->vt == &PortForwarding_channelvt);
PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
PortForwarding *pf = container_of(chan, PortForwarding, chan);
pf->ready = 1;
sk_set_frozen(pf->s, 0);
@ -636,7 +639,7 @@ static void pfd_open_confirmation(Channel *chan)
static void pfd_open_failure(Channel *chan, const char *errtext)
{
assert(chan->vt == &PortForwarding_channelvt);
PortForwarding *pf = FROMFIELD(chan, PortForwarding, chan);
PortForwarding *pf = container_of(chan, PortForwarding, chan);
logeventf(pf->cl->frontend,
"Forwarded connection refused by server%s%s",

26
proxy.c
View File

@ -79,7 +79,7 @@ void proxy_activate (ProxySocket *p)
static Plug *sk_proxy_plug (Socket *s, Plug *p)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
Plug *ret = ps->plug;
if (p)
ps->plug = p;
@ -88,7 +88,7 @@ static Plug *sk_proxy_plug (Socket *s, Plug *p)
static void sk_proxy_close (Socket *s)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
sk_close(ps->sub_socket);
sk_addr_free(ps->remote_addr);
@ -97,7 +97,7 @@ static void sk_proxy_close (Socket *s)
static int sk_proxy_write (Socket *s, const void *data, int len)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
if (ps->state != PROXY_STATE_ACTIVE) {
bufchain_add(&ps->pending_output_data, data, len);
@ -108,7 +108,7 @@ static int sk_proxy_write (Socket *s, const void *data, int len)
static int sk_proxy_write_oob (Socket *s, const void *data, int len)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
if (ps->state != PROXY_STATE_ACTIVE) {
bufchain_clear(&ps->pending_output_data);
@ -121,7 +121,7 @@ static int sk_proxy_write_oob (Socket *s, const void *data, int len)
static void sk_proxy_write_eof (Socket *s)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
if (ps->state != PROXY_STATE_ACTIVE) {
ps->pending_eof = 1;
@ -132,7 +132,7 @@ static void sk_proxy_write_eof (Socket *s)
static void sk_proxy_flush (Socket *s)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
if (ps->state != PROXY_STATE_ACTIVE) {
ps->pending_flush = 1;
@ -143,7 +143,7 @@ static void sk_proxy_flush (Socket *s)
static void sk_proxy_set_frozen (Socket *s, int is_frozen)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
if (ps->state != PROXY_STATE_ACTIVE) {
ps->freeze = is_frozen;
@ -182,7 +182,7 @@ static void sk_proxy_set_frozen (Socket *s, int is_frozen)
static const char * sk_proxy_socket_error (Socket *s)
{
ProxySocket *ps = FROMFIELD(s, ProxySocket, sock);
ProxySocket *ps = container_of(s, ProxySocket, sock);
if (ps->error != NULL || ps->sub_socket == NULL) {
return ps->error;
}
@ -194,7 +194,7 @@ static const char * sk_proxy_socket_error (Socket *s)
static void plug_proxy_log(Plug *plug, int type, SockAddr *addr, int port,
const char *error_msg, int error_code)
{
ProxySocket *ps = FROMFIELD(plug, ProxySocket, plugimpl);
ProxySocket *ps = container_of(plug, ProxySocket, plugimpl);
plug_log(ps->plug, type, addr, port, error_msg, error_code);
}
@ -202,7 +202,7 @@ static void plug_proxy_log(Plug *plug, int type, SockAddr *addr, int port,
static void plug_proxy_closing (Plug *p, const char *error_msg,
int error_code, int calling_back)
{
ProxySocket *ps = FROMFIELD(p, ProxySocket, plugimpl);
ProxySocket *ps = container_of(p, ProxySocket, plugimpl);
if (ps->state != PROXY_STATE_ACTIVE) {
ps->closing_error_msg = error_msg;
@ -216,7 +216,7 @@ static void plug_proxy_closing (Plug *p, const char *error_msg,
static void plug_proxy_receive (Plug *p, int urgent, char *data, int len)
{
ProxySocket *ps = FROMFIELD(p, ProxySocket, plugimpl);
ProxySocket *ps = container_of(p, ProxySocket, plugimpl);
if (ps->state != PROXY_STATE_ACTIVE) {
/* we will lose the urgentness of this data, but since most,
@ -235,7 +235,7 @@ static void plug_proxy_receive (Plug *p, int urgent, char *data, int len)
static void plug_proxy_sent (Plug *p, int bufsize)
{
ProxySocket *ps = FROMFIELD(p, ProxySocket, plugimpl);
ProxySocket *ps = container_of(p, ProxySocket, plugimpl);
if (ps->state != PROXY_STATE_ACTIVE) {
ps->sent_bufsize = bufsize;
@ -248,7 +248,7 @@ static void plug_proxy_sent (Plug *p, int bufsize)
static int plug_proxy_accepting(Plug *p,
accept_fn_t constructor, accept_ctx_t ctx)
{
ProxySocket *ps = FROMFIELD(p, ProxySocket, plugimpl);
ProxySocket *ps = container_of(p, ProxySocket, plugimpl);
if (ps->state != PROXY_STATE_ACTIVE) {
ps->accepting_constructor = constructor;

22
raw.c
View File

@ -35,7 +35,7 @@ static void c_write(Raw *raw, const void *buf, int len)
static void raw_log(Plug *plug, int type, SockAddr *addr, int port,
const char *error_msg, int error_code)
{
Raw *raw = FROMFIELD(plug, Raw, plug);
Raw *raw = container_of(plug, Raw, plug);
backend_socket_log(raw->frontend, type, addr, port,
error_msg, error_code, raw->conf, raw->session_started);
}
@ -58,7 +58,7 @@ static void raw_check_close(Raw *raw)
static void raw_closing(Plug *plug, const char *error_msg, int error_code,
int calling_back)
{
Raw *raw = FROMFIELD(plug, Raw, plug);
Raw *raw = container_of(plug, Raw, plug);
if (error_msg) {
/* A socket error has occurred. */
@ -90,7 +90,7 @@ static void raw_closing(Plug *plug, const char *error_msg, int error_code,
static void raw_receive(Plug *plug, int urgent, char *data, int len)
{
Raw *raw = FROMFIELD(plug, Raw, plug);
Raw *raw = container_of(plug, Raw, plug);
c_write(raw, data, len);
/* We count 'session start', for proxy logging purposes, as being
* when data is received from the network and printed. */
@ -99,7 +99,7 @@ static void raw_receive(Plug *plug, int urgent, char *data, int len)
static void raw_sent(Plug *plug, int bufsize)
{
Raw *raw = FROMFIELD(plug, Raw, plug);
Raw *raw = container_of(plug, Raw, plug);
raw->bufsize = bufsize;
}
@ -181,7 +181,7 @@ static const char *raw_init(Frontend *frontend, Backend **backend_handle,
static void raw_free(Backend *be)
{
Raw *raw = FROMFIELD(be, Raw, backend);
Raw *raw = container_of(be, Raw, backend);
if (raw->s)
sk_close(raw->s);
@ -201,7 +201,7 @@ static void raw_reconfig(Backend *be, Conf *conf)
*/
static int raw_send(Backend *be, const char *buf, int len)
{
Raw *raw = FROMFIELD(be, Raw, backend);
Raw *raw = container_of(be, Raw, backend);
if (raw->s == NULL)
return 0;
@ -216,7 +216,7 @@ static int raw_send(Backend *be, const char *buf, int len)
*/
static int raw_sendbuffer(Backend *be)
{
Raw *raw = FROMFIELD(be, Raw, backend);
Raw *raw = container_of(be, Raw, backend);
return raw->bufsize;
}
@ -234,7 +234,7 @@ static void raw_size(Backend *be, int width, int height)
*/
static void raw_special(Backend *be, SessionSpecialCode code, int arg)
{
Raw *raw = FROMFIELD(be, Raw, backend);
Raw *raw = container_of(be, Raw, backend);
if (code == SS_EOF && raw->s) {
sk_write_eof(raw->s);
raw->sent_socket_eof= TRUE;
@ -255,7 +255,7 @@ static const SessionSpecial *raw_get_specials(Backend *be)
static int raw_connected(Backend *be)
{
Raw *raw = FROMFIELD(be, Raw, backend);
Raw *raw = container_of(be, Raw, backend);
return raw->s != NULL;
}
@ -266,7 +266,7 @@ static int raw_sendok(Backend *be)
static void raw_unthrottle(Backend *be, int backlog)
{
Raw *raw = FROMFIELD(be, Raw, backend);
Raw *raw = container_of(be, Raw, backend);
sk_set_frozen(raw->s, backlog > RAW_MAX_BACKLOG);
}
@ -289,7 +289,7 @@ static void raw_provide_logctx(Backend *be, LogContext *logctx)
static int raw_exitcode(Backend *be)
{
Raw *raw = FROMFIELD(be, Raw, backend);
Raw *raw = container_of(be, Raw, backend);
if (raw->s != NULL)
return -1; /* still connected */
else if (raw->closed_on_socket_error)

26
rlogin.c
View File

@ -39,7 +39,7 @@ static void c_write(Rlogin *rlogin, const void *buf, int len)
static void rlogin_log(Plug *plug, int type, SockAddr *addr, int port,
const char *error_msg, int error_code)
{
Rlogin *rlogin = FROMFIELD(plug, Rlogin, plug);
Rlogin *rlogin = container_of(plug, Rlogin, plug);
backend_socket_log(rlogin->frontend, type, addr, port,
error_msg, error_code,
rlogin->conf, !rlogin->firstbyte);
@ -48,7 +48,7 @@ static void rlogin_log(Plug *plug, int type, SockAddr *addr, int port,
static void rlogin_closing(Plug *plug, const char *error_msg, int error_code,
int calling_back)
{
Rlogin *rlogin = FROMFIELD(plug, Rlogin, plug);
Rlogin *rlogin = container_of(plug, Rlogin, plug);
/*
* We don't implement independent EOF in each direction for Telnet
@ -72,7 +72,7 @@ static void rlogin_closing(Plug *plug, const char *error_msg, int error_code,
static void rlogin_receive(Plug *plug, int urgent, char *data, int len)
{
Rlogin *rlogin = FROMFIELD(plug, Rlogin, plug);
Rlogin *rlogin = container_of(plug, Rlogin, plug);
if (urgent == 2) {
char c;
@ -109,7 +109,7 @@ static void rlogin_receive(Plug *plug, int urgent, char *data, int len)
static void rlogin_sent(Plug *plug, int bufsize)
{
Rlogin *rlogin = FROMFIELD(plug, Rlogin, plug);
Rlogin *rlogin = container_of(plug, Rlogin, plug);
rlogin->bufsize = bufsize;
}
@ -236,7 +236,7 @@ static const char *rlogin_init(Frontend *frontend, Backend **backend_handle,
static void rlogin_free(Backend *be)
{
Rlogin *rlogin = FROMFIELD(be, Rlogin, backend);
Rlogin *rlogin = container_of(be, Rlogin, backend);
if (rlogin->prompt)
free_prompts(rlogin->prompt);
@ -258,7 +258,7 @@ static void rlogin_reconfig(Backend *be, Conf *conf)
*/
static int rlogin_send(Backend *be, const char *buf, int len)
{
Rlogin *rlogin = FROMFIELD(be, Rlogin, backend);
Rlogin *rlogin = container_of(be, Rlogin, backend);
bufchain bc;
if (rlogin->s == NULL)
@ -300,7 +300,7 @@ static int rlogin_send(Backend *be, const char *buf, int len)
*/
static int rlogin_sendbuffer(Backend *be)
{
Rlogin *rlogin = FROMFIELD(be, Rlogin, backend);
Rlogin *rlogin = container_of(be, Rlogin, backend);
return rlogin->bufsize;
}
@ -309,7 +309,7 @@ static int rlogin_sendbuffer(Backend *be)
*/
static void rlogin_size(Backend *be, int width, int height)
{
Rlogin *rlogin = FROMFIELD(be, Rlogin, backend);
Rlogin *rlogin = container_of(be, Rlogin, backend);
char b[12] = { '\xFF', '\xFF', 0x73, 0x73, 0, 0, 0, 0, 0, 0, 0, 0 };
rlogin->term_width = width;
@ -346,25 +346,25 @@ static const SessionSpecial *rlogin_get_specials(Backend *be)
static int rlogin_connected(Backend *be)
{
Rlogin *rlogin = FROMFIELD(be, Rlogin, backend);
Rlogin *rlogin = container_of(be, Rlogin, backend);
return rlogin->s != NULL;
}
static int rlogin_sendok(Backend *be)
{
/* Rlogin *rlogin = FROMFIELD(be, Rlogin, backend); */
/* Rlogin *rlogin = container_of(be, Rlogin, backend); */
return 1;
}
static void rlogin_unthrottle(Backend *be, int backlog)
{
Rlogin *rlogin = FROMFIELD(be, Rlogin, backend);
Rlogin *rlogin = container_of(be, Rlogin, backend);
sk_set_frozen(rlogin->s, backlog > RLOGIN_MAX_BACKLOG);
}
static int rlogin_ldisc(Backend *be, int option)
{
/* Rlogin *rlogin = FROMFIELD(be, Rlogin, backend); */
/* Rlogin *rlogin = container_of(be, Rlogin, backend); */
return 0;
}
@ -380,7 +380,7 @@ static void rlogin_provide_logctx(Backend *be, LogContext *logctx)
static int rlogin_exitcode(Backend *be)
{
Rlogin *rlogin = FROMFIELD(be, Rlogin, backend);
Rlogin *rlogin = container_of(be, Rlogin, backend);
if (rlogin->s != NULL)
return -1; /* still connected */
else if (rlogin->closed_on_socket_error)

42
ssh.c
View File

@ -141,7 +141,7 @@ static void ssh_connect_ppl(Ssh *ssh, PacketProtocolLayer *ppl)
static void ssh_got_ssh_version(struct ssh_version_receiver *rcv,
int major_version)
{
Ssh *ssh = FROMFIELD(rcv, Ssh, version_receiver);
Ssh *ssh = container_of(rcv, Ssh, version_receiver);
BinaryPacketProtocol *old_bpp;
PacketProtocolLayer *connection_layer;
@ -489,7 +489,7 @@ void ssh_user_close(Ssh *ssh, const char *fmt, ...)
static void ssh_socket_log(Plug *plug, int type, SockAddr *addr, int port,
const char *error_msg, int error_code)
{
Ssh *ssh = FROMFIELD(plug, Ssh, plug);
Ssh *ssh = container_of(plug, Ssh, plug);
/*
* While we're attempting connection sharing, don't loudly log
@ -509,7 +509,7 @@ static void ssh_socket_log(Plug *plug, int type, SockAddr *addr, int port,
static void ssh_closing(Plug *plug, const char *error_msg, int error_code,
int calling_back)
{
Ssh *ssh = FROMFIELD(plug, Ssh, plug);
Ssh *ssh = container_of(plug, Ssh, plug);
if (error_msg) {
ssh_remote_error(ssh, "Network error: %s", error_msg);
} else if (ssh->bpp) {
@ -520,7 +520,7 @@ static void ssh_closing(Plug *plug, const char *error_msg, int error_code,
static void ssh_receive(Plug *plug, int urgent, char *data, int len)
{
Ssh *ssh = FROMFIELD(plug, Ssh, plug);
Ssh *ssh = container_of(plug, Ssh, plug);
/* Log raw data, if we're in that mode. */
if (ssh->logctx)
@ -534,7 +534,7 @@ static void ssh_receive(Plug *plug, int urgent, char *data, int len)
static void ssh_sent(Plug *plug, int bufsize)
{
Ssh *ssh = FROMFIELD(plug, Ssh, plug);
Ssh *ssh = container_of(plug, Ssh, plug);
/*
* If the send backlog on the SSH socket itself clears, we should
* unthrottle the whole world if it was throttled. Also trigger an
@ -825,7 +825,7 @@ static const char *ssh_init(Frontend *frontend, Backend **backend_handle,
static void ssh_free(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
int need_random_unref;
ssh_shutdown(ssh);
@ -860,7 +860,7 @@ static void ssh_free(Backend *be)
*/
static void ssh_reconfig(Backend *be, Conf *conf)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
if (ssh->pinger)
pinger_reconfig(ssh->pinger, ssh->conf, conf);
@ -877,7 +877,7 @@ static void ssh_reconfig(Backend *be, Conf *conf)
*/
static int ssh_send(Backend *be, const char *buf, int len)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
if (ssh == NULL || ssh->s == NULL)
return 0;
@ -894,7 +894,7 @@ static int ssh_send(Backend *be, const char *buf, int len)
*/
static int ssh_sendbuffer(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
int backlog;
if (!ssh || !ssh->s || !ssh->cl)
@ -919,7 +919,7 @@ static int ssh_sendbuffer(Backend *be)
*/
static void ssh_size(Backend *be, int width, int height)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
ssh->term_width = width;
ssh->term_height = height;
@ -956,7 +956,7 @@ static void ssh_add_special(void *vctx, const char *text,
*/
static const SessionSpecial *ssh_get_specials(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
/*
* Ask all our active protocol layers what specials they've got,
@ -986,7 +986,7 @@ static const SessionSpecial *ssh_get_specials(Backend *be)
*/
static void ssh_special(Backend *be, SessionSpecialCode code, int arg)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
if (ssh->base_layer)
ssh_ppl_special_cmd(ssh->base_layer, code, arg);
@ -998,20 +998,20 @@ static void ssh_special(Backend *be, SessionSpecialCode code, int arg)
*/
static void ssh_unthrottle(Backend *be, int bufsize)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
ssh_stdout_unthrottle(ssh->cl, bufsize);
}
static int ssh_connected(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
return ssh->s != NULL;
}
static int ssh_sendok(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
return ssh->base_layer && ssh_ppl_want_user_input(ssh->base_layer);
}
@ -1025,19 +1025,19 @@ void ssh_ldisc_update(Ssh *ssh)
static int ssh_ldisc(Backend *be, int option)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
return ssh->cl ? ssh_ldisc_option(ssh->cl, option) : FALSE;
}
static void ssh_provide_ldisc(Backend *be, Ldisc *ldisc)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
ssh->ldisc = ldisc;
}
static void ssh_provide_logctx(Backend *be, LogContext *logctx)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
ssh->logctx = logctx;
}
@ -1048,7 +1048,7 @@ void ssh_got_exitcode(Ssh *ssh, int exitcode)
static int ssh_return_exitcode(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
if (ssh->s && (!ssh->session_started || ssh->base_layer))
return -1;
else
@ -1062,7 +1062,7 @@ static int ssh_return_exitcode(Backend *be)
*/
static int ssh_cfg_info(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
if (ssh->version == 0)
return 0; /* don't know yet */
else if (ssh->bare_connection)
@ -1078,7 +1078,7 @@ static int ssh_cfg_info(Backend *be)
*/
extern int ssh_fallback_cmd(Backend *be)
{
Ssh *ssh = FROMFIELD(be, Ssh, backend);
Ssh *ssh = container_of(be, Ssh, backend);
return ssh->fallback_cmd;
}

8
ssh1bpp.c
View File

@ -54,7 +54,7 @@ BinaryPacketProtocol *ssh1_bpp_new(void)
static void ssh1_bpp_free(BinaryPacketProtocol *bpp)
{
struct ssh1_bpp_state *s = FROMFIELD(bpp, struct ssh1_bpp_state, bpp);
struct ssh1_bpp_state *s = container_of(bpp, struct ssh1_bpp_state, bpp);
if (s->cipher)
ssh1_cipher_free(s->cipher);
if (s->compctx)
@ -73,7 +73,7 @@ void ssh1_bpp_new_cipher(BinaryPacketProtocol *bpp,
{
struct ssh1_bpp_state *s;
assert(bpp->vt == &ssh1_bpp_vtable);
s = FROMFIELD(bpp, struct ssh1_bpp_state, bpp);
s = container_of(bpp, struct ssh1_bpp_state, bpp);
assert(!s->cipher);
@ -97,7 +97,7 @@ void ssh1_bpp_new_cipher(BinaryPacketProtocol *bpp,
static void ssh1_bpp_handle_input(BinaryPacketProtocol *bpp)
{
struct ssh1_bpp_state *s = FROMFIELD(bpp, struct ssh1_bpp_state, bpp);
struct ssh1_bpp_state *s = container_of(bpp, struct ssh1_bpp_state, bpp);
crBegin(s->crState);
@ -314,7 +314,7 @@ static void ssh1_bpp_format_packet(struct ssh1_bpp_state *s, PktOut *pkt)
static void ssh1_bpp_handle_output(BinaryPacketProtocol *bpp)
{
struct ssh1_bpp_state *s = FROMFIELD(bpp, struct ssh1_bpp_state, bpp);
struct ssh1_bpp_state *s = container_of(bpp, struct ssh1_bpp_state, bpp);
PktOut *pkt;
if (s->pending_compression_request) {

38
ssh1connection.c
View File

@ -276,7 +276,7 @@ PacketProtocolLayer *ssh1_connection_new(
static void ssh1_connection_free(PacketProtocolLayer *ppl)
{
struct ssh1_connection_state *s =
FROMFIELD(ppl, struct ssh1_connection_state, ppl);
container_of(ppl, struct ssh1_connection_state, ppl);
struct X11FakeAuth *auth;
struct ssh1_channel *c;
struct ssh_rportfwd *rpf;
@ -305,7 +305,7 @@ void ssh1_connection_set_local_protoflags(PacketProtocolLayer *ppl, int flags)
{
assert(ppl->vt == &ssh1_connection_vtable);
struct ssh1_connection_state *s =
FROMFIELD(ppl, struct ssh1_connection_state, ppl);
container_of(ppl, struct ssh1_connection_state, ppl);
s->local_protoflags = flags;
}
@ -619,7 +619,7 @@ static PktIn *ssh1_connection_pop(struct ssh1_connection_state *s)
static void ssh1_connection_process_queue(PacketProtocolLayer *ppl)
{
struct ssh1_connection_state *s =
FROMFIELD(ppl, struct ssh1_connection_state, ppl);
container_of(ppl, struct ssh1_connection_state, ppl);
PktIn *pktin;
PktOut *pktout;
@ -942,14 +942,14 @@ static void ssh1_channel_init(struct ssh1_channel *c)
static Conf *ssh1channel_get_conf(SshChannel *sc)
{
struct ssh1_channel *c = FROMFIELD(sc, struct ssh1_channel, sc);
struct ssh1_channel *c = container_of(sc, struct ssh1_channel, sc);
struct ssh1_connection_state *s = c->connlayer;
return s->conf;
}
static void ssh1channel_write_eof(SshChannel *sc)
{
struct ssh1_channel *c = FROMFIELD(sc, struct ssh1_channel, sc);
struct ssh1_channel *c = container_of(sc, struct ssh1_channel, sc);
if (c->closes & CLOSES_SENT_CLOSE)
return;
@ -960,7 +960,7 @@ static void ssh1channel_write_eof(SshChannel *sc)
static void ssh1channel_unclean_close(SshChannel *sc, const char *err)
{
struct ssh1_channel *c = FROMFIELD(sc, struct ssh1_channel, sc);
struct ssh1_channel *c = container_of(sc, struct ssh1_channel, sc);
char *reason;
reason = dupprintf("due to local error: %s", err);
@ -973,7 +973,7 @@ static void ssh1channel_unclean_close(SshChannel *sc, const char *err)
static void ssh1channel_unthrottle(SshChannel *sc, int bufsize)
{
struct ssh1_channel *c = FROMFIELD(sc, struct ssh1_channel, sc);
struct ssh1_channel *c = container_of(sc, struct ssh1_channel, sc);
struct ssh1_connection_state *s = c->connlayer;
if (c->throttling_conn && bufsize <= SSH1_BUFFER_LIMIT) {
@ -984,7 +984,7 @@ static void ssh1channel_unthrottle(SshChannel *sc, int bufsize)
static int ssh1channel_write(SshChannel *sc, const void *buf, int len)
{
struct ssh1_channel *c = FROMFIELD(sc, struct ssh1_channel, sc);
struct ssh1_channel *c = container_of(sc, struct ssh1_channel, sc);
struct ssh1_connection_state *s = c->connlayer;
assert(!(c->closes & CLOSES_SENT_CLOSE));
@ -1009,7 +1009,7 @@ static SshChannel *ssh1_lportfwd_open(
const char *org, Channel *chan)
{
struct ssh1_connection_state *s =
FROMFIELD(cl, struct ssh1_connection_state, cl);
container_of(cl, struct ssh1_connection_state, cl);
PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */
struct ssh1_channel *c = snew(struct ssh1_channel);
PktOut *pktout;
@ -1059,7 +1059,7 @@ static struct ssh_rportfwd *ssh1_rportfwd_alloc(
ssh_sharing_connstate *share_ctx)
{
struct ssh1_connection_state *s =
FROMFIELD(cl, struct ssh1_connection_state, cl);
container_of(cl, struct ssh1_connection_state, cl);
struct ssh_rportfwd *rpf = snew(struct ssh_rportfwd);
rpf->shost = dupstr(shost);
@ -1098,7 +1098,7 @@ static void ssh1_rportfwd_remove(ConnectionLayer *cl, struct ssh_rportfwd *rpf)
static int ssh1_agent_forwarding_permitted(ConnectionLayer *cl)
{
struct ssh1_connection_state *s =
FROMFIELD(cl, struct ssh1_connection_state, cl);
container_of(cl, struct ssh1_connection_state, cl);
return conf_get_int(s->conf, CONF_agentfwd) && agent_exists();
}
@ -1106,7 +1106,7 @@ static void ssh1_connection_special_cmd(PacketProtocolLayer *ppl,
SessionSpecialCode code, int arg)
{
struct ssh1_connection_state *s =
FROMFIELD(ppl, struct ssh1_connection_state, ppl);
container_of(ppl, struct ssh1_connection_state, ppl);
PktOut *pktout;
if (code == SS_PING || code == SS_NOP) {
@ -1134,7 +1134,7 @@ static void ssh1_connection_special_cmd(PacketProtocolLayer *ppl,
static void ssh1_terminal_size(ConnectionLayer *cl, int width, int height)
{
struct ssh1_connection_state *s =
FROMFIELD(cl, struct ssh1_connection_state, cl);
container_of(cl, struct ssh1_connection_state, cl);
s->term_width = width;
s->term_height = height;
@ -1152,7 +1152,7 @@ static void ssh1_terminal_size(ConnectionLayer *cl, int width, int height)
static void ssh1_stdout_unthrottle(ConnectionLayer *cl, int bufsize)
{
struct ssh1_connection_state *s =
FROMFIELD(cl, struct ssh1_connection_state, cl);
container_of(cl, struct ssh1_connection_state, cl);
if (s->stdout_throttling && bufsize < SSH1_BUFFER_LIMIT) {
s->stdout_throttling = 0;
@ -1168,7 +1168,7 @@ static int ssh1_stdin_backlog(ConnectionLayer *cl)
static void ssh1_throttle_all_channels(ConnectionLayer *cl, int throttled)
{
struct ssh1_connection_state *s =
FROMFIELD(cl, struct ssh1_connection_state, cl);
container_of(cl, struct ssh1_connection_state, cl);
struct ssh1_channel *c;
int i;
@ -1179,7 +1179,7 @@ static void ssh1_throttle_all_channels(ConnectionLayer *cl, int throttled)
static int ssh1_ldisc_option(ConnectionLayer *cl, int option)
{
struct ssh1_connection_state *s =
FROMFIELD(cl, struct ssh1_connection_state, cl);
container_of(cl, struct ssh1_connection_state, cl);
/* We always return the same value for LD_ECHO and LD_EDIT */
return s->echoedit;
@ -1188,14 +1188,14 @@ static int ssh1_ldisc_option(ConnectionLayer *cl, int option)
static int ssh1_connection_want_user_input(PacketProtocolLayer *ppl)
{
struct ssh1_connection_state *s =
FROMFIELD(ppl, struct ssh1_connection_state, ppl);
container_of(ppl, struct ssh1_connection_state, ppl);
return s->session_ready && !s->session_eof_sent;
}
static void ssh1_connection_got_user_input(PacketProtocolLayer *ppl)
{
struct ssh1_connection_state *s =
FROMFIELD(ppl, struct ssh1_connection_state, ppl);
container_of(ppl, struct ssh1_connection_state, ppl);
if (s->session_ready && !s->session_eof_sent)
queue_idempotent_callback(&s->ppl.ic_process_queue);
}
@ -1203,7 +1203,7 @@ static void ssh1_connection_got_user_input(PacketProtocolLayer *ppl)
static void ssh1_connection_reconfigure(PacketProtocolLayer *ppl, Conf *conf)
{
struct ssh1_connection_state *s =
FROMFIELD(ppl, struct ssh1_connection_state, ppl);
container_of(ppl, struct ssh1_connection_state, ppl);
conf_free(s->conf);
s->conf = conf_copy(conf);

14
ssh1login.c
View File

@ -99,7 +99,8 @@ PacketProtocolLayer *ssh1_login_new(
static void ssh1_login_free(PacketProtocolLayer *ppl)
{
struct ssh1_login_state *s = FROMFIELD(ppl, struct ssh1_login_state, ppl);
struct ssh1_login_state *s =
container_of(ppl, struct ssh1_login_state, ppl);
if (s->successor_layer)
ssh_ppl_free(s->successor_layer);
@ -166,7 +167,8 @@ static PktIn *ssh1_login_pop(struct ssh1_login_state *s)
static void ssh1_login_process_queue(PacketProtocolLayer *ppl)
{
struct ssh1_login_state *s = FROMFIELD(ppl, struct ssh1_login_state, ppl);
struct ssh1_login_state *s =
container_of(ppl, struct ssh1_login_state, ppl);
PktIn *pktin;
PktOut *pkt;
int i;
@ -1172,7 +1174,7 @@ static void ssh1_login_special_cmd(PacketProtocolLayer *ppl,
SessionSpecialCode code, int arg)
{
struct ssh1_login_state *s =
FROMFIELD(ppl, struct ssh1_login_state, ppl);
container_of(ppl, struct ssh1_login_state, ppl);
PktOut *pktout;
if (code == SS_PING || code == SS_NOP) {
@ -1187,14 +1189,14 @@ static void ssh1_login_special_cmd(PacketProtocolLayer *ppl,
static int ssh1_login_want_user_input(PacketProtocolLayer *ppl)
{
struct ssh1_login_state *s =
FROMFIELD(ppl, struct ssh1_login_state, ppl);
container_of(ppl, struct ssh1_login_state, ppl);
return s->want_user_input;
}
static void ssh1_login_got_user_input(PacketProtocolLayer *ppl)
{
struct ssh1_login_state *s =
FROMFIELD(ppl, struct ssh1_login_state, ppl);
container_of(ppl, struct ssh1_login_state, ppl);
if (s->want_user_input)
queue_idempotent_callback(&s->ppl.ic_process_queue);
}
@ -1202,6 +1204,6 @@ static void ssh1_login_got_user_input(PacketProtocolLayer *ppl)
static void ssh1_login_reconfigure(PacketProtocolLayer *ppl, Conf *conf)
{
struct ssh1_login_state *s =
FROMFIELD(ppl, struct ssh1_login_state, ppl);
container_of(ppl, struct ssh1_login_state, ppl);
ssh_ppl_reconfigure(s->successor_layer, conf);
}

6
ssh2bpp-bare.c
View File

@ -45,7 +45,7 @@ BinaryPacketProtocol *ssh2_bare_bpp_new(void)
static void ssh2_bare_bpp_free(BinaryPacketProtocol *bpp)
{
struct ssh2_bare_bpp_state *s =
FROMFIELD(bpp, struct ssh2_bare_bpp_state, bpp);
container_of(bpp, struct ssh2_bare_bpp_state, bpp);
sfree(s->pktin);
sfree(s);
}
@ -62,7 +62,7 @@ static void ssh2_bare_bpp_free(BinaryPacketProtocol *bpp)
static void ssh2_bare_bpp_handle_input(BinaryPacketProtocol *bpp)
{
struct ssh2_bare_bpp_state *s =
FROMFIELD(bpp, struct ssh2_bare_bpp_state, bpp);
container_of(bpp, struct ssh2_bare_bpp_state, bpp);
crBegin(s->crState);
@ -175,7 +175,7 @@ static void ssh2_bare_bpp_format_packet(struct ssh2_bare_bpp_state *s,
static void ssh2_bare_bpp_handle_output(BinaryPacketProtocol *bpp)
{
struct ssh2_bare_bpp_state *s =
FROMFIELD(bpp, struct ssh2_bare_bpp_state, bpp);
container_of(bpp, struct ssh2_bare_bpp_state, bpp);
PktOut *pkt;
while ((pkt = pq_pop(&s->bpp.out_pq)) != NULL) {

10
ssh2bpp.c
View File

@ -63,7 +63,7 @@ BinaryPacketProtocol *ssh2_bpp_new(struct DataTransferStats *stats)
static void ssh2_bpp_free(BinaryPacketProtocol *bpp)
{
struct ssh2_bpp_state *s = FROMFIELD(bpp, struct ssh2_bpp_state, bpp);
struct ssh2_bpp_state *s = container_of(bpp, struct ssh2_bpp_state, bpp);
sfree(s->buf);
if (s->out.cipher)
ssh2_cipher_free(s->out.cipher);
@ -89,7 +89,7 @@ void ssh2_bpp_new_outgoing_crypto(
{
struct ssh2_bpp_state *s;
assert(bpp->vt == &ssh2_bpp_vtable);
s = FROMFIELD(bpp, struct ssh2_bpp_state, bpp);
s = container_of(bpp, struct ssh2_bpp_state, bpp);
if (s->out.cipher)
ssh2_cipher_free(s->out.cipher);
@ -132,7 +132,7 @@ void ssh2_bpp_new_incoming_crypto(
{
struct ssh2_bpp_state *s;
assert(bpp->vt == &ssh2_bpp_vtable);
s = FROMFIELD(bpp, struct ssh2_bpp_state, bpp);
s = container_of(bpp, struct ssh2_bpp_state, bpp);
if (s->in.cipher)
ssh2_cipher_free(s->in.cipher);
@ -177,7 +177,7 @@ void ssh2_bpp_new_incoming_crypto(
static void ssh2_bpp_handle_input(BinaryPacketProtocol *bpp)
{
struct ssh2_bpp_state *s = FROMFIELD(bpp, struct ssh2_bpp_state, bpp);
struct ssh2_bpp_state *s = container_of(bpp, struct ssh2_bpp_state, bpp);
crBegin(s->crState);
@ -700,7 +700,7 @@ static void ssh2_bpp_format_packet(struct ssh2_bpp_state *s, PktOut *pkt)
static void ssh2_bpp_handle_output(BinaryPacketProtocol *bpp)
{
struct ssh2_bpp_state *s = FROMFIELD(bpp, struct ssh2_bpp_state, bpp);
struct ssh2_bpp_state *s = container_of(bpp, struct ssh2_bpp_state, bpp);
PktOut *pkt;
if (s->cbc_ignore_workaround) {

74
ssh2connection.c
View File

@ -407,7 +407,7 @@ PacketProtocolLayer *ssh2_connection_new(
static void ssh2_connection_free(PacketProtocolLayer *ppl)
{
struct ssh2_connection_state *s =
FROMFIELD(ppl, struct ssh2_connection_state, ppl);
container_of(ppl, struct ssh2_connection_state, ppl);
struct X11FakeAuth *auth;
struct ssh2_channel *c;
struct ssh_rportfwd *rpf;
@ -1153,7 +1153,7 @@ static PktIn *ssh2_connection_pop(struct ssh2_connection_state *s)
static void ssh2_connection_process_queue(PacketProtocolLayer *ppl)
{
struct ssh2_connection_state *s =
FROMFIELD(ppl, struct ssh2_connection_state, ppl);
container_of(ppl, struct ssh2_connection_state, ppl);
PktIn *pktin;
PktOut *pktout;
@ -1198,7 +1198,7 @@ static void ssh2_connection_process_queue(PacketProtocolLayer *ppl)
&s->cl, conf_get_str(s->conf, CONF_ssh_nc_host),
conf_get_int(s->conf, CONF_ssh_nc_port),
"main channel", &mc->chan);
s->mainchan = FROMFIELD(mc->sc, struct ssh2_channel, sc);
s->mainchan = container_of(mc->sc, struct ssh2_channel, sc);
break;
}
@ -1865,14 +1865,14 @@ static PktOut *ssh2_chanreq_init(struct ssh2_channel *c, const char *type,
static Conf *ssh2channel_get_conf(SshChannel *sc)
{
struct ssh2_channel *c = FROMFIELD(sc, struct ssh2_channel, sc);
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
struct ssh2_connection_state *s = c->connlayer;
return s->conf;
}
static void ssh2channel_write_eof(SshChannel *sc)
{
struct ssh2_channel *c = FROMFIELD(sc, struct ssh2_channel, sc);
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
if (c->closes & CLOSES_SENT_EOF)
return;
@ -1883,7 +1883,7 @@ static void ssh2channel_write_eof(SshChannel *sc)
static void ssh2channel_unclean_close(SshChannel *sc, const char *err)
{
struct ssh2_channel *c = FROMFIELD(sc, struct ssh2_channel, sc);
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
char *reason;
reason = dupprintf("due to local error: %s", err);
@ -1896,7 +1896,7 @@ static void ssh2channel_unclean_close(SshChannel *sc, const char *err)
static void ssh2channel_unthrottle(SshChannel *sc, int bufsize)
{
struct ssh2_channel *c = FROMFIELD(sc, struct ssh2_channel, sc);
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
struct ssh2_connection_state *s = c->connlayer;
int buflimit;
@ -1912,7 +1912,7 @@ static void ssh2channel_unthrottle(SshChannel *sc, int bufsize)
static int ssh2channel_write(SshChannel *sc, const void *buf, int len)
{
struct ssh2_channel *c = FROMFIELD(sc, struct ssh2_channel, sc);
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
assert(!(c->closes & CLOSES_SENT_EOF));
bufchain_add(&c->outbuffer, buf, len);
return ssh2_try_send(c);
@ -1923,7 +1923,7 @@ static void ssh2channel_x11_sharing_handover(
const char *peer_addr, int peer_port, int endian,
int protomajor, int protominor, const void *initial_data, int initial_len)
{
struct ssh2_channel *c = FROMFIELD(sc, struct ssh2_channel, sc);
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
/*
* This function is called when we've just discovered that an X
* forwarding channel on which we'd been handling the initial auth
@ -1945,7 +1945,7 @@ static void ssh2channel_x11_sharing_handover(
static void ssh2channel_window_override_removed(SshChannel *sc)
{
struct ssh2_channel *c = FROMFIELD(sc, struct ssh2_channel, sc);
struct ssh2_channel *c = container_of(sc, struct ssh2_channel, sc);
struct ssh2_connection_state *s = c->connlayer;
/*
@ -1961,7 +1961,7 @@ static SshChannel *ssh2_lportfwd_open(
const char *org, Channel *chan)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */
struct ssh2_channel *c = snew(struct ssh2_channel);
PktOut *pktout;
@ -2022,7 +2022,7 @@ static struct ssh_rportfwd *ssh2_rportfwd_alloc(
ssh_sharing_connstate *share_ctx)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
struct ssh_rportfwd *rpf = snew(struct ssh_rportfwd);
rpf->shost = dupstr(shost);
@ -2058,7 +2058,7 @@ static struct ssh_rportfwd *ssh2_rportfwd_alloc(
static void ssh2_rportfwd_remove(ConnectionLayer *cl, struct ssh_rportfwd *rpf)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
if (rpf->share_ctx) {
/*
@ -2095,14 +2095,14 @@ static void ssh2_sharing_queue_global_request(
ConnectionLayer *cl, ssh_sharing_connstate *cs)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
ssh2_queue_global_request_handler(s, ssh2_sharing_globreq_response, cs);
}
static void ssh2_sharing_no_more_downstreams(ConnectionLayer *cl)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
queue_toplevel_callback(ssh2_check_termination_callback, s);
}
@ -2111,7 +2111,7 @@ static struct X11FakeAuth *ssh2_add_sharing_x11_display(
share_channel *share_chan)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
struct X11FakeAuth *auth;
/*
@ -2130,7 +2130,7 @@ static void ssh2_remove_sharing_x11_display(
ConnectionLayer *cl, struct X11FakeAuth *auth)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
del234(s->x11authtree, auth);
x11_free_fake_auth(auth);
}
@ -2139,7 +2139,7 @@ static unsigned ssh2_alloc_sharing_channel(
ConnectionLayer *cl, ssh_sharing_connstate *connstate)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
struct ssh2_channel *c = snew(struct ssh2_channel);
c->connlayer = s;
@ -2152,7 +2152,7 @@ static unsigned ssh2_alloc_sharing_channel(
static void ssh2_delete_sharing_channel(ConnectionLayer *cl, unsigned localid)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
struct ssh2_channel *c = find234(s->channels, &localid, ssh2_channelfind);
if (c)
ssh2_channel_destroy(c);
@ -2163,7 +2163,7 @@ static void ssh2_send_packet_from_downstream(
const void *data, int datalen, const char *additional_log_text)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
PktOut *pkt = ssh_bpp_new_pktout(s->ppl.bpp, type);
pkt->downstream_id = id;
pkt->additional_log_text = additional_log_text;
@ -2174,7 +2174,7 @@ static void ssh2_send_packet_from_downstream(
static int ssh2_agent_forwarding_permitted(ConnectionLayer *cl)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
return conf_get_int(s->conf, CONF_agentfwd) && agent_exists();
}
@ -2210,7 +2210,7 @@ static mainchan *mainchan_new(struct ssh2_connection_state *s)
static void mainchan_free(Channel *chan)
{
assert(chan->vt == &mainchan_channelvt);
mainchan *mc = FROMFIELD(chan, mainchan, chan);
mainchan *mc = container_of(chan, mainchan, chan);
struct ssh2_connection_state *s = mc->connlayer;
s->mainchan = NULL;
sfree(mc);
@ -2218,7 +2218,7 @@ static void mainchan_free(Channel *chan)
static void mainchan_open_confirmation(Channel *chan)
{
mainchan *mc = FROMFIELD(chan, mainchan, chan);
mainchan *mc = container_of(chan, mainchan, chan);
struct ssh2_connection_state *s = mc->connlayer;
PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */
@ -2229,7 +2229,7 @@ static void mainchan_open_confirmation(Channel *chan)
static void mainchan_open_failure(Channel *chan, const char *errtext)
{
assert(chan->vt == &mainchan_channelvt);
mainchan *mc = FROMFIELD(chan, mainchan, chan);
mainchan *mc = container_of(chan, mainchan, chan);
struct ssh2_connection_state *s = mc->connlayer;
/*
@ -2244,7 +2244,7 @@ static int mainchan_send(Channel *chan, int is_stderr,
const void *data, int length)
{
assert(chan->vt == &mainchan_channelvt);
mainchan *mc = FROMFIELD(chan, mainchan, chan);
mainchan *mc = container_of(chan, mainchan, chan);
struct ssh2_connection_state *s = mc->connlayer;
return from_backend(s->ppl.frontend, is_stderr, data, length);
}
@ -2252,7 +2252,7 @@ static int mainchan_send(Channel *chan, int is_stderr,
static void mainchan_send_eof(Channel *chan)
{
assert(chan->vt == &mainchan_channelvt);
mainchan *mc = FROMFIELD(chan, mainchan, chan);
mainchan *mc = container_of(chan, mainchan, chan);
struct ssh2_connection_state *s = mc->connlayer;
PacketProtocolLayer *ppl = &s->ppl; /* for ppl_logevent */
@ -2275,7 +2275,7 @@ static void mainchan_send_eof(Channel *chan)
static void mainchan_set_input_wanted(Channel *chan, int wanted)
{
assert(chan->vt == &mainchan_channelvt);
mainchan *mc = FROMFIELD(chan, mainchan, chan);
mainchan *mc = container_of(chan, mainchan, chan);
struct ssh2_connection_state *s = mc->connlayer;
/*
@ -2321,7 +2321,7 @@ static int ssh2_connection_get_specials(
PacketProtocolLayer *ppl, add_special_fn_t add_special, void *ctx)
{
struct ssh2_connection_state *s =
FROMFIELD(ppl, struct ssh2_connection_state, ppl);
container_of(ppl, struct ssh2_connection_state, ppl);
int toret = FALSE;
if (s->mainchan) {
@ -2381,7 +2381,7 @@ static void ssh2_connection_special_cmd(PacketProtocolLayer *ppl,
SessionSpecialCode code, int arg)
{
struct ssh2_connection_state *s =
FROMFIELD(ppl, struct ssh2_connection_state, ppl);
container_of(ppl, struct ssh2_connection_state, ppl);
PktOut *pktout;
const char *signame;
@ -2421,7 +2421,7 @@ static void ssh2_connection_special_cmd(PacketProtocolLayer *ppl,
static void ssh2_terminal_size(ConnectionLayer *cl, int width, int height)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
s->term_width = width;
s->term_height = height;
@ -2440,7 +2440,7 @@ static void ssh2_terminal_size(ConnectionLayer *cl, int width, int height)
static void ssh2_stdout_unthrottle(ConnectionLayer *cl, int bufsize)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
if (s->mainchan)
ssh2channel_unthrottle(&s->mainchan->sc, bufsize);
@ -2449,7 +2449,7 @@ static void ssh2_stdout_unthrottle(ConnectionLayer *cl, int bufsize)
static int ssh2_stdin_backlog(ConnectionLayer *cl)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
return s->mainchan ? bufchain_size(&s->mainchan->outbuffer) : 0;
}
@ -2457,7 +2457,7 @@ static int ssh2_stdin_backlog(ConnectionLayer *cl)
static void ssh2_throttle_all_channels(ConnectionLayer *cl, int throttled)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
struct ssh2_channel *c;
int i;
@ -2470,7 +2470,7 @@ static void ssh2_throttle_all_channels(ConnectionLayer *cl, int throttled)
static int ssh2_ldisc_option(ConnectionLayer *cl, int option)
{
struct ssh2_connection_state *s =
FROMFIELD(cl, struct ssh2_connection_state, cl);
container_of(cl, struct ssh2_connection_state, cl);
/* We always return the same value for LD_ECHO and LD_EDIT */
return s->echoedit;
@ -2479,14 +2479,14 @@ static int ssh2_ldisc_option(ConnectionLayer *cl, int option)
static int ssh2_connection_want_user_input(PacketProtocolLayer *ppl)
{
struct ssh2_connection_state *s =
FROMFIELD(ppl, struct ssh2_connection_state, ppl);
container_of(ppl, struct ssh2_connection_state, ppl);
return s->mainchan_ready && s->want_user_input;
}
static void ssh2_connection_got_user_input(PacketProtocolLayer *ppl)
{
struct ssh2_connection_state *s =
FROMFIELD(ppl, struct ssh2_connection_state, ppl);
container_of(ppl, struct ssh2_connection_state, ppl);
while (s->mainchan && bufchain_size(s->ppl.user_input) > 0) {
/*
@ -2503,7 +2503,7 @@ static void ssh2_connection_got_user_input(PacketProtocolLayer *ppl)
static void ssh2_connection_reconfigure(PacketProtocolLayer *ppl, Conf *conf)
{
struct ssh2_connection_state *s =
FROMFIELD(ppl, struct ssh2_connection_state, ppl);
container_of(ppl, struct ssh2_connection_state, ppl);
conf_free(s->conf);
s->conf = conf_copy(conf);

18
ssh2transport.c
View File

@ -357,7 +357,7 @@ PacketProtocolLayer *ssh2_transport_new(
static void ssh2_transport_free(PacketProtocolLayer *ppl)
{
struct ssh2_transport_state *s =
FROMFIELD(ppl, struct ssh2_transport_state, ppl);
container_of(ppl, struct ssh2_transport_state, ppl);
/*
* As our last act before being freed, move any outgoing packets
@ -596,7 +596,7 @@ static PktIn *ssh2_transport_pop(struct ssh2_transport_state *s)
static void ssh2_transport_process_queue(PacketProtocolLayer *ppl)
{
struct ssh2_transport_state *s =
FROMFIELD(ppl, struct ssh2_transport_state, ppl);
container_of(ppl, struct ssh2_transport_state, ppl);
PktIn *pktin;
PktOut *pktout;
@ -2767,7 +2767,7 @@ ptrlen ssh2_transport_get_session_id(PacketProtocolLayer *ppl)
struct ssh2_transport_state *s;
assert(ppl->vt == &ssh2_transport_vtable);
s = FROMFIELD(ppl, struct ssh2_transport_state, ppl);
s = container_of(ppl, struct ssh2_transport_state, ppl);
assert(s->got_session_id);
return make_ptrlen(s->session_id, s->session_id_len);
@ -2778,7 +2778,7 @@ void ssh2_transport_notify_auth_done(PacketProtocolLayer *ppl)
struct ssh2_transport_state *s;
assert(ppl->vt == &ssh2_transport_vtable);
s = FROMFIELD(ppl, struct ssh2_transport_state, ppl);
s = container_of(ppl, struct ssh2_transport_state, ppl);
s->rekey_reason = NULL; /* will be filled in later */
s->rekey_class = RK_POST_USERAUTH;
@ -2791,7 +2791,7 @@ static int ssh2_transport_get_specials(
PacketProtocolLayer *ppl, add_special_fn_t add_special, void *ctx)
{
struct ssh2_transport_state *s =
FROMFIELD(ppl, struct ssh2_transport_state, ppl);
container_of(ppl, struct ssh2_transport_state, ppl);
int need_separator = FALSE;
int toret;
@ -2836,7 +2836,7 @@ static void ssh2_transport_special_cmd(PacketProtocolLayer *ppl,
SessionSpecialCode code, int arg)
{
struct ssh2_transport_state *s =
FROMFIELD(ppl, struct ssh2_transport_state, ppl);
container_of(ppl, struct ssh2_transport_state, ppl);
if (code == SS_REKEY) {
if (!s->kex_in_progress) {
@ -2884,7 +2884,7 @@ static void ssh2_transport_reconfigure(PacketProtocolLayer *ppl, Conf *conf)
int i;
assert(ppl->vt == &ssh2_transport_vtable);
s = FROMFIELD(ppl, struct ssh2_transport_state, ppl);
s = container_of(ppl, struct ssh2_transport_state, ppl);
rekey_time = sanitise_rekey_time(
conf_get_int(conf, CONF_ssh_rekey_time), 60);
@ -2951,7 +2951,7 @@ static void ssh2_transport_reconfigure(PacketProtocolLayer *ppl, Conf *conf)
static int ssh2_transport_want_user_input(PacketProtocolLayer *ppl)
{
struct ssh2_transport_state *s =
FROMFIELD(ppl, struct ssh2_transport_state, ppl);
container_of(ppl, struct ssh2_transport_state, ppl);
/* Just delegate this to the higher layer */
return ssh_ppl_want_user_input(s->higher_layer);
@ -2960,7 +2960,7 @@ static int ssh2_transport_want_user_input(PacketProtocolLayer *ppl)
static void ssh2_transport_got_user_input(PacketProtocolLayer *ppl)
{
struct ssh2_transport_state *s =
FROMFIELD(ppl, struct ssh2_transport_state, ppl);
container_of(ppl, struct ssh2_transport_state, ppl);
/* Just delegate this to the higher layer */
ssh_ppl_got_user_input(s->higher_layer);

12
ssh2userauth.c
View File

@ -145,14 +145,14 @@ void ssh2_userauth_set_transport_layer(PacketProtocolLayer *userauth,
PacketProtocolLayer *transport)
{
struct ssh2_userauth_state *s =
FROMFIELD(userauth, struct ssh2_userauth_state, ppl);
container_of(userauth, struct ssh2_userauth_state, ppl);
s->transport_layer = transport;
}
static void ssh2_userauth_free(PacketProtocolLayer *ppl)
{
struct ssh2_userauth_state *s =
FROMFIELD(ppl, struct ssh2_userauth_state, ppl);
container_of(ppl, struct ssh2_userauth_state, ppl);
bufchain_clear(&s->banner);
if (s->successor_layer)
@ -198,7 +198,7 @@ static PktIn *ssh2_userauth_pop(struct ssh2_userauth_state *s)
static void ssh2_userauth_process_queue(PacketProtocolLayer *ppl)
{
struct ssh2_userauth_state *s =
FROMFIELD(ppl, struct ssh2_userauth_state, ppl);
container_of(ppl, struct ssh2_userauth_state, ppl);
PktIn *pktin;
ssh2_userauth_filter_queue(s); /* no matter why we were called */
@ -1653,14 +1653,14 @@ static void ssh2_userauth_special_cmd(PacketProtocolLayer *ppl,
static int ssh2_userauth_want_user_input(PacketProtocolLayer *ppl)
{
struct ssh2_userauth_state *s =
FROMFIELD(ppl, struct ssh2_userauth_state, ppl);
container_of(ppl, struct ssh2_userauth_state, ppl);
return s->want_user_input;
}
static void ssh2_userauth_got_user_input(PacketProtocolLayer *ppl)
{
struct ssh2_userauth_state *s =
FROMFIELD(ppl, struct ssh2_userauth_state, ppl);
container_of(ppl, struct ssh2_userauth_state, ppl);
if (s->want_user_input)
queue_idempotent_callback(&s->ppl.ic_process_queue);
}
@ -1668,6 +1668,6 @@ static void ssh2_userauth_got_user_input(PacketProtocolLayer *ppl)
static void ssh2_userauth_reconfigure(PacketProtocolLayer *ppl, Conf *conf)
{
struct ssh2_userauth_state *s =
FROMFIELD(ppl, struct ssh2_userauth_state, ppl);
container_of(ppl, struct ssh2_userauth_state, ppl);
ssh_ppl_reconfigure(s->successor_layer, conf);
}

12
sshaes.c
View File

@ -1054,38 +1054,38 @@ ssh2_cipher *aes_ssh2_new(const struct ssh2_cipheralg *alg)
static void aes_ssh2_free(ssh2_cipher *cipher)
{
struct aes_ssh2_ctx *ctx = FROMFIELD(cipher, struct aes_ssh2_ctx, vt);
struct aes_ssh2_ctx *ctx = container_of(cipher, struct aes_ssh2_ctx, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
static void aes_ssh2_setiv(ssh2_cipher *cipher, const void *iv)
{
struct aes_ssh2_ctx *ctx = FROMFIELD(cipher, struct aes_ssh2_ctx, vt);
struct aes_ssh2_ctx *ctx = container_of(cipher, struct aes_ssh2_ctx, vt);
aes_iv(&ctx->context, iv);
}
static void aes_ssh2_setkey(ssh2_cipher *cipher, const void *key)
{
struct aes_ssh2_ctx *ctx = FROMFIELD(cipher, struct aes_ssh2_ctx, vt);
struct aes_ssh2_ctx *ctx = container_of(cipher, struct aes_ssh2_ctx, vt);
aes_setup(&ctx->context, key, ctx->vt->padded_keybytes);
}
static void aes_ssh2_encrypt(ssh2_cipher *cipher, void *blk, int len)
{
struct aes_ssh2_ctx *ctx = FROMFIELD(cipher, struct aes_ssh2_ctx, vt);
struct aes_ssh2_ctx *ctx = container_of(cipher, struct aes_ssh2_ctx, vt);
aes_encrypt_cbc(blk, len, &ctx->context);
}
static void aes_ssh2_decrypt(ssh2_cipher *cipher, void *blk, int len)
{
struct aes_ssh2_ctx *ctx = FROMFIELD(cipher, struct aes_ssh2_ctx, vt);
struct aes_ssh2_ctx *ctx = container_of(cipher, struct aes_ssh2_ctx, vt);
aes_decrypt_cbc(blk, len, &ctx->context);
}
static void aes_ssh2_sdctr_method(ssh2_cipher *cipher, void *blk, int len)
{
struct aes_ssh2_ctx *ctx = FROMFIELD(cipher, struct aes_ssh2_ctx, vt);
struct aes_ssh2_ctx *ctx = container_of(cipher, struct aes_ssh2_ctx, vt);
aes_sdctr(blk, len, &ctx->context);
}

6
ssharcf.c
View File

@ -71,7 +71,7 @@ static ssh2_cipher *arcfour_new(const struct ssh2_cipheralg *alg)
static void arcfour_free(ssh2_cipher *cipher)
{
ArcfourContext *ctx = FROMFIELD(cipher, ArcfourContext, vt);
ArcfourContext *ctx = container_of(cipher, ArcfourContext, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
@ -92,14 +92,14 @@ static void arcfour_ssh2_setiv(ssh2_cipher *cipher, const void *key)
static void arcfour_ssh2_setkey(ssh2_cipher *cipher, const void *key)
{
ArcfourContext *ctx = FROMFIELD(cipher, ArcfourContext, vt);
ArcfourContext *ctx = container_of(cipher, ArcfourContext, vt);
arcfour_setkey(ctx, key, ctx->vt->padded_keybytes);
arcfour_stir(ctx);
}
static void arcfour_ssh2_block(ssh2_cipher *cipher, void *blk, int len)
{
ArcfourContext *ctx = FROMFIELD(cipher, ArcfourContext, vt);
ArcfourContext *ctx = container_of(cipher, ArcfourContext, vt);
arcfour_block(ctx, blk, len);
}

20
sshblowf.c
View File

@ -589,7 +589,7 @@ static ssh1_cipher *blowfish_ssh1_new(void)
static void blowfish_ssh1_free(ssh1_cipher *cipher)
{
struct blowfish_ssh1_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh1_ctx, vt);
container_of(cipher, struct blowfish_ssh1_ctx, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
@ -597,7 +597,7 @@ static void blowfish_ssh1_free(ssh1_cipher *cipher)
static void blowfish_ssh1_sesskey(ssh1_cipher *cipher, const void *key)
{
struct blowfish_ssh1_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh1_ctx, vt);
container_of(cipher, struct blowfish_ssh1_ctx, vt);
blowfish_setkey(&ctx->contexts[0], key, SSH1_SESSION_KEY_LENGTH);
ctx->contexts[0].iv0 = ctx->contexts[0].iv1 = 0;
ctx->contexts[1] = ctx->contexts[0]; /* structure copy */
@ -606,14 +606,14 @@ static void blowfish_ssh1_sesskey(ssh1_cipher *cipher, const void *key)
static void blowfish_ssh1_encrypt_blk(ssh1_cipher *cipher, void *blk, int len)
{
struct blowfish_ssh1_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh1_ctx, vt);
container_of(cipher, struct blowfish_ssh1_ctx, vt);
blowfish_lsb_encrypt_cbc(blk, len, ctx->contexts);
}
static void blowfish_ssh1_decrypt_blk(ssh1_cipher *cipher, void *blk, int len)
{
struct blowfish_ssh1_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh1_ctx, vt);
container_of(cipher, struct blowfish_ssh1_ctx, vt);
blowfish_lsb_decrypt_cbc(blk, len, ctx->contexts+1);
}
@ -632,7 +632,7 @@ static ssh2_cipher *blowfish_ssh2_new(const struct ssh2_cipheralg *alg)
static void blowfish_ssh2_free(ssh2_cipher *cipher)
{
struct blowfish_ssh2_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh2_ctx, vt);
container_of(cipher, struct blowfish_ssh2_ctx, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
@ -640,35 +640,35 @@ static void blowfish_ssh2_free(ssh2_cipher *cipher)
static void blowfish_ssh2_setiv(ssh2_cipher *cipher, const void *iv)
{
struct blowfish_ssh2_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh2_ctx, vt);
container_of(cipher, struct blowfish_ssh2_ctx, vt);
blowfish_iv(&ctx->context, iv);
}
static void blowfish_ssh2_setkey(ssh2_cipher *cipher, const void *key)
{
struct blowfish_ssh2_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh2_ctx, vt);
container_of(cipher, struct blowfish_ssh2_ctx, vt);
blowfish_setkey(&ctx->context, key, ctx->vt->padded_keybytes);
}
static void blowfish_ssh2_encrypt_blk(ssh2_cipher *cipher, void *blk, int len)
{
struct blowfish_ssh2_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh2_ctx, vt);
container_of(cipher, struct blowfish_ssh2_ctx, vt);
blowfish_msb_encrypt_cbc(blk, len, &ctx->context);
}
static void blowfish_ssh2_decrypt_blk(ssh2_cipher *cipher, void *blk, int len)
{
struct blowfish_ssh2_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh2_ctx, vt);
container_of(cipher, struct blowfish_ssh2_ctx, vt);
blowfish_msb_decrypt_cbc(blk, len, &ctx->context);
}
static void blowfish_ssh2_sdctr(ssh2_cipher *cipher, void *blk, int len)
{
struct blowfish_ssh2_ctx *ctx =
FROMFIELD(cipher, struct blowfish_ssh2_ctx, vt);
container_of(cipher, struct blowfish_ssh2_ctx, vt);
blowfish_msb_sdctr(blk, len, &ctx->context);
}

21
sshccp.c
View File

@ -873,7 +873,7 @@ struct ccp_context {
static ssh2_mac *poly_ssh2_new(
const struct ssh2_macalg *alg, ssh2_cipher *cipher)
{
struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt);
struct ccp_context *ctx = container_of(cipher, struct ccp_context, cvt);
ctx->mac_if.vt = alg;
BinarySink_DELEGATE_INIT(&ctx->mac_if, ctx);
return &ctx->mac_if;
@ -891,7 +891,7 @@ static void poly_setkey(ssh2_mac *mac, const void *key)
static void poly_start(ssh2_mac *mac)
{
struct ccp_context *ctx = FROMFIELD(mac, struct ccp_context, mac_if);
struct ccp_context *ctx = container_of(mac, struct ccp_context, mac_if);
ctx->mac_initialised = 0;
memset(ctx->mac_iv, 0, 8);
@ -933,7 +933,7 @@ static void poly_BinarySink_write(BinarySink *bs, const void *blkv, size_t len)
static void poly_genresult(ssh2_mac *mac, unsigned char *blk)
{
struct ccp_context *ctx = FROMFIELD(mac, struct ccp_context, mac_if);
struct ccp_context *ctx = container_of(mac, struct ccp_context, mac_if);
poly1305_finalise(&ctx->mac, blk);
}
@ -956,7 +956,7 @@ static ssh2_cipher *ccp_new(const struct ssh2_cipheralg *alg)
static void ccp_free(ssh2_cipher *cipher)
{
struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt);
struct ccp_context *ctx = container_of(cipher, struct ccp_context, cvt);
smemclr(&ctx->a_cipher, sizeof(ctx->a_cipher));
smemclr(&ctx->b_cipher, sizeof(ctx->b_cipher));
smemclr(&ctx->mac, sizeof(ctx->mac));
@ -965,14 +965,15 @@ static void ccp_free(ssh2_cipher *cipher)
static void ccp_iv(ssh2_cipher *cipher, const void *iv)
{
/* struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt); */
/* struct ccp_context *ctx =
container_of(cipher, struct ccp_context, cvt); */
/* IV is set based on the sequence number */
}
static void ccp_key(ssh2_cipher *cipher, const void *vkey)
{
const unsigned char *key = (const unsigned char *)vkey;
struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt);
struct ccp_context *ctx = container_of(cipher, struct ccp_context, cvt);
/* Initialise the a_cipher (for decrypting lengths) with the first 256 bits */
chacha20_key(&ctx->a_cipher, key + 32);
/* Initialise the b_cipher (for content and MAC) with the second 256 bits */
@ -981,13 +982,13 @@ static void ccp_key(ssh2_cipher *cipher, const void *vkey)
static void ccp_encrypt(ssh2_cipher *cipher, void *blk, int len)
{
struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt);
struct ccp_context *ctx = container_of(cipher, struct ccp_context, cvt);
chacha20_encrypt(&ctx->b_cipher, blk, len);
}
static void ccp_decrypt(ssh2_cipher *cipher, void *blk, int len)
{
struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt);
struct ccp_context *ctx = container_of(cipher, struct ccp_context, cvt);
chacha20_decrypt(&ctx->b_cipher, blk, len);
}
@ -1011,7 +1012,7 @@ static void ccp_length_op(struct ccp_context *ctx, void *blk, int len,
static void ccp_encrypt_length(ssh2_cipher *cipher, void *blk, int len,
unsigned long seq)
{
struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt);
struct ccp_context *ctx = container_of(cipher, struct ccp_context, cvt);
ccp_length_op(ctx, blk, len, seq);
chacha20_encrypt(&ctx->a_cipher, blk, len);
}
@ -1019,7 +1020,7 @@ static void ccp_encrypt_length(ssh2_cipher *cipher, void *blk, int len,
static void ccp_decrypt_length(ssh2_cipher *cipher, void *blk, int len,
unsigned long seq)
{
struct ccp_context *ctx = FROMFIELD(cipher, struct ccp_context, cvt);
struct ccp_context *ctx = container_of(cipher, struct ccp_context, cvt);
ccp_length_op(ctx, blk, len, seq);
chacha20_decrypt(&ctx->a_cipher, blk, len);
}

6
sshcommon.c
View File

@ -59,7 +59,7 @@ static void pktin_free_queue_callback(void *vctx)
{
while (pktin_freeq_head.next != &pktin_freeq_head) {
PacketQueueNode *node = pktin_freeq_head.next;
PktIn *pktin = FROMFIELD(node, PktIn, qnode);
PktIn *pktin = container_of(node, PktIn, qnode);
pktin_freeq_head.next = node->next;
sfree(pktin);
}
@ -89,7 +89,7 @@ static PktIn *pq_in_get(PacketQueueBase *pqb, int pop)
queue_idempotent_callback(&ic_pktin_free);
}
return FROMFIELD(node, PktIn, qnode);
return container_of(node, PktIn, qnode);
}
static PktOut *pq_out_get(PacketQueueBase *pqb, int pop)
@ -104,7 +104,7 @@ static PktOut *pq_out_get(PacketQueueBase *pqb, int pop)
node->prev = node->next = NULL;
}
return FROMFIELD(node, PktOut, qnode);
return container_of(node, PktOut, qnode);
}
void pq_in_init(PktInQueue *pq)

38
sshdes.c
View File

@ -800,53 +800,53 @@ static ssh1_cipher *des_ssh1_new(void)
static void des3_ssh1_free(ssh1_cipher *cipher)
{
struct des3_ssh1_ctx *ctx = FROMFIELD(cipher, struct des3_ssh1_ctx, vt);
struct des3_ssh1_ctx *ctx = container_of(cipher, struct des3_ssh1_ctx, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
static void des_ssh1_free(ssh1_cipher *cipher)
{
struct des_ssh1_ctx *ctx = FROMFIELD(cipher, struct des_ssh1_ctx, vt);
struct des_ssh1_ctx *ctx = container_of(cipher, struct des_ssh1_ctx, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
static void des3_ssh1_sesskey(ssh1_cipher *cipher, const void *key)
{
struct des3_ssh1_ctx *ctx = FROMFIELD(cipher, struct des3_ssh1_ctx, vt);
struct des3_ssh1_ctx *ctx = container_of(cipher, struct des3_ssh1_ctx, vt);
des3_key(ctx->contexts, key);
des3_key(ctx->contexts+3, key);
}
static void des3_ssh1_encrypt_blk(ssh1_cipher *cipher, void *blk, int len)
{
struct des3_ssh1_ctx *ctx = FROMFIELD(cipher, struct des3_ssh1_ctx, vt);
struct des3_ssh1_ctx *ctx = container_of(cipher, struct des3_ssh1_ctx, vt);
des_3cbc_encrypt(blk, len, ctx->contexts);
}
static void des3_ssh1_decrypt_blk(ssh1_cipher *cipher, void *blk, int len)
{
struct des3_ssh1_ctx *ctx = FROMFIELD(cipher, struct des3_ssh1_ctx, vt);
struct des3_ssh1_ctx *ctx = container_of(cipher, struct des3_ssh1_ctx, vt);
des_3cbc_decrypt(blk, len, ctx->contexts+3);
}
static void des_ssh1_sesskey(ssh1_cipher *cipher, const void *key)
{
struct des_ssh1_ctx *ctx = FROMFIELD(cipher, struct des_ssh1_ctx, vt);
struct des_ssh1_ctx *ctx = container_of(cipher, struct des_ssh1_ctx, vt);
des_key(ctx->contexts, key);
des_key(ctx->contexts+1, key);
}
static void des_ssh1_encrypt_blk(ssh1_cipher *cipher, void *blk, int len)
{
struct des_ssh1_ctx *ctx = FROMFIELD(cipher, struct des_ssh1_ctx, vt);
struct des_ssh1_ctx *ctx = container_of(cipher, struct des_ssh1_ctx, vt);
des_cbc_encrypt(blk, len, ctx->contexts);
}
static void des_ssh1_decrypt_blk(ssh1_cipher *cipher, void *blk, int len)
{
struct des_ssh1_ctx *ctx = FROMFIELD(cipher, struct des_ssh1_ctx, vt);
struct des_ssh1_ctx *ctx = container_of(cipher, struct des_ssh1_ctx, vt);
des_cbc_decrypt(blk, len, ctx->contexts+1);
}
@ -876,21 +876,21 @@ static ssh2_cipher *des_ssh2_new(const struct ssh2_cipheralg *alg)
static void des3_ssh2_free(ssh2_cipher *cipher)
{
struct des3_ssh2_ctx *ctx = FROMFIELD(cipher, struct des3_ssh2_ctx, vt);
struct des3_ssh2_ctx *ctx = container_of(cipher, struct des3_ssh2_ctx, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
static void des_ssh2_free(ssh2_cipher *cipher)
{
struct des_ssh2_ctx *ctx = FROMFIELD(cipher, struct des_ssh2_ctx, vt);
struct des_ssh2_ctx *ctx = container_of(cipher, struct des_ssh2_ctx, vt);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
static void des3_ssh2_setiv(ssh2_cipher *cipher, const void *iv)
{
struct des3_ssh2_ctx *ctx = FROMFIELD(cipher, struct des3_ssh2_ctx, vt);
struct des3_ssh2_ctx *ctx = container_of(cipher, struct des3_ssh2_ctx, vt);
des_iv(&ctx->contexts[0], iv);
/* SSH-2 treats triple-DES as a single block cipher to wrap in
* CBC, so there's only one IV required, not three */
@ -898,49 +898,49 @@ static void des3_ssh2_setiv(ssh2_cipher *cipher, const void *iv)
static void des3_ssh2_setkey(ssh2_cipher *cipher, const void *key)
{
struct des3_ssh2_ctx *ctx = FROMFIELD(cipher, struct des3_ssh2_ctx, vt);
struct des3_ssh2_ctx *ctx = container_of(cipher, struct des3_ssh2_ctx, vt);
des3_key(ctx->contexts, key);
}
static void des_ssh2_setiv(ssh2_cipher *cipher, const void *iv)
{
struct des_ssh2_ctx *ctx = FROMFIELD(cipher, struct des_ssh2_ctx, vt);
struct des_ssh2_ctx *ctx = container_of(cipher, struct des_ssh2_ctx, vt);
des_iv(&ctx->context, iv);
}
static void des_ssh2_setkey(ssh2_cipher *cipher, const void *key)
{
struct des_ssh2_ctx *ctx = FROMFIELD(cipher, struct des_ssh2_ctx, vt);
struct des_ssh2_ctx *ctx = container_of(cipher, struct des_ssh2_ctx, vt);
des_key(&ctx->context, key);
}
static void des3_ssh2_encrypt_blk(ssh2_cipher *cipher, void *blk, int len)
{
struct des3_ssh2_ctx *ctx = FROMFIELD(cipher, struct des3_ssh2_ctx, vt);
struct des3_ssh2_ctx *ctx = container_of(cipher, struct des3_ssh2_ctx, vt);
des_cbc3_encrypt(blk, len, ctx->contexts);
}
static void des3_ssh2_decrypt_blk(ssh2_cipher *cipher, void *blk, int len)
{
struct des3_ssh2_ctx *ctx = FROMFIELD(cipher, struct des3_ssh2_ctx, vt);
struct des3_ssh2_ctx *ctx = container_of(cipher, struct des3_ssh2_ctx, vt);
des_cbc3_decrypt(blk, len, ctx->contexts);
}
static void des3_ssh2_sdctr(ssh2_cipher *cipher, void *blk, int len)
{
struct des3_ssh2_ctx *ctx = FROMFIELD(cipher, struct des3_ssh2_ctx, vt);
struct des3_ssh2_ctx *ctx = container_of(cipher, struct des3_ssh2_ctx, vt);
des_sdctr3(blk, len, ctx->contexts);
}
static void des_ssh2_encrypt_blk(ssh2_cipher *cipher, void *blk, int len)
{
struct des_ssh2_ctx *ctx = FROMFIELD(cipher, struct des_ssh2_ctx, vt);
struct des_ssh2_ctx *ctx = container_of(cipher, struct des_ssh2_ctx, vt);
des_cbc_encrypt(blk, len, &ctx->context);
}
static void des_ssh2_decrypt_blk(ssh2_cipher *cipher, void *blk, int len)
{
struct des_ssh2_ctx *ctx = FROMFIELD(cipher, struct des_ssh2_ctx, vt);
struct des_ssh2_ctx *ctx = container_of(cipher, struct des_ssh2_ctx, vt);
des_cbc_decrypt(blk, len, &ctx->context);
}

18
sshdss.c
View File

@ -40,7 +40,7 @@ static ssh_key *dss_new_pub(const ssh_keyalg *self, ptrlen data)
static void dss_freekey(ssh_key *key)
{
struct dss_key *dss = FROMFIELD(key, struct dss_key, sshk);
struct dss_key *dss = container_of(key, struct dss_key, sshk);
if (dss->p)
freebn(dss->p);
if (dss->q)
@ -56,7 +56,7 @@ static void dss_freekey(ssh_key *key)
static char *dss_cache_str(ssh_key *key)
{
struct dss_key *dss = FROMFIELD(key, struct dss_key, sshk);
struct dss_key *dss = container_of(key, struct dss_key, sshk);
char *p;
int len, i, pos, nibbles;
static const char hex[] = "0123456789abcdef";
@ -106,7 +106,7 @@ static char *dss_cache_str(ssh_key *key)
static int dss_verify(ssh_key *key, ptrlen sig, ptrlen data)
{
struct dss_key *dss = FROMFIELD(key, struct dss_key, sshk);
struct dss_key *dss = container_of(key, struct dss_key, sshk);
BinarySource src[1];
unsigned char hash[20];
Bignum r, s, w, gu1p, yu2p, gu1yu2p, u1, u2, sha, v;
@ -206,7 +206,7 @@ static int dss_verify(ssh_key *key, ptrlen sig, ptrlen data)
static void dss_public_blob(ssh_key *key, BinarySink *bs)
{
struct dss_key *dss = FROMFIELD(key, struct dss_key, sshk);
struct dss_key *dss = container_of(key, struct dss_key, sshk);
put_stringz(bs, "ssh-dss");
put_mp_ssh2(bs, dss->p);
@ -217,7 +217,7 @@ static void dss_public_blob(ssh_key *key, BinarySink *bs)
static void dss_private_blob(ssh_key *key, BinarySink *bs)
{
struct dss_key *dss = FROMFIELD(key, struct dss_key, sshk);
struct dss_key *dss = container_of(key, struct dss_key, sshk);
put_mp_ssh2(bs, dss->x);
}
@ -236,7 +236,7 @@ static ssh_key *dss_new_priv(const ssh_keyalg *self, ptrlen pub, ptrlen priv)
if (!sshk)
return NULL;
dss = FROMFIELD(sshk, struct dss_key, sshk);
dss = container_of(sshk, struct dss_key, sshk);
BinarySource_BARE_INIT(src, priv.ptr, priv.len);
dss->x = get_mp_ssh2(src);
if (get_err(src)) {
@ -300,7 +300,7 @@ static ssh_key *dss_new_priv_openssh(const ssh_keyalg *self,
static void dss_openssh_blob(ssh_key *key, BinarySink *bs)
{
struct dss_key *dss = FROMFIELD(key, struct dss_key, sshk);
struct dss_key *dss = container_of(key, struct dss_key, sshk);
put_mp_ssh2(bs, dss->p);
put_mp_ssh2(bs, dss->q);
@ -319,7 +319,7 @@ static int dss_pubkey_bits(const ssh_keyalg *self, ptrlen pub)
if (!sshk)
return -1;
dss = FROMFIELD(sshk, struct dss_key, sshk);
dss = container_of(sshk, struct dss_key, sshk);
ret = bignum_bitcount(dss->p);
dss_freekey(&dss->sshk);
@ -449,7 +449,7 @@ Bignum *dss_gen_k(const char *id_string, Bignum modulus, Bignum private_key,
static void dss_sign(ssh_key *key, const void *data, int datalen,
BinarySink *bs)
{
struct dss_key *dss = FROMFIELD(key, struct dss_key, sshk);
struct dss_key *dss = container_of(key, struct dss_key, sshk);
Bignum k, gkp, hash, kinv, hxr, r, s;
unsigned char digest[20];
int i;

20
sshecc.c
View File

@ -1700,7 +1700,7 @@ static void ecdsa_freekey(ssh_key *key)
struct ec_key *ec;
if (!key) return;
ec = FROMFIELD(key, struct ec_key, sshk);
ec = container_of(key, struct ec_key, sshk);
if (ec->publicKey.x)
freebn(ec->publicKey.x);
@ -1760,7 +1760,7 @@ static ssh_key *ecdsa_new_pub(const ssh_keyalg *self, ptrlen data)
static char *ecdsa_cache_str(ssh_key *key)
{
struct ec_key *ec = FROMFIELD(key, struct ec_key, sshk);
struct ec_key *ec = container_of(key, struct ec_key, sshk);
char *p;
int len, i, pos, nibbles;
static const char hex[] = "0123456789abcdef";
@ -1799,7 +1799,7 @@ static char *ecdsa_cache_str(ssh_key *key)
static void ecdsa_public_blob(ssh_key *key, BinarySink *bs)
{
struct ec_key *ec = FROMFIELD(key, struct ec_key, sshk);
struct ec_key *ec = container_of(key, struct ec_key, sshk);
int pointlen;
int i;
@ -1839,7 +1839,7 @@ static void ecdsa_public_blob(ssh_key *key, BinarySink *bs)
static void ecdsa_private_blob(ssh_key *key, BinarySink *bs)
{
struct ec_key *ec = FROMFIELD(key, struct ec_key, sshk);
struct ec_key *ec = container_of(key, struct ec_key, sshk);
int keylen;
int i;
@ -1875,7 +1875,7 @@ static ssh_key *ecdsa_new_priv(const ssh_keyalg *self, ptrlen pub, ptrlen priv)
if (!sshk)
return NULL;
ec = FROMFIELD(sshk, struct ec_key, sshk);
ec = container_of(sshk, struct ec_key, sshk);
BinarySource_BARE_INIT(src, priv.ptr, priv.len);
if (ec->publicKey.curve->type != EC_WEIERSTRASS
@ -1967,7 +1967,7 @@ static ssh_key *ed25519_new_priv_openssh(const ssh_keyalg *self,
static void ed25519_openssh_blob(ssh_key *key, BinarySink *bs)
{
struct ec_key *ec = FROMFIELD(key, struct ec_key, sshk);
struct ec_key *ec = container_of(key, struct ec_key, sshk);
strbuf *pub;
int pointlen;
@ -2068,7 +2068,7 @@ static ssh_key *ecdsa_new_priv_openssh(const ssh_keyalg *self,
static void ecdsa_openssh_blob(ssh_key *key, BinarySink *bs)
{
struct ec_key *ec = FROMFIELD(key, struct ec_key, sshk);
struct ec_key *ec = container_of(key, struct ec_key, sshk);
int pointlen;
int i;
@ -2099,7 +2099,7 @@ static int ecdsa_pubkey_bits(const ssh_keyalg *self, ptrlen blob)
if (!sshk)
return -1;
ec = FROMFIELD(sshk, struct ec_key, sshk);
ec = container_of(sshk, struct ec_key, sshk);
ret = ec->publicKey.curve->fieldBits;
ecdsa_freekey(&ec->sshk);
@ -2108,7 +2108,7 @@ static int ecdsa_pubkey_bits(const ssh_keyalg *self, ptrlen blob)
static int ecdsa_verify(ssh_key *key, ptrlen sig, ptrlen data)
{
struct ec_key *ec = FROMFIELD(key, struct ec_key, sshk);
struct ec_key *ec = container_of(key, struct ec_key, sshk);
const struct ecsign_extra *extra =
(const struct ecsign_extra *)ec->sshk->extra;
BinarySource src[1];
@ -2258,7 +2258,7 @@ static int ecdsa_verify(ssh_key *key, ptrlen sig, ptrlen data)
static void ecdsa_sign(ssh_key *key, const void *data, int datalen,
BinarySink *bs)
{
struct ec_key *ec = FROMFIELD(key, struct ec_key, sshk);
struct ec_key *ec = container_of(key, struct ec_key, sshk);
const struct ecsign_extra *extra =
(const struct ecsign_extra *)ec->sshk->extra;
unsigned char digest[512 / 8];

12
sshmd5.c
View File

@ -256,7 +256,8 @@ void hmacmd5_free_context(struct hmacmd5_context *ctx)
static void hmacmd5_ssh2_free(ssh2_mac *mac)
{
struct hmacmd5_context *ctx = FROMFIELD(mac, struct hmacmd5_context, mac);
struct hmacmd5_context *ctx =
container_of(mac, struct hmacmd5_context, mac);
hmacmd5_free_context(ctx);
}
@ -283,13 +284,15 @@ void hmacmd5_key(struct hmacmd5_context *ctx, void const *keyv, int len)
static void hmacmd5_ssh2_setkey(ssh2_mac *mac, const void *key)
{
struct hmacmd5_context *ctx = FROMFIELD(mac, struct hmacmd5_context, mac);
struct hmacmd5_context *ctx =
container_of(mac, struct hmacmd5_context, mac);
hmacmd5_key(ctx, key, ctx->mac.vt->keylen);
}
static void hmacmd5_start(ssh2_mac *mac)
{
struct hmacmd5_context *ctx = FROMFIELD(mac, struct hmacmd5_context, mac);
struct hmacmd5_context *ctx =
container_of(mac, struct hmacmd5_context, mac);
ctx->md5[2] = ctx->md5[0]; /* structure copy */
BinarySink_COPIED(&ctx->md5[2]);
@ -297,7 +300,8 @@ static void hmacmd5_start(ssh2_mac *mac)
static void hmacmd5_genresult(ssh2_mac *mac, unsigned char *hmac)
{
struct hmacmd5_context *ctx = FROMFIELD(mac, struct hmacmd5_context, mac);
struct hmacmd5_context *ctx =
container_of(mac, struct hmacmd5_context, mac);
struct MD5Context s;
unsigned char intermediate[16];

20
sshrsa.c
View File

@ -501,14 +501,14 @@ static ssh_key *rsa2_new_pub(const ssh_keyalg *self, ptrlen data)
static void rsa2_freekey(ssh_key *key)
{
struct RSAKey *rsa = FROMFIELD(key, struct RSAKey, sshk);
struct RSAKey *rsa = container_of(key, struct RSAKey, sshk);
freersakey(rsa);
sfree(rsa);
}
static char *rsa2_cache_str(ssh_key *key)
{
struct RSAKey *rsa = FROMFIELD(key, struct RSAKey, sshk);
struct RSAKey *rsa = container_of(key, struct RSAKey, sshk);
char *p;
int len;
@ -520,7 +520,7 @@ static char *rsa2_cache_str(ssh_key *key)
static void rsa2_public_blob(ssh_key *key, BinarySink *bs)
{
struct RSAKey *rsa = FROMFIELD(key, struct RSAKey, sshk);
struct RSAKey *rsa = container_of(key, struct RSAKey, sshk);
put_stringz(bs, "ssh-rsa");
put_mp_ssh2(bs, rsa->exponent);
@ -529,7 +529,7 @@ static void rsa2_public_blob(ssh_key *key, BinarySink *bs)
static void rsa2_private_blob(ssh_key *key, BinarySink *bs)
{
struct RSAKey *rsa = FROMFIELD(key, struct RSAKey, sshk);
struct RSAKey *rsa = container_of(key, struct RSAKey, sshk);
put_mp_ssh2(bs, rsa->private_exponent);
put_mp_ssh2(bs, rsa->p);
@ -548,7 +548,7 @@ static ssh_key *rsa2_new_priv(const ssh_keyalg *self,
if (!sshk)
return NULL;
rsa = FROMFIELD(sshk, struct RSAKey, sshk);
rsa = container_of(sshk, struct RSAKey, sshk);
BinarySource_BARE_INIT(src, priv.ptr, priv.len);
rsa->private_exponent = get_mp_ssh2(src);
rsa->p = get_mp_ssh2(src);
@ -589,7 +589,7 @@ static ssh_key *rsa2_new_priv_openssh(const ssh_keyalg *self,
static void rsa2_openssh_blob(ssh_key *key, BinarySink *bs)
{
struct RSAKey *rsa = FROMFIELD(key, struct RSAKey, sshk);
struct RSAKey *rsa = container_of(key, struct RSAKey, sshk);
put_mp_ssh2(bs, rsa->modulus);
put_mp_ssh2(bs, rsa->exponent);
@ -609,7 +609,7 @@ static int rsa2_pubkey_bits(const ssh_keyalg *self, ptrlen pub)
if (!sshk)
return -1;
rsa = FROMFIELD(sshk, struct RSAKey, sshk);
rsa = container_of(sshk, struct RSAKey, sshk);
ret = bignum_bitcount(rsa->modulus);
rsa2_freekey(&rsa->sshk);
@ -649,7 +649,7 @@ static const unsigned char asn1_weird_stuff[] = {
static int rsa2_verify(ssh_key *key, ptrlen sig, ptrlen data)
{
struct RSAKey *rsa = FROMFIELD(key, struct RSAKey, sshk);
struct RSAKey *rsa = container_of(key, struct RSAKey, sshk);
BinarySource src[1];
ptrlen type, in_pl;
Bignum in, out;
@ -709,7 +709,7 @@ static int rsa2_verify(ssh_key *key, ptrlen sig, ptrlen data)
static void rsa2_sign(ssh_key *key, const void *data, int datalen,
BinarySink *bs)
{
struct RSAKey *rsa = FROMFIELD(key, struct RSAKey, sshk);
struct RSAKey *rsa = container_of(key, struct RSAKey, sshk);
unsigned char *bytes;
int nbytes;
unsigned char hash[20];
@ -770,7 +770,7 @@ struct RSAKey *ssh_rsakex_newkey(const void *data, int len)
ssh_key *sshk = rsa2_new_pub(&ssh_rsa, make_ptrlen(data, len));
if (!sshk)
return NULL;
return FROMFIELD(sshk, struct RSAKey, sshk);
return container_of(sshk, struct RSAKey, sshk);
}
void ssh_rsakex_freekey(struct RSAKey *key)

16
sshsh256.c
View File

@ -223,8 +223,8 @@ static ssh_hash *sha256_copy(ssh_hash *hashold)
struct sha256_hash *hold, *hnew;
ssh_hash *hashnew = sha256_new(hashold->vt);
hold = FROMFIELD(hashold, struct sha256_hash, hash);
hnew = FROMFIELD(hashnew, struct sha256_hash, hash);
hold = container_of(hashold, struct sha256_hash, hash);
hnew = container_of(hashnew, struct sha256_hash, hash);
hnew->state = hold->state;
BinarySink_COPIED(&hnew->state);
@ -234,7 +234,7 @@ static ssh_hash *sha256_copy(ssh_hash *hashold)
static void sha256_free(ssh_hash *hash)
{
struct sha256_hash *h = FROMFIELD(hash, struct sha256_hash, hash);
struct sha256_hash *h = container_of(hash, struct sha256_hash, hash);
smemclr(h, sizeof(*h));
sfree(h);
@ -242,7 +242,7 @@ static void sha256_free(ssh_hash *hash)
static void sha256_final(ssh_hash *hash, unsigned char *output)
{
struct sha256_hash *h = FROMFIELD(hash, struct sha256_hash, hash);
struct sha256_hash *h = container_of(hash, struct sha256_hash, hash);
SHA256_Final(&h->state, output);
sha256_free(hash);
}
@ -272,7 +272,7 @@ static ssh2_mac *hmacsha256_new(
static void hmacsha256_free(ssh2_mac *mac)
{
struct hmacsha256 *ctx = FROMFIELD(mac, struct hmacsha256, mac);
struct hmacsha256 *ctx = container_of(mac, struct hmacsha256, mac);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
@ -300,13 +300,13 @@ static void sha256_key_internal(struct hmacsha256 *ctx,
static void hmacsha256_key(ssh2_mac *mac, const void *key)
{
struct hmacsha256 *ctx = FROMFIELD(mac, struct hmacsha256, mac);
struct hmacsha256 *ctx = container_of(mac, struct hmacsha256, mac);
sha256_key_internal(ctx, key, ctx->mac.vt->keylen);
}
static void hmacsha256_start(ssh2_mac *mac)
{
struct hmacsha256 *ctx = FROMFIELD(mac, struct hmacsha256, mac);
struct hmacsha256 *ctx = container_of(mac, struct hmacsha256, mac);
ctx->sha[2] = ctx->sha[0]; /* structure copy */
BinarySink_COPIED(&ctx->sha[2]);
@ -314,7 +314,7 @@ static void hmacsha256_start(ssh2_mac *mac)
static void hmacsha256_genresult(ssh2_mac *mac, unsigned char *hmac)
{
struct hmacsha256 *ctx = FROMFIELD(mac, struct hmacsha256, mac);
struct hmacsha256 *ctx = container_of(mac, struct hmacsha256, mac);
SHA256_State s;
unsigned char intermediate[32];

10
sshsh512.c
View File

@ -346,8 +346,8 @@ static ssh_hash *sha512_copy(ssh_hash *hashold)
struct sha512_hash *hold, *hnew;
ssh_hash *hashnew = sha512_new(hashold->vt);
hold = FROMFIELD(hashold, struct sha512_hash, hash);
hnew = FROMFIELD(hashnew, struct sha512_hash, hash);
hold = container_of(hashold, struct sha512_hash, hash);
hnew = container_of(hashnew, struct sha512_hash, hash);
hnew->state = hold->state;
BinarySink_COPIED(&hnew->state);
@ -357,7 +357,7 @@ static ssh_hash *sha512_copy(ssh_hash *hashold)
static void sha512_free(ssh_hash *hash)
{
struct sha512_hash *h = FROMFIELD(hash, struct sha512_hash, hash);
struct sha512_hash *h = container_of(hash, struct sha512_hash, hash);
smemclr(h, sizeof(*h));
sfree(h);
@ -365,7 +365,7 @@ static void sha512_free(ssh_hash *hash)
static void sha512_final(ssh_hash *hash, unsigned char *output)
{
struct sha512_hash *h = FROMFIELD(hash, struct sha512_hash, hash);
struct sha512_hash *h = container_of(hash, struct sha512_hash, hash);
SHA512_Final(&h->state, output);
sha512_free(hash);
}
@ -385,7 +385,7 @@ static ssh_hash *sha384_new(const struct ssh_hashalg *alg)
static void sha384_final(ssh_hash *hash, unsigned char *output)
{
struct sha512_hash *h = FROMFIELD(hash, struct sha512_hash, hash);
struct sha512_hash *h = container_of(hash, struct sha512_hash, hash);
SHA384_Final(&h->state, output);
sha512_free(hash);
}

16
sshsha.c
View File

@ -251,8 +251,8 @@ static ssh_hash *sha1_copy(ssh_hash *hashold)
struct sha1_hash *hold, *hnew;
ssh_hash *hashnew = sha1_new(hashold->vt);
hold = FROMFIELD(hashold, struct sha1_hash, hash);
hnew = FROMFIELD(hashnew, struct sha1_hash, hash);
hold = container_of(hashold, struct sha1_hash, hash);
hnew = container_of(hashnew, struct sha1_hash, hash);
hnew->state = hold->state;
BinarySink_COPIED(&hnew->state);
@ -262,7 +262,7 @@ static ssh_hash *sha1_copy(ssh_hash *hashold)
static void sha1_free(ssh_hash *hash)
{
struct sha1_hash *h = FROMFIELD(hash, struct sha1_hash, hash);
struct sha1_hash *h = container_of(hash, struct sha1_hash, hash);
smemclr(h, sizeof(*h));
sfree(h);
@ -270,7 +270,7 @@ static void sha1_free(ssh_hash *hash)
static void sha1_final(ssh_hash *hash, unsigned char *output)
{
struct sha1_hash *h = FROMFIELD(hash, struct sha1_hash, hash);
struct sha1_hash *h = container_of(hash, struct sha1_hash, hash);
SHA_Final(&h->state, output);
sha1_free(hash);
}
@ -300,7 +300,7 @@ static ssh2_mac *hmacsha1_new(
static void hmacsha1_free(ssh2_mac *mac)
{
struct hmacsha1 *ctx = FROMFIELD(mac, struct hmacsha1, mac);
struct hmacsha1 *ctx = container_of(mac, struct hmacsha1, mac);
smemclr(ctx, sizeof(*ctx));
sfree(ctx);
}
@ -328,7 +328,7 @@ static void sha1_key_internal(SHA_State *keys,
static void hmacsha1_key(ssh2_mac *mac, const void *key)
{
struct hmacsha1 *ctx = FROMFIELD(mac, struct hmacsha1, mac);
struct hmacsha1 *ctx = container_of(mac, struct hmacsha1, mac);
/* Reading the key length out of the ssh2_macalg structure means
* this same method can be used for the _buggy variants which use
* a shorter key */
@ -337,7 +337,7 @@ static void hmacsha1_key(ssh2_mac *mac, const void *key)
static void hmacsha1_start(ssh2_mac *mac)
{
struct hmacsha1 *ctx = FROMFIELD(mac, struct hmacsha1, mac);
struct hmacsha1 *ctx = container_of(mac, struct hmacsha1, mac);
ctx->sha[2] = ctx->sha[0]; /* structure copy */
BinarySink_COPIED(&ctx->sha[2]);
@ -345,7 +345,7 @@ static void hmacsha1_start(ssh2_mac *mac)
static void hmacsha1_genresult(ssh2_mac *mac, unsigned char *hmac)
{
struct hmacsha1 *ctx = FROMFIELD(mac, struct hmacsha1, mac);
struct hmacsha1 *ctx = container_of(mac, struct hmacsha1, mac);
SHA_State s;
unsigned char intermediate[20];

11
sshshare.c
View File

@ -950,7 +950,7 @@ static void share_disconnect(struct ssh_sharing_connstate *cs,
static void share_closing(Plug *plug, const char *error_msg, int error_code,
int calling_back)
{
struct ssh_sharing_connstate *cs = FROMFIELD(
struct ssh_sharing_connstate *cs = container_of(
plug, struct ssh_sharing_connstate, plug);
if (error_msg) {
@ -1766,7 +1766,7 @@ static void share_got_pkt_from_downstream(struct ssh_sharing_connstate *cs,
static void share_receive(Plug *plug, int urgent, char *data, int len)
{
ssh_sharing_connstate *cs = FROMFIELD(
ssh_sharing_connstate *cs = container_of(
plug, ssh_sharing_connstate, plug);
static const char expected_verstring_prefix[] =
"SSHCONNECTION@putty.projects.tartarus.org-2.0-";
@ -1842,7 +1842,7 @@ static void share_receive(Plug *plug, int urgent, char *data, int len)
static void share_sent(Plug *plug, int bufsize)
{
/* ssh_sharing_connstate *cs = FROMFIELD(
/* ssh_sharing_connstate *cs = container_of(
plug, ssh_sharing_connstate, plug); */
/*
@ -1858,7 +1858,8 @@ static void share_sent(Plug *plug, int bufsize)
static void share_listen_closing(Plug *plug, const char *error_msg,
int error_code, int calling_back)
{
ssh_sharing_state *sharestate = FROMFIELD(plug, ssh_sharing_state, plug);
ssh_sharing_state *sharestate =
container_of(plug, ssh_sharing_state, plug);
if (error_msg)
log_general(sharestate, "listening socket: %s", error_msg);
sk_close(sharestate->listensock);
@ -1921,7 +1922,7 @@ static const PlugVtable ssh_sharing_conn_plugvt = {
static int share_listen_accepting(Plug *plug,
accept_fn_t constructor, accept_ctx_t ctx)
{
struct ssh_sharing_state *sharestate = FROMFIELD(
struct ssh_sharing_state *sharestate = container_of(
plug, struct ssh_sharing_state, plug);
struct ssh_sharing_connstate *cs;
const char *err;

10
sshverstring.c
View File

@ -107,7 +107,7 @@ BinaryPacketProtocol *ssh_verstring_new(
void ssh_verstring_free(BinaryPacketProtocol *bpp)
{
struct ssh_verstring_state *s =
FROMFIELD(bpp, struct ssh_verstring_state, bpp);
container_of(bpp, struct ssh_verstring_state, bpp);
conf_free(s->conf);
sfree(s->vstring);
sfree(s->protoversion);
@ -213,7 +213,7 @@ static void ssh_verstring_send(struct ssh_verstring_state *s)
void ssh_verstring_handle_input(BinaryPacketProtocol *bpp)
{
struct ssh_verstring_state *s =
FROMFIELD(bpp, struct ssh_verstring_state, bpp);
container_of(bpp, struct ssh_verstring_state, bpp);
crBegin(s->crState);
@ -604,21 +604,21 @@ static void ssh_detect_bugs(struct ssh_verstring_state *s)
const char *ssh_verstring_get_remote(BinaryPacketProtocol *bpp)
{
struct ssh_verstring_state *s =
FROMFIELD(bpp, struct ssh_verstring_state, bpp);
container_of(bpp, struct ssh_verstring_state, bpp);
return s->vstring;
}
const char *ssh_verstring_get_local(BinaryPacketProtocol *bpp)
{
struct ssh_verstring_state *s =
FROMFIELD(bpp, struct ssh_verstring_state, bpp);
container_of(bpp, struct ssh_verstring_state, bpp);
return s->our_vstring;
}
int ssh_verstring_get_bugs(BinaryPacketProtocol *bpp)
{
struct ssh_verstring_state *s =
FROMFIELD(bpp, struct ssh_verstring_state, bpp);
container_of(bpp, struct ssh_verstring_state, bpp);
return s->remote_bugs;
}

8
sshzlib.c
View File

@ -630,7 +630,7 @@ ssh_compressor *zlib_compress_init(void)
void zlib_compress_cleanup(ssh_compressor *sc)
{
struct ssh_zlib_compressor *comp =
FROMFIELD(sc, struct ssh_zlib_compressor, sc);
container_of(sc, struct ssh_zlib_compressor, sc);
sfree(comp->ectx.userdata);
sfree(comp->ectx.ictx);
sfree(comp);
@ -641,7 +641,7 @@ void zlib_compress_block(ssh_compressor *sc, unsigned char *block, int len,
int minlen)
{
struct ssh_zlib_compressor *comp =
FROMFIELD(sc, struct ssh_zlib_compressor, sc);
container_of(sc, struct ssh_zlib_compressor, sc);
struct Outbuf *out = (struct Outbuf *) comp->ectx.userdata;
int in_block;
@ -916,7 +916,7 @@ ssh_decompressor *zlib_decompress_init(void)
void zlib_decompress_cleanup(ssh_decompressor *dc)
{
struct zlib_decompress_ctx *dctx =
FROMFIELD(dc, struct zlib_decompress_ctx, dc);
container_of(dc, struct zlib_decompress_ctx, dc);
if (dctx->currlentable && dctx->currlentable != dctx->staticlentable)
zlib_freetable(&dctx->currlentable);
@ -978,7 +978,7 @@ int zlib_decompress_block(ssh_decompressor *dc, unsigned char *block, int len,
unsigned char **outblock, int *outlen)
{
struct zlib_decompress_ctx *dctx =
FROMFIELD(dc, struct zlib_decompress_ctx, dc);
container_of(dc, struct zlib_decompress_ctx, dc);
const coderecord *rec;
int code, blktype, rep, dist, nlen, header;
static const unsigned char lenlenmap[] = {

32
telnet.c
View File

@ -645,7 +645,7 @@ static void do_telnet_read(Telnet *telnet, char *buf, int len)
static void telnet_log(Plug *plug, int type, SockAddr *addr, int port,
const char *error_msg, int error_code)
{
Telnet *telnet = FROMFIELD(plug, Telnet, plug);
Telnet *telnet = container_of(plug, Telnet, plug);
backend_socket_log(telnet->frontend, type, addr, port,
error_msg, error_code, telnet->conf,
telnet->session_started);
@ -654,7 +654,7 @@ static void telnet_log(Plug *plug, int type, SockAddr *addr, int port,
static void telnet_closing(Plug *plug, const char *error_msg, int error_code,
int calling_back)
{
Telnet *telnet = FROMFIELD(plug, Telnet, plug);
Telnet *telnet = container_of(plug, Telnet, plug);
/*
* We don't implement independent EOF in each direction for Telnet
@ -678,7 +678,7 @@ static void telnet_closing(Plug *plug, const char *error_msg, int error_code,
static void telnet_receive(Plug *plug, int urgent, char *data, int len)
{
Telnet *telnet = FROMFIELD(plug, Telnet, plug);
Telnet *telnet = container_of(plug, Telnet, plug);
if (urgent)
telnet->in_synch = TRUE;
telnet->session_started = TRUE;
@ -687,7 +687,7 @@ static void telnet_receive(Plug *plug, int urgent, char *data, int len)
static void telnet_sent(Plug *plug, int bufsize)
{
Telnet *telnet = FROMFIELD(plug, Telnet, plug);
Telnet *telnet = container_of(plug, Telnet, plug);
telnet->bufsize = bufsize;
}
@ -809,7 +809,7 @@ static const char *telnet_init(Frontend *frontend, Backend **backend_handle,
static void telnet_free(Backend *be)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
sfree(telnet->sb_buf);
if (telnet->s)
@ -826,7 +826,7 @@ static void telnet_free(Backend *be)
*/
static void telnet_reconfig(Backend *be, Conf *conf)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
pinger_reconfig(telnet->pinger, telnet->conf, conf);
conf_free(telnet->conf);
telnet->conf = conf_copy(conf);
@ -837,7 +837,7 @@ static void telnet_reconfig(Backend *be, Conf *conf)
*/
static int telnet_send(Backend *be, const char *buf, int len)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
unsigned char *p, *end;
static const unsigned char iac[2] = { IAC, IAC };
static const unsigned char cr[2] = { CR, NUL };
@ -872,7 +872,7 @@ static int telnet_send(Backend *be, const char *buf, int len)
*/
static int telnet_sendbuffer(Backend *be)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
return telnet->bufsize;
}
@ -881,7 +881,7 @@ static int telnet_sendbuffer(Backend *be)
*/
static void telnet_size(Backend *be, int width, int height)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
unsigned char b[24];
int n;
char *logbuf;
@ -917,7 +917,7 @@ static void telnet_size(Backend *be, int width, int height)
*/
static void telnet_special(Backend *be, SessionSpecialCode code, int arg)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
unsigned char b[2];
if (telnet->s == NULL)
@ -1022,25 +1022,25 @@ static const SessionSpecial *telnet_get_specials(Backend *be)
static int telnet_connected(Backend *be)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
return telnet->s != NULL;
}
static int telnet_sendok(Backend *be)
{
/* Telnet *telnet = FROMFIELD(be, Telnet, backend); */
/* Telnet *telnet = container_of(be, Telnet, backend); */
return 1;
}
static void telnet_unthrottle(Backend *be, int backlog)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
sk_set_frozen(telnet->s, backlog > TELNET_MAX_BACKLOG);
}
static int telnet_ldisc(Backend *be, int option)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
if (option == LD_ECHO)
return telnet->echoing;
if (option == LD_EDIT)
@ -1050,7 +1050,7 @@ static int telnet_ldisc(Backend *be, int option)
static void telnet_provide_ldisc(Backend *be, Ldisc *ldisc)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
telnet->ldisc = ldisc;
}
@ -1061,7 +1061,7 @@ static void telnet_provide_logctx(Backend *be, LogContext *logctx)
static int telnet_exitcode(Backend *be)
{
Telnet *telnet = FROMFIELD(be, Telnet, backend);
Telnet *telnet = container_of(be, Telnet, backend);
if (telnet->s != NULL)
return -1; /* still connected */
else if (telnet->closed_on_socket_error)

4
testback.c
View File

@ -97,7 +97,7 @@ static void null_free(Backend *be)
static void loop_free(Backend *be)
{
struct loop_state *st = FROMFIELD(be, struct loop_state, backend);
struct loop_state *st = container_of(be, struct loop_state, backend);
sfree(st);
}
@ -112,7 +112,7 @@ static int null_send(Backend *be, const char *buf, int len) {
}
static int loop_send(Backend *be, const char *buf, int len) {
struct loop_state *st = FROMFIELD(be, struct loop_state, backend);
struct loop_state *st = container_of(be, struct loop_state, backend);
return from_backend(st->frontend, 0, buf, len);
}

26
unix/gtkfont.c
View File

@ -541,7 +541,7 @@ static unifont *x11font_create(GtkWidget *widget, const char *name,
static void x11font_destroy(unifont *font)
{
struct x11font *xfont = FROMFIELD(font, struct x11font, u);
struct x11font *xfont = container_of(font, struct x11font, u);
Display *disp = xfont->disp;
int i;
@ -579,7 +579,7 @@ static void x11_alloc_subfont(struct x11font *xfont, int sfid)
static int x11font_has_glyph(unifont *font, wchar_t glyph)
{
struct x11font *xfont = FROMFIELD(font, struct x11font, u);
struct x11font *xfont = container_of(font, struct x11font, u);
if (xfont->sixteen_bit) {
/*
@ -893,7 +893,7 @@ static void x11font_draw_text(unifont_drawctx *ctx, unifont *font,
int x, int y, const wchar_t *string, int len,
int wide, int bold, int cellwidth)
{
struct x11font *xfont = FROMFIELD(font, struct x11font, u);
struct x11font *xfont = container_of(font, struct x11font, u);
int sfid;
int shadowoffset = 0;
int mult = (wide ? 2 : 1);
@ -1200,7 +1200,7 @@ static char *x11font_scale_fontname(GtkWidget *widget, const char *name,
static char *x11font_size_increment(unifont *font, int increment)
{
struct x11font *xfont = FROMFIELD(font, struct x11font, u);
struct x11font *xfont = container_of(font, struct x11font, u);
Display *disp = xfont->disp;
Atom fontprop = XInternAtom(disp, "FONT", False);
char *returned_name = NULL;
@ -1523,7 +1523,7 @@ static unifont *pangofont_create_fallback(GtkWidget *widget, int height,
static void pangofont_destroy(unifont *font)
{
struct pangofont *pfont = FROMFIELD(font, struct pangofont, u);
struct pangofont *pfont = container_of(font, struct pangofont, u);
pango_font_description_free(pfont->desc);
sfree(pfont->widthcache);
g_object_unref(pfont->fset);
@ -1587,7 +1587,7 @@ static void pangofont_draw_internal(unifont_drawctx *ctx, unifont *font,
int len, int wide, int bold, int cellwidth,
int combining)
{
struct pangofont *pfont = FROMFIELD(font, struct pangofont, u);
struct pangofont *pfont = container_of(font, struct pangofont, u);
PangoLayout *layout;
PangoRectangle rect;
char *utfstring, *utfptr;
@ -2018,7 +2018,7 @@ static char *pangofont_scale_fontname(GtkWidget *widget, const char *name,
static char *pangofont_size_increment(unifont *font, int increment)
{
struct pangofont *pfont = FROMFIELD(font, struct pangofont, u);
struct pangofont *pfont = container_of(font, struct pangofont, u);
PangoFontDescription *desc;
int size;
char *newname, *retname;
@ -2244,7 +2244,7 @@ unifont *multifont_create(GtkWidget *widget, const char *name,
static void multifont_destroy(unifont *font)
{
struct multifont *mfont = FROMFIELD(font, struct multifont, u);
struct multifont *mfont = container_of(font, struct multifont, u);
unifont_destroy(mfont->main);
if (mfont->fallback)
unifont_destroy(mfont->fallback);
@ -2261,7 +2261,7 @@ static void multifont_draw_main(unifont_drawctx *ctx, unifont *font, int x,
int wide, int bold, int cellwidth,
int cellinc, unifont_draw_func_t draw)
{
struct multifont *mfont = FROMFIELD(font, struct multifont, u);
struct multifont *mfont = container_of(font, struct multifont, u);
unifont *f;
int ok, i;
@ -2307,7 +2307,7 @@ static void multifont_draw_combining(unifont_drawctx *ctx, unifont *font,
static char *multifont_size_increment(unifont *font, int increment)
{
struct multifont *mfont = FROMFIELD(font, struct multifont, u);
struct multifont *mfont = container_of(font, struct multifont, u);
return unifont_size_increment(mfont->main, increment);
}
@ -3680,7 +3680,7 @@ unifontsel *unifontsel_new(const char *wintitle)
void unifontsel_destroy(unifontsel *fontsel)
{
unifontsel_internal *fs = FROMFIELD(fontsel, unifontsel_internal, u);
unifontsel_internal *fs = container_of(fontsel, unifontsel_internal, u);
fontinfo *info;
#ifndef NO_BACKING_PIXMAPS
@ -3699,7 +3699,7 @@ void unifontsel_destroy(unifontsel *fontsel)
void unifontsel_set_name(unifontsel *fontsel, const char *fontname)
{
unifontsel_internal *fs = FROMFIELD(fontsel, unifontsel_internal, u);
unifontsel_internal *fs = container_of(fontsel, unifontsel_internal, u);
int i, start, end, size, flags;
const char *fontname2 = NULL;
fontinfo *info;
@ -3759,7 +3759,7 @@ void unifontsel_set_name(unifontsel *fontsel, const char *fontname)
char *unifontsel_get_name(unifontsel *fontsel)
{
unifontsel_internal *fs = FROMFIELD(fontsel, unifontsel_internal, u);
unifontsel_internal *fs = container_of(fontsel, unifontsel_internal, u);
char *name;
if (!fs->selected)

20
unix/uxnet.c
View File

@ -483,7 +483,7 @@ SockAddr *sk_addr_dup(SockAddr *addr)
static Plug *sk_net_plug(Socket *sock, Plug *p)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
Plug *ret = s->plug;
if (p)
s->plug = p;
@ -980,7 +980,7 @@ Socket *sk_newlistener(const char *srcaddr, int port, Plug *plug,
if (address_family == AF_INET6 && orig_address_family == ADDRTYPE_UNSPEC) {
NetSocket *other;
other = FROMFIELD(
other = container_of(
sk_newlistener(srcaddr, port, plug,
local_host_only, ADDRTYPE_IPV4),
NetSocket, sock);
@ -1010,7 +1010,7 @@ Socket *sk_newlistener(const char *srcaddr, int port, Plug *plug,
static void sk_net_close(Socket *sock)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
if (s->child)
sk_net_close(&s->child->sock);
@ -1039,7 +1039,7 @@ void *sk_getxdmdata(Socket *sock, int *lenp)
*/
if (sock->vt != &NetSocket_sockvt)
return NULL; /* failure */
s = FROMFIELD(sock, NetSocket, sock);
s = container_of(sock, NetSocket, sock);
addrlen = sizeof(u);
if (getsockname(s->s, &u.sa, &addrlen) < 0)
@ -1185,7 +1185,7 @@ void try_send(NetSocket *s)
static int sk_net_write(Socket *sock, const void *buf, int len)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
assert(s->outgoingeof == EOF_NO);
@ -1211,7 +1211,7 @@ static int sk_net_write(Socket *sock, const void *buf, int len)
static int sk_net_write_oob(Socket *sock, const void *buf, int len)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
assert(s->outgoingeof == EOF_NO);
@ -1240,7 +1240,7 @@ static int sk_net_write_oob(Socket *sock, const void *buf, int len)
static void sk_net_write_eof(Socket *sock)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
assert(s->outgoingeof == EOF_NO);
@ -1467,13 +1467,13 @@ const char *sk_addr_error(SockAddr *addr)
}
static const char *sk_net_socket_error(Socket *sock)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
return s->error;
}
static void sk_net_set_frozen(Socket *sock, int is_frozen)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
if (s->frozen == is_frozen)
return;
s->frozen = is_frozen;
@ -1482,7 +1482,7 @@ static void sk_net_set_frozen(Socket *sock, int is_frozen)
static char *sk_net_peer_info(Socket *sock)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
union sockaddr_union addr;
socklen_t addrlen = sizeof(addr);
#ifndef NO_IPV6

14
unix/uxproxy.c
View File

@ -104,7 +104,7 @@ static int localproxy_errfd_find(void *av, void *bv)
static Plug *sk_localproxy_plug (Socket *s, Plug *p)
{
LocalProxySocket *ps = FROMFIELD(s, LocalProxySocket, sock);
LocalProxySocket *ps = container_of(s, LocalProxySocket, sock);
Plug *ret = ps->plug;
if (p)
ps->plug = p;
@ -113,7 +113,7 @@ static Plug *sk_localproxy_plug (Socket *s, Plug *p)
static void sk_localproxy_close (Socket *s)
{
LocalProxySocket *ps = FROMFIELD(s, LocalProxySocket, sock);
LocalProxySocket *ps = container_of(s, LocalProxySocket, sock);
if (ps->to_cmd >= 0) {
del234(localproxy_by_tofd, ps);
@ -201,7 +201,7 @@ static int localproxy_try_send(LocalProxySocket *ps)
static int sk_localproxy_write (Socket *s, const void *data, int len)
{
LocalProxySocket *ps = FROMFIELD(s, LocalProxySocket, sock);
LocalProxySocket *ps = container_of(s, LocalProxySocket, sock);
assert(ps->outgoingeof == EOF_NO);
@ -223,7 +223,7 @@ static int sk_localproxy_write_oob (Socket *s, const void *data, int len)
static void sk_localproxy_write_eof (Socket *s)
{
LocalProxySocket *ps = FROMFIELD(s, LocalProxySocket, sock);
LocalProxySocket *ps = container_of(s, LocalProxySocket, sock);
assert(ps->outgoingeof == EOF_NO);
ps->outgoingeof = EOF_PENDING;
@ -233,13 +233,13 @@ static void sk_localproxy_write_eof (Socket *s)
static void sk_localproxy_flush (Socket *s)
{
/* LocalProxySocket *ps = FROMFIELD(s, LocalProxySocket, sock); */
/* LocalProxySocket *ps = container_of(s, LocalProxySocket, sock); */
/* do nothing */
}
static void sk_localproxy_set_frozen (Socket *s, int is_frozen)
{
LocalProxySocket *ps = FROMFIELD(s, LocalProxySocket, sock);
LocalProxySocket *ps = container_of(s, LocalProxySocket, sock);
if (ps->from_cmd < 0)
return;
@ -252,7 +252,7 @@ static void sk_localproxy_set_frozen (Socket *s, int is_frozen)
static const char * sk_localproxy_socket_error (Socket *s)
{
LocalProxySocket *ps = FROMFIELD(s, LocalProxySocket, sock);
LocalProxySocket *ps = container_of(s, LocalProxySocket, sock);
return ps->error;
}

30
unix/uxpty.c
View File

@ -1041,7 +1041,7 @@ static const char *pty_init(Frontend *frontend, Backend **backend_handle,
static void pty_reconfig(Backend *be, Conf *conf)
{
Pty *pty = FROMFIELD(be, Pty, backend);
Pty *pty = container_of(be, Pty, backend);
/*
* We don't have much need to reconfigure this backend, but
* unfortunately we do need to pick up the setting of Close On
@ -1055,7 +1055,7 @@ static void pty_reconfig(Backend *be, Conf *conf)
*/
static void pty_free(Backend *be)
{
Pty *pty = FROMFIELD(be, Pty, backend);
Pty *pty = container_of(be, Pty, backend);
/* Either of these may fail `not found'. That's fine with us. */
del234(ptys_by_pid, pty);
@ -1108,7 +1108,7 @@ static void pty_try_write(Pty *pty)
*/
static int pty_send(Backend *be, const char *buf, int len)
{
Pty *pty = FROMFIELD(be, Pty, backend);
Pty *pty = container_of(be, Pty, backend);
if (pty->master_fd < 0)
return 0; /* ignore all writes if fd closed */
@ -1138,7 +1138,7 @@ static void pty_close(Pty *pty)
*/
static int pty_sendbuffer(Backend *be)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
return 0;
}
@ -1147,7 +1147,7 @@ static int pty_sendbuffer(Backend *be)
*/
static void pty_size(Backend *be, int width, int height)
{
Pty *pty = FROMFIELD(be, Pty, backend);
Pty *pty = container_of(be, Pty, backend);
struct winsize size;
pty->term_width = width;
@ -1168,7 +1168,7 @@ static void pty_size(Backend *be, int width, int height)
*/
static void pty_special(Backend *be, SessionSpecialCode code, int arg)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
/* Do nothing! */
return;
}
@ -1179,7 +1179,7 @@ static void pty_special(Backend *be, SessionSpecialCode code, int arg)
*/
static const SessionSpecial *pty_get_specials(Backend *be)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
/*
* Hmm. When I get round to having this actually usable, it
* might be quite nice to have the ability to deliver a few
@ -1191,43 +1191,43 @@ static const SessionSpecial *pty_get_specials(Backend *be)
static int pty_connected(Backend *be)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
return TRUE;
}
static int pty_sendok(Backend *be)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
return 1;
}
static void pty_unthrottle(Backend *be, int backlog)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
/* do nothing */
}
static int pty_ldisc(Backend *be, int option)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
return 0; /* neither editing nor echoing */
}
static void pty_provide_ldisc(Backend *be, Ldisc *ldisc)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
/* This is a stub. */
}
static void pty_provide_logctx(Backend *be, LogContext *logctx)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
/* This is a stub. */
}
static int pty_exitcode(Backend *be)
{
Pty *pty = FROMFIELD(be, Pty, backend);
Pty *pty = container_of(be, Pty, backend);
if (!pty->finished)
return -1; /* not dead yet */
else
@ -1236,7 +1236,7 @@ static int pty_exitcode(Backend *be)
static int pty_cfg_info(Backend *be)
{
/* Pty *pty = FROMFIELD(be, Pty, backend); */
/* Pty *pty = container_of(be, Pty, backend); */
return 0;
}

14
unix/uxser.c
View File

@ -350,7 +350,7 @@ static void serial_close(Serial *serial)
static void serial_free(Backend *be)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
serial_close(serial);
@ -361,7 +361,7 @@ static void serial_free(Backend *be)
static void serial_reconfig(Backend *be, Conf *conf)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
/*
* FIXME: what should we do if this returns an error?
@ -465,7 +465,7 @@ static void serial_try_write(Serial *serial)
*/
static int serial_send(Backend *be, const char *buf, int len)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
if (serial->fd < 0)
return 0;
@ -481,7 +481,7 @@ static int serial_send(Backend *be, const char *buf, int len)
*/
static int serial_sendbuffer(Backend *be)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
return bufchain_size(&serial->output_data);
}
@ -499,7 +499,7 @@ static void serial_size(Backend *be, int width, int height)
*/
static void serial_special(Backend *be, SessionSpecialCode code, int arg)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
if (serial->fd >= 0 && code == SS_BRK) {
tcsendbreak(serial->fd, 0);
@ -534,7 +534,7 @@ static int serial_sendok(Backend *be)
static void serial_unthrottle(Backend *be, int backlog)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
serial->inbufsize = backlog;
serial_uxsel_setup(serial);
}
@ -559,7 +559,7 @@ static void serial_provide_logctx(Backend *be, LogContext *logctx)
static int serial_exitcode(Backend *be)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
if (serial->fd >= 0)
return -1; /* still connected */
else

16
windows/winhsock.c
View File

@ -106,7 +106,7 @@ static void handle_sentdata(struct handle *h, int new_backlog)
static Plug *sk_handle_plug(Socket *s, Plug *p)
{
HandleSocket *hs = FROMFIELD(s, HandleSocket, sock);
HandleSocket *hs = container_of(s, HandleSocket, sock);
Plug *ret = hs->plug;
if (p)
hs->plug = p;
@ -115,7 +115,7 @@ static Plug *sk_handle_plug(Socket *s, Plug *p)
static void sk_handle_close(Socket *s)
{
HandleSocket *hs = FROMFIELD(s, HandleSocket, sock);
HandleSocket *hs = container_of(s, HandleSocket, sock);
if (hs->defer_close) {
hs->deferred_close = TRUE;
@ -135,7 +135,7 @@ static void sk_handle_close(Socket *s)
static int sk_handle_write(Socket *s, const void *data, int len)
{
HandleSocket *hs = FROMFIELD(s, HandleSocket, sock);
HandleSocket *hs = container_of(s, HandleSocket, sock);
return handle_write(hs->send_h, data, len);
}
@ -151,14 +151,14 @@ static int sk_handle_write_oob(Socket *s, const void *data, int len)
static void sk_handle_write_eof(Socket *s)
{
HandleSocket *hs = FROMFIELD(s, HandleSocket, sock);
HandleSocket *hs = container_of(s, HandleSocket, sock);
handle_write_eof(hs->send_h);
}
static void sk_handle_flush(Socket *s)
{
/* HandleSocket *hs = FROMFIELD(s, HandleSocket, sock); */
/* HandleSocket *hs = container_of(s, HandleSocket, sock); */
/* do nothing */
}
@ -211,7 +211,7 @@ static void handle_socket_unfreeze(void *hsv)
static void sk_handle_set_frozen(Socket *s, int is_frozen)
{
HandleSocket *hs = FROMFIELD(s, HandleSocket, sock);
HandleSocket *hs = container_of(s, HandleSocket, sock);
if (is_frozen) {
switch (hs->frozen) {
@ -266,13 +266,13 @@ static void sk_handle_set_frozen(Socket *s, int is_frozen)
static const char *sk_handle_socket_error(Socket *s)
{
HandleSocket *hs = FROMFIELD(s, HandleSocket, sock);
HandleSocket *hs = container_of(s, HandleSocket, sock);
return hs->error;
}
static char *sk_handle_peer_info(Socket *s)
{
HandleSocket *hs = FROMFIELD(s, HandleSocket, sock);
HandleSocket *hs = container_of(s, HandleSocket, sock);
ULONG pid;
static HMODULE kernel32_module;
DECL_WINDOWS_FUNCTION(static, BOOL, GetNamedPipeClientProcessId,

18
windows/winnet.c
View File

@ -909,7 +909,7 @@ SockAddr *sk_addr_dup(SockAddr *addr)
static Plug *sk_net_plug(Socket *sock, Plug *p)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
Plug *ret = s->plug;
if (p)
s->plug = p;
@ -1411,7 +1411,7 @@ Socket *sk_newlistener(const char *srcaddr, int port, Plug *plug,
local_host_only, ADDRTYPE_IPV6);
if (other) {
NetSocket *ns = FROMFIELD(other, NetSocket, sock);
NetSocket *ns = container_of(other, NetSocket, sock);
if (!ns->error) {
ns->parent = ret;
ret->child = ns;
@ -1428,7 +1428,7 @@ Socket *sk_newlistener(const char *srcaddr, int port, Plug *plug,
static void sk_net_close(Socket *sock)
{
extern char *do_select(SOCKET skt, int startup);
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
if (s->child)
sk_net_close(&s->child->sock);
@ -1539,7 +1539,7 @@ void try_send(NetSocket *s)
static int sk_net_write(Socket *sock, const void *buf, int len)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
assert(s->outgoingeof == EOF_NO);
@ -1559,7 +1559,7 @@ static int sk_net_write(Socket *sock, const void *buf, int len)
static int sk_net_write_oob(Socket *sock, const void *buf, int len)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
assert(s->outgoingeof == EOF_NO);
@ -1582,7 +1582,7 @@ static int sk_net_write_oob(Socket *sock, const void *buf, int len)
static void sk_net_write_eof(Socket *sock)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
assert(s->outgoingeof == EOF_NO);
@ -1785,13 +1785,13 @@ const char *sk_addr_error(SockAddr *addr)
}
static const char *sk_net_socket_error(Socket *sock)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
return s->error;
}
static char *sk_net_peer_info(Socket *sock)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
#ifdef NO_IPV6
struct sockaddr_in addr;
#else
@ -1823,7 +1823,7 @@ static char *sk_net_peer_info(Socket *sock)
static void sk_net_set_frozen(Socket *sock, int is_frozen)
{
NetSocket *s = FROMFIELD(sock, NetSocket, sock);
NetSocket *s = container_of(sock, NetSocket, sock);
if (s->frozen == is_frozen)
return;
s->frozen = is_frozen;

6
windows/winnps.c
View File

@ -38,7 +38,7 @@ typedef struct NamedPipeServerSocket {
static Plug *sk_namedpipeserver_plug(Socket *s, Plug *p)
{
NamedPipeServerSocket *ps = FROMFIELD(s, NamedPipeServerSocket, sock);
NamedPipeServerSocket *ps = container_of(s, NamedPipeServerSocket, sock);
Plug *ret = ps->plug;
if (p)
ps->plug = p;
@ -47,7 +47,7 @@ static Plug *sk_namedpipeserver_plug(Socket *s, Plug *p)
static void sk_namedpipeserver_close(Socket *s)
{
NamedPipeServerSocket *ps = FROMFIELD(s, NamedPipeServerSocket, sock);
NamedPipeServerSocket *ps = container_of(s, NamedPipeServerSocket, sock);
if (ps->callback_handle)
handle_free(ps->callback_handle);
@ -64,7 +64,7 @@ static void sk_namedpipeserver_close(Socket *s)
static const char *sk_namedpipeserver_socket_error(Socket *s)
{
NamedPipeServerSocket *ps = FROMFIELD(s, NamedPipeServerSocket, sock);
NamedPipeServerSocket *ps = container_of(s, NamedPipeServerSocket, sock);
return ps->error;
}

14
windows/winser.c
View File

@ -284,7 +284,7 @@ static const char *serial_init(Frontend *frontend, Backend **backend_handle,
static void serial_free(Backend *be)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
serial_terminate(serial);
expire_timer_context(serial);
@ -293,7 +293,7 @@ static void serial_free(Backend *be)
static void serial_reconfig(Backend *be, Conf *conf)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
serial_configure(serial, serial->port, conf);
@ -308,7 +308,7 @@ static void serial_reconfig(Backend *be, Conf *conf)
*/
static int serial_send(Backend *be, const char *buf, int len)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
if (serial->out == NULL)
return 0;
@ -322,7 +322,7 @@ static int serial_send(Backend *be, const char *buf, int len)
*/
static int serial_sendbuffer(Backend *be)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
return serial->bufsize;
}
@ -351,7 +351,7 @@ static void serbreak_timer(void *ctx, unsigned long now)
*/
static void serial_special(Backend *be, SessionSpecialCode code, int arg)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
if (serial->port && code == SS_BRK) {
logevent(serial->frontend, "Starting serial break at user request");
@ -399,7 +399,7 @@ static int serial_sendok(Backend *be)
static void serial_unthrottle(Backend *be, int backlog)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
if (serial->in)
handle_unthrottle(serial->in, backlog);
}
@ -424,7 +424,7 @@ static void serial_provide_logctx(Backend *be, LogContext *logctx)
static int serial_exitcode(Backend *be)
{
Serial *serial = FROMFIELD(be, Serial, backend);
Serial *serial = container_of(be, Serial, backend);
if (serial->port != INVALID_HANDLE_VALUE)
return -1; /* still connected */
else

14
x11fwd.c
View File

@ -634,7 +634,7 @@ static void x11_send_init_error(struct X11Connection *conn,
static void x11_closing(Plug *plug, const char *error_msg, int error_code,
int calling_back)
{
struct X11Connection *xconn = FROMFIELD(
struct X11Connection *xconn = container_of(
plug, struct X11Connection, plug);
if (error_msg) {
@ -666,7 +666,7 @@ static void x11_closing(Plug *plug, const char *error_msg, int error_code,
static void x11_receive(Plug *plug, int urgent, char *data, int len)
{
struct X11Connection *xconn = FROMFIELD(
struct X11Connection *xconn = container_of(
plug, struct X11Connection, plug);
xconn->no_data_sent_to_x_client = FALSE;
@ -675,7 +675,7 @@ static void x11_receive(Plug *plug, int urgent, char *data, int len)
static void x11_sent(Plug *plug, int bufsize)
{
struct X11Connection *xconn = FROMFIELD(
struct X11Connection *xconn = container_of(
plug, struct X11Connection, plug);
sshfwd_unthrottle(xconn->c, bufsize);
@ -773,7 +773,7 @@ Channel *x11_new_channel(tree234 *authtree, SshChannel *c,
static void x11_chan_free(Channel *chan)
{
assert(chan->vt == &X11Connection_channelvt);
X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
X11Connection *xconn = container_of(chan, X11Connection, chan);
if (xconn->auth_protocol) {
sfree(xconn->auth_protocol);
@ -790,7 +790,7 @@ static void x11_chan_free(Channel *chan)
static void x11_set_input_wanted(Channel *chan, int wanted)
{
assert(chan->vt == &X11Connection_channelvt);
X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
X11Connection *xconn = container_of(chan, X11Connection, chan);
xconn->input_wanted = wanted;
if (xconn->s)
@ -845,7 +845,7 @@ static int x11_parse_ip(const char *addr_string, unsigned long *ip)
static int x11_send(Channel *chan, int is_stderr, const void *vdata, int len)
{
assert(chan->vt == &X11Connection_channelvt);
X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
X11Connection *xconn = container_of(chan, X11Connection, chan);
const char *data = (const char *)vdata;
/*
@ -999,7 +999,7 @@ static int x11_send(Channel *chan, int is_stderr, const void *vdata, int len)
static void x11_send_eof(Channel *chan)
{
assert(chan->vt == &X11Connection_channelvt);
X11Connection *xconn = FROMFIELD(chan, X11Connection, chan);
X11Connection *xconn = container_of(chan, X11Connection, chan);
if (xconn->s) {
sk_write_eof(xconn->s);