crypto/openssh/auth-options.c

176

} else if (sshbuf_len(data) != 0) {

crypto/openssh/auth-options.c

90

while (sshbuf_len(c) > 0) {

crypto/openssh/auth-options.c

99

name, sshbuf_len(data));

crypto/openssh/auth.c

589

while (sshbuf_len(auth_debug) != 0) {

crypto/openssh/auth2-chall.c

118

sshbuf_len(b) ? "," : "", devices[i]->name)) != 0)

crypto/openssh/auth2-gss.c

308

gssbuf.length = sshbuf_len(b);

crypto/openssh/auth2-hostbased.c

152

sshbuf_ptr(b), sshbuf_len(b), pkalg, ssh->compat, NULL) == 0)

crypto/openssh/auth2-pubkey.c

225

sshbuf_ptr(b), sshbuf_len(b),

crypto/openssh/auth2.c

414

if (sshbuf_len(loginmsg) > 0) {

crypto/openssh/auth2.c

509

if ((r = sshbuf_putf(b, "%s%s", sshbuf_len(b) ? "," : "",

crypto/openssh/authfd.c

145

len = sshbuf_len(request);

crypto/openssh/authfd.c

151

sshbuf_len(request)) != sshbuf_len(request))

crypto/openssh/channels.c

1023

c->istate, sshbuf_len(c->input),

crypto/openssh/channels.c

1024

c->ostate, sshbuf_len(c->output),

crypto/openssh/channels.c

1025

channel_format_extended_usage(c), sshbuf_len(c->extended),

crypto/openssh/channels.c

1264

sshbuf_len(c->input) < c->remote_window &&

crypto/openssh/channels.c

1269

if (sshbuf_len(c->output) > 0) {

crypto/openssh/channels.c

1275

c->efd, sshbuf_len(c->extended));

crypto/openssh/channels.c

1284

sshbuf_len(c->extended) > 0)

crypto/openssh/channels.c

1289

sshbuf_len(c->extended) < c->remote_window)

crypto/openssh/channels.c

1320

if (sshbuf_len(b) < 12)

crypto/openssh/channels.c

1338

if (sshbuf_len(b) <

crypto/openssh/channels.c

1433

if (sshbuf_len(c->output) > 0)

crypto/openssh/channels.c

1458

have = sshbuf_len(input);

crypto/openssh/channels.c

1494

have = sshbuf_len(input);

crypto/openssh/channels.c

1512

have = sshbuf_len(input);

crypto/openssh/channels.c

1580

have = sshbuf_len(input);

crypto/openssh/channels.c

1721

have = sshbuf_len(c->input);

crypto/openssh/channels.c

1750

if (sshbuf_len(c->output))

crypto/openssh/channels.c

1775

have = sshbuf_len(c->output);

crypto/openssh/channels.c

1807

len = sshbuf_len(c->input);

crypto/openssh/channels.c

2130

if ((have = sshbuf_len(c->input)) >= c->remote_window)

crypto/openssh/channels.c

2197

if (sshbuf_len(c->output) == 0)

crypto/openssh/channels.c

2201

olen = sshbuf_len(c->output);

crypto/openssh/channels.c

2217

dlen = sshbuf_len(c->output);

crypto/openssh/channels.c

2273

c->local_consumed += olen - sshbuf_len(c->output);

crypto/openssh/channels.c

2286

if (sshbuf_len(c->extended) == 0)

crypto/openssh/channels.c

2290

sshbuf_len(c->extended));

crypto/openssh/channels.c

2399

if (sshbuf_len(c->input) < need) {

crypto/openssh/channels.c

2400

rlen = need - sshbuf_len(c->input);

crypto/openssh/channels.c

2403

return sshbuf_len(c->input);

crypto/openssh/channels.c

2412

return sshbuf_len(c->input);

crypto/openssh/channels.c

2459

if (sshbuf_len(c->output) == 0)

crypto/openssh/channels.c

2462

len = write(c->wfd, sshbuf_ptr(c->output), sshbuf_len(c->output));

crypto/openssh/channels.c

2952

if ((len = sshbuf_len(c->input)) == 0) {

crypto/openssh/channels.c

2964

c->self, c->efd, sshbuf_len(c->extended));

crypto/openssh/channels.c

3025

if ((len = sshbuf_len(c->extended)) == 0)

crypto/openssh/channels.c

3029

c->remote_window, sshbuf_len(c->extended), c->extended_usage);

crypto/openssh/channels.c

3538

if (sshbuf_len(c->input) == 0)

crypto/openssh/channels.c

884

if (sshbuf_len(c->output) > maxsize) {

crypto/openssh/channels.c

886

c->self, sshbuf_len(c->output), maxsize);

crypto/openssh/channels.h

272

sshbuf_len(c->extended) > 0))

crypto/openssh/channels.h

276

sshbuf_len(c->extended) > 0))

crypto/openssh/clientloop.c

2401

sshbuf_ptr(signdata), sshbuf_len(signdata),

crypto/openssh/clientloop.c

2761

len = sshbuf_len(cmd);

crypto/openssh/clientloop.c

767

if (sshbuf_len(bout) > 0)

crypto/openssh/clientloop.c

769

sshbuf_len(bout));

crypto/openssh/clientloop.c

770

if (sshbuf_len(berr) > 0)

crypto/openssh/clientloop.c

772

sshbuf_len(berr));

crypto/openssh/digest-libc.c

215

return ssh_digest_update(ctx, sshbuf_ptr(b), sshbuf_len(b));

crypto/openssh/digest-libc.c

265

return ssh_digest_memory(alg, sshbuf_ptr(b), sshbuf_len(b), d, dlen);

crypto/openssh/digest-openssl.c

155

return ssh_digest_update(ctx, sshbuf_ptr(b), sshbuf_len(b));

crypto/openssh/digest-openssl.c

205

return ssh_digest_memory(alg, sshbuf_ptr(b), sshbuf_len(b), d, dlen);

crypto/openssh/kex.c

1136

if (sshbuf_len(kex->session_id) != 0) {

crypto/openssh/kex.c

1142

} else if (sshbuf_len(kex->session_id) == 0) {

crypto/openssh/kex.c

1266

sshbuf_len(our_version)) != sshbuf_len(our_version)) {

crypto/openssh/kex.c

1344

if (sshbuf_len(peer_version) > SSH_MAX_BANNER_LEN) {

crypto/openssh/kex.c

1350

if (sshbuf_len(peer_version) > 4 &&

crypto/openssh/kex.c

1373

if ((remote_version = calloc(1, sshbuf_len(peer_version))) == NULL) {

crypto/openssh/kex.c

587

if (sshbuf_len(kex->my) < KEX_COOKIE_LEN) {

crypto/openssh/kex.c

589

sshbuf_len(kex->my), KEX_COOKIE_LEN);

crypto/openssh/kexc25519.c

127

if (sshbuf_len(client_blob) != CURVE25519_SIZE) {

crypto/openssh/kexc25519.c

152

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexc25519.c

175

if (sshbuf_len(server_blob) != CURVE25519_SIZE) {

crypto/openssh/kexc25519.c

192

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexgen.c

70

(r = sshbuf_put_u32(b, sshbuf_len(client_kexinit) + 1)) != 0 ||

crypto/openssh/kexgen.c

73

(r = sshbuf_put_u32(b, sshbuf_len(server_kexinit) + 1)) != 0 ||

crypto/openssh/kexgex.c

72

(r = sshbuf_put_u32(b, sshbuf_len(client_kexinit) + 1)) != 0 ||

crypto/openssh/kexgex.c

75

(r = sshbuf_put_u32(b, sshbuf_len(server_kexinit) + 1)) != 0 ||

crypto/openssh/kexgexc.c

201

sshbuf_ptr(shared_secret), sshbuf_len(shared_secret),

crypto/openssh/kexgexs.c

179

sshbuf_ptr(shared_secret), sshbuf_len(shared_secret),

crypto/openssh/kexsntrup761x25519.c

137

sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

145

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

173

if (sshbuf_len(server_blob) != need) {

crypto/openssh/kexsntrup761x25519.c

202

sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

209

dump_digest("encoded shared secret:", sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/kexsntrup761x25519.c

91

if (sshbuf_len(client_blob) != need) {

crypto/openssh/krl.c

1021

if (sshbuf_len(sect) != 0) {

crypto/openssh/krl.c

1027

name, critical, sshbuf_len(value));

crypto/openssh/krl.c

1092

while (sshbuf_len(copy) > 0) {

crypto/openssh/krl.c

1136

if (sect != NULL && sshbuf_len(sect) > 0) {

crypto/openssh/krl.c

718

if (sshbuf_len(sect) != 0) {

crypto/openssh/krl.c

772

if (sshbuf_len(sect) != 0) {

crypto/openssh/krl.c

783

if (sshbuf_len(sect) != 0) {

crypto/openssh/krl.c

795

if (sshbuf_len(sect) != 0) {

crypto/openssh/krl.c

841

if (sshbuf_len(subsect) != 0) {

crypto/openssh/krl.c

848

name, critical, sshbuf_len(value));

crypto/openssh/krl.c

887

while (sshbuf_len(buf) > 0) {

crypto/openssh/krl.c

898

while (sshbuf_len(subsect) > 0) {

crypto/openssh/krl.c

944

while (sshbuf_len(subsect) > 0) {

crypto/openssh/krl.c

964

if (sshbuf_len(subsect) > 0) {

crypto/openssh/krl.c

989

while (sshbuf_len(sect) > 0) {

crypto/openssh/misc.c

2157

if ((ret = malloc(sshbuf_len(buf) + 1)) == NULL)

crypto/openssh/misc.c

2159

memcpy(ret, sshbuf_ptr(buf), sshbuf_len(buf));

crypto/openssh/misc.c

2160

ret[sshbuf_len(buf)] = '\0';

crypto/openssh/monitor.c

1274

len = sshbuf_len(b);

crypto/openssh/monitor.c

1323

if (sshbuf_len(b) != 0)

crypto/openssh/monitor.c

1402

if (sshbuf_len(b) != 0)

crypto/openssh/monitor.c

1744

if (session_id2_len != sshbuf_len(ssh->kex->session_id)) {

crypto/openssh/monitor.c

1746

sshbuf_len(ssh->kex->session_id), session_id2_len);

crypto/openssh/monitor.c

661

if (datlen != sshbuf_len(sigbuf) ||

crypto/openssh/monitor.c

662

memcmp(p, sshbuf_ptr(sigbuf), sshbuf_len(sigbuf)) != 0)

crypto/openssh/monitor.c

664

datlen, sshbuf_len(sigbuf));

crypto/openssh/monitor_wrap.c

105

if ((len = sshbuf_len(log_msg)) < 4 || len > 0xffffffff)

crypto/openssh/monitor_wrap.c

158

size_t mlen = sshbuf_len(m);

crypto/openssh/monitor_wrap.c

255

debug3_f("remaining %zu", sshbuf_len(m));

crypto/openssh/msg.c

48

u_int mlen = sshbuf_len(m);

crypto/openssh/msg.c

50

debug3_f("type %u len %zu", (unsigned int)type & 0xff, sshbuf_len(m));

crypto/openssh/mux.c

1189

type, sshbuf_len(in));

crypto/openssh/mux.c

1216

if (sshbuf_len(out) != 0 &&

crypto/openssh/mux.c

1519

need = sshbuf_len(queue);

crypto/openssh/mux.c

1638

while (sshbuf_len(m) > 0) {

crypto/openssh/mux.c

292

while (sshbuf_len(m) > 0) {

crypto/openssh/mux.c

369

while (sshbuf_len(m) > 0) {

crypto/openssh/nchan.c

132

if (sshbuf_len(c->input)) {

crypto/openssh/nchan.c

154

if (sshbuf_len(c->output)) {

crypto/openssh/nchan.c

262

sshbuf_len(c->output) == 0 &&

crypto/openssh/nchan.c

344

sshbuf_len(c->extended) > 0) {

crypto/openssh/nchan.c

346

c->self, c->efd, sshbuf_len(c->extended));

crypto/openssh/packet.c

1196

len = sshbuf_len(state->outgoing_packet);

crypto/openssh/packet.c

1211

sshbuf_len(state->outgoing_packet)));

crypto/openssh/packet.c

1215

len = sshbuf_len(state->outgoing_packet);

crypto/openssh/packet.c

1256

len = sshbuf_len(state->outgoing_packet);

crypto/openssh/packet.c

1278

sshbuf_len(state->outgoing_packet) + authlen, &cp)) != 0)

crypto/openssh/packet.c

1351

if (sshbuf_len(state->outgoing_packet) < 6)

crypto/openssh/packet.c

1355

ssh_packet_need_rekeying(ssh, sshbuf_len(state->outgoing_packet));

crypto/openssh/packet.c

1404

sshbuf_len(p->payload))) {

crypto/openssh/packet.c

1533

if (sshbuf_len(state->input) < 4 + 1)

crypto/openssh/packet.c

1541

if (sshbuf_len(state->input) < need)

crypto/openssh/packet.c

1593

sshbuf_ptr(state->input), sshbuf_len(state->input)) != 0)

crypto/openssh/packet.c

1611

if (sshbuf_len(state->input) < block_size)

crypto/openssh/packet.c

1665

if (sshbuf_len(state->input) < aadlen + need + authlen + maclen)

crypto/openssh/packet.c

1694

sshbuf_len(state->incoming_packet),

crypto/openssh/packet.c

1702

sshbuf_len(state->incoming_packet),

crypto/openssh/packet.c

1743

sshbuf_len(state->incoming_packet)));

crypto/openssh/packet.c

1754

sshbuf_len(state->incoming_packet)));

crypto/openssh/packet.c

1938

return sshbuf_len(ssh->state->incoming_packet);

crypto/openssh/packet.c

2102

int len = sshbuf_len(state->output);

crypto/openssh/packet.c

2176

return sshbuf_len(ssh->state->output) != 0;

crypto/openssh/packet.c

2185

return sshbuf_len(ssh->state->output) < 16384;

crypto/openssh/packet.c

2187

return sshbuf_len(ssh->state->output) < 128 * 1024;

crypto/openssh/packet.c

2199

sshbuf_len(ssh->state->output) < 256;

crypto/openssh/packet.c

2483

if (sshbuf_len(b) != 0) {

crypto/openssh/packet.c

2582

if (sshbuf_len(m))

crypto/openssh/packet.c

2732

if (sshbuf_len(ssh->state->incoming_packet) > 0)

crypto/openssh/packet.c

2741

*lenp = sshbuf_len(ssh->state->incoming_packet);

crypto/openssh/packet.c

2769

len = sshbuf_len(state->outgoing_packet);

crypto/openssh/packet.c

391

while (sshbuf_len(state->incoming_packet) < dlen)

crypto/openssh/packet.c

425

if (sshbuf_len(state->input) >= discard)

crypto/openssh/packet.c

427

state->packet_discard = discard - sshbuf_len(state->input);

crypto/openssh/packet.c

833

if (sshbuf_len(in) == 0)

crypto/openssh/packet.c

840

ssh->state->compression_out_stream.avail_in = sshbuf_len(in);

crypto/openssh/packet.c

881

ssh->state->compression_in_stream.avail_in = sshbuf_len(in);

crypto/openssh/servconf.c

2738

debug2_f("done config len = %zu", sshbuf_len(conf));

crypto/openssh/servconf.c

2952

debug2_f("config %s len %zu%s", filename, sshbuf_len(conf),

crypto/openssh/serverloop.c

710

sshbuf_ptr(sigbuf), sshbuf_len(sigbuf), sigalg)) != 0 ||

crypto/openssh/session.c

262

if (sshbuf_len(loginmsg) == 0)

crypto/openssh/session.c

285

sshbuf_len(info)) != sshbuf_len(info)) {

crypto/openssh/sftp-client.c

169

if (sshbuf_len(m) > SFTP_MAX_MSG_LENGTH)

crypto/openssh/sftp-client.c

170

fatal("Outbound message too long %zu", sshbuf_len(m));

crypto/openssh/sftp-client.c

173

put_u32(mlen, sshbuf_len(m));

crypto/openssh/sftp-client.c

177

iov[1].iov_len = sshbuf_len(m);

crypto/openssh/sftp-client.c

181

sshbuf_len(m) + sizeof(mlen))

crypto/openssh/sftp-client.c

2941

if (sshbuf_len(uidbuf) != 0)

crypto/openssh/sftp-client.c

2943

if (sshbuf_len(gidbuf) != 0)

crypto/openssh/sftp-client.c

501

while (sshbuf_len(msg) > 0) {

crypto/openssh/sftp-server.c

1742

sshbuf_len(uids), sshbuf_len(gids));

crypto/openssh/sftp-server.c

1743

while (sshbuf_len(uids) != 0) {

crypto/openssh/sftp-server.c

1753

while (sshbuf_len(gids) != 0) {

crypto/openssh/sftp-server.c

1813

buf_len = sshbuf_len(iqueue);

crypto/openssh/sftp-server.c

1863

if (buf_len < sshbuf_len(iqueue)) {

crypto/openssh/sftp-server.c

1867

consumed = buf_len - sshbuf_len(iqueue);

crypto/openssh/sftp-server.c

2056

olen = sshbuf_len(oqueue);

crypto/openssh/ssh-agent.c

1098

while (sshbuf_len(b) != 0) {

crypto/openssh/ssh-agent.c

1217

while (sshbuf_len(b) != 0) {

crypto/openssh/ssh-agent.c

1245

while (sshbuf_len(b) != 0) {

crypto/openssh/ssh-agent.c

1281

while (sshbuf_len(m)) {

crypto/openssh/ssh-agent.c

1710

if ((r = sshkey_verify(key, sshbuf_ptr(sig), sshbuf_len(sig),

crypto/openssh/ssh-agent.c

1711

sshbuf_ptr(sid), sshbuf_len(sid), NULL, 0, NULL)) != 0) {

crypto/openssh/ssh-agent.c

1805

if (sshbuf_len(e->input) < 5)

crypto/openssh/ssh-agent.c

1814

if (sshbuf_len(e->input) < msg_len + 4)

crypto/openssh/ssh-agent.c

1994

if (sshbuf_len(sockets[socknum].output) == 0)

crypto/openssh/ssh-agent.c

1998

sshbuf_len(sockets[socknum].output))) <= 0) {

crypto/openssh/ssh-agent.c

2121

if (sshbuf_len(sockets[i].output) > 0)

crypto/openssh/ssh-agent.c

709

if (sshbuf_len(sess_id) == 0) {

crypto/openssh/ssh-agent.c

736

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-agent.c

787

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-agent.c

828

if (sshbuf_len(a) != sshbuf_len(b))

crypto/openssh/ssh-agent.c

830

if (timingsafe_bcmp(sshbuf_ptr(a), sshbuf_ptr(b), sshbuf_len(a)) != 0)

crypto/openssh/ssh-agent.c

942

sshbuf_ptr(data), sshbuf_len(data), agent_decode_alg(key, flags),

crypto/openssh/ssh-dss.c

310

len = sshbuf_len(b);

crypto/openssh/ssh-dss.c

361

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-ecdsa-sk.c

189

((flags & 0x80) == 0 /* ED */) != (sshbuf_len(extensions) == 0)) {

crypto/openssh/ssh-ecdsa-sk.c

217

if ((r = sshbuf_cmp(wrapper, 0, sshbuf_ptr(m), sshbuf_len(m))) != 0)

crypto/openssh/ssh-ecdsa-sk.c

294

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-ecdsa-sk.c

305

if (sshbuf_len(sigbuf) != 0) {

crypto/openssh/ssh-ecdsa.c

271

len = sshbuf_len(b);

crypto/openssh/ssh-ecdsa.c

326

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-ecdsa.c

347

if (sshbuf_len(sigbuf) != 0) {

crypto/openssh/ssh-ed25519-sk.c

176

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-ed25519-sk.c

220

smlen = sshbuf_len(encoded);

crypto/openssh/ssh-ed25519.c

184

len = sshbuf_len(b);

crypto/openssh/ssh-ed25519.c

234

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-keygen.c

2085

while (sshbuf_len(options) != 0) {

crypto/openssh/ssh-keygen.c

2110

} else if (sshbuf_len(option) > 0) {

crypto/openssh/ssh-keygen.c

2113

hex, sshbuf_len(option));

crypto/openssh/ssh-keygen.c

2119

if (sshbuf_len(option) != 0)

crypto/openssh/ssh-keygen.c

2158

if (sshbuf_len(key->cert->critical) == 0)

crypto/openssh/ssh-keygen.c

2165

if (sshbuf_len(key->cert->extensions) == 0)

crypto/openssh/ssh-keygen.c

2274

*lenp = sshbuf_len(b);

crypto/openssh/ssh-keygen.c

3260

if (attest == NULL || sshbuf_len(attest) == 0)

crypto/openssh/ssh-keygen.c

467

if (sshbuf_len(b) < bytes)

crypto/openssh/ssh-keygen.c

469

bytes, sshbuf_len(b));

crypto/openssh/ssh-keygen.c

599

rlen = sshbuf_len(b);

crypto/openssh/ssh-keysign.c

152

if (sshbuf_len(b) != 0)

crypto/openssh/ssh-pkcs11-client.c

187

size_t mlen = sshbuf_len(m);

crypto/openssh/ssh-pkcs11-client.c

195

sshbuf_len(m)) != sshbuf_len(m))

crypto/openssh/ssh-pkcs11-helper.c

263

buf_len = sshbuf_len(iqueue);

crypto/openssh/ssh-pkcs11-helper.c

296

if (buf_len < sshbuf_len(iqueue)) {

crypto/openssh/ssh-pkcs11-helper.c

300

consumed = buf_len - sshbuf_len(iqueue);

crypto/openssh/ssh-pkcs11-helper.c

378

if (sshbuf_len(oqueue) > 0)

crypto/openssh/ssh-pkcs11-helper.c

402

sshbuf_len(oqueue));

crypto/openssh/ssh-rsa.c

455

len = sshbuf_len(b);

crypto/openssh/ssh-rsa.c

522

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh-sk-client.c

272

if (sshbuf_len(resp) != 0) {

crypto/openssh/ssh-sk-client.c

342

if (sshbuf_len(resp) != 0) {

crypto/openssh/ssh-sk-client.c

427

while (sshbuf_len(resp) != 0) {

crypto/openssh/ssh-xmss.c

244

len = sshbuf_len(b);

crypto/openssh/ssh-xmss.c

310

if (sshbuf_len(b) != 0) {

crypto/openssh/ssh.c

1365

} else if (sshbuf_len(command) != 0 ||

crypto/openssh/ssh.c

1379

if (sshbuf_len(command) != 0 && options.remote_command != NULL)

crypto/openssh/ssh.c

1383

if (options.fork_after_authentication && sshbuf_len(command) == 0 &&

crypto/openssh/ssh.c

1402

if (sshbuf_len(command) == 0 && options.remote_command == NULL)

crypto/openssh/ssh_api.c

264

if (sshbuf_len(ssh->kex->client_version) == 0 ||

crypto/openssh/ssh_api.c

265

sshbuf_len(ssh->kex->server_version) == 0)

crypto/openssh/ssh_api.c

316

*len = sshbuf_len(output);

crypto/openssh/ssh_api.c

354

if (j >= sshbuf_len(input))

crypto/openssh/ssh_api.c

367

if (sshbuf_len(banner) > SSH_MAX_BANNER_LEN)

crypto/openssh/ssh_api.c

370

if (sshbuf_len(banner) >= 4 &&

crypto/openssh/ssh_api.c

373

debug_f("%.*s", (int)sshbuf_len(banner),

crypto/openssh/ssh_api.c

389

(remote_version = calloc(1, sshbuf_len(banner))) == NULL) {

crypto/openssh/ssh_api.c

455

if (sshbuf_len(ssh->kex->server_version) == 0)

crypto/openssh/ssh_api.c

458

sshbuf_len(ssh->kex->server_version) != 0 &&

crypto/openssh/ssh_api.c

459

sshbuf_len(ssh->kex->client_version) == 0)

crypto/openssh/ssh_api.c

462

if (sshbuf_len(ssh->kex->server_version) == 0)

crypto/openssh/ssh_api.c

465

sshbuf_len(ssh->kex->server_version) != 0 &&

crypto/openssh/ssh_api.c

466

sshbuf_len(ssh->kex->client_version) == 0)

crypto/openssh/ssh_api.c

472

if (sshbuf_len(ssh->kex->server_version) != 0 &&

crypto/openssh/ssh_api.c

473

sshbuf_len(ssh->kex->client_version) != 0) {

crypto/openssh/sshbuf-getput-basic.c

106

if (offset + len > sshbuf_len(buf)) {

crypto/openssh/sshbuf-getput-basic.c

250

if (sshbuf_len(buf) < 4) {

crypto/openssh/sshbuf-getput-basic.c

259

if (sshbuf_len(buf) - 4 < len) {

crypto/openssh/sshbuf-getput-basic.c

343

return sshbuf_put(buf, sshbuf_ptr(v), sshbuf_len(v));

crypto/openssh/sshbuf-getput-basic.c

543

return sshbuf_put_string(buf, sshbuf_ptr(v), sshbuf_len(v));

crypto/openssh/sshbuf-io.c

108

sshbuf_len(buf)) != sshbuf_len(buf) || close(fd) != 0) {

crypto/openssh/sshbuf-io.c

60

if (sshbuf_len(blob) > SSHBUF_SIZE_MAX) {

crypto/openssh/sshbuf-io.c

66

st.st_size != (off_t)sshbuf_len(blob)) {

crypto/openssh/sshbuf-misc.c

100

if (d == NULL || b64 == NULL || sshbuf_len(d) >= SIZE_MAX / 2)

crypto/openssh/sshbuf-misc.c

102

if (sshbuf_len(d) == 0)

crypto/openssh/sshbuf-misc.c

104

slen = ((sshbuf_len(d) + 2) / 3) * 4 + 1;

crypto/openssh/sshbuf-misc.c

107

if (b64_ntop(sshbuf_ptr(d), sshbuf_len(d), s, slen) == -1) {

crypto/openssh/sshbuf-misc.c

186

l = sshbuf_len(b);

crypto/openssh/sshbuf-misc.c

197

l = sshbuf_len(b);

crypto/openssh/sshbuf-misc.c

218

size_t l = sshbuf_len(buf);

crypto/openssh/sshbuf-misc.c

245

if (offset + len > sshbuf_len(b))

crypto/openssh/sshbuf-misc.c

264

if (start_offset > sshbuf_len(b) || start_offset + len > sshbuf_len(b))

crypto/openssh/sshbuf-misc.c

267

sshbuf_len(b) - start_offset, s, len)) == NULL)

crypto/openssh/sshbuf-misc.c

69

fprintf(f, "buffer len = %zu\n", sshbuf_len(buf));

crypto/openssh/sshbuf-misc.c

70

sshbuf_dump_data(sshbuf_ptr(buf), sshbuf_len(buf), f);

crypto/openssh/sshbuf-misc.c

76

size_t i, j, len = sshbuf_len(buf);

crypto/openssh/sshbuf.c

149

if ((ret = sshbuf_from(sshbuf_ptr(buf), sshbuf_len(buf))) == NULL)

crypto/openssh/sshbuf.c

401

if (len > sshbuf_len(buf))

crypto/openssh/sshbuf.c

421

if (len > sshbuf_len(buf))

crypto/openssh/sshbuf.h

91

size_t sshbuf_len(const struct sshbuf *buf);

crypto/openssh/sshconnect2.c

1406

skip = sshbuf_len(b);

crypto/openssh/sshconnect2.c

1426

sshbuf_ptr(b), sshbuf_len(b), ssh->compat, alg);

crypto/openssh/sshconnect2.c

2227

sshbuf_ptr(b), sshbuf_len(b))) != 0) {

crypto/openssh/sshconnect2.c

2355

sshbuf_len(b) ? "," : "", method->name)) != 0)

crypto/openssh/sshconnect2.c

862

gssbuf.length = sshbuf_len(b);

crypto/openssh/sshd-session.c

455

if ((r = sshbuf_putf(b, "%s%s", sshbuf_len(b) > 0 ? "," : "", s)) != 0)

crypto/openssh/sshd-session.c

687

while (sshbuf_len(hostkeys) != 0) {

crypto/openssh/sshd-session.c

703

if (sshbuf_len(kbuf) != 0 &&

crypto/openssh/sshd-session.c

761

while (sshbuf_len(inc) != 0) {

crypto/openssh/sshd.c

1133

sshbuf_len(server_cfg)) != 0)

crypto/openssh/sshd.c

1149

if (ssh_digest_update(ctx, sshbuf_ptr(buf), sshbuf_len(buf)) != 0)

crypto/openssh/sshd.c

684

sshbuf_len(conf));

crypto/openssh/sshd.c

722

sz = ROUNDUP(sshbuf_len(m) + 5, 16*1024);

crypto/openssh/sshkey-xmss.c

1020

if (sshbuf_len(encoded) < sizeof(XMSS_MAGIC) ||

crypto/openssh/sshkey-xmss.c

1037

if (sshbuf_len(encoded) < authlen ||

crypto/openssh/sshkey-xmss.c

1038

sshbuf_len(encoded) - authlen < encrypted_len) {

crypto/openssh/sshkey-xmss.c

1043

aadlen = sshbuf_len(copy) - sshbuf_len(encoded);

crypto/openssh/sshkey-xmss.c

1060

if (sshbuf_len(encoded) != 0) {

crypto/openssh/sshkey-xmss.c

355

if (sshbuf_len(b) == 0)

crypto/openssh/sshkey-xmss.c

623

POKE_U32(buf, sshbuf_len(enc));

crypto/openssh/sshkey-xmss.c

630

if (atomicio(vwrite, fd, sshbuf_mutable_ptr(enc), sshbuf_len(enc)) !=

crypto/openssh/sshkey-xmss.c

631

sshbuf_len(enc)) {

crypto/openssh/sshkey-xmss.c

939

while (sshbuf_len(padded) % blocksize) {

crypto/openssh/sshkey-xmss.c

943

encrypted_len = sshbuf_len(padded);

crypto/openssh/sshkey-xmss.c

948

aadlen = sshbuf_len(encoded);

crypto/openssh/sshkey.c

1304

if (fwrite(sshbuf_ptr(b), sshbuf_len(b), 1, f) != 1) {

crypto/openssh/sshkey.c

1590

while (sshbuf_len(prvbuf) % cipher_blocksize(cipher)) {

crypto/openssh/sshkey.c

1599

enclen = sshbuf_len(prvbuf);

crypto/openssh/sshkey.c

1605

sshbuf_ptr(prvbuf), sshbuf_len(prvbuf), 0, 0)) != 0)

crypto/openssh/sshkey.c

1656

while (sshbuf_len(decrypted)) {

crypto/openssh/sshkey.c

1791

signed_len = sshbuf_len(key->cert->certblob) - sshbuf_len(b);

crypto/openssh/sshkey.c

1805

while (sshbuf_len(principals) > 0) {

crypto/openssh/sshkey.c

1843

while (sshbuf_len(crit) != 0) {

crypto/openssh/sshkey.c

1851

while (exts != NULL && sshbuf_len(exts) != 0) {

crypto/openssh/sshkey.c

1947

if (key != NULL && sshbuf_len(b) != 0) {

crypto/openssh/sshkey.c

2256

sshbuf_len(cert), alg, sk_provider, sk_pin, 0, signer_ctx)) != 0)

crypto/openssh/sshkey.c

2389

if (sshbuf_len(key->cert->critical) != 0) {

crypto/openssh/sshkey.c

2460

sshbuf_len(key->cert->certblob) == 0) {

crypto/openssh/sshkey.c

2832

while (sshbuf_len(encrypted) % blocksize) {

crypto/openssh/sshkey.c

2838

if ((r = sshbuf_put_u32(encoded, sshbuf_len(encrypted))) != 0)

crypto/openssh/sshkey.c

2843

sshbuf_len(encrypted) + authlen, &cp)) != 0)

crypto/openssh/sshkey.c

2846

sshbuf_ptr(encrypted), sshbuf_len(encrypted), 0, authlen)) != 0)

crypto/openssh/sshkey.c

2895

encoded_len = sshbuf_len(blob);

crypto/openssh/sshkey.c

2933

if (sshbuf_len(decoded) < sizeof(AUTH_MAGIC) ||

crypto/openssh/sshkey.c

3037

if (sshbuf_len(decoded) < authlen ||

crypto/openssh/sshkey.c

3038

sshbuf_len(decoded) - authlen < encrypted_len) {

crypto/openssh/sshkey.c

3058

if (sshbuf_len(decoded) != 0) {

crypto/openssh/sshkey.c

3435

if ((bio = BIO_new(BIO_s_mem())) == NULL || sshbuf_len(blob) > INT_MAX)

crypto/openssh/sshkey.c

3437

if (BIO_write(bio, sshbuf_ptr(blob), sshbuf_len(blob)) !=

crypto/openssh/sshkey.c

3438

(int)sshbuf_len(blob)) {

crypto/openssh/sshkey.c

680

if (sshbuf_len(a->certblob) != sshbuf_len(b->certblob))

crypto/openssh/sshkey.c

683

sshbuf_len(a->certblob)) != 0)

crypto/openssh/sshkey.c

757

if (sshbuf_len(key->cert->certblob) == 0)

crypto/openssh/sshkey.c

823

len = sshbuf_len(b);

crypto/openssh/sshsig.c

130

if ((r = sshbuf_consume_end(sbuf, sshbuf_len(sbuf)-eoffset)) != 0) {

crypto/openssh/sshsig.c

198

sshbuf_ptr(tosign), sshbuf_len(tosign),

crypto/openssh/sshsig.c

205

sshbuf_ptr(tosign), sshbuf_len(tosign),

crypto/openssh/sshsig.c

311

debug_f("verify message length %zu", sshbuf_len(h_message));

crypto/openssh/sshsig.c

344

if (sshbuf_len(signature) != 0) {

crypto/openssh/sshsig.c

379

sshbuf_len(toverify), NULL, 0, sig_details)) != 0) {

crypto/openssh/sshsig.c

862

sshbuf_len(nprincipals) != 0 ? "," : "",

crypto/openssh/sshsig.c

870

if (sshbuf_len(nprincipals) == 0) {

crypto/openssh/ttymodes.c

372

while (sshbuf_len(buf) > 0) {

crypto/openssh/ttymodes.c

438

len = sshbuf_len(buf);