crypto/openssh/audit-bsm.c

395

audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/audit-linux.c

100

audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/audit-linux.c

117

ssh_remote_ipaddr(ssh), "sshd", 0);

crypto/openssh/audit.c

134

audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/audit.h

30

struct ssh;

crypto/openssh/audit.h

51

void audit_event(struct ssh *, ssh_audit_event_t);

crypto/openssh/auth-pam.c

1063

start_pam(struct ssh *ssh)

crypto/openssh/auth-pam.c

1065

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/auth-pam.c

1070

if (sshpam_init(ssh, authctxt) == -1)

crypto/openssh/auth-pam.c

1209

do_pam_session(struct ssh *ssh)

crypto/openssh/auth-pam.c

1225

auth_restrict_session(ssh);

crypto/openssh/auth-pam.c

688

sshpam_init(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/auth-pam.c

700

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth-pam.c

703

if (ssh == NULL) {

crypto/openssh/auth-pam.c

729

if (ssh != NULL && sshpam_rhost == NULL) {

crypto/openssh/auth-pam.c

734

sshpam_rhost = xstrdup(auth_get_canonical_hostname(ssh,

crypto/openssh/auth-pam.c

737

ssh_packet_get_connection_in(ssh));

crypto/openssh/auth-pam.c

749

if (ssh != NULL && sshpam_laddr != NULL) {

crypto/openssh/auth-pam.c

754

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/auth-pam.c

755

sshpam_laddr, ssh_local_port(ssh));

crypto/openssh/auth-pam.h

28

struct ssh;

crypto/openssh/auth-pam.h

30

void start_pam(struct ssh *);

crypto/openssh/auth-pam.h

33

void do_pam_session(struct ssh *);

crypto/openssh/auth-passwd.c

125

result = sys_auth_passwd(ssh, password);

crypto/openssh/auth-passwd.c

127

auth_restrict_session(ssh);

crypto/openssh/auth-passwd.c

167

sys_auth_passwd(struct ssh *ssh, const char *password)

crypto/openssh/auth-passwd.c

169

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth-passwd.c

179

auth_restrict_session(ssh);

crypto/openssh/auth-passwd.c

192

sys_auth_passwd(struct ssh *ssh, const char *password)

crypto/openssh/auth-passwd.c

194

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth-passwd.c

77

auth_password(struct ssh *ssh, const char *password)

crypto/openssh/auth-passwd.c

79

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth-sia.c

53

sys_auth_passwd(struct ssh *ssh, const char *pass)

crypto/openssh/auth-sia.c

58

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth.c

100

allowed_user(struct ssh *ssh, struct passwd * pw)

crypto/openssh/auth.c

144

hostname = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth.c

145

ipaddr = ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

267

auth_log(struct ssh *ssh, int authenticated, int partial,

crypto/openssh/auth.c

270

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/auth.c

292

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_OK,

crypto/openssh/auth.c

307

ssh_remote_ipaddr(ssh),

crypto/openssh/auth.c

308

ssh_remote_port(ssh),

crypto/openssh/auth.c

321

record_failed_login(ssh, authctxt->user,

crypto/openssh/auth.c

322

auth_get_canonical_hostname(ssh, options.use_dns), "ssh");

crypto/openssh/auth.c

325

audit_event(ssh, audit_classify_auth(method));

crypto/openssh/auth.c

332

auth_get_canonical_hostname(ssh, options.use_dns), "ssh",

crypto/openssh/auth.c

338

auth_maxtries_exceeded(struct ssh *ssh)

crypto/openssh/auth.c

340

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/auth.c

342

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL, "Maximum attempts exceeded");

crypto/openssh/auth.c

347

ssh_remote_ipaddr(ssh),

crypto/openssh/auth.c

348

ssh_remote_port(ssh));

crypto/openssh/auth.c

349

ssh_packet_disconnect(ssh, "Too many authentication failures");

crypto/openssh/auth.c

357

auth_root_allowed(struct ssh *ssh, const char *method)

crypto/openssh/auth.c

376

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth.c

468

getpwnamallow(struct ssh *ssh, const char *user)

crypto/openssh/auth.c

483

ci = server_get_connection_info(ssh, 1, options.use_dns);

crypto/openssh/auth.c

491

server_process_permitopen(ssh);

crypto/openssh/auth.c

503

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL, "Invalid user");

crypto/openssh/auth.c

505

user, ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth.c

507

record_failed_login(ssh, user,

crypto/openssh/auth.c

508

auth_get_canonical_hostname(ssh, options.use_dns), "ssh");

crypto/openssh/auth.c

511

audit_event(ssh, SSH_INVALID_USER);

crypto/openssh/auth.c

515

if (!allowed_user(ssh, pw))

crypto/openssh/auth.c

523

from_host = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth.c

524

from_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

608

auth_debug_send(struct ssh *ssh)

crypto/openssh/auth.c

618

ssh_packet_send_debug(ssh, "%s", msg);

crypto/openssh/auth.c

672

auth_get_canonical_hostname(struct ssh *ssh, int use_dns)

crypto/openssh/auth.c

677

return ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

680

dnsname = ssh_remote_hostname(ssh);

crypto/openssh/auth.c

758

auth_activate_options(struct ssh *ssh, struct sshauthopt *opts)

crypto/openssh/auth.c

773

auth_restrict_session(struct ssh *ssh)

crypto/openssh/auth.c

785

if (auth_activate_options(ssh, restricted) != 0)

crypto/openssh/auth.h

115

int (*userauth)(struct ssh *, const char *);

crypto/openssh/auth.h

138

int auth_password(struct ssh *, const char *);

crypto/openssh/auth.h

140

int hostbased_key_allowed(struct ssh *, struct passwd *,

crypto/openssh/auth.h

142

int user_key_allowed(struct ssh *ssh, struct passwd *, struct sshkey *,

crypto/openssh/auth.h

172

void do_authentication2(struct ssh *);

crypto/openssh/auth.h

174

void auth_log(struct ssh *, int, int, const char *, const char *);

crypto/openssh/auth.h

175

void auth_maxtries_exceeded(struct ssh *) __attribute__((noreturn));

crypto/openssh/auth.h

176

void userauth_finish(struct ssh *, int, const char *, const char *);

crypto/openssh/auth.h

177

int auth_root_allowed(struct ssh *, const char *);

crypto/openssh/auth.h

187

int auth2_challenge(struct ssh *, char *);

crypto/openssh/auth.h

188

void auth2_challenge_stop(struct ssh *);

crypto/openssh/auth.h

192

int allowed_user(struct ssh *, struct passwd *);

crypto/openssh/auth.h

193

struct passwd * getpwnamallow(struct ssh *, const char *user);

crypto/openssh/auth.h

200

const char *auth_get_canonical_hostname(struct ssh *, int);

crypto/openssh/auth.h

208

struct sshkey *get_hostkey_public_by_index(int, struct ssh *);

crypto/openssh/auth.h

209

struct sshkey *get_hostkey_public_by_type(int, int, struct ssh *);

crypto/openssh/auth.h

210

struct sshkey *get_hostkey_private_by_type(int, int, struct ssh *);

crypto/openssh/auth.h

211

int get_hostkey_index(struct sshkey *, int, struct ssh *);

crypto/openssh/auth.h

212

int sshd_hostkey_sign(struct ssh *, struct sshkey *, struct sshkey *,

crypto/openssh/auth.h

216

int auth_activate_options(struct ssh *, struct sshauthopt *);

crypto/openssh/auth.h

217

void auth_restrict_session(struct ssh *);

crypto/openssh/auth.h

223

void auth_debug_send(struct ssh *);

crypto/openssh/auth.h

242

int sys_auth_passwd(struct ssh *, const char *);

crypto/openssh/auth.h

45

struct ssh;

crypto/openssh/auth2-chall.c

193

auth2_challenge(struct ssh *ssh, char *devs)

crypto/openssh/auth2-chall.c

195

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

204

return auth2_challenge_start(ssh);

crypto/openssh/auth2-chall.c

209

auth2_challenge_stop(struct ssh *ssh)

crypto/openssh/auth2-chall.c

211

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

213

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE, NULL);

crypto/openssh/auth2-chall.c

222

auth2_challenge_start(struct ssh *ssh)

crypto/openssh/auth2-chall.c

224

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

231

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

238

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

241

if (send_userauth_info_request(ssh) == 0) {

crypto/openssh/auth2-chall.c

242

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

245

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE,

crypto/openssh/auth2-chall.c

253

send_userauth_info_request(struct ssh *ssh)

crypto/openssh/auth2-chall.c

255

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

265

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_INFO_REQUEST)) != 0 ||

crypto/openssh/auth2-chall.c

266

(r = sshpkt_put_cstring(ssh, name)) != 0 ||

crypto/openssh/auth2-chall.c

267

(r = sshpkt_put_cstring(ssh, instr)) != 0 ||

crypto/openssh/auth2-chall.c

268

(r = sshpkt_put_cstring(ssh, "")) != 0 || /* language not used */

crypto/openssh/auth2-chall.c

269

(r = sshpkt_put_u32(ssh, kbdintctxt->nreq)) != 0)

crypto/openssh/auth2-chall.c

272

if ((r = sshpkt_put_cstring(ssh, prompts[i])) != 0 ||

crypto/openssh/auth2-chall.c

273

(r = sshpkt_put_u8(ssh, echo_on[i])) != 0)

crypto/openssh/auth2-chall.c

276

if ((r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/auth2-chall.c

277

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/auth2-chall.c

290

input_userauth_info_response(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/auth2-chall.c

292

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

309

if ((r = sshpkt_get_u32(ssh, &nresp)) != 0)

crypto/openssh/auth2-chall.c

318

if ((r = sshpkt_get_cstring(ssh, &response[i], NULL)) != 0)

crypto/openssh/auth2-chall.c

322

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-chall.c

340

if (send_userauth_info_request(ssh) == 1)

crypto/openssh/auth2-chall.c

350

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

354

auth2_challenge_start(ssh);

crypto/openssh/auth2-chall.c

357

userauth_finish(ssh, authenticated, "keyboard-interactive",

crypto/openssh/auth2-chall.c

52

static int auth2_challenge_start(struct ssh *);

crypto/openssh/auth2-chall.c

53

static int send_userauth_info_request(struct ssh *);

crypto/openssh/auth2-chall.c

54

static int input_userauth_info_response(int, u_int32_t, struct ssh *);

crypto/openssh/auth2-gss.c

131

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_GSSAPI_RESPONSE)) != 0 ||

crypto/openssh/auth2-gss.c

132

(r = sshpkt_put_string(ssh, doid, len)) != 0 ||

crypto/openssh/auth2-gss.c

133

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/auth2-gss.c

138

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);

crypto/openssh/auth2-gss.c

139

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);

crypto/openssh/auth2-gss.c

146

input_gssapi_token(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/auth2-gss.c

148

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

161

if ((r = sshpkt_get_string(ssh, &p, &len)) != 0 ||

crypto/openssh/auth2-gss.c

162

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-gss.c

174

if ((r = sshpkt_start(ssh,

crypto/openssh/auth2-gss.c

176

(r = sshpkt_put_string(ssh, send_tok.value,

crypto/openssh/auth2-gss.c

178

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/auth2-gss.c

182

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

183

userauth_finish(ssh, 0, "gssapi-with-mic", NULL);

crypto/openssh/auth2-gss.c

186

if ((r = sshpkt_start(ssh,

crypto/openssh/auth2-gss.c

188

(r = sshpkt_put_string(ssh, send_tok.value,

crypto/openssh/auth2-gss.c

190

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/auth2-gss.c

194

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

196

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC,

crypto/openssh/auth2-gss.c

199

ssh_dispatch_set(ssh,

crypto/openssh/auth2-gss.c

210

input_gssapi_errtok(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/auth2-gss.c

212

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

225

if ((r = sshpkt_get_string(ssh, &p, &len)) != 0 ||

crypto/openssh/auth2-gss.c

226

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-gss.c

238

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

239

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);

crypto/openssh/auth2-gss.c

254

input_gssapi_exchange_complete(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/auth2-gss.c

256

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

267

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-gss.c

273

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

274

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);

crypto/openssh/auth2-gss.c

275

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC, NULL);

crypto/openssh/auth2-gss.c

276

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);

crypto/openssh/auth2-gss.c

277

userauth_finish(ssh, authenticated, "gssapi-with-mic", NULL);

crypto/openssh/auth2-gss.c

282

input_gssapi_mic(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/auth2-gss.c

284

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

297

if ((r = sshpkt_get_string(ssh, &p, &len)) != 0)

crypto/openssh/auth2-gss.c

304

"gssapi-with-mic", ssh->kex->session_id);

crypto/openssh/auth2-gss.c

319

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

320

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);

crypto/openssh/auth2-gss.c

321

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC, NULL);

crypto/openssh/auth2-gss.c

322

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);

crypto/openssh/auth2-gss.c

323

userauth_finish(ssh, authenticated, "gssapi-with-mic", NULL);

crypto/openssh/auth2-gss.c

56

static int input_gssapi_token(int type, u_int32_t plen, struct ssh *ssh);

crypto/openssh/auth2-gss.c

57

static int input_gssapi_mic(int type, u_int32_t plen, struct ssh *ssh);

crypto/openssh/auth2-gss.c

58

static int input_gssapi_exchange_complete(int type, u_int32_t plen, struct ssh *ssh);

crypto/openssh/auth2-gss.c

59

static int input_gssapi_errtok(int, u_int32_t, struct ssh *);

crypto/openssh/auth2-gss.c

66

userauth_gssapi(struct ssh *ssh, const char *method)

crypto/openssh/auth2-gss.c

68

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

77

if ((r = sshpkt_get_u32(ssh, &mechs)) != 0)

crypto/openssh/auth2-gss.c

95

if ((r = sshpkt_get_string(ssh, &doid, &len)) != 0)

crypto/openssh/auth2-hostbased.c

130

if ((r = sshbuf_put_stringb(b, ssh->kex->session_id)) != 0 ||

crypto/openssh/auth2-hostbased.c

149

if (mm_hostbased_key_allowed(ssh, authctxt->pw, cuser,

crypto/openssh/auth2-hostbased.c

152

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

crypto/openssh/auth2-hostbased.c

170

hostbased_key_allowed(struct ssh *ssh, struct passwd *pw,

crypto/openssh/auth2-hostbased.c

181

resolvedname = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth2-hostbased.c

182

ipaddr = ssh_remote_ipaddr(ssh);

crypto/openssh/auth2-hostbased.c

60

userauth_hostbased(struct ssh *ssh, const char *method)

crypto/openssh/auth2-hostbased.c

62

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-hostbased.c

71

if ((r = sshpkt_get_cstring(ssh, &pkalg, &alen)) != 0 ||

crypto/openssh/auth2-hostbased.c

72

(r = sshpkt_get_string(ssh, &pkblob, &blen)) != 0 ||

crypto/openssh/auth2-hostbased.c

73

(r = sshpkt_get_cstring(ssh, &chost, NULL)) != 0 ||

crypto/openssh/auth2-hostbased.c

74

(r = sshpkt_get_cstring(ssh, &cuser, NULL)) != 0 ||

crypto/openssh/auth2-hostbased.c

75

(r = sshpkt_get_string(ssh, &sig, &slen)) != 0)

crypto/openssh/auth2-kbdint.c

48

userauth_kbdint(struct ssh *ssh, const char *method)

crypto/openssh/auth2-kbdint.c

53

if ((r = sshpkt_get_cstring(ssh, &lang, NULL)) != 0 ||

crypto/openssh/auth2-kbdint.c

54

(r = sshpkt_get_cstring(ssh, &devs, NULL)) != 0 ||

crypto/openssh/auth2-kbdint.c

55

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-kbdint.c

61

authenticated = auth2_challenge(ssh, devs);

crypto/openssh/auth2-none.c

61

userauth_none(struct ssh *ssh, const char *method)

crypto/openssh/auth2-none.c

66

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-none.c

69

return mm_auth_password(ssh, "");

crypto/openssh/auth2-passwd.c

53

userauth_passwd(struct ssh *ssh, const char *method)

crypto/openssh/auth2-passwd.c

60

if ((r = sshpkt_get_u8(ssh, &change)) != 0 ||

crypto/openssh/auth2-passwd.c

61

(r = sshpkt_get_cstring(ssh, &password, &len)) != 0 ||

crypto/openssh/auth2-passwd.c

62

(change && (r = sshpkt_get_cstring(ssh, NULL, NULL)) != 0) ||

crypto/openssh/auth2-passwd.c

63

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/auth2-passwd.c

70

else if (mm_auth_password(ssh, password) == 1)

crypto/openssh/auth2-pubkey.c

110

if ((r = sshpkt_get_u8(ssh, &have_sig)) != 0 ||

crypto/openssh/auth2-pubkey.c

111

(r = sshpkt_get_cstring(ssh, &pkalg, NULL)) != 0 ||

crypto/openssh/auth2-pubkey.c

112

(r = sshpkt_get_string(ssh, &pkblob, &blen)) != 0)

crypto/openssh/auth2-pubkey.c

117

if ((r = sshpkt_getb_froms(ssh, &b)) != 0 ||

crypto/openssh/auth2-pubkey.c

120

if (ssh->kex->initial_hostkey == NULL)

crypto/openssh/auth2-pubkey.c

122

if (!sshkey_equal(hostkey, ssh->kex->initial_hostkey))

crypto/openssh/auth2-pubkey.c

191

if ((r = sshpkt_get_string(ssh, &sig, &slen)) != 0 ||

crypto/openssh/auth2-pubkey.c

192

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-pubkey.c

196

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/auth2-pubkey.c

197

if ((r = sshbuf_putb(b, ssh->kex->session_id)) != 0)

crypto/openssh/auth2-pubkey.c

201

ssh->kex->session_id)) != 0)

crypto/openssh/auth2-pubkey.c

221

(r = sshkey_puts(ssh->kex->initial_hostkey, b)) != 0)

crypto/openssh/auth2-pubkey.c

228

if (mm_user_key_allowed(ssh, pw, key, 1, &authopts) &&

crypto/openssh/auth2-pubkey.c

231

(ssh->compat & SSH_BUG_SIGTYPE) == 0 ? pkalg : NULL,

crypto/openssh/auth2-pubkey.c

232

ssh->compat, &sig_details) == 0) {

crypto/openssh/auth2-pubkey.c

250

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/auth2-pubkey.c

251

ssh_remote_port(ssh));

crypto/openssh/auth2-pubkey.c

264

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/auth2-pubkey.c

265

ssh_remote_port(ssh));

crypto/openssh/auth2-pubkey.c

275

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2-pubkey.c

290

if (mm_user_key_allowed(ssh, pw, key, 0, NULL)) {

crypto/openssh/auth2-pubkey.c

291

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_PK_OK))

crypto/openssh/auth2-pubkey.c

293

(r = sshpkt_put_cstring(ssh, pkalg)) != 0 ||

crypto/openssh/auth2-pubkey.c

294

(r = sshpkt_put_string(ssh, pkblob, blen)) != 0 ||

crypto/openssh/auth2-pubkey.c

295

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/auth2-pubkey.c

296

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/auth2-pubkey.c

302

if (authenticated == 1 && auth_activate_options(ssh, authopts) != 0) {

crypto/openssh/auth2-pubkey.c

789

user_key_allowed(struct ssh *ssh, struct passwd *pw, struct sshkey *key,

crypto/openssh/auth2-pubkey.c

806

if ((rdomain = ssh_packet_rdomain_in(ssh)) == NULL)

crypto/openssh/auth2-pubkey.c

808

remote_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/auth2-pubkey.c

809

remote_host = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth2-pubkey.c

811

ssh_local_ipaddr(ssh), ssh_local_port(ssh),

crypto/openssh/auth2-pubkey.c

812

remote_ip, ssh_remote_port(ssh));

crypto/openssh/auth2-pubkey.c

94

userauth_pubkey(struct ssh *ssh, const char *method)

crypto/openssh/auth2-pubkey.c

96

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2.c

139

userauth_send_banner(struct ssh *ssh, const char *msg)

crypto/openssh/auth2.c

143

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_BANNER)) != 0 ||

crypto/openssh/auth2.c

144

(r = sshpkt_put_cstring(ssh, msg)) != 0 ||

crypto/openssh/auth2.c

145

(r = sshpkt_put_cstring(ssh, "")) != 0 || /* language, unused */

crypto/openssh/auth2.c

146

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/auth2.c

152

userauth_banner(struct ssh *ssh)

crypto/openssh/auth2.c

161

userauth_send_banner(ssh, banner);

crypto/openssh/auth2.c

171

do_authentication2(struct ssh *ssh)

crypto/openssh/auth2.c

173

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2.c

175

ssh_dispatch_init(ssh, &dispatch_protocol_error);

crypto/openssh/auth2.c

176

if (ssh->kex->ext_info_c)

crypto/openssh/auth2.c

177

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &kex_input_ext_info);

crypto/openssh/auth2.c

178

ssh_dispatch_set(ssh, SSH2_MSG_SERVICE_REQUEST, &input_service_request);

crypto/openssh/auth2.c

179

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &authctxt->success);

crypto/openssh/auth2.c

180

ssh->authctxt = NULL;

crypto/openssh/auth2.c

184

input_service_request(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/auth2.c

186

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2.c

190

if ((r = sshpkt_get_cstring(ssh, &service, NULL)) != 0 ||

crypto/openssh/auth2.c

191

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/auth2.c

201

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_REQUEST,

crypto/openssh/auth2.c

208

if ((r = sshpkt_start(ssh, SSH2_MSG_SERVICE_ACCEPT)) != 0 ||

crypto/openssh/auth2.c

209

(r = sshpkt_put_cstring(ssh, service)) != 0 ||

crypto/openssh/auth2.c

210

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/auth2.c

211

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/auth2.c

215

ssh_packet_disconnect(ssh, "bad service request %s", service);

crypto/openssh/auth2.c

217

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &dispatch_protocol_error);

crypto/openssh/auth2.c

269

input_userauth_request(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/auth2.c

271

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2.c

280

if ((r = sshpkt_get_cstring(ssh, &user, NULL)) != 0 ||

crypto/openssh/auth2.c

281

(r = sshpkt_get_cstring(ssh, &service, NULL)) != 0 ||

crypto/openssh/auth2.c

282

(r = sshpkt_get_cstring(ssh, &method, NULL)) != 0)

crypto/openssh/auth2.c

291

auth_maxtries_exceeded(ssh);

crypto/openssh/auth2.c

294

authctxt->pw = mm_getpwnamallow(ssh, user);

crypto/openssh/auth2.c

304

mm_audit_event(ssh, SSH_INVALID_USER);

crypto/openssh/auth2.c

309

mm_start_pam(ssh);

crypto/openssh/auth2.c

311

ssh_packet_set_log_preamble(ssh, "%suser %s",

crypto/openssh/auth2.c

317

userauth_banner(ssh);

crypto/openssh/auth2.c

318

if ((r = kex_server_update_ext_info(ssh)) != 0)

crypto/openssh/auth2.c

321

ssh_packet_disconnect(ssh,

crypto/openssh/auth2.c

325

ssh_packet_disconnect(ssh, "Change of username or service "

crypto/openssh/auth2.c

330

auth2_challenge_stop(ssh);

crypto/openssh/auth2.c

334

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2.c

335

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);

crypto/openssh/auth2.c

346

authenticated = m->userauth(ssh, method);

crypto/openssh/auth2.c

351

userauth_finish(ssh, authenticated, method, NULL);

crypto/openssh/auth2.c

361

userauth_finish(struct ssh *ssh, int authenticated, const char *packet_method,

crypto/openssh/auth2.c

364

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2.c

385

!auth_root_allowed(ssh, method)) {

crypto/openssh/auth2.c

388

mm_audit_event(ssh, SSH_LOGIN_ROOT_DENIED);

crypto/openssh/auth2.c

400

auth_log(ssh, authenticated, partial, method, submethod);

crypto/openssh/auth2.c

418

userauth_send_banner(ssh, sshbuf_ptr(loginmsg));

crypto/openssh/auth2.c

419

if ((r = ssh_packet_write_wait(ssh)) != 0) {

crypto/openssh/auth2.c

420

sshpkt_fatal(ssh, r,

crypto/openssh/auth2.c

433

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_REQUEST,

crypto/openssh/auth2.c

435

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_SUCCESS)) != 0 ||

crypto/openssh/auth2.c

436

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/auth2.c

437

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/auth2.c

441

ssh_packet_set_log_preamble(ssh, "user %s", authctxt->user);

crypto/openssh/auth2.c

449

mm_audit_event(ssh, SSH_LOGIN_EXCEED_MAXTRIES);

crypto/openssh/auth2.c

451

auth_maxtries_exceeded(ssh);

crypto/openssh/auth2.c

456

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_FAILURE)) != 0 ||

crypto/openssh/auth2.c

457

(r = sshpkt_put_cstring(ssh, methods)) != 0 ||

crypto/openssh/auth2.c

458

(r = sshpkt_put_u8(ssh, partial)) != 0 ||

crypto/openssh/auth2.c

459

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/auth2.c

460

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/auth2.c

91

static int input_service_request(int, u_int32_t, struct ssh *);

crypto/openssh/auth2.c

92

static int input_userauth_request(int, u_int32_t, struct ssh *);

crypto/openssh/blocklist.c

91

blocklist_notify(struct ssh *ssh, int action, const char *msg)

crypto/openssh/blocklist.c

94

if (blstate != NULL && ssh_packet_connection_is_on_socket(ssh))

crypto/openssh/blocklist.c

96

ssh_packet_get_connection_in(ssh), msg);

crypto/openssh/blocklist_client.h

48

void blocklist_notify(struct ssh *, int, const char *);

crypto/openssh/blocklist_client.h

51

#define BLOCKLIST_NOTIFY(ssh,x,msg) blocklist_notify(ssh,x,msg)

crypto/openssh/blocklist_client.h

56

#define BLOCKLIST_NOTIFY(ssh,x,msg)

crypto/openssh/channels.c

103

typedef void chan_fn(struct ssh *, Channel *c);

crypto/openssh/channels.c

1041

channel_open_message(struct ssh *ssh)

crypto/openssh/channels.c

1054

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

1055

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

1100

open_preamble(struct ssh *ssh, const char *where, Channel *c, const char *type)

crypto/openssh/channels.c

1104

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN)) != 0 ||

crypto/openssh/channels.c

1105

(r = sshpkt_put_cstring(ssh, type)) != 0 ||

crypto/openssh/channels.c

1106

(r = sshpkt_put_u32(ssh, c->self)) != 0 ||

crypto/openssh/channels.c

1107

(r = sshpkt_put_u32(ssh, c->local_window)) != 0 ||

crypto/openssh/channels.c

1108

(r = sshpkt_put_u32(ssh, c->local_maxpacket)) != 0) {

crypto/openssh/channels.c

1114

channel_send_open(struct ssh *ssh, int id)

crypto/openssh/channels.c

1116

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1124

open_preamble(ssh, __func__, c, c->ctype);

crypto/openssh/channels.c

1125

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

1130

channel_request_start(struct ssh *ssh, int id, char *service, int wantconfirm)

crypto/openssh/channels.c

1132

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1143

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_REQUEST)) != 0 ||

crypto/openssh/channels.c

1144

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

1145

(r = sshpkt_put_cstring(ssh, service)) != 0 ||

crypto/openssh/channels.c

1146

(r = sshpkt_put_u8(ssh, wantconfirm)) != 0) {

crypto/openssh/channels.c

1152

channel_register_status_confirm(struct ssh *ssh, int id,

crypto/openssh/channels.c

1158

if ((c = channel_lookup(ssh, id)) == NULL)

crypto/openssh/channels.c

1169

channel_register_open_confirm(struct ssh *ssh, int id,

crypto/openssh/channels.c

1172

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1183

channel_register_cleanup(struct ssh *ssh, int id,

crypto/openssh/channels.c

1186

Channel *c = channel_by_id(ssh, id);

crypto/openssh/channels.c

1197

channel_cancel_cleanup(struct ssh *ssh, int id)

crypto/openssh/channels.c

1199

Channel *c = channel_by_id(ssh, id);

crypto/openssh/channels.c

1210

channel_register_filter(struct ssh *ssh, int id, channel_infilter_fn *ifn,

crypto/openssh/channels.c

1213

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1226

channel_set_fds(struct ssh *ssh, int id, int rfd, int wfd, int efd,

crypto/openssh/channels.c

1229

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1237

channel_register_fds(ssh, c, rfd, wfd, efd, extusage, nonblock, is_tty);

crypto/openssh/channels.c

1239

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

1242

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST)) != 0 ||

crypto/openssh/channels.c

1243

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

1244

(r = sshpkt_put_u32(ssh, c->local_window)) != 0 ||

crypto/openssh/channels.c

1245

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

1250

channel_pre_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1256

channel_pre_connecting(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1263

channel_pre_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1281

chan_obuf_empty(ssh, c);

crypto/openssh/channels.c

1309

x11_open_helper(struct ssh *ssh, struct sshbuf *b)

crypto/openssh/channels.c

1311

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

1376

channel_force_close(struct ssh *ssh, Channel *c, int abandon)

crypto/openssh/channels.c

1380

chan_read_failed(ssh, c);

crypto/openssh/channels.c

1383

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

1388

chan_write_failed(ssh, c);

crypto/openssh/channels.c

1391

c->detach_user(ssh, c->self, 1, NULL);

crypto/openssh/channels.c

1393

channel_close_fd(ssh, c, &c->efd);

crypto/openssh/channels.c

1402

channel_pre_x11_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1404

int ret = x11_open_helper(ssh, c->output);

crypto/openssh/channels.c

1410

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

1411

channel_pre_open(ssh, c);

crypto/openssh/channels.c

1417

channel_force_close(ssh, c, 0);

crypto/openssh/channels.c

1422

channel_pre_mux_client(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1431

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

1433

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

1440

chan_obuf_empty(ssh, c);

crypto/openssh/channels.c

1692

channel_connect_stdio_fwd(struct ssh *ssh,

crypto/openssh/channels.c

1700

c = channel_new(ssh, "stdio-forward", SSH_CHANNEL_OPENING, in, out,

crypto/openssh/channels.c

1709

channel_register_fds(ssh, c, in, out, -1, 0, 1, 0);

crypto/openssh/channels.c

1710

port_open_helper(ssh, c, port_to_connect == PORT_STREAMLOCAL ?

crypto/openssh/channels.c

1718

channel_pre_dynamic(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1749

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

1759

port_open_helper(ssh, c, "direct-tcpip");

crypto/openssh/channels.c

1765

rdynamic_close(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1768

channel_force_close(ssh, c, 0);

crypto/openssh/channels.c

1773

channel_before_prepare_io_rdynamic(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1786

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1807

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1813

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_DATA)) != 0 ||

crypto/openssh/channels.c

1814

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

1815

(r = sshpkt_put_stringb(ssh, c->input)) != 0 ||

crypto/openssh/channels.c

1816

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/channels.c

1823

} else if (rdynamic_connect_finish(ssh, c) < 0) {

crypto/openssh/channels.c

1825

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1831

channel_post_x11_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1848

channel_close_fd(ssh, c, &c->sock);

crypto/openssh/channels.c

1849

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

1866

nc = channel_new(ssh, "x11-connection",

crypto/openssh/channels.c

1869

open_preamble(ssh, __func__, nc, "x11");

crypto/openssh/channels.c

1870

if ((r = sshpkt_put_cstring(ssh, remote_ipaddr)) != 0 ||

crypto/openssh/channels.c

1871

(r = sshpkt_put_u32(ssh, remote_port)) != 0) {

crypto/openssh/channels.c

1874

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

1880

port_open_helper(struct ssh *ssh, Channel *c, char *rtype)

crypto/openssh/channels.c

1902

open_preamble(ssh, __func__, c, rtype);

crypto/openssh/channels.c

1905

if ((r = sshpkt_put_cstring(ssh, c->path)) != 0 ||

crypto/openssh/channels.c

1906

(r = sshpkt_put_u32(ssh, c->host_port)) != 0)

crypto/openssh/channels.c

1910

if ((r = sshpkt_put_cstring(ssh, c->path)) != 0)

crypto/openssh/channels.c

1914

if ((r = sshpkt_put_cstring(ssh, c->path)) != 0)

crypto/openssh/channels.c

1918

if ((r = sshpkt_put_cstring(ssh, c->path)) != 0 ||

crypto/openssh/channels.c

1919

(r = sshpkt_put_u32(ssh, local_port)) != 0)

crypto/openssh/channels.c

1924

if ((r = sshpkt_put_cstring(ssh, "")) != 0)

crypto/openssh/channels.c

1928

if ((r = sshpkt_put_cstring(ssh, remote_ipaddr)) != 0 ||

crypto/openssh/channels.c

1929

(r = sshpkt_put_u32(ssh, (u_int)remote_port)) != 0)

crypto/openssh/channels.c

1932

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

1939

channel_set_x11_refuse_time(struct ssh *ssh, time_t refuse_time)

crypto/openssh/channels.c

1941

ssh->chanctxt->x11_refuse_time = refuse_time;

crypto/openssh/channels.c

1948

channel_post_port_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1991

nc = channel_new(ssh, rtype, nextstate, newsock, newsock, -1,

crypto/openssh/channels.c

1999

port_open_helper(ssh, nc, rtype);

crypto/openssh/channels.c

2007

channel_post_auth_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2025

nc = channel_new(ssh, "agent-connection",

crypto/openssh/channels.c

2029

open_preamble(ssh, __func__, nc, "auth-agent@openssh.com");

crypto/openssh/channels.c

2030

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

2035

channel_post_connecting(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2058

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2062

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2064

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

2065

(r = sshpkt_put_u32(ssh, c->self)) != 0 ||

crypto/openssh/channels.c

2066

(r = sshpkt_put_u32(ssh, c->local_window)) != 0 ||

crypto/openssh/channels.c

2067

(r = sshpkt_put_u32(ssh, c->local_maxpacket)) != 0 ||

crypto/openssh/channels.c

2068

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

2086

rdynamic_close(ssh, c);

crypto/openssh/channels.c

2088

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2090

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

2091

(r = sshpkt_put_u32(ssh,

crypto/openssh/channels.c

2093

(r = sshpkt_put_cstring(ssh, strerror(err))) != 0 ||

crypto/openssh/channels.c

2094

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/channels.c

2095

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

2097

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2107

channel_handle_rfd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2150

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2169

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2172

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2176

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2178

if (c->input_filter(ssh, c, buf, len) == -1) {

crypto/openssh/channels.c

218

static void port_open_helper(struct ssh *ssh, Channel *c, char *rtype);

crypto/openssh/channels.c

2180

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2192

channel_handle_wfd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2207

if ((buf = c->output_filter(ssh, c, &data, &dlen)) == NULL) {

crypto/openssh/channels.c

2210

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2212

chan_write_failed(ssh, c);

crypto/openssh/channels.c

224

static Channel *rdynamic_connect_prepare(struct ssh *, char *, char *);

crypto/openssh/channels.c

225

static int rdynamic_connect_finish(struct ssh *, Channel *);

crypto/openssh/channels.c

2250

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2253

chan_write_failed(ssh, c);

crypto/openssh/channels.c

2257

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2268

if ((r = sshpkt_msg_ignore(ssh, 4+len)) != 0 ||

crypto/openssh/channels.c

2269

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

2283

channel_handle_efd_write(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2301

channel_close_fd(ssh, c, &c->efd);

crypto/openssh/channels.c

2306

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2312

channel_handle_efd_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

233

channel_init_channels(struct ssh *ssh)

crypto/openssh/channels.c

2330

channel_close_fd(ssh, c, &c->efd);

crypto/openssh/channels.c

2333

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2342

channel_handle_efd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2350

return channel_handle_efd_write(ssh, c);

crypto/openssh/channels.c

2353

return channel_handle_efd_read(ssh, c);

crypto/openssh/channels.c

2359

channel_check_window(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2371

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2373

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

2374

(r = sshpkt_put_u32(ssh, c->local_consumed)) != 0 ||

crypto/openssh/channels.c

2375

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/channels.c

2387

channel_post_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2389

channel_handle_rfd(ssh, c);

crypto/openssh/channels.c

2390

channel_handle_wfd(ssh, c);

crypto/openssh/channels.c

2391

channel_handle_efd(ssh, c);

crypto/openssh/channels.c

2392

channel_check_window(ssh, c);

crypto/openssh/channels.c

2396

read_mux(struct ssh *ssh, Channel *c, u_int need)

crypto/openssh/channels.c

2411

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2420

channel_post_mux_client_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2435

if (read_mux(ssh, c, 4) < 4) /* read header */

crypto/openssh/channels.c

244

ssh->chanctxt = sc;

crypto/openssh/channels.c

2443

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

2446

if (read_mux(ssh, c, need + 4) < need + 4) /* read body */

crypto/openssh/channels.c

2448

if (c->mux_rcb(ssh, c) != 0) {

crypto/openssh/channels.c

2450

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2456

channel_post_mux_client_write(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2470

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2478

channel_post_mux_client(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

248

channel_by_id(struct ssh *ssh, int id)

crypto/openssh/channels.c

2480

channel_post_mux_client_read(ssh, c);

crypto/openssh/channels.c

2481

channel_post_mux_client_write(ssh, c);

crypto/openssh/channels.c

2485

channel_post_mux_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

252

if (id < 0 || (u_int)id >= ssh->chanctxt->channels_alloc) {

crypto/openssh/channels.c

2523

nc = channel_new(ssh, "mux-control", SSH_CHANNEL_MUX_CLIENT,

crypto/openssh/channels.c

2529

nc->mux_rcb(ssh, nc);

crypto/openssh/channels.c

256

c = ssh->chanctxt->channels[id];

crypto/openssh/channels.c

2576

channel_garbage_collect(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2581

if (!chan_is_dead(ssh, c, c->detach_close))

crypto/openssh/channels.c

2585

c->detach_user(ssh, c->self, 0, NULL);

crypto/openssh/channels.c

2591

if (!chan_is_dead(ssh, c, 1))

crypto/openssh/channels.c

2594

channel_free(ssh, c);

crypto/openssh/channels.c

2600

channel_handler(struct ssh *ssh, int table, struct timespec *timeout)

crypto/openssh/channels.c

2602

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2614

if (ssh_packet_is_rekeying(ssh) && c->type != SSH_CHANNEL_OPEN)

crypto/openssh/channels.c

2624

channel_get_expiry(ssh, c) != 0 &&

crypto/openssh/channels.c

2625

now >= channel_get_expiry(ssh, c)) {

crypto/openssh/channels.c

2630

channel_force_close(ssh, c, 1);

crypto/openssh/channels.c

2633

(*ftab[c->type])(ssh, c);

crypto/openssh/channels.c

2637

channel_get_expiry(ssh, c) != 0) {

crypto/openssh/channels.c

2639

channel_get_expiry(ssh, c));

crypto/openssh/channels.c

265

channel_by_remote_id(struct ssh *ssh, u_int remote_id)

crypto/openssh/channels.c

2650

channel_garbage_collect(ssh, c);

crypto/openssh/channels.c

2661

channel_before_prepare_io(struct ssh *ssh)

crypto/openssh/channels.c

2663

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2672

channel_before_prepare_io_rdynamic(ssh, c);

crypto/openssh/channels.c

270

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

271

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

2796

channel_prepare_poll(struct ssh *ssh, struct pollfd **pfdp, u_int *npfd_allocp,

crypto/openssh/channels.c

2799

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2802

channel_before_prepare_io(ssh); /* might create a new channel */

crypto/openssh/channels.c

2821

channel_handler(ssh, CHAN_PRE, timeout);

crypto/openssh/channels.c

283

channel_lookup(struct ssh *ssh, int id)

crypto/openssh/channels.c

2865

channel_after_poll(struct ssh *ssh, struct pollfd *pfd, u_int npfd)

crypto/openssh/channels.c

2867

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

287

if ((c = channel_by_id(ssh, id)) == NULL)

crypto/openssh/channels.c

2942

channel_handler(ssh, CHAN_POST, NULL);

crypto/openssh/channels.c

2950

channel_output_poll_input_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2970

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

2992

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_DATA)) != 0 ||

crypto/openssh/channels.c

2993

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

2994

(r = sshpkt_put_string(ssh, pkt, plen)) != 0 ||

crypto/openssh/channels.c

2995

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

3008

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_DATA)) != 0 ||

crypto/openssh/channels.c

3009

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

3010

(r = sshpkt_put_string(ssh, sshbuf_ptr(c->input), len)) != 0 ||

crypto/openssh/channels.c

3011

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

3024

channel_output_poll_extended_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

3042

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_EXTENDED_DATA)) != 0 ||

crypto/openssh/channels.c

3043

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

3044

(r = sshpkt_put_u32(ssh, SSH2_EXTENDED_DATA_STDERR)) != 0 ||

crypto/openssh/channels.c

3045

(r = sshpkt_put_string(ssh, sshbuf_ptr(c->extended), len)) != 0 ||

crypto/openssh/channels.c

3046

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

3060

channel_output_poll(struct ssh *ssh)

crypto/openssh/channels.c

3062

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3088

ret |= channel_output_poll_input_open(ssh, c);

crypto/openssh/channels.c

3092

ret |= channel_output_poll_extended_read(ssh, c);

crypto/openssh/channels.c

312

channel_add_timeout(struct ssh *ssh, const char *type_pattern,

crypto/openssh/channels.c

3138

channel_proxy_downstream(struct ssh *ssh, Channel *downstream)

crypto/openssh/channels.c

315

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3179

c = channel_new(ssh, "mux-proxy", SSH_CHANNEL_MUX_PROXY,

crypto/openssh/channels.c

3187

channel_free(ssh, c);

crypto/openssh/channels.c

3206

c = channel_new(ssh, "mux-proxy", SSH_CHANNEL_MUX_PROXY,

crypto/openssh/channels.c

3216

channel_free(ssh, c);

crypto/openssh/channels.c

3245

permission_set_add(ssh, FORWARD_USER, FORWARD_LOCAL, "<mux>",

crypto/openssh/channels.c

3252

if ((c = channel_by_remote_id(ssh, remote_id)) != NULL) {

crypto/openssh/channels.c

3254

channel_free(ssh, c);

crypto/openssh/channels.c

3261

if ((r = sshpkt_start(ssh, type)) != 0 ||

crypto/openssh/channels.c

3262

(r = sshpkt_putb(ssh, modified)) != 0 ||

crypto/openssh/channels.c

3263

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/channels.c

3268

if ((r = sshpkt_start(ssh, type)) != 0 ||

crypto/openssh/channels.c

3269

(r = sshpkt_put(ssh, cp, have)) != 0 ||

crypto/openssh/channels.c

3270

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/channels.c

3291

channel_proxy_upstream(Channel *c, int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

333

channel_clear_timeouts(struct ssh *ssh)

crypto/openssh/channels.c

3330

cp = sshpkt_ptr(ssh, &len);

crypto/openssh/channels.c

335

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3359

channel_free(ssh, c);

crypto/openssh/channels.c

3372

channel_parse_id(struct ssh *ssh, const char *where, const char *what)

crypto/openssh/channels.c

3377

if ((r = sshpkt_get_u32(ssh, &id)) != 0) {

crypto/openssh/channels.c

3379

ssh_packet_disconnect(ssh, "Invalid %s message", what);

crypto/openssh/channels.c

3383

ssh_packet_disconnect(ssh, "Invalid %s channel id", what);

crypto/openssh/channels.c

3390

channel_from_packet_id(struct ssh *ssh, const char *where, const char *what)

crypto/openssh/channels.c

3392

int id = channel_parse_id(ssh, where, what);

crypto/openssh/channels.c

3395

if ((c = channel_lookup(ssh, id)) == NULL) {

crypto/openssh/channels.c

3396

ssh_packet_disconnect(ssh,

crypto/openssh/channels.c

3403

channel_input_data(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3407

Channel *c = channel_from_packet_id(ssh, __func__, "data");

crypto/openssh/channels.c

3410

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3421

if ((r = sshpkt_get_string_direct(ssh, &data, &data_len)) != 0 ||

crypto/openssh/channels.c

3422

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/channels.c

3453

ssh_packet_disconnect(ssh, "channel %d: peer ignored "

crypto/openssh/channels.c

347

lookup_timeout(struct ssh *ssh, const char *type)

crypto/openssh/channels.c

3471

channel_input_extended_data(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3476

Channel *c = channel_from_packet_id(ssh, __func__, "extended data");

crypto/openssh/channels.c

3479

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3486

if (ssh->compat & SSH_BUG_EXTEOF)

crypto/openssh/channels.c

349

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3490

ssh_packet_disconnect(ssh, "Received extended_data "

crypto/openssh/channels.c

3494

if ((r = sshpkt_get_u32(ssh, &tcode)) != 0) {

crypto/openssh/channels.c

3496

ssh_packet_disconnect(ssh, "Invalid extended_data message");

crypto/openssh/channels.c

3504

if ((r = sshpkt_get_string_direct(ssh, &data, &data_len)) != 0 ||

crypto/openssh/channels.c

3505

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/channels.c

3507

ssh_packet_disconnect(ssh, "Invalid extended_data message");

crypto/openssh/channels.c

3524

channel_input_ieof(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3526

Channel *c = channel_from_packet_id(ssh, __func__, "ieof");

crypto/openssh/channels.c

3529

if ((r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/channels.c

3531

ssh_packet_disconnect(ssh, "Invalid ieof message");

crypto/openssh/channels.c

3534

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3536

chan_rcvd_ieof(ssh, c);

crypto/openssh/channels.c

3543

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

3549

channel_input_oclose(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3551

Channel *c = channel_from_packet_id(ssh, __func__, "oclose");

crypto/openssh/channels.c

3554

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3556

if ((r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/channels.c

3558

ssh_packet_disconnect(ssh, "Invalid oclose message");

crypto/openssh/channels.c

3560

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

3565

channel_input_open_confirmation(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3567

Channel *c = channel_from_packet_id(ssh, __func__, "open confirmation");

crypto/openssh/channels.c

3571

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3574

ssh_packet_disconnect(ssh, "Received open confirmation for "

crypto/openssh/channels.c

3580

if ((r = sshpkt_get_u32(ssh, &c->remote_id)) != 0 ||

crypto/openssh/channels.c

3581

(r = sshpkt_get_u32(ssh, &remote_window)) != 0 ||

crypto/openssh/channels.c

3582

(r = sshpkt_get_u32(ssh, &remote_maxpacket)) != 0 ||

crypto/openssh/channels.c

3583

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/channels.c

3585

ssh_packet_disconnect(ssh, "Invalid open confirmation message");

crypto/openssh/channels.c

3594

c->open_confirm(ssh, c->self, 1, c->open_confirm_ctx);

crypto/openssh/channels.c

3597

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

3620

channel_input_open_failure(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3622

Channel *c = channel_from_packet_id(ssh, __func__, "open failure");

crypto/openssh/channels.c

3627

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3630

ssh_packet_disconnect(ssh, "Received open failure for "

crypto/openssh/channels.c

3632

if ((r = sshpkt_get_u32(ssh, &reason)) != 0) {

crypto/openssh/channels.c

3634

ssh_packet_disconnect(ssh, "Invalid open failure message");

crypto/openssh/channels.c

3637

if ((r = sshpkt_get_cstring(ssh, &msg, NULL)) != 0 ||

crypto/openssh/channels.c

3638

(r = sshpkt_get_string_direct(ssh, NULL, NULL)) != 0 ||

crypto/openssh/channels.c

3639

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/channels.c

3641

ssh_packet_disconnect(ssh, "Invalid open failure message");

crypto/openssh/channels.c

3648

c->open_confirm(ssh, c->self, 0, c->open_confirm_ctx);

crypto/openssh/channels.c

3652

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

3657

channel_input_window_adjust(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3659

int id = channel_parse_id(ssh, __func__, "window adjust");

crypto/openssh/channels.c

3665

if ((c = channel_lookup(ssh, id)) == NULL) {

crypto/openssh/channels.c

367

channel_set_xtype(struct ssh *ssh, int id, const char *xctype)

crypto/openssh/channels.c

3670

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3672

if ((r = sshpkt_get_u32(ssh, &adjust)) != 0 ||

crypto/openssh/channels.c

3673

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/channels.c

3675

ssh_packet_disconnect(ssh, "Invalid window adjust message");

crypto/openssh/channels.c

3687

channel_input_status_confirm(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/channels.c

3689

int id = channel_parse_id(ssh, __func__, "status confirm");

crypto/openssh/channels.c

3694

ssh_packet_set_alive_timeouts(ssh, 0);

crypto/openssh/channels.c

3698

if ((c = channel_lookup(ssh, id)) == NULL) {

crypto/openssh/channels.c

3702

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/channels.c

3704

if (sshpkt_get_end(ssh) != 0)

crypto/openssh/channels.c

3705

ssh_packet_disconnect(ssh, "Invalid status confirm message");

crypto/openssh/channels.c

3708

cc->cb(ssh, type, c, cc->ctx);

crypto/openssh/channels.c

371

if ((c = channel_by_id(ssh, id)) == NULL)

crypto/openssh/channels.c

3717

channel_set_af(struct ssh *ssh, int af)

crypto/openssh/channels.c

3719

ssh->chanctxt->IPv4or6 = af;

crypto/openssh/channels.c

3739

channel_fwd_bind_addr(struct ssh *ssh, const char *listen_addr, int *wildcardp,

crypto/openssh/channels.c

3750

if (((ssh->compat & SSH_OLD_FORWARD_ADDR) &&

crypto/openssh/channels.c

3762

ssh_packet_send_debug(ssh,

crypto/openssh/channels.c

377

c->inactive_deadline = lookup_timeout(ssh, c->xctype);

crypto/openssh/channels.c

3793

channel_setup_fwd_listener_tcpip(struct ssh *ssh, int type,

crypto/openssh/channels.c

3822

addr = channel_fwd_bind_addr(ssh, fwd->listen_host, &wildcard,

crypto/openssh/channels.c

3832

hints.ai_family = ssh->chanctxt->IPv4or6;

crypto/openssh/channels.c

3839

ssh_packet_disconnect(ssh, "getaddrinfo: fatal error: %s",

crypto/openssh/channels.c

387

channel_set_used_time(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

389

ssh->chanctxt->lastused = monotime();

crypto/openssh/channels.c

391

c->lastused = ssh->chanctxt->lastused;

crypto/openssh/channels.c

3931

c = channel_new(ssh, "port-listener", type, sock, sock, -1,

crypto/openssh/channels.c

3938

!(ssh->compat & SSH_BUG_DYNAMIC_RPORT))

crypto/openssh/channels.c

3951

channel_setup_fwd_listener_streamlocal(struct ssh *ssh, int type,

crypto/openssh/channels.c

399

channel_get_expiry(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

401

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4014

c = channel_new(ssh, "unix-listener", type, sock, sock, -1,

crypto/openssh/channels.c

4025

channel_cancel_rport_listener_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4031

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

4032

Channel *c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

4037

channel_free(ssh, c);

crypto/openssh/channels.c

4046

channel_cancel_rport_listener_streamlocal(struct ssh *ssh, const char *path)

crypto/openssh/channels.c

4051

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

4052

Channel *c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

4059

channel_free(ssh, c);

crypto/openssh/channels.c

4068

channel_cancel_rport_listener(struct ssh *ssh, struct Forward *fwd)

crypto/openssh/channels.c

4071

return channel_cancel_rport_listener_streamlocal(ssh,

crypto/openssh/channels.c

4074

return channel_cancel_rport_listener_tcpip(ssh,

crypto/openssh/channels.c

4080

channel_cancel_lport_listener_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4086

const char *addr = channel_fwd_bind_addr(ssh, lhost, NULL, 1, fwd_opts);

crypto/openssh/channels.c

4088

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

4089

Channel *c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

4107

channel_free(ssh, c);

crypto/openssh/channels.c

4116

channel_cancel_lport_listener_streamlocal(struct ssh *ssh, const char *path)

crypto/openssh/channels.c

4126

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

4127

Channel *c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

4134

channel_free(ssh, c);

crypto/openssh/channels.c

4143

channel_cancel_lport_listener(struct ssh *ssh,

crypto/openssh/channels.c

4147

return channel_cancel_lport_listener_streamlocal(ssh,

crypto/openssh/channels.c

4150

return channel_cancel_lport_listener_tcpip(ssh,

crypto/openssh/channels.c

4157

channel_setup_local_fwd_listener(struct ssh *ssh,

crypto/openssh/channels.c

4161

return channel_setup_fwd_listener_streamlocal(ssh,

crypto/openssh/channels.c

4164

return channel_setup_fwd_listener_tcpip(ssh,

crypto/openssh/channels.c

419

channel_register_fds(struct ssh *ssh, Channel *c, int rfd, int wfd, int efd,

crypto/openssh/channels.c

4198

check_rfwd_permission(struct ssh *ssh, struct Forward *fwd)

crypto/openssh/channels.c

4200

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4234

channel_setup_remote_fwd_listener(struct ssh *ssh, struct Forward *fwd,

crypto/openssh/channels.c

4237

if (!check_rfwd_permission(ssh, fwd)) {

crypto/openssh/channels.c

4238

ssh_packet_send_debug(ssh, "port forwarding refused");

crypto/openssh/channels.c

4244

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/channels.c

4250

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/channels.c

4255

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/channels.c

4259

return channel_setup_fwd_listener_streamlocal(ssh,

crypto/openssh/channels.c

4262

return channel_setup_fwd_listener_tcpip(ssh,

crypto/openssh/channels.c

4290

channel_request_remote_forwarding(struct ssh *ssh, struct Forward *fwd)

crypto/openssh/channels.c

4298

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/channels.c

4299

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4301

(r = sshpkt_put_u8(ssh, 1)) != 0 || /* want reply */

crypto/openssh/channels.c

4302

(r = sshpkt_put_cstring(ssh, fwd->listen_path)) != 0 ||

crypto/openssh/channels.c

4303

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/channels.c

4304

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/channels.c

4307

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/channels.c

4308

(r = sshpkt_put_cstring(ssh, "tcpip-forward")) != 0 ||

crypto/openssh/channels.c

4309

(r = sshpkt_put_u8(ssh, 1)) != 0 || /* want reply */

crypto/openssh/channels.c

4310

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4312

(r = sshpkt_put_u32(ssh, fwd->listen_port)) != 0 ||

crypto/openssh/channels.c

4313

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/channels.c

4314

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/channels.c

4337

idx = permission_set_add(ssh, FORWARD_USER, FORWARD_LOCAL,

crypto/openssh/channels.c

4406

channel_request_rforward_cancel_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4409

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4425

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/channels.c

4426

(r = sshpkt_put_cstring(ssh, "cancel-tcpip-forward")) != 0 ||

crypto/openssh/channels.c

4427

(r = sshpkt_put_u8(ssh, 0)) != 0 || /* want reply */

crypto/openssh/channels.c

4428

(r = sshpkt_put_cstring(ssh, channel_rfwd_bind_host(host))) != 0 ||

crypto/openssh/channels.c

4429

(r = sshpkt_put_u32(ssh, port)) != 0 ||

crypto/openssh/channels.c

4430

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

4443

channel_request_rforward_cancel_streamlocal(struct ssh *ssh, const char *path)

crypto/openssh/channels.c

4445

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4461

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/channels.c

4462

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4464

(r = sshpkt_put_u8(ssh, 0)) != 0 || /* want reply */

crypto/openssh/channels.c

4465

(r = sshpkt_put_cstring(ssh, path)) != 0 ||

crypto/openssh/channels.c

4466

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

4478

channel_request_rforward_cancel(struct ssh *ssh, struct Forward *fwd)

crypto/openssh/channels.c

4481

return channel_request_rforward_cancel_streamlocal(ssh,

crypto/openssh/channels.c

4484

return channel_request_rforward_cancel_tcpip(ssh,

crypto/openssh/channels.c

4496

channel_permit_all(struct ssh *ssh, int where)

crypto/openssh/channels.c

4498

struct permission_set *pset = permission_set_get(ssh, where);

crypto/openssh/channels.c

4508

channel_add_permission(struct ssh *ssh, int who, int where,

crypto/openssh/channels.c

4512

struct permission_set *pset = permission_set_get(ssh, where);

crypto/openssh/channels.c

4520

permission_set_add(ssh, who, where,

crypto/openssh/channels.c

4530

channel_disable_admin(struct ssh *ssh, int where)

crypto/openssh/channels.c

4532

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/channels.c

4533

permission_set_add(ssh, FORWARD_ADM, where,

crypto/openssh/channels.c

4541

channel_clear_permission(struct ssh *ssh, int who, int where)

crypto/openssh/channels.c

4546

permission_set_get_array(ssh, who, where, &permp, &npermp);

crypto/openssh/channels.c

4557

channel_update_permission(struct ssh *ssh, int idx, int newport)

crypto/openssh/channels.c

4559

struct permission_set *pset = &ssh->chanctxt->local_perms;

crypto/openssh/channels.c

4575

(ssh->compat & SSH_BUG_DYNAMIC_RPORT) ? 0 : newport;

crypto/openssh/channels.c

4657

connect_to_helper(struct ssh *ssh, const char *name, int port, int socktype,

crypto/openssh/channels.c

4693

hints.ai_family = ssh->chanctxt->IPv4or6;

crypto/openssh/channels.c

4723

connect_to(struct ssh *ssh, const char *host, int port,

crypto/openssh/channels.c

4731

sock = connect_to_helper(ssh, host, port, SOCK_STREAM, ctype, rname,

crypto/openssh/channels.c

4737

c = channel_new(ssh, ctype, SSH_CHANNEL_CONNECTING, sock, sock, -1,

crypto/openssh/channels.c

4751

channel_connect_by_listen_address(struct ssh *ssh, const char *listen_host,

crypto/openssh/channels.c

4754

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4766

return rdynamic_connect_prepare(ssh,

crypto/openssh/channels.c

4768

return connect_to(ssh,

crypto/openssh/channels.c

4779

channel_connect_by_listen_path(struct ssh *ssh, const char *path,

crypto/openssh/channels.c

4782

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4790

return connect_to(ssh,

crypto/openssh/channels.c

480

channel_set_used_time(ssh, NULL);

crypto/openssh/channels.c

4802

channel_connect_to_port(struct ssh *ssh, const char *host, u_short port,

crypto/openssh/channels.c

4805

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4838

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh), host, port);

crypto/openssh/channels.c

4845

sock = connect_to_helper(ssh, host, port, SOCK_STREAM, ctype, rname,

crypto/openssh/channels.c

4852

c = channel_new(ssh, ctype, SSH_CHANNEL_CONNECTING, sock, sock, -1,

crypto/openssh/channels.c

4863

channel_connect_to_path(struct ssh *ssh, const char *path,

crypto/openssh/channels.c

4866

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

487

channel_new(struct ssh *ssh, char *ctype, int type, int rfd, int wfd, int efd,

crypto/openssh/channels.c

4898

return connect_to(ssh, path, PORT_STREAMLOCAL, ctype, rname);

crypto/openssh/channels.c

4902

channel_send_window_changes(struct ssh *ssh)

crypto/openssh/channels.c

4904

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

491

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4915

channel_request_start(ssh, i, "window-change", 0);

crypto/openssh/channels.c

4916

if ((r = sshpkt_put_u32(ssh, (u_int)ws.ws_col)) != 0 ||

crypto/openssh/channels.c

4917

(r = sshpkt_put_u32(ssh, (u_int)ws.ws_row)) != 0 ||

crypto/openssh/channels.c

4918

(r = sshpkt_put_u32(ssh, (u_int)ws.ws_xpixel)) != 0 ||

crypto/openssh/channels.c

4919

(r = sshpkt_put_u32(ssh, (u_int)ws.ws_ypixel)) != 0 ||

crypto/openssh/channels.c

4920

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/channels.c

4927

rdynamic_connect_prepare(struct ssh *ssh, char *ctype, char *rname)

crypto/openssh/channels.c

4932

c = channel_new(ssh, ctype, SSH_CHANNEL_RDYNAMIC_OPEN, -1, -1, -1,

crypto/openssh/channels.c

4941

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION)) != 0 ||

crypto/openssh/channels.c

4942

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/channels.c

4943

(r = sshpkt_put_u32(ssh, c->self)) != 0 ||

crypto/openssh/channels.c

4944

(r = sshpkt_put_u32(ssh, c->local_window)) != 0 ||

crypto/openssh/channels.c

4945

(r = sshpkt_put_u32(ssh, c->local_maxpacket)) != 0)

crypto/openssh/channels.c

4952

rdynamic_connect_finish(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

4954

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4977

sock = connect_to_helper(ssh, c->path, c->host_port, SOCK_STREAM, NULL,

crypto/openssh/channels.c

4985

channel_register_fds(ssh, c, sock, sock, -1, 0, 1, 0);

crypto/openssh/channels.c

4998

x11_create_display_inet(struct ssh *ssh, int x11_display_offset,

crypto/openssh/channels.c

5017

hints.ai_family = ssh->chanctxt->IPv4or6;

crypto/openssh/channels.c

5086

nc = channel_new(ssh, "x11-listener",

crypto/openssh/channels.c

5157

x11_connect_display(struct ssh *ssh)

crypto/openssh/channels.c

5240

hints.ai_family = ssh->chanctxt->IPv4or6;

crypto/openssh/channels.c

528

channel_register_fds(ssh, c, rfd, wfd, efd, extusage, nonblock, 0);

crypto/openssh/channels.c

5281

x11_request_forwarding_with_spoofing(struct ssh *ssh, int client_session_id,

crypto/openssh/channels.c

5284

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

5332

channel_request_start(ssh, client_session_id, "x11-req", want_reply);

crypto/openssh/channels.c

5333

if ((r = sshpkt_put_u8(ssh, 0)) != 0 || /* bool: single connection */

crypto/openssh/channels.c

5334

(r = sshpkt_put_cstring(ssh, proto)) != 0 ||

crypto/openssh/channels.c

5335

(r = sshpkt_put_cstring(ssh, new_data)) != 0 ||

crypto/openssh/channels.c

5336

(r = sshpkt_put_u32(ssh, screen_number)) != 0 ||

crypto/openssh/channels.c

5337

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/channels.c

5338

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/channels.c

5347

x11_channel_used_recently(struct ssh *ssh) {

crypto/openssh/channels.c

5352

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

5353

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

538

c->inactive_deadline = lookup_timeout(ssh, c->ctype);

crypto/openssh/channels.c

546

channel_close_fd(struct ssh *ssh, Channel *c, int *fdp)

crypto/openssh/channels.c

596

channel_close_fds(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

600

channel_close_fd(ssh, c, &c->sock);

crypto/openssh/channels.c

602

channel_close_fd(ssh, c, &c->rfd);

crypto/openssh/channels.c

604

channel_close_fd(ssh, c, &c->wfd);

crypto/openssh/channels.c

606

channel_close_fd(ssh, c, &c->efd);

crypto/openssh/channels.c

638

permission_set_get(struct ssh *ssh, int where)

crypto/openssh/channels.c

640

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

656

permission_set_get_array(struct ssh *ssh, int who, int where,

crypto/openssh/channels.c

659

struct permission_set *pset = permission_set_get(ssh, where);

crypto/openssh/channels.c

677

permission_set_add(struct ssh *ssh, int who, int where,

crypto/openssh/channels.c

685

permission_set_get_array(ssh, who, where, &permp, &npermp);

crypto/openssh/channels.c

704

mux_remove_remote_forwardings(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

706

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

720

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/channels.c

721

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

723

(r = sshpkt_put_u8(ssh, 0)) != 0 ||

crypto/openssh/channels.c

724

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

726

(r = sshpkt_put_u32(ssh, perm->listen_port)) != 0 ||

crypto/openssh/channels.c

727

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/channels.c

736

channel_free(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

738

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

762

mux_remove_remote_forwardings(ssh, c);

crypto/openssh/channels.c

771

s = channel_open_message(ssh);

crypto/openssh/channels.c

776

channel_close_fds(ssh, c);

crypto/openssh/channels.c

791

cc->abandon_cb(ssh, c, cc->ctx);

crypto/openssh/channels.c

796

c->filter_cleanup(ssh, c->self, c->filter_ctx);

crypto/openssh/channels.c

802

channel_free_all(struct ssh *ssh)

crypto/openssh/channels.c

805

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

809

channel_free(ssh, sc->channels[i]);

crypto/openssh/channels.c

835

channel_close_all(struct ssh *ssh)

crypto/openssh/channels.c

839

for (i = 0; i < ssh->chanctxt->channels_alloc; i++)

crypto/openssh/channels.c

840

if (ssh->chanctxt->channels[i] != NULL)

crypto/openssh/channels.c

841

channel_close_fds(ssh, ssh->chanctxt->channels[i]);

crypto/openssh/channels.c

848

channel_stop_listening(struct ssh *ssh)

crypto/openssh/channels.c

853

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

854

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

863

channel_close_fd(ssh, c, &c->sock);

crypto/openssh/channels.c

864

channel_free(ssh, c);

crypto/openssh/channels.c

876

channel_not_very_much_buffered_data(struct ssh *ssh)

crypto/openssh/channels.c

879

u_int maxsize = ssh_packet_get_maxsize(ssh);

crypto/openssh/channels.c

882

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

883

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

897

channel_still_open(struct ssh *ssh)

crypto/openssh/channels.c

902

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

903

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

940

channel_tty_open(struct ssh *ssh)

crypto/openssh/channels.c

945

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

946

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.c

957

channel_find_open(struct ssh *ssh)

crypto/openssh/channels.c

962

for (i = 0; i < ssh->chanctxt->channels_alloc; i++) {

crypto/openssh/channels.c

963

c = ssh->chanctxt->channels[i];

crypto/openssh/channels.h

115

typedef int mux_callback_fn(struct ssh *, struct Channel *);

crypto/openssh/channels.h

281

void channel_init_channels(struct ssh *ssh);

crypto/openssh/channels.h

285

Channel *channel_by_id(struct ssh *, int);

crypto/openssh/channels.h

286

Channel *channel_by_remote_id(struct ssh *, u_int);

crypto/openssh/channels.h

287

Channel *channel_lookup(struct ssh *, int);

crypto/openssh/channels.h

288

Channel *channel_new(struct ssh *, char *, int, int, int, int,

crypto/openssh/channels.h

290

void channel_set_fds(struct ssh *, int, int, int, int, int,

crypto/openssh/channels.h

292

void channel_free(struct ssh *, Channel *);

crypto/openssh/channels.h

293

void channel_free_all(struct ssh *);

crypto/openssh/channels.h

294

void channel_stop_listening(struct ssh *);

crypto/openssh/channels.h

295

void channel_force_close(struct ssh *, Channel *, int);

crypto/openssh/channels.h

296

void channel_set_xtype(struct ssh *, int, const char *);

crypto/openssh/channels.h

298

void channel_send_open(struct ssh *, int);

crypto/openssh/channels.h

299

void channel_request_start(struct ssh *, int, char *, int);

crypto/openssh/channels.h

300

void channel_register_cleanup(struct ssh *, int,

crypto/openssh/channels.h

302

void channel_register_open_confirm(struct ssh *, int,

crypto/openssh/channels.h

304

void channel_register_filter(struct ssh *, int, channel_infilter_fn *,

crypto/openssh/channels.h

306

void channel_register_status_confirm(struct ssh *, int,

crypto/openssh/channels.h

308

void channel_cancel_cleanup(struct ssh *, int);

crypto/openssh/channels.h

309

int channel_close_fd(struct ssh *, Channel *, int *);

crypto/openssh/channels.h

310

void channel_send_window_changes(struct ssh *);

crypto/openssh/channels.h

313

void channel_add_timeout(struct ssh *, const char *, int);

crypto/openssh/channels.h

314

void channel_clear_timeouts(struct ssh *);

crypto/openssh/channels.h

318

int channel_proxy_downstream(struct ssh *, Channel *mc);

crypto/openssh/channels.h

319

int channel_proxy_upstream(Channel *, int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

323

int channel_input_data(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

324

int channel_input_extended_data(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

325

int channel_input_ieof(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

326

int channel_input_oclose(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

327

int channel_input_open_confirmation(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

328

int channel_input_open_failure(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

329

int channel_input_window_adjust(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

330

int channel_input_status_confirm(int, u_int32_t, struct ssh *);

crypto/openssh/channels.h

336

void channel_prepare_poll(struct ssh *, struct pollfd **,

crypto/openssh/channels.h

338

void channel_after_poll(struct ssh *, struct pollfd *, u_int);

crypto/openssh/channels.h

339

int channel_output_poll(struct ssh *);

crypto/openssh/channels.h

341

int channel_not_very_much_buffered_data(struct ssh *);

crypto/openssh/channels.h

342

void channel_close_all(struct ssh *);

crypto/openssh/channels.h

343

int channel_still_open(struct ssh *);

crypto/openssh/channels.h

344

int channel_tty_open(struct ssh *);

crypto/openssh/channels.h

346

char *channel_open_message(struct ssh *);

crypto/openssh/channels.h

347

int channel_find_open(struct ssh *);

crypto/openssh/channels.h

352

void channel_set_af(struct ssh *, int af);

crypto/openssh/channels.h

353

void channel_permit_all(struct ssh *, int);

crypto/openssh/channels.h

354

void channel_add_permission(struct ssh *, int, int, char *, int);

crypto/openssh/channels.h

355

void channel_clear_permission(struct ssh *, int, int);

crypto/openssh/channels.h

356

void channel_disable_admin(struct ssh *, int);

crypto/openssh/channels.h

357

void channel_update_permission(struct ssh *, int, int);

crypto/openssh/channels.h

358

Channel *channel_connect_to_port(struct ssh *, const char *, u_short,

crypto/openssh/channels.h

360

Channel *channel_connect_to_path(struct ssh *, const char *, char *, char *);

crypto/openssh/channels.h

361

Channel *channel_connect_stdio_fwd(struct ssh *, const char*,

crypto/openssh/channels.h

363

Channel *channel_connect_by_listen_address(struct ssh *, const char *,

crypto/openssh/channels.h

365

Channel *channel_connect_by_listen_path(struct ssh *, const char *,

crypto/openssh/channels.h

367

int channel_request_remote_forwarding(struct ssh *, struct Forward *);

crypto/openssh/channels.h

368

int channel_setup_local_fwd_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

370

int channel_request_rforward_cancel(struct ssh *, struct Forward *);

crypto/openssh/channels.h

371

int channel_setup_remote_fwd_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

373

int channel_cancel_rport_listener(struct ssh *, struct Forward *);

crypto/openssh/channels.h

374

int channel_cancel_lport_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

380

void channel_set_x11_refuse_time(struct ssh *, time_t);

crypto/openssh/channels.h

381

int x11_connect_display(struct ssh *);

crypto/openssh/channels.h

382

int x11_create_display_inet(struct ssh *, int, int, int, u_int *, int **);

crypto/openssh/channels.h

383

void x11_request_forwarding_with_spoofing(struct ssh *, int,

crypto/openssh/channels.h

385

int x11_channel_used_recently(struct ssh *ssh);

crypto/openssh/channels.h

389

int chan_is_dead(struct ssh *, Channel *, int);

crypto/openssh/channels.h

390

void chan_mark_dead(struct ssh *, Channel *);

crypto/openssh/channels.h

394

void chan_rcvd_oclose(struct ssh *, Channel *);

crypto/openssh/channels.h

395

void chan_rcvd_eow(struct ssh *, Channel *);

crypto/openssh/channels.h

396

void chan_read_failed(struct ssh *, Channel *);

crypto/openssh/channels.h

397

void chan_ibuf_empty(struct ssh *, Channel *);

crypto/openssh/channels.h

398

void chan_rcvd_ieof(struct ssh *, Channel *);

crypto/openssh/channels.h

399

void chan_write_failed(struct ssh *, Channel *);

crypto/openssh/channels.h

400

void chan_obuf_empty(struct ssh *, Channel *);

crypto/openssh/channels.h

85

struct ssh;

crypto/openssh/channels.h

89

typedef void channel_open_fn(struct ssh *, int, int, void *);

crypto/openssh/channels.h

90

typedef void channel_callback_fn(struct ssh *, int, int, void *);

crypto/openssh/channels.h

91

typedef int channel_infilter_fn(struct ssh *, struct Channel *, char *, int);

crypto/openssh/channels.h

92

typedef void channel_filter_cleanup_fn(struct ssh *, int, void *);

crypto/openssh/channels.h

93

typedef u_char *channel_outfilter_fn(struct ssh *, struct Channel *,

crypto/openssh/channels.h

97

typedef void channel_confirm_cb(struct ssh *, int, struct Channel *, void *);

crypto/openssh/channels.h

98

typedef void channel_confirm_abandon_cb(struct ssh *, struct Channel *, void *);

crypto/openssh/clientloop.c

1059

ok = channel_request_rforward_cancel(ssh, &fwd) == 0;

crypto/openssh/clientloop.c

1061

ok = channel_cancel_lport_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1064

ok = channel_cancel_lport_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1085

if (!channel_setup_local_fwd_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1091

if (channel_request_remote_forwarding(ssh, &fwd) < 0) {

crypto/openssh/clientloop.c

1171

process_escapes(struct ssh *ssh, Channel *c,

crypto/openssh/clientloop.c

1204

channel_force_close(ssh, c, 1);

crypto/openssh/clientloop.c

1242

channel_request_start(ssh, c->self, "break", 0);

crypto/openssh/clientloop.c

1243

if ((r = sshpkt_put_u32(ssh, 1000)) != 0 ||

crypto/openssh/clientloop.c

1244

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

1249

if (ssh->compat & SSH_BUG_NOREKEY)

crypto/openssh/clientloop.c

1294

channel_stop_listening(ssh);

crypto/openssh/clientloop.c

1325

s = channel_open_message(ssh);

crypto/openssh/clientloop.c

1340

process_cmdline(ssh);

crypto/openssh/clientloop.c

1393

client_process_buffered_input_packets(struct ssh *ssh)

crypto/openssh/clientloop.c

1395

ssh_dispatch_run_fatal(ssh, DISPATCH_NONBLOCK, &quit_pending);

crypto/openssh/clientloop.c

1414

client_filter_cleanup(struct ssh *ssh, int cid, void *ctx)

crypto/openssh/clientloop.c

1420

client_simple_escape_filter(struct ssh *ssh, Channel *c, char *buf, int len)

crypto/openssh/clientloop.c

1425

return process_escapes(ssh, c, c->input, c->output, c->extended,

crypto/openssh/clientloop.c

1430

client_channel_closed(struct ssh *ssh, int id, int force, void *arg)

crypto/openssh/clientloop.c

1432

channel_cancel_cleanup(ssh, id);

crypto/openssh/clientloop.c

1444

client_loop(struct ssh *ssh, int have_pty, int escape_char_arg,

crypto/openssh/clientloop.c

1497

connection_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/clientloop.c

1498

connection_out = ssh_packet_get_connection_out(ssh);

crypto/openssh/clientloop.c

1502

client_init_dispatch(ssh);

crypto/openssh/clientloop.c

1523

channel_register_filter(ssh, session_ident,

crypto/openssh/clientloop.c

1529

channel_register_cleanup(ssh, session_ident,

crypto/openssh/clientloop.c

1547

client_process_buffered_input_packets(ssh);

crypto/openssh/clientloop.c

1549

if (session_closed && !channel_still_open(ssh))

crypto/openssh/clientloop.c

1552

if (ssh_packet_is_rekeying(ssh)) {

crypto/openssh/clientloop.c

1557

if ((r = kex_start_rekex(ssh)) != 0)

crypto/openssh/clientloop.c

1565

if (ssh_packet_not_very_much_data_to_write(ssh))

crypto/openssh/clientloop.c

1566

channel_did_enqueue = channel_output_poll(ssh);

crypto/openssh/clientloop.c

1572

client_check_window_change(ssh);

crypto/openssh/clientloop.c

1582

client_wait_until_can_do_something(ssh, &pfd, &npfd_alloc,

crypto/openssh/clientloop.c

1592

channel_after_poll(ssh, pfd, npfd_active);

crypto/openssh/clientloop.c

1596

client_process_net_input(ssh);

crypto/openssh/clientloop.c

1602

if ((r = ssh_packet_check_rekey(ssh)) != 0)

crypto/openssh/clientloop.c

1610

if ((r = ssh_packet_write_poll(ssh)) != 0) {

crypto/openssh/clientloop.c

1611

sshpkt_fatal(ssh, r,

crypto/openssh/clientloop.c

1643

if ((r = sshpkt_start(ssh, SSH2_MSG_DISCONNECT)) != 0 ||

crypto/openssh/clientloop.c

1644

(r = sshpkt_put_u32(ssh, SSH2_DISCONNECT_BY_APPLICATION)) != 0 ||

crypto/openssh/clientloop.c

1645

(r = sshpkt_put_cstring(ssh, "disconnected by user")) != 0 ||

crypto/openssh/clientloop.c

1646

(r = sshpkt_put_cstring(ssh, "")) != 0 || /* language tag */

crypto/openssh/clientloop.c

1647

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/clientloop.c

1648

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/clientloop.c

1651

channel_free_all(ssh);

crypto/openssh/clientloop.c

1674

ssh_packet_get_bytes(ssh, &ibytes, &obytes);

crypto/openssh/clientloop.c

168

static void client_init_dispatch(struct ssh *ssh);

crypto/openssh/clientloop.c

1688

client_request_forwarded_tcpip(struct ssh *ssh, const char *request_type,

crypto/openssh/clientloop.c

1698

if ((r = sshpkt_get_cstring(ssh, &listen_address, NULL)) != 0 ||

crypto/openssh/clientloop.c

1699

(r = sshpkt_get_u32(ssh, &listen_port)) != 0 ||

crypto/openssh/clientloop.c

1700

(r = sshpkt_get_cstring(ssh, &originator_address, NULL)) != 0 ||

crypto/openssh/clientloop.c

1701

(r = sshpkt_get_u32(ssh, &originator_port)) != 0 ||

crypto/openssh/clientloop.c

1702

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/clientloop.c

1713

c = channel_connect_by_listen_address(ssh,

crypto/openssh/clientloop.c

1748

client_request_forwarded_streamlocal(struct ssh *ssh,

crypto/openssh/clientloop.c

1756

if ((r = sshpkt_get_cstring(ssh, &listen_path, NULL)) != 0 ||

crypto/openssh/clientloop.c

1757

(r = sshpkt_get_string(ssh, NULL, NULL)) != 0 || /* reserved */

crypto/openssh/clientloop.c

1758

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/clientloop.c

1763

c = channel_connect_by_listen_path(ssh, listen_path,

crypto/openssh/clientloop.c

1770

client_request_x11(struct ssh *ssh, const char *request_type, int rchan)

crypto/openssh/clientloop.c

1788

if ((r = sshpkt_get_cstring(ssh, &originator, NULL)) != 0 ||

crypto/openssh/clientloop.c

1789

(r = sshpkt_get_u32(ssh, &originator_port)) != 0 ||

crypto/openssh/clientloop.c

1790

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/clientloop.c

1797

sock = x11_connect_display(ssh);

crypto/openssh/clientloop.c

1800

c = channel_new(ssh, "x11-connection",

crypto/openssh/clientloop.c

1808

client_request_agent(struct ssh *ssh, const char *request_type, int rchan)

crypto/openssh/clientloop.c

1829

if ((r = ssh_agent_bind_hostkey(sock, ssh->kex->initial_hostkey,

crypto/openssh/clientloop.c

1830

ssh->kex->session_id, ssh->kex->initial_sig, 1)) == 0)

crypto/openssh/clientloop.c

1835

c = channel_new(ssh, "agent-connection",

crypto/openssh/clientloop.c

1844

client_request_tun_fwd(struct ssh *ssh, int tun_mode,

crypto/openssh/clientloop.c

1863

c = channel_new(ssh, "tun-connection", SSH_CHANNEL_OPENING, fd, fd, -1,

crypto/openssh/clientloop.c

1869

channel_register_filter(ssh, c->self, sys_tun_infilter,

crypto/openssh/clientloop.c

1874

channel_register_open_confirm(ssh, c->self, cb, cbctx);

crypto/openssh/clientloop.c

1876

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN)) != 0 ||

crypto/openssh/clientloop.c

1877

(r = sshpkt_put_cstring(ssh, "tun@openssh.com")) != 0 ||

crypto/openssh/clientloop.c

1878

(r = sshpkt_put_u32(ssh, c->self)) != 0 ||

crypto/openssh/clientloop.c

1879

(r = sshpkt_put_u32(ssh, c->local_window_max)) != 0 ||

crypto/openssh/clientloop.c

1880

(r = sshpkt_put_u32(ssh, c->local_maxpacket)) != 0 ||

crypto/openssh/clientloop.c

1881

(r = sshpkt_put_u32(ssh, tun_mode)) != 0 ||

crypto/openssh/clientloop.c

1882

(r = sshpkt_put_u32(ssh, remote_tun)) != 0 ||

crypto/openssh/clientloop.c

1883

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

1884

sshpkt_fatal(ssh, r, "%s: send reply", __func__);

crypto/openssh/clientloop.c

1891

client_input_channel_open(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/clientloop.c

1900

if ((r = sshpkt_get_cstring(ssh, &ctype, &len)) != 0 ||

crypto/openssh/clientloop.c

1901

(r = sshpkt_get_u32(ssh, &rchan)) != 0 ||

crypto/openssh/clientloop.c

1902

(r = sshpkt_get_u32(ssh, &rwindow)) != 0 ||

crypto/openssh/clientloop.c

1903

(r = sshpkt_get_u32(ssh, &rmaxpack)) != 0)

crypto/openssh/clientloop.c

1910

c = client_request_forwarded_tcpip(ssh, ctype, rchan, rwindow,

crypto/openssh/clientloop.c

1913

c = client_request_forwarded_streamlocal(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1915

c = client_request_x11(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1917

c = client_request_agent(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1928

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION)) != 0 ||

crypto/openssh/clientloop.c

1929

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/clientloop.c

1930

(r = sshpkt_put_u32(ssh, c->self)) != 0 ||

crypto/openssh/clientloop.c

1931

(r = sshpkt_put_u32(ssh, c->local_window)) != 0 ||

crypto/openssh/clientloop.c

1932

(r = sshpkt_put_u32(ssh, c->local_maxpacket)) != 0 ||

crypto/openssh/clientloop.c

1933

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

1934

sshpkt_fatal(ssh, r, "%s: send reply", __func__);

crypto/openssh/clientloop.c

1938

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE)) != 0 ||

crypto/openssh/clientloop.c

1939

(r = sshpkt_put_u32(ssh, rchan)) != 0 ||

crypto/openssh/clientloop.c

1940

(r = sshpkt_put_u32(ssh, SSH2_OPEN_ADMINISTRATIVELY_PROHIBITED)) != 0 ||

crypto/openssh/clientloop.c

1941

(r = sshpkt_put_cstring(ssh, "open failed")) != 0 ||

crypto/openssh/clientloop.c

1942

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/clientloop.c

1943

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

1944

sshpkt_fatal(ssh, r, "%s: send failure", __func__);

crypto/openssh/clientloop.c

1953

client_input_channel_req(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/clientloop.c

1961

if ((r = sshpkt_get_u32(ssh, &id)) != 0)

crypto/openssh/clientloop.c

1964

c = channel_lookup(ssh, id);

crypto/openssh/clientloop.c

1965

if (channel_proxy_upstream(c, type, seq, ssh))

crypto/openssh/clientloop.c

1967

if ((r = sshpkt_get_cstring(ssh, &rtype, NULL)) != 0 ||

crypto/openssh/clientloop.c

1968

(r = sshpkt_get_u8(ssh, &reply)) != 0)

crypto/openssh/clientloop.c

1978

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/clientloop.c

1980

chan_rcvd_eow(ssh, c);

crypto/openssh/clientloop.c

1982

if ((r = sshpkt_get_u32(ssh, &exitval)) != 0)

crypto/openssh/clientloop.c

1985

mux_exit_message(ssh, c, exitval);

crypto/openssh/clientloop.c

1996

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/clientloop.c

2002

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/clientloop.c

2004

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/clientloop.c

2005

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

2006

sshpkt_fatal(ssh, r, "%s: send failure", __func__);

crypto/openssh/clientloop.c

2330

client_global_hostkeys_prove_confirm(struct ssh *ssh, int type,

crypto/openssh/clientloop.c

2351

ssh->kex->hostkey_alg)) == KEY_RSA)

crypto/openssh/clientloop.c

2352

rsa_kexalg = ssh->kex->hostkey_alg;

crypto/openssh/clientloop.c

2369

ssh->kex->session_id)) != 0 ||

crypto/openssh/clientloop.c

2373

if ((r = sshpkt_get_string_direct(ssh, &sig, &siglen)) != 0) {

crypto/openssh/clientloop.c

2415

if ((r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/clientloop.c

2434

client_input_hostkeys(struct ssh *ssh)

crypto/openssh/clientloop.c

245

set_control_persist_exit_time(struct ssh *ssh)

crypto/openssh/clientloop.c

2454

while (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/clientloop.c

2457

if ((r = sshpkt_get_string_direct(ssh, &blob, &len)) != 0) {

crypto/openssh/clientloop.c

251

} else if (channel_still_open(ssh)) {

crypto/openssh/clientloop.c

2600

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/clientloop.c

2601

(r = sshpkt_put_cstring(ssh,

crypto/openssh/clientloop.c

2603

(r = sshpkt_put_u8(ssh, 1)) != 0) /* bool: want reply */

crypto/openssh/clientloop.c

2612

(r = sshpkt_put_stringb(ssh, buf)) != 0)

crypto/openssh/clientloop.c

2615

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

2640

client_input_global_request(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/clientloop.c

2646

if ((r = sshpkt_get_cstring(ssh, &rtype, NULL)) != 0 ||

crypto/openssh/clientloop.c

2647

(r = sshpkt_get_u8(ssh, &want_reply)) != 0)

crypto/openssh/clientloop.c

2652

success = client_input_hostkeys(ssh);

crypto/openssh/clientloop.c

2654

if ((r = sshpkt_start(ssh, success ? SSH2_MSG_REQUEST_SUCCESS :

crypto/openssh/clientloop.c

2656

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/clientloop.c

2657

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/clientloop.c

2667

client_send_env(struct ssh *ssh, int id, const char *name, const char *val)

crypto/openssh/clientloop.c

2672

channel_request_start(ssh, id, "env", 0);

crypto/openssh/clientloop.c

2673

if ((r = sshpkt_put_cstring(ssh, name)) != 0 ||

crypto/openssh/clientloop.c

2674

(r = sshpkt_put_cstring(ssh, val)) != 0 ||

crypto/openssh/clientloop.c

2675

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

2680

client_session2_setup(struct ssh *ssh, int id, int want_tty, int want_subsystem,

crypto/openssh/clientloop.c

2691

if ((c = channel_lookup(ssh, id)) == NULL)

crypto/openssh/clientloop.c

2694

ssh_packet_set_interactive(ssh, want_tty,

crypto/openssh/clientloop.c

2704

channel_request_start(ssh, id, "pty-req", 1);

crypto/openssh/clientloop.c

2705

client_expect_confirm(ssh, id, "PTY allocation", CONFIRM_TTY);

crypto/openssh/clientloop.c

2706

if ((r = sshpkt_put_cstring(ssh, term != NULL ? term : ""))

crypto/openssh/clientloop.c

2708

(r = sshpkt_put_u32(ssh, (u_int)ws.ws_col)) != 0 ||

crypto/openssh/clientloop.c

2709

(r = sshpkt_put_u32(ssh, (u_int)ws.ws_row)) != 0 ||

crypto/openssh/clientloop.c

2710

(r = sshpkt_put_u32(ssh, (u_int)ws.ws_xpixel)) != 0 ||

crypto/openssh/clientloop.c

2711

(r = sshpkt_put_u32(ssh, (u_int)ws.ws_ypixel)) != 0)

crypto/openssh/clientloop.c

2715

ssh_tty_make_modes(ssh, -1, tiop);

crypto/openssh/clientloop.c

2716

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

2746

client_send_env(ssh, id, name, val);

crypto/openssh/clientloop.c

2758

client_send_env(ssh, id, name, val);

crypto/openssh/clientloop.c

2769

channel_request_start(ssh, id, "subsystem", 1);

crypto/openssh/clientloop.c

2770

client_expect_confirm(ssh, id, "subsystem",

crypto/openssh/clientloop.c

2775

channel_request_start(ssh, id, "exec", 1);

crypto/openssh/clientloop.c

2776

client_expect_confirm(ssh, id, "exec", CONFIRM_CLOSE);

crypto/openssh/clientloop.c

2778

if ((r = sshpkt_put_stringb(ssh, cmd)) != 0 ||

crypto/openssh/clientloop.c

2779

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

2782

channel_request_start(ssh, id, "shell", 1);

crypto/openssh/clientloop.c

2783

client_expect_confirm(ssh, id, "shell", CONFIRM_CLOSE);

crypto/openssh/clientloop.c

2784

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

2793

client_init_dispatch(struct ssh *ssh)

crypto/openssh/clientloop.c

2795

ssh_dispatch_init(ssh, &dispatch_protocol_error);

crypto/openssh/clientloop.c

2797

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);

crypto/openssh/clientloop.c

2798

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_DATA, &channel_input_data);

crypto/openssh/clientloop.c

2799

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);

crypto/openssh/clientloop.c

2800

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);

crypto/openssh/clientloop.c

2801

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN, &client_input_channel_open);

crypto/openssh/clientloop.c

2802

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);

crypto/openssh/clientloop.c

2803

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);

crypto/openssh/clientloop.c

2804

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_REQUEST, &client_input_channel_req);

crypto/openssh/clientloop.c

2805

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);

crypto/openssh/clientloop.c

2806

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_SUCCESS, &channel_input_status_confirm);

crypto/openssh/clientloop.c

2807

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_FAILURE, &channel_input_status_confirm);

crypto/openssh/clientloop.c

2808

ssh_dispatch_set(ssh, SSH2_MSG_GLOBAL_REQUEST, &client_input_global_request);

crypto/openssh/clientloop.c

2811

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/clientloop.c

2814

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_FAILURE, &client_global_request_reply);

crypto/openssh/clientloop.c

2815

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_SUCCESS, &client_global_request_reply);

crypto/openssh/clientloop.c

289

client_x11_get_proto(struct ssh *ssh, const char *display,

crypto/openssh/clientloop.c

384

channel_set_x11_refuse_time(ssh,

crypto/openssh/clientloop.c

460

client_check_window_change(struct ssh *ssh)

crypto/openssh/clientloop.c

466

channel_send_window_changes(ssh);

crypto/openssh/clientloop.c

470

client_global_request_reply(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/clientloop.c

477

gc->cb(ssh, type, seq, gc->ctx);

crypto/openssh/clientloop.c

483

ssh_packet_set_alive_timeouts(ssh, 0);

crypto/openssh/clientloop.c

495

server_alive_check(struct ssh *ssh)

crypto/openssh/clientloop.c

499

if (ssh_packet_inc_alive_timeouts(ssh) > options.server_alive_count_max) {

crypto/openssh/clientloop.c

503

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/clientloop.c

504

(r = sshpkt_put_cstring(ssh, "keepalive@openssh.com")) != 0 ||

crypto/openssh/clientloop.c

505

(r = sshpkt_put_u8(ssh, 1)) != 0 || /* boolean: want reply */

crypto/openssh/clientloop.c

506

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

515

send_chaff(struct ssh *ssh)

crypto/openssh/clientloop.c

519

if (ssh->kex == NULL || (ssh->kex->flags & KEX_HAS_PING) == 0)

crypto/openssh/clientloop.c

527

if ((r = sshpkt_start(ssh, SSH2_MSG_PING)) != 0 ||

crypto/openssh/clientloop.c

528

(r = sshpkt_put_cstring(ssh, "PING!")) != 0 ||

crypto/openssh/clientloop.c

529

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/clientloop.c

576

obfuscate_keystroke_timing(struct ssh *ssh, struct timespec *timeout,

crypto/openssh/clientloop.c

592

if (!channel_tty_open(ssh) || quit_pending) {

crypto/openssh/clientloop.c

595

} else if (ssh_packet_is_rekeying(ssh)) {

crypto/openssh/clientloop.c

598

} else if (!ssh_packet_interactive_data_to_write(ssh) &&

crypto/openssh/clientloop.c

599

ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

603

ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

611

!ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

613

if (send_chaff(ssh))

crypto/openssh/clientloop.c

633

if (!active && ssh_packet_interactive_data_to_write(ssh) &&

crypto/openssh/clientloop.c

634

channel_did_enqueue && ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

665

return x11_channel_used_recently(ssh);

crypto/openssh/clientloop.c

684

client_wait_until_can_do_something(struct ssh *ssh, struct pollfd **pfdp,

crypto/openssh/clientloop.c

696

channel_prepare_poll(ssh, pfdp, npfd_allocp, npfd_activep, 2, &timeout);

crypto/openssh/clientloop.c

701

if (session_closed && !channel_still_open(ssh) &&

crypto/openssh/clientloop.c

702

!ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

709

oready = obfuscate_keystroke_timing(ssh, &timeout, channel_did_enqueue);

crypto/openssh/clientloop.c

715

(*pfdp)[1].events = (oready && ssh_packet_have_data_to_write(ssh)) ?

crypto/openssh/clientloop.c

723

set_control_persist_exit_time(ssh);

crypto/openssh/clientloop.c

728

if (options.rekey_interval > 0 && !ssh_packet_is_rekeying(ssh)) {

crypto/openssh/clientloop.c

730

ssh_packet_get_rekey_timeout(ssh));

crypto/openssh/clientloop.c

760

server_alive_check(ssh);

crypto/openssh/clientloop.c

791

client_process_net_input(struct ssh *ssh)

crypto/openssh/clientloop.c

800

if ((r = ssh_packet_process_read(ssh, connection_in)) == 0)

crypto/openssh/clientloop.c

815

client_status_confirm(struct ssh *ssh, int type, Channel *c, void *ctx)

crypto/openssh/clientloop.c

869

mux_tty_alloc_failed(ssh, c);

crypto/openssh/clientloop.c

871

chan_read_failed(ssh, c);

crypto/openssh/clientloop.c

872

chan_write_failed(ssh, c);

crypto/openssh/clientloop.c

879

client_abandon_status_confirm(struct ssh *ssh, Channel *c, void *ctx)

crypto/openssh/clientloop.c

885

client_expect_confirm(struct ssh *ssh, int id, const char *request,

crypto/openssh/clientloop.c

893

channel_register_status_confirm(ssh, id, client_status_confirm,

crypto/openssh/clientloop.c

985

process_cmdline(struct ssh *ssh)

crypto/openssh/clientloop.h

40

struct ssh;

crypto/openssh/clientloop.h

43

int client_loop(struct ssh *, int, int, int);

crypto/openssh/clientloop.h

44

int client_x11_get_proto(struct ssh *, const char *, const char *,

crypto/openssh/clientloop.h

46

void client_session2_setup(struct ssh *, int, int, int,

crypto/openssh/clientloop.h

48

char *client_request_tun_fwd(struct ssh *, int, int, int,

crypto/openssh/clientloop.h

54

void client_filter_cleanup(struct ssh *, int, void *);

crypto/openssh/clientloop.h

55

int client_simple_escape_filter(struct ssh *, Channel *, char *, int);

crypto/openssh/clientloop.h

58

typedef void global_confirm_cb(struct ssh *, int, u_int32_t, void *);

crypto/openssh/clientloop.h

63

void client_expect_confirm(struct ssh *, int, const char *,

crypto/openssh/clientloop.h

79

void muxserver_listen(struct ssh *);

crypto/openssh/clientloop.h

81

void mux_exit_message(struct ssh *, Channel *, int);

crypto/openssh/clientloop.h

82

void mux_tty_alloc_failed(struct ssh *ssh, Channel *);

crypto/openssh/compat.c

128

ssh->compat = 0;

crypto/openssh/compat.c

133

ssh->compat = check[i].bugs;

crypto/openssh/compat.c

142

compat_kex_proposal(struct ssh *ssh, const char *p)

crypto/openssh/compat.c

146

if ((ssh->compat & (SSH_BUG_CURVE25519PAD|SSH_OLD_DHGEX)) == 0)

crypto/openssh/compat.c

149

if ((ssh->compat & SSH_BUG_CURVE25519PAD) != 0)

crypto/openssh/compat.c

153

if ((ssh->compat & SSH_OLD_DHGEX) != 0) {

crypto/openssh/compat.c

42

compat_banner(struct ssh *ssh, const char *version)

crypto/openssh/compat.h

61

struct ssh;

crypto/openssh/compat.h

63

void compat_banner(struct ssh *, const char *);

crypto/openssh/compat.h

64

char *compat_kex_proposal(struct ssh *, const char *);

crypto/openssh/dispatch.c

106

ssh->dispatch[type] != NULL) {

crypto/openssh/dispatch.c

107

if (ssh->dispatch_skip_packets) {

crypto/openssh/dispatch.c

109

ssh->dispatch_skip_packets--;

crypto/openssh/dispatch.c

112

r = (*ssh->dispatch[type])(type, seqnr, ssh);

crypto/openssh/dispatch.c

116

r = sshpkt_disconnect(ssh,

crypto/openssh/dispatch.c

128

ssh_dispatch_run_fatal(struct ssh *ssh, int mode, volatile sig_atomic_t *done)

crypto/openssh/dispatch.c

132

if ((r = ssh_dispatch_run(ssh, mode, done)) != 0)

crypto/openssh/dispatch.c

133

sshpkt_fatal(ssh, r, "%s", __func__);

crypto/openssh/dispatch.c

40

dispatch_protocol_error(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/dispatch.c

45

if ((r = sshpkt_start(ssh, SSH2_MSG_UNIMPLEMENTED)) != 0 ||

crypto/openssh/dispatch.c

46

(r = sshpkt_put_u32(ssh, seq)) != 0 ||

crypto/openssh/dispatch.c

47

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/dispatch.c

48

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/dispatch.c

49

sshpkt_fatal(ssh, r, "%s", __func__);

crypto/openssh/dispatch.c

54

dispatch_protocol_ignore(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/dispatch.c

61

ssh_dispatch_init(struct ssh *ssh, dispatch_fn *dflt)

crypto/openssh/dispatch.c

65

ssh->dispatch[i] = dflt;

crypto/openssh/dispatch.c

69

ssh_dispatch_range(struct ssh *ssh, u_int from, u_int to, dispatch_fn *fn)

crypto/openssh/dispatch.c

76

ssh->dispatch[i] = fn;

crypto/openssh/dispatch.c

81

ssh_dispatch_set(struct ssh *ssh, int type, dispatch_fn *fn)

crypto/openssh/dispatch.c

83

ssh->dispatch[type] = fn;

crypto/openssh/dispatch.c

87

ssh_dispatch_run(struct ssh *ssh, int mode, volatile sig_atomic_t *done)

crypto/openssh/dispatch.c

95

r = ssh_packet_read_seqnr(ssh, &type, &seqnr);

crypto/openssh/dispatch.c

99

r = ssh_packet_read_poll_seqnr(ssh, &type, &seqnr);

crypto/openssh/dispatch.h

37

struct ssh;

crypto/openssh/dispatch.h

39

typedef int dispatch_fn(int, u_int32_t, struct ssh *);

crypto/openssh/dispatch.h

41

int dispatch_protocol_error(int, u_int32_t, struct ssh *);

crypto/openssh/dispatch.h

42

int dispatch_protocol_ignore(int, u_int32_t, struct ssh *);

crypto/openssh/dispatch.h

43

void ssh_dispatch_init(struct ssh *, dispatch_fn *);

crypto/openssh/dispatch.h

44

void ssh_dispatch_set(struct ssh *, int, dispatch_fn *);

crypto/openssh/dispatch.h

45

void ssh_dispatch_range(struct ssh *, u_int, u_int, dispatch_fn *);

crypto/openssh/dispatch.h

46

int ssh_dispatch_run(struct ssh *, int, volatile sig_atomic_t *);

crypto/openssh/dispatch.h

47

void ssh_dispatch_run_fatal(struct ssh *, int, volatile sig_atomic_t *);

crypto/openssh/kex.c

1014

(r = choose_mac(ssh, &newkeys->mac, cprop[nmac],

crypto/openssh/kex.c

1050

ssh->dispatch_skip_packets = 1;

crypto/openssh/kex.c

1059

derive_key(struct ssh *ssh, int id, u_int need, u_char *hash, u_int hashlen,

crypto/openssh/kex.c

1062

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

107

if ((cp = kex_names_cat(kexalgos, ssh->kex->server ?

crypto/openssh/kex.c

1124

kex_derive_keys(struct ssh *ssh, u_char *hash, u_int hashlen,

crypto/openssh/kex.c

1127

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1145

if ((r = derive_key(ssh, 'A'+i, kex->we_need, hash, hashlen,

crypto/openssh/kex.c

115

prop[i] = compat_kex_proposal(ssh, cp);

crypto/openssh/kex.c

1163

kex_load_hostkey(struct ssh *ssh, struct sshkey **prvp, struct sshkey **pubp)

crypto/openssh/kex.c

1165

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1175

kex->hostkey_nid, ssh);

crypto/openssh/kex.c

1177

kex->hostkey_nid, ssh);

crypto/openssh/kex.c

1184

kex_verify_host_key(struct ssh *ssh, struct sshkey *server_host_key)

crypto/openssh/kex.c

1186

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1196

if (kex->verify_host_key(server_host_key, ssh) == -1)

crypto/openssh/kex.c

1215

send_error(struct ssh *ssh, char *msg)

crypto/openssh/kex.c

1219

if (!ssh->kex->server)

crypto/openssh/kex.c

1222

if (atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1224

atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1235

kex_exchange_identification(struct ssh *ssh, int timeout_ms,

crypto/openssh/kex.c

1242

struct sshbuf *our_version = ssh->kex->server ?

crypto/openssh/kex.c

1243

ssh->kex->server_version : ssh->kex->client_version;

crypto/openssh/kex.c

1244

struct sshbuf *peer_version = ssh->kex->server ?

crypto/openssh/kex.c

1245

ssh->kex->client_version : ssh->kex->server_version;

crypto/openssh/kex.c

1262

if (atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1286

send_error(ssh, "No SSH identification string "

crypto/openssh/kex.c

1297

r = waitrfd(ssh_packet_get_connection_in(ssh),

crypto/openssh/kex.c

1300

send_error(ssh, "Timed out waiting "

crypto/openssh/kex.c

1314

len = atomicio(read, ssh_packet_get_connection_in(ssh),

crypto/openssh/kex.c

1358

if (ssh->kex->server) {

crypto/openssh/kex.c

1386

send_error(ssh, "Invalid SSH identification string.");

crypto/openssh/kex.c

1392

compat_banner(ssh, remote_version);

crypto/openssh/kex.c

1409

send_error(ssh, "Protocol major versions differ.");

crypto/openssh/kex.c

1414

if (ssh->kex->server && (ssh->compat & SSH_BUG_PROBE) != 0) {

crypto/openssh/kex.c

1416

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/kex.c

1421

if (ssh->kex->server && (ssh->compat & SSH_BUG_SCANNER) != 0) {

crypto/openssh/kex.c

1423

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/kex.c

236

kex_protocol_error(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kex.c

241

if ((ssh->kex->flags & KEX_INITIAL) && ssh->kex->kex_strict) {

crypto/openssh/kex.c

242

ssh_packet_disconnect(ssh, "strict KEX violation: "

crypto/openssh/kex.c

246

if ((r = sshpkt_start(ssh, SSH2_MSG_UNIMPLEMENTED)) != 0 ||

crypto/openssh/kex.c

247

(r = sshpkt_put_u32(ssh, seq)) != 0 ||

crypto/openssh/kex.c

248

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kex.c

254

kex_reset_dispatch(struct ssh *ssh)

crypto/openssh/kex.c

256

ssh_dispatch_range(ssh, SSH2_MSG_TRANSPORT_MIN,

crypto/openssh/kex.c

261

kex_set_server_sig_algs(struct ssh *ssh, const char *allowed_algs)

crypto/openssh/kex.c

276

free(ssh->kex->server_sig_algs);

crypto/openssh/kex.c

277

ssh->kex->server_sig_algs = NULL;

crypto/openssh/kex.c

285

if (ssh->kex->server_sig_algs != NULL &&

crypto/openssh/kex.c

286

kex_has_any_alg(sigalg, ssh->kex->server_sig_algs))

crypto/openssh/kex.c

288

xextendf(&ssh->kex->server_sig_algs, ",", "%s", sigalg);

crypto/openssh/kex.c

292

if (ssh->kex->server_sig_algs == NULL)

crypto/openssh/kex.c

293

ssh->kex->server_sig_algs = xstrdup("");

crypto/openssh/kex.c

297

kex_compose_ext_info_server(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/kex.c

301

if (ssh->kex->server_sig_algs == NULL &&

crypto/openssh/kex.c

302

(ssh->kex->server_sig_algs = sshkey_alg_list(0, 1, 1, ',')) == NULL)

crypto/openssh/kex.c

306

(r = sshbuf_put_cstring(m, ssh->kex->server_sig_algs)) != 0 ||

crypto/openssh/kex.c

319

kex_compose_ext_info_client(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/kex.c

336

kex_maybe_send_ext_info(struct ssh *ssh)

crypto/openssh/kex.c

341

if ((ssh->kex->flags & KEX_INITIAL) == 0)

crypto/openssh/kex.c

343

if (!ssh->kex->ext_info_c && !ssh->kex->ext_info_s)

crypto/openssh/kex.c

349

if (ssh->kex->ext_info_c &&

crypto/openssh/kex.c

350

(r = kex_compose_ext_info_server(ssh, m)) != 0)

crypto/openssh/kex.c

352

if (ssh->kex->ext_info_s &&

crypto/openssh/kex.c

353

(r = kex_compose_ext_info_client(ssh, m)) != 0)

crypto/openssh/kex.c

358

if ((r = sshpkt_start(ssh, SSH2_MSG_EXT_INFO)) != 0 ||

crypto/openssh/kex.c

359

(r = sshpkt_putb(ssh, m)) != 0 ||

crypto/openssh/kex.c

360

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/kex.c

373

kex_server_update_ext_info(struct ssh *ssh)

crypto/openssh/kex.c

377

if ((ssh->kex->flags & KEX_HAS_EXT_INFO_IN_AUTH) == 0)

crypto/openssh/kex.c

381

if ((r = sshpkt_start(ssh, SSH2_MSG_EXT_INFO)) != 0 ||

crypto/openssh/kex.c

382

(r = sshpkt_put_u32(ssh, 1)) != 0 ||

crypto/openssh/kex.c

383

(r = sshpkt_put_cstring(ssh, "server-sig-algs")) != 0 ||

crypto/openssh/kex.c

384

(r = sshpkt_put_cstring(ssh, ssh->kex->server_sig_algs)) != 0 ||

crypto/openssh/kex.c

385

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/kex.c

393

kex_send_newkeys(struct ssh *ssh)

crypto/openssh/kex.c

397

kex_reset_dispatch(ssh);

crypto/openssh/kex.c

398

if ((r = sshpkt_start(ssh, SSH2_MSG_NEWKEYS)) != 0 ||

crypto/openssh/kex.c

399

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kex.c

402

ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_input_newkeys);

crypto/openssh/kex.c

403

if ((r = kex_maybe_send_ext_info(ssh)) != 0)

crypto/openssh/kex.c

427

kex_ext_info_client_parse(struct ssh *ssh, const char *name,

crypto/openssh/kex.c

440

free(ssh->kex->server_sig_algs);

crypto/openssh/kex.c

441

ssh->kex->server_sig_algs = xstrdup((const char *)value);

crypto/openssh/kex.c

442

} else if (ssh->kex->ext_info_received == 1 &&

crypto/openssh/kex.c

444

if ((r = kex_ext_info_check_ver(ssh->kex, name, value, vlen,

crypto/openssh/kex.c

448

} else if (ssh->kex->ext_info_received == 1 &&

crypto/openssh/kex.c

450

if ((r = kex_ext_info_check_ver(ssh->kex, name, value, vlen,

crypto/openssh/kex.c

461

kex_ext_info_server_parse(struct ssh *ssh, const char *name,

crypto/openssh/kex.c

467

if ((r = kex_ext_info_check_ver(ssh->kex, name, value, vlen,

crypto/openssh/kex.c

477

kex_input_ext_info(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kex.c

479

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

490

return dispatch_protocol_error(type, seq, ssh);

crypto/openssh/kex.c

492

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &kex_protocol_error);

crypto/openssh/kex.c

493

if ((r = sshpkt_get_u32(ssh, &ninfo)) != 0)

crypto/openssh/kex.c

498

return dispatch_protocol_error(type, seq, ssh);

crypto/openssh/kex.c

501

if ((r = sshpkt_get_cstring(ssh, &name, NULL)) != 0)

crypto/openssh/kex.c

503

if ((r = sshpkt_get_string(ssh, &val, &vlen)) != 0) {

crypto/openssh/kex.c

509

if ((r = kex_ext_info_server_parse(ssh, name,

crypto/openssh/kex.c

513

if ((r = kex_ext_info_client_parse(ssh, name,

crypto/openssh/kex.c

520

return sshpkt_get_end(ssh);

crypto/openssh/kex.c

524

kex_input_newkeys(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kex.c

526

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

532

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &kex_input_ext_info);

crypto/openssh/kex.c

533

ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_protocol_error);

crypto/openssh/kex.c

534

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/kex.c

535

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/kex.c

537

if ((r = ssh_set_newkeys(ssh, MODE_IN)) != 0)

crypto/openssh/kex.c

552

if ((r = kex_prop2buf(ssh->kex->my, prop)) != 0) {

crypto/openssh/kex.c

572

kex_send_kexinit(struct ssh *ssh)

crypto/openssh/kex.c

575

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

598

if ((r = sshpkt_start(ssh, SSH2_MSG_KEXINIT)) != 0 ||

crypto/openssh/kex.c

599

(r = sshpkt_putb(ssh, kex->my)) != 0 ||

crypto/openssh/kex.c

600

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/kex.c

610

kex_input_kexinit(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kex.c

612

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

623

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_protocol_error);

crypto/openssh/kex.c

624

ptr = sshpkt_ptr(ssh, &dlen);

crypto/openssh/kex.c

630

if ((r = sshpkt_get_u8(ssh, NULL)) != 0) {

crypto/openssh/kex.c

636

if ((r = sshpkt_get_string(ssh, NULL, NULL)) != 0) {

crypto/openssh/kex.c

651

if ((r = sshpkt_get_u8(ssh, NULL)) != 0 || /* first_kex_follows */

crypto/openssh/kex.c

652

(r = sshpkt_get_u32(ssh, NULL)) != 0 || /* reserved */

crypto/openssh/kex.c

653

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/kex.c

657

if ((r = kex_send_kexinit(ssh)) != 0)

crypto/openssh/kex.c

659

if ((r = kex_choose_conf(ssh, seq)) != 0)

crypto/openssh/kex.c

663

return (kex->kex[kex->kex_type])(ssh);

crypto/openssh/kex.c

68

static int kex_choose_conf(struct ssh *, uint32_t seq);

crypto/openssh/kex.c

69

static int kex_input_newkeys(int, u_int32_t, struct ssh *);

crypto/openssh/kex.c

749

kex_ready(struct ssh *ssh, char *proposal[PROPOSAL_MAX])

crypto/openssh/kex.c

753

if ((r = kex_prop2buf(ssh->kex->my, proposal)) != 0)

crypto/openssh/kex.c

755

ssh->kex->flags = KEX_INITIAL;

crypto/openssh/kex.c

756

kex_reset_dispatch(ssh);

crypto/openssh/kex.c

757

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/kex.c

762

kex_setup(struct ssh *ssh, char *proposal[PROPOSAL_MAX])

crypto/openssh/kex.c

766

if ((r = kex_ready(ssh, proposal)) != 0)

crypto/openssh/kex.c

768

if ((r = kex_send_kexinit(ssh)) != 0) { /* we start */

crypto/openssh/kex.c

769

kex_free(ssh->kex);

crypto/openssh/kex.c

770

ssh->kex = NULL;

crypto/openssh/kex.c

781

kex_start_rekex(struct ssh *ssh)

crypto/openssh/kex.c

783

if (ssh->kex == NULL) {

crypto/openssh/kex.c

787

if (ssh->kex->done == 0) {

crypto/openssh/kex.c

791

ssh->kex->done = 0;

crypto/openssh/kex.c

792

return kex_send_kexinit(ssh);

crypto/openssh/kex.c

818

choose_mac(struct ssh *ssh, struct sshmac *mac, char *client, char *server)

crypto/openssh/kex.c

91

kex_proposal_populate_entries(struct ssh *ssh, char *prop[PROPOSAL_MAX],

crypto/openssh/kex.c

926

kex_choose_conf(struct ssh *ssh, uint32_t seq)

crypto/openssh/kex.c

928

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

965

ssh_packet_disconnect(ssh,

crypto/openssh/kex.c

97

const char **defprop = ssh->kex->server ? defpropserver : defpropclient;

crypto/openssh/kex.h

139

struct ssh;

crypto/openssh/kex.h

169

int (*verify_host_key)(struct sshkey *, struct ssh *);

crypto/openssh/kex.h

170

struct sshkey *(*load_host_public_key)(int, int, struct ssh *);

crypto/openssh/kex.h

171

struct sshkey *(*load_host_private_key)(int, int, struct ssh *);

crypto/openssh/kex.h

172

int (*host_key_index)(struct sshkey *, int, struct ssh *);

crypto/openssh/kex.h

173

int (*sign)(struct ssh *, struct sshkey *, struct sshkey *,

crypto/openssh/kex.h

175

int (*kex[KEX_MAX])(struct ssh *);

crypto/openssh/kex.h

197

void kex_proposal_populate_entries(struct ssh *, char *prop[PROPOSAL_MAX],

crypto/openssh/kex.h

201

int kex_exchange_identification(struct ssh *, int, const char *);

crypto/openssh/kex.h

204

int kex_ready(struct ssh *, char *[PROPOSAL_MAX]);

crypto/openssh/kex.h

205

int kex_setup(struct ssh *, char *[PROPOSAL_MAX]);

crypto/openssh/kex.h

212

int kex_load_hostkey(struct ssh *, struct sshkey **, struct sshkey **);

crypto/openssh/kex.h

213

int kex_verify_host_key(struct ssh *, struct sshkey *);

crypto/openssh/kex.h

215

int kex_send_kexinit(struct ssh *);

crypto/openssh/kex.h

216

int kex_input_kexinit(int, u_int32_t, struct ssh *);

crypto/openssh/kex.h

217

int kex_input_ext_info(int, u_int32_t, struct ssh *);

crypto/openssh/kex.h

218

int kex_protocol_error(int, u_int32_t, struct ssh *);

crypto/openssh/kex.h

219

int kex_derive_keys(struct ssh *, u_char *, u_int, const struct sshbuf *);

crypto/openssh/kex.h

220

int kex_send_newkeys(struct ssh *);

crypto/openssh/kex.h

221

int kex_start_rekex(struct ssh *);

crypto/openssh/kex.h

222

int kex_server_update_ext_info(struct ssh *);

crypto/openssh/kex.h

223

void kex_set_server_sig_algs(struct ssh *, const char *);

crypto/openssh/kex.h

225

int kexgex_client(struct ssh *);

crypto/openssh/kex.h

226

int kexgex_server(struct ssh *);

crypto/openssh/kex.h

227

int kex_gen_client(struct ssh *);

crypto/openssh/kex.h

228

int kex_gen_server(struct ssh *);

crypto/openssh/kexgen.c

101

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

132

if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_ECDH_INIT)) != 0 ||

crypto/openssh/kexgen.c

133

(r = sshpkt_put_stringb(ssh, kex->client_pub)) != 0 ||

crypto/openssh/kexgen.c

134

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kexgen.c

137

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &input_kex_gen_reply);

crypto/openssh/kexgen.c

142

input_kex_gen_reply(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kexgen.c

144

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

155

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &kex_protocol_error);

crypto/openssh/kexgen.c

158

if ((r = sshpkt_getb_froms(ssh, &server_host_key_blob)) != 0)

crypto/openssh/kexgen.c

167

if ((r = kex_verify_host_key(ssh, server_host_key)) != 0)

crypto/openssh/kexgen.c

172

if ((r = sshpkt_getb_froms(ssh, &server_blob)) != 0 ||

crypto/openssh/kexgen.c

173

(r = sshpkt_get_string(ssh, &signature, &slen)) != 0 ||

crypto/openssh/kexgen.c

174

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/kexgen.c

225

kex->hostkey_alg, ssh->compat, NULL)) != 0)

crypto/openssh/kexgen.c

228

if ((r = kex_derive_keys(ssh, hash, hashlen, shared_secret)) != 0 ||

crypto/openssh/kexgen.c

229

(r = kex_send_newkeys(ssh)) != 0)

crypto/openssh/kexgen.c

267

kex_gen_server(struct ssh *ssh)

crypto/openssh/kexgen.c

270

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_INIT, &input_kex_gen_init);

crypto/openssh/kexgen.c

275

input_kex_gen_init(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kexgen.c

277

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

288

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_INIT, &kex_protocol_error);

crypto/openssh/kexgen.c

290

if ((r = kex_load_hostkey(ssh, &server_host_private,

crypto/openssh/kexgen.c

294

if ((r = sshpkt_getb_froms(ssh, &client_pubkey)) != 0 ||

crypto/openssh/kexgen.c

295

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/kexgen.c

355

if ((r = kex->sign(ssh, server_host_private, server_host_public,

crypto/openssh/kexgen.c

360

if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_ECDH_REPLY)) != 0 ||

crypto/openssh/kexgen.c

361

(r = sshpkt_put_stringb(ssh, server_host_key_blob)) != 0 ||

crypto/openssh/kexgen.c

362

(r = sshpkt_put_stringb(ssh, server_pubkey)) != 0 ||

crypto/openssh/kexgen.c

363

(r = sshpkt_put_string(ssh, signature, slen)) != 0 ||

crypto/openssh/kexgen.c

364

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kexgen.c

367

if ((r = kex_derive_keys(ssh, hash, hashlen, shared_secret)) != 0 ||

crypto/openssh/kexgen.c

368

(r = kex_send_newkeys(ssh)) != 0)

crypto/openssh/kexgen.c

44

static int input_kex_gen_init(int, u_int32_t, struct ssh *);

crypto/openssh/kexgen.c

45

static int input_kex_gen_reply(int type, u_int32_t seq, struct ssh *ssh);

crypto/openssh/kexgen.c

99

kex_gen_client(struct ssh *ssh)

crypto/openssh/kexgexc.c

103

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP, &kex_protocol_error);

crypto/openssh/kexgexc.c

105

if ((r = sshpkt_get_bignum2(ssh, &p)) != 0 ||

crypto/openssh/kexgexc.c

106

(r = sshpkt_get_bignum2(ssh, &g)) != 0 ||

crypto/openssh/kexgexc.c

107

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/kexgexc.c

124

if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_INIT)) != 0 ||

crypto/openssh/kexgexc.c

125

(r = sshpkt_put_bignum2(ssh, pub_key)) != 0 ||

crypto/openssh/kexgexc.c

126

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kexgexc.c

136

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REPLY, &input_kex_dh_gex_reply);

crypto/openssh/kexgexc.c

145

input_kex_dh_gex_reply(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kexgexc.c

147

struct kex *kex = ssh->kex;

crypto/openssh/kexgexc.c

159

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REPLY, &kex_protocol_error);

crypto/openssh/kexgexc.c

162

if ((r = sshpkt_getb_froms(ssh, &server_host_key_blob)) != 0)

crypto/openssh/kexgexc.c

170

(r = kex_verify_host_key(ssh, server_host_key)) != 0)

crypto/openssh/kexgexc.c

173

if ((r = sshpkt_get_bignum2(ssh, &dh_server_pub)) != 0 ||

crypto/openssh/kexgexc.c

174

(r = sshpkt_get_string(ssh, &signature, &slen)) != 0 ||

crypto/openssh/kexgexc.c

175

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/kexgexc.c

183

if (ssh->compat & SSH_OLD_DHGEX)

crypto/openssh/kexgexc.c

206

hashlen, kex->hostkey_alg, ssh->compat, NULL)) != 0)

crypto/openssh/kexgexc.c

209

if ((r = kex_derive_keys(ssh, hash, hashlen, shared_secret)) != 0 ||

crypto/openssh/kexgexc.c

210

(r = kex_send_newkeys(ssh)) != 0)

crypto/openssh/kexgexc.c

56

static int input_kex_dh_gex_group(int, u_int32_t, struct ssh *);

crypto/openssh/kexgexc.c

57

static int input_kex_dh_gex_reply(int, u_int32_t, struct ssh *);

crypto/openssh/kexgexc.c

60

kexgex_client(struct ssh *ssh)

crypto/openssh/kexgexc.c

62

struct kex *kex = ssh->kex;

crypto/openssh/kexgexc.c

71

if (ssh->compat & SSH_BUG_DHGEX_LARGE)

crypto/openssh/kexgexc.c

74

if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST)) != 0 ||

crypto/openssh/kexgexc.c

75

(r = sshpkt_put_u32(ssh, kex->min)) != 0 ||

crypto/openssh/kexgexc.c

76

(r = sshpkt_put_u32(ssh, kex->nbits)) != 0 ||

crypto/openssh/kexgexc.c

77

(r = sshpkt_put_u32(ssh, kex->max)) != 0 ||

crypto/openssh/kexgexc.c

78

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kexgexc.c

87

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP,

crypto/openssh/kexgexc.c

95

input_kex_dh_gex_group(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kexgexc.c

97

struct kex *kex = ssh->kex;

crypto/openssh/kexgexs.c

103

(void)sshpkt_disconnect(ssh, "no matching DH grp found");

crypto/openssh/kexgexs.c

109

if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_GROUP)) != 0 ||

crypto/openssh/kexgexs.c

110

(r = sshpkt_put_bignum2(ssh, dh_p)) != 0 ||

crypto/openssh/kexgexs.c

111

(r = sshpkt_put_bignum2(ssh, dh_g)) != 0 ||

crypto/openssh/kexgexs.c

112

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kexgexs.c

120

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_INIT, &input_kex_dh_gex_init);

crypto/openssh/kexgexs.c

127

input_kex_dh_gex_init(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kexgexs.c

129

struct kex *kex = ssh->kex;

crypto/openssh/kexgexs.c

141

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_INIT, &kex_protocol_error);

crypto/openssh/kexgexs.c

143

if ((r = kex_load_hostkey(ssh, &server_host_private,

crypto/openssh/kexgexs.c

148

if ((r = sshpkt_get_bignum2(ssh, &dh_client_pub)) != 0 ||

crypto/openssh/kexgexs.c

149

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/kexgexs.c

184

if ((r = kex->sign(ssh, server_host_private, server_host_public,

crypto/openssh/kexgexs.c

189

if ((r = sshpkt_start(ssh, SSH2_MSG_KEX_DH_GEX_REPLY)) != 0 ||

crypto/openssh/kexgexs.c

190

(r = sshpkt_put_stringb(ssh, server_host_key_blob)) != 0 ||

crypto/openssh/kexgexs.c

191

(r = sshpkt_put_bignum2(ssh, pub_key)) != 0 || /* f */

crypto/openssh/kexgexs.c

192

(r = sshpkt_put_string(ssh, signature, slen)) != 0 ||

crypto/openssh/kexgexs.c

193

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/kexgexs.c

196

if ((r = kex_derive_keys(ssh, hash, hashlen, shared_secret)) != 0 ||

crypto/openssh/kexgexs.c

197

(r = kex_send_newkeys(ssh)) != 0)

crypto/openssh/kexgexs.c

58

static int input_kex_dh_gex_request(int, u_int32_t, struct ssh *);

crypto/openssh/kexgexs.c

59

static int input_kex_dh_gex_init(int, u_int32_t, struct ssh *);

crypto/openssh/kexgexs.c

62

kexgex_server(struct ssh *ssh)

crypto/openssh/kexgexs.c

64

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST,

crypto/openssh/kexgexs.c

71

input_kex_dh_gex_request(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/kexgexs.c

73

struct kex *kex = ssh->kex;

crypto/openssh/kexgexs.c

79

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST, &kex_protocol_error);

crypto/openssh/kexgexs.c

81

if ((r = sshpkt_get_u32(ssh, &min)) != 0 ||

crypto/openssh/kexgexs.c

82

(r = sshpkt_get_u32(ssh, &nbits)) != 0 ||

crypto/openssh/kexgexs.c

83

(r = sshpkt_get_u32(ssh, &max)) != 0 ||

crypto/openssh/kexgexs.c

84

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/loginrec.c

1711

record_failed_login(struct ssh *ssh, const char *username, const char *hostname,

crypto/openssh/loginrec.c

1748

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/loginrec.c

1749

(void)getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/loginrec.h

134

void record_failed_login(struct ssh *, const char *, const char *,

crypto/openssh/loginrec.h

34

struct ssh;

crypto/openssh/monitor.c

1000

mm_answer_authpassword(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1013

auth_password(ssh, passwd);

crypto/openssh/monitor.c

1040

mm_answer_bsdauthquery(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1074

mm_answer_bsdauthrespond(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1108

mm_answer_pam_start(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1113

start_pam(ssh);

crypto/openssh/monitor.c

1123

mm_answer_pam_account(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1146

mm_answer_pam_init_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1171

mm_answer_pam_query(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

120

int mm_answer_moduli(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

121

int mm_answer_sign(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1212

mm_answer_pam_respond(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

122

int mm_answer_pwnamallow(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

123

int mm_answer_auth2_read_banner(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

124

int mm_answer_authserv(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

125

int mm_answer_authpassword(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1254

mm_answer_pam_free_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

126

int mm_answer_bsdauthquery(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

127

int mm_answer_bsdauthrespond(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1274

mm_answer_keyallowed(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

128

int mm_answer_keyallowed(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

129

int mm_answer_keyverify(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

130

int mm_answer_pty(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1302

allowed = user_key_allowed(ssh, authctxt->pw, key,

crypto/openssh/monitor.c

131

int mm_answer_pty_cleanup(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1314

allowed = hostbased_key_allowed(ssh, authctxt->pw,

crypto/openssh/monitor.c

132

int mm_answer_term(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

133

int mm_answer_state(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1346

auth_log(ssh, 0, 0, auth_method, NULL);

crypto/openssh/monitor.c

136

int mm_answer_pam_start(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1366

monitor_valid_userblob(struct ssh *ssh, const u_char *data, u_int datalen)

crypto/openssh/monitor.c

137

int mm_answer_pam_account(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1379

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/monitor.c

138

int mm_answer_pam_init_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

139

int mm_answer_pam_query(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

140

int mm_answer_pam_respond(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

141

int mm_answer_pam_free_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1439

if (get_hostkey_index(hostkey, 1, ssh) == -1)

crypto/openssh/monitor.c

145

int mm_answer_gss_setup_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

146

int mm_answer_gss_accept_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

147

int mm_answer_gss_userok(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

148

int mm_answer_gss_checkmic(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1516

mm_answer_keyverify(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

152

int mm_answer_audit_event(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

153

int mm_answer_audit_command(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1548

valid_data = monitor_valid_userblob(ssh, data, datalen);

crypto/openssh/monitor.c

1570

sigalg, ssh->compat, &sig_details);

crypto/openssh/monitor.c

1587

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

1588

ssh_remote_port(ssh));

crypto/openssh/monitor.c

1599

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

1600

ssh_remote_port(ssh));

crypto/openssh/monitor.c

1607

auth_activate_options(ssh, key_opts);

crypto/openssh/monitor.c

1633

mm_record_login(struct ssh *ssh, Session *s, struct passwd *pw)

crypto/openssh/monitor.c

1644

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/monitor.c

1645

if (getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/monitor.c

1653

session_get_remote_name_or_ip(ssh, utmp_len, options.use_dns),

crypto/openssh/monitor.c

1669

mm_answer_pty(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1697

mm_record_login(ssh, s, authctxt->pw);

crypto/openssh/monitor.c

1739

mm_answer_pty_cleanup(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

175

int (*f)(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1757

mm_answer_term(struct ssh *ssh, int sock, struct sshbuf *req)

crypto/openssh/monitor.c

1765

session_destroy_all(ssh, &mm_session_close);

crypto/openssh/monitor.c

1785

mm_answer_audit_event(struct ssh *ssh, int socket, struct sshbuf *m)

crypto/openssh/monitor.c

1804

audit_event(ssh, event);

crypto/openssh/monitor.c

1814

mm_answer_audit_command(struct ssh *ssh, int socket, struct sshbuf *m)

crypto/openssh/monitor.c

1830

monitor_clear_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1832

ssh_clear_newkeys(ssh, MODE_IN);

crypto/openssh/monitor.c

1833

ssh_clear_newkeys(ssh, MODE_OUT);

crypto/openssh/monitor.c

1839

monitor_apply_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1845

if ((r = ssh_packet_set_state(ssh, child_state)) != 0)

crypto/openssh/monitor.c

1849

if ((kex = ssh->kex) == NULL)

crypto/openssh/monitor.c

1851

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

crypto/openssh/monitor.c

1853

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

crypto/openssh/monitor.c

1855

if (memcmp(sshbuf_ptr(ssh->kex->session_id), session_id2,

crypto/openssh/monitor.c

187

static int monitor_read(struct ssh *, struct monitor *, struct mon_table *,

crypto/openssh/monitor.c

1883

mm_get_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1953

mm_answer_gss_setup_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1986

mm_answer_gss_accept_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

2020

mm_answer_gss_checkmic(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

2051

mm_answer_gss_userok(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

274

monitor_child_preauth(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

287

authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/monitor.c

289

ssh->authctxt = authctxt;

crypto/openssh/monitor.c

306

authenticated = (monitor_read(ssh, pmonitor,

crypto/openssh/monitor.c

329

!auth_root_allowed(ssh, auth_method))

crypto/openssh/monitor.c

342

ssh, pmonitor->m_sendfd, m);

crypto/openssh/monitor.c

348

auth_log(ssh, authenticated, partial,

crypto/openssh/monitor.c

358

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL,

crypto/openssh/monitor.c

367

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL,

crypto/openssh/monitor.c

372

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL,

crypto/openssh/monitor.c

379

ssh->authctxt = NULL;

crypto/openssh/monitor.c

380

ssh_packet_set_log_preamble(ssh, "user %s", authctxt->user);

crypto/openssh/monitor.c

382

mm_get_keystate(ssh, pmonitor);

crypto/openssh/monitor.c

408

monitor_child_postauth(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

435

monitor_read(ssh, pmonitor, mon_dispatch, NULL);

crypto/openssh/monitor.c

492

monitor_read(struct ssh *ssh, struct monitor *pmonitor, struct mon_table *ent,

crypto/openssh/monitor.c

541

ret = (*ent->f)(ssh, pmonitor->m_sendfd, m);

crypto/openssh/monitor.c

590

mm_answer_state(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

643

(r = sshbuf_put_stringb(m, ssh->kex->server_version)) != 0 ||

crypto/openssh/monitor.c

644

(r = sshbuf_put_stringb(m, ssh->kex->client_version)) != 0 ||

crypto/openssh/monitor.c

667

mm_answer_moduli(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

707

mm_answer_sign(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

727

if ((keyid = get_hostkey_index(pubkey, 1, ssh)) == -1)

crypto/openssh/monitor.c

750

if ((key = get_hostkey_public_by_index(keyid, ssh)) == NULL)

crypto/openssh/monitor.c

778

} else if ((key = get_hostkey_public_by_index(keyid, ssh)) != NULL &&

crypto/openssh/monitor.c

841

mm_answer_pwnamallow(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

854

pwent = getpwnamallow(ssh, authctxt->user);

crypto/openssh/monitor.c

895

ssh_packet_set_log_preamble(ssh, "%suser %s",

crypto/openssh/monitor.c

902

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

903

ssh_remote_port(ssh));

crypto/openssh/monitor.c

935

int mm_answer_auth2_read_banner(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

951

mm_answer_authserv(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.h

69

struct ssh;

crypto/openssh/monitor.h

85

void monitor_child_preauth(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

86

void monitor_child_postauth(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

88

void monitor_clear_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

89

void monitor_apply_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

95

void mm_get_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor_wrap.c

1139

server_process_permitopen_list(struct ssh *ssh, int listen,

crypto/openssh/monitor_wrap.c

1148

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/monitor_wrap.c

1156

channel_disable_admin(ssh, where);

crypto/openssh/monitor_wrap.c

1169

channel_add_permission(ssh, FORWARD_ADM,

crypto/openssh/monitor_wrap.c

1179

server_process_permitopen(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

1181

server_process_permitopen_list(ssh, 0,

crypto/openssh/monitor_wrap.c

1183

server_process_permitopen_list(ssh, 1,

crypto/openssh/monitor_wrap.c

1188

server_process_channel_timeouts(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

1194

channel_clear_timeouts(ssh);

crypto/openssh/monitor_wrap.c

1201

channel_add_timeout(ssh, type, secs);

crypto/openssh/monitor_wrap.c

1207

server_get_connection_info(struct ssh *ssh, int populate, int use_dns)

crypto/openssh/monitor_wrap.c

1211

if (ssh == NULL || !populate)

crypto/openssh/monitor_wrap.c

1213

ci.host = use_dns ? ssh_remote_hostname(ssh) : ssh_remote_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1214

ci.address = ssh_remote_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1215

ci.laddress = ssh_local_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1216

ci.lport = ssh_local_port(ssh);

crypto/openssh/monitor_wrap.c

1217

ci.rdomain = ssh_packet_rdomain_in(ssh);

crypto/openssh/monitor_wrap.c

253

mm_sshkey_sign(struct ssh *ssh, struct sshkey *key, u_char **sigp, size_t *lenp,

crypto/openssh/monitor_wrap.c

283

mm_decode_activate_server_options(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/monitor_wrap.c

335

mm_getpwnamallow(struct ssh *ssh, const char *username)

crypto/openssh/monitor_wrap.c

387

mm_decode_activate_server_options(ssh, m);

crypto/openssh/monitor_wrap.c

388

server_process_permitopen(ssh);

crypto/openssh/monitor_wrap.c

389

server_process_channel_timeouts(ssh);

crypto/openssh/monitor_wrap.c

390

kex_set_server_sig_algs(ssh, options.pubkey_accepted_algos);

crypto/openssh/monitor_wrap.c

447

mm_auth_password(struct ssh *ssh, char *password)

crypto/openssh/monitor_wrap.c

484

mm_user_key_allowed(struct ssh *ssh, struct passwd *pw, struct sshkey *key,

crypto/openssh/monitor_wrap.c

492

mm_hostbased_key_allowed(struct ssh *ssh, struct passwd *pw,

crypto/openssh/monitor_wrap.c

599

mm_send_keystate(struct ssh *ssh, struct monitor *monitor)

crypto/openssh/monitor_wrap.c

606

if ((r = ssh_packet_get_state(ssh, m)) != 0)

crypto/openssh/monitor_wrap.c

691

mm_start_pam(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

857

mm_get_state(struct ssh *ssh, struct include_list *includes,

crypto/openssh/monitor_wrap.c

884

(r = sshbuf_get_stringb(m, ssh->kex->server_version)) != 0 ||

crypto/openssh/monitor_wrap.c

885

(r = sshbuf_get_stringb(m, ssh->kex->client_version)) != 0 ||

crypto/openssh/monitor_wrap.c

998

mm_audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/monitor_wrap.h

104

void server_process_permitopen(struct ssh *);

crypto/openssh/monitor_wrap.h

105

void server_process_channel_timeouts(struct ssh *ssh);

crypto/openssh/monitor_wrap.h

107

server_get_connection_info(struct ssh *, int, int);

crypto/openssh/monitor_wrap.h

33

struct ssh;

crypto/openssh/monitor_wrap.h

45

int mm_sshkey_sign(struct ssh *, struct sshkey *, u_char **, size_t *,

crypto/openssh/monitor_wrap.h

49

struct passwd *mm_getpwnamallow(struct ssh *, const char *);

crypto/openssh/monitor_wrap.h

51

int mm_auth_password(struct ssh *, char *);

crypto/openssh/monitor_wrap.h

54

int mm_user_key_allowed(struct ssh *ssh, struct passwd *, struct sshkey *, int,

crypto/openssh/monitor_wrap.h

56

int mm_hostbased_key_allowed(struct ssh *, struct passwd *, const char *,

crypto/openssh/monitor_wrap.h

61

void mm_decode_activate_server_options(struct ssh *ssh, struct sshbuf *m);

crypto/openssh/monitor_wrap.h

72

void mm_start_pam(struct ssh *ssh);

crypto/openssh/monitor_wrap.h

82

void mm_audit_event(struct ssh *, ssh_audit_event_t);

crypto/openssh/monitor_wrap.h

91

void mm_send_keystate(struct ssh *, struct monitor*);

crypto/openssh/monitor_wrap.h

95

void mm_get_state(struct ssh *, struct include_list *, struct sshbuf *,

crypto/openssh/mux.c

1032

nc = channel_connect_stdio_fwd(ssh, chost, cport, new_fd[0], new_fd[1],

crypto/openssh/mux.c

1042

channel_register_cleanup(ssh, nc->self,

crypto/openssh/mux.c

1047

channel_register_open_confirm(ssh, nc->self, mux_stdio_confirm, cctx);

crypto/openssh/mux.c

1056

mux_stdio_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/mux.c

1065

if ((c = channel_by_id(ssh, id)) == NULL)

crypto/openssh/mux.c

1067

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1102

mux_master_process_stop_listening(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

1119

channel_free(ssh, mux_listener_channel);

crypto/openssh/mux.c

1132

mux_master_process_proxy(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

1149

mux_master_read_cb(struct ssh *ssh, Channel *c)

crypto/openssh/mux.c

1163

channel_register_cleanup(ssh, c->self,

crypto/openssh/mux.c

1204

ret = mux_master_handlers[i].handler(ssh, rid,

crypto/openssh/mux.c

1225

mux_exit_message(struct ssh *ssh, Channel *c, int exitval)

crypto/openssh/mux.c

1233

if ((mux_chan = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1248

mux_tty_alloc_failed(struct ssh *ssh, Channel *c)

crypto/openssh/mux.c

1256

if ((mux_chan = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1271

muxserver_listen(struct ssh *ssh)

crypto/openssh/mux.c

1344

mux_listener_channel = channel_new(ssh, "mux listener",

crypto/openssh/mux.c

1355

mux_session_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/mux.c

1365

if ((c = channel_by_id(ssh, id)) == NULL)

crypto/openssh/mux.c

1367

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1385

if (client_x11_get_proto(ssh, display, options.xauth_location,

crypto/openssh/mux.c

1391

x11_request_forwarding_with_spoofing(ssh, id,

crypto/openssh/mux.c

1394

client_expect_confirm(ssh, id, "X11 forwarding",

crypto/openssh/mux.c

1401

channel_request_start(ssh, id, "auth-agent-req@openssh.com", 0);

crypto/openssh/mux.c

1402

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/mux.c

1406

client_session2_setup(ssh, id, cctx->want_tty, cctx->want_subsys,

crypto/openssh/mux.c

150

static void mux_session_confirm(struct ssh *, int, int, void *);

crypto/openssh/mux.c

151

static void mux_stdio_confirm(struct ssh *, int, int, void *);

crypto/openssh/mux.c

153

static int mux_master_process_hello(struct ssh *, u_int,

crypto/openssh/mux.c

155

static int mux_master_process_new_session(struct ssh *, u_int,

crypto/openssh/mux.c

157

static int mux_master_process_alive_check(struct ssh *, u_int,

crypto/openssh/mux.c

159

static int mux_master_process_terminate(struct ssh *, u_int,

crypto/openssh/mux.c

161

static int mux_master_process_open_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

163

static int mux_master_process_close_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

165

static int mux_master_process_stdio_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

167

static int mux_master_process_stop_listening(struct ssh *, u_int,

crypto/openssh/mux.c

169

static int mux_master_process_proxy(struct ssh *, u_int,

crypto/openssh/mux.c

174

int (*handler)(struct ssh *, u_int, Channel *,

crypto/openssh/mux.c

191

mux_master_session_cleanup_cb(struct ssh *ssh, int cid, int force, void *unused)

crypto/openssh/mux.c

193

Channel *cc, *c = channel_by_id(ssh, cid);

crypto/openssh/mux.c

199

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

205

chan_rcvd_oclose(ssh, cc);

crypto/openssh/mux.c

207

channel_cancel_cleanup(ssh, c->self);

crypto/openssh/mux.c

212

mux_master_control_cleanup_cb(struct ssh *ssh, int cid, int force, void *unused)

crypto/openssh/mux.c

214

Channel *sc, *c = channel_by_id(ssh, cid);

crypto/openssh/mux.c

220

if ((sc = channel_by_id(ssh, c->ctl_child_id)) == NULL)

crypto/openssh/mux.c

229

chan_mark_dead(ssh, sc);

crypto/openssh/mux.c

232

chan_read_failed(ssh, sc);

crypto/openssh/mux.c

234

chan_write_failed(ssh, sc);

crypto/openssh/mux.c

237

channel_cancel_cleanup(ssh, c->self);

crypto/openssh/mux.c

266

mux_master_process_hello(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

332

mux_master_process_new_session(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

460

nc = channel_new(ssh, "session", SSH_CHANNEL_OPENING,

crypto/openssh/mux.c

469

channel_register_filter(ssh, nc->self,

crypto/openssh/mux.c

478

channel_send_open(ssh, nc->self);

crypto/openssh/mux.c

479

channel_register_open_confirm(ssh, nc->self, mux_session_confirm, cctx);

crypto/openssh/mux.c

481

channel_register_cleanup(ssh, nc->self,

crypto/openssh/mux.c

489

mux_master_process_alive_check(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

506

mux_master_process_terminate(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

594

mux_confirm_remote_forward(struct ssh *ssh, int type, u_int32_t seq, void *ctxt)

crypto/openssh/mux.c

604

if ((c = channel_by_id(ssh, fctx->cid)) == NULL) {

crypto/openssh/mux.c

624

if ((r = sshpkt_get_u32(ssh, &port)) != 0)

crypto/openssh/mux.c

641

channel_update_permission(ssh, rfwd->handle,

crypto/openssh/mux.c

649

channel_update_permission(ssh, rfwd->handle, -1);

crypto/openssh/mux.c

682

mux_master_process_open_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

806

if (!channel_setup_local_fwd_listener(ssh, &fwd,

crypto/openssh/mux.c

819

fwd.handle = channel_request_remote_forwarding(ssh, &fwd);

crypto/openssh/mux.c

847

mux_master_process_close_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

929

if (channel_request_rforward_cancel(ssh, found_fwd) == -1)

crypto/openssh/mux.c

933

if (channel_cancel_lport_listener(ssh, &fwd, fwd.connect_port,

crypto/openssh/mux.c

959

mux_master_process_stdio_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/nchan.c

113

chan_read_failed(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

118

chan_shutdown_read(ssh, c);

crypto/openssh/nchan.c

129

chan_ibuf_empty(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

140

chan_send_eof2(ssh, c);

crypto/openssh/nchan.c

151

chan_obuf_empty(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

161

chan_shutdown_write(ssh, c);

crypto/openssh/nchan.c

172

chan_rcvd_eow(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

177

chan_shutdown_read(ssh, c);

crypto/openssh/nchan.c

184

chan_send_eof2(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

193

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_EOF)) != 0 ||

crypto/openssh/nchan.c

194

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/nchan.c

195

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/nchan.c

207

chan_send_close2(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

223

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_CLOSE)) != 0 ||

crypto/openssh/nchan.c

224

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/nchan.c

225

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/nchan.c

232

chan_send_eow2(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

242

if (!(ssh->compat & SSH_NEW_OPENSSH))

crypto/openssh/nchan.c

246

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_REQUEST)) != 0 ||

crypto/openssh/nchan.c

247

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/nchan.c

248

(r = sshpkt_put_cstring(ssh, "eow@openssh.com")) != 0 ||

crypto/openssh/nchan.c

249

(r = sshpkt_put_u8(ssh, 0)) != 0 ||

crypto/openssh/nchan.c

250

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/nchan.c

257

chan_rcvd_ieof(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

266

chan_obuf_empty(ssh, c);

crypto/openssh/nchan.c

270

chan_rcvd_oclose(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

296

chan_shutdown_read(ssh, c);

crypto/openssh/nchan.c

297

chan_shutdown_extended_read(ssh, c);

crypto/openssh/nchan.c

302

chan_send_eof2(ssh, c);

crypto/openssh/nchan.c

303

chan_shutdown_extended_read(ssh, c);

crypto/openssh/nchan.c

310

chan_write_failed(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

316

chan_shutdown_write(ssh, c);

crypto/openssh/nchan.c

318

chan_send_eow2(ssh, c);

crypto/openssh/nchan.c

329

chan_mark_dead(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

335

chan_is_dead(struct ssh *ssh, Channel *c, int do_send)

crypto/openssh/nchan.c

343

if ((ssh->compat & SSH_BUG_EXTEOF) &&

crypto/openssh/nchan.c

357

chan_send_close2(ssh, c);

crypto/openssh/nchan.c

377

chan_shutdown_write(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

393

if (channel_close_fd(ssh, c, &c->wfd) < 0) {

crypto/openssh/nchan.c

402

chan_shutdown_read(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

421

if (channel_close_fd(ssh, c, &c->rfd) < 0) {

crypto/openssh/nchan.c

430

chan_shutdown_extended_read(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

440

if (channel_close_fd(ssh, c, &c->efd) < 0) {

crypto/openssh/nchan.c

77

static void chan_send_eof2(struct ssh *, Channel *);

crypto/openssh/nchan.c

78

static void chan_send_eow2(struct ssh *, Channel *);

crypto/openssh/nchan.c

81

static void chan_shutdown_write(struct ssh *, Channel *);

crypto/openssh/nchan.c

82

static void chan_shutdown_read(struct ssh *, Channel *);

crypto/openssh/nchan.c

83

static void chan_shutdown_extended_read(struct ssh *, Channel *);

crypto/openssh/openbsd-compat/port-aix.c

176

sys_auth_passwd(struct ssh *ssh, const char *password)

crypto/openssh/openbsd-compat/port-aix.c

178

Authctxt *ctxt = ssh->authctxt;

crypto/openssh/openbsd-compat/port-aix.c

316

record_failed_login(struct ssh *ssh, const char *user, const char *hostname,

crypto/openssh/openbsd-compat/port-aix.h

33

struct ssh;

crypto/openssh/openbsd-compat/port-net.c

309

sys_tun_infilter(struct ssh *ssh, struct Channel *c, char *buf, int _len)

crypto/openssh/openbsd-compat/port-net.c

353

sys_tun_outfilter(struct ssh *ssh, struct Channel *c,

crypto/openssh/openbsd-compat/port-net.h

21

struct ssh;

crypto/openssh/openbsd-compat/port-net.h

30

int sys_tun_infilter(struct ssh *, struct Channel *, char *, int);

crypto/openssh/openbsd-compat/port-net.h

31

u_char *sys_tun_outfilter(struct ssh *, struct Channel *, u_char **, size_t *);

crypto/openssh/openbsd-compat/port-uw.c

53

sys_auth_passwd(struct ssh *ssh, const char *password)

crypto/openssh/openbsd-compat/port-uw.c

55

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/packet.c

1020

if ((r = ssh_packet_init_compression(ssh)) < 0)

crypto/openssh/packet.c

1023

if ((r = start_compression_out(ssh, 6)) != 0)

crypto/openssh/packet.c

1026

if ((r = start_compression_in(ssh)) != 0)

crypto/openssh/packet.c

1050

ssh_packet_need_rekeying(struct ssh *ssh, u_int outbound_packet_len)

crypto/openssh/packet.c

1052

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1060

if (ssh_packet_is_rekeying(ssh))

crypto/openssh/packet.c

1064

if (ssh->compat & SSH_BUG_NOREKEY)

crypto/openssh/packet.c

1097

ssh_packet_check_rekey(struct ssh *ssh)

crypto/openssh/packet.c

1099

if (!ssh_packet_need_rekeying(ssh, 0))

crypto/openssh/packet.c

1102

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1111

ssh_packet_enable_delayed_compress(struct ssh *ssh)

crypto/openssh/packet.c

1113

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1128

if ((r = ssh_packet_init_compression(ssh)) != 0)

crypto/openssh/packet.c

1131

if ((r = start_compression_out(ssh, 6)) != 0)

crypto/openssh/packet.c

1134

if ((r = start_compression_in(ssh)) != 0)

crypto/openssh/packet.c

1163

ssh_packet_send2_wrapped(struct ssh *ssh)

crypto/openssh/packet.c

1165

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1200

if ((r = compress_buffer(ssh, state->outgoing_packet,

crypto/openssh/packet.c

1302

if ((ssh->kex->flags & KEX_INITIAL) != 0) {

crypto/openssh/packet.c

1303

ssh_packet_disconnect(ssh, "outgoing sequence number "

crypto/openssh/packet.c

1309

if (!(ssh->compat & SSH_BUG_NOREKEY))

crypto/openssh/packet.c

1315

if (type == SSH2_MSG_NEWKEYS && ssh->kex->kex_strict) {

crypto/openssh/packet.c

1321

r = ssh_set_newkeys(ssh, MODE_OUT);

crypto/openssh/packet.c

1323

r = ssh_packet_enable_delayed_compress(ssh);

crypto/openssh/packet.c

1343

ssh_packet_send2(struct ssh *ssh)

crypto/openssh/packet.c

1345

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1354

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

crypto/openssh/packet.c

1379

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1388

if ((r = ssh_packet_send2_wrapped(ssh)) != 0)

crypto/openssh/packet.c

1402

if (ssh_packet_need_rekeying(ssh,

crypto/openssh/packet.c

1405

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1413

if ((r = ssh_packet_send2_wrapped(ssh)) != 0)

crypto/openssh/packet.c

1427

ssh_packet_read_seqnr(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1429

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1442

if ((r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

1448

if ((r = ssh_packet_read_poll_seqnr(ssh, typep, seqnr_p)) != 0)

crypto/openssh/packet.c

1501

if ((r = ssh_packet_process_incoming(ssh, buf, len)) != 0)

crypto/openssh/packet.c

1509

ssh_packet_read(struct ssh *ssh)

crypto/openssh/packet.c

1514

if ((r = ssh_packet_read_seqnr(ssh, &type, NULL)) != 0)

crypto/openssh/packet.c

1520

ssh_packet_read_poll2_mux(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1522

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1527

if (ssh->kex)

crypto/openssh/packet.c

1558

ssh_packet_read_poll2(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1560

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1570

return ssh_packet_read_poll2_mux(ssh, typep, seqnr_p);

crypto/openssh/packet.c

1600

if ((r = sshpkt_disconnect(ssh, "Packet corrupt")) != 0)

crypto/openssh/packet.c

1630

return ssh_packet_start_discard(ssh, enc, mac, 0,

crypto/openssh/packet.c

1653

return ssh_packet_start_discard(ssh, enc, mac, 0,

crypto/openssh/packet.c

1700

return ssh_packet_start_discard(ssh, enc, mac,

crypto/openssh/packet.c

1713

if ((ssh->kex->flags & KEX_INITIAL) != 0) {

crypto/openssh/packet.c

1714

ssh_packet_disconnect(ssh, "incoming sequence number "

crypto/openssh/packet.c

1720

if (!(ssh->compat & SSH_BUG_NOREKEY))

crypto/openssh/packet.c

1729

if ((r = sshpkt_disconnect(ssh,

crypto/openssh/packet.c

1731

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

1745

if ((r = uncompress_buffer(ssh, state->incoming_packet,

crypto/openssh/packet.c

1764

if ((r = sshpkt_disconnect(ssh,

crypto/openssh/packet.c

1766

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

1771

(r = state->hook_in(ssh, state->incoming_packet, typep,

crypto/openssh/packet.c

1775

r = ssh_packet_enable_delayed_compress(ssh);

crypto/openssh/packet.c

1784

if (*typep == SSH2_MSG_NEWKEYS && ssh->kex->kex_strict) {

crypto/openssh/packet.c

1789

if ((r = ssh_packet_check_rekey(ssh)) != 0)

crypto/openssh/packet.c

1796

ssh_packet_read_poll_seqnr(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1798

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1807

r = ssh_packet_read_poll2(ssh, typep, seqnr_p);

crypto/openssh/packet.c

1819

if ((r = sshpkt_get_u32(ssh, &reason)) != 0 ||

crypto/openssh/packet.c

1820

(r = sshpkt_get_string(ssh, &msg, NULL)) != 0)

crypto/openssh/packet.c

1823

do_log2(ssh->state->server_side &&

crypto/openssh/packet.c

1827

"%u: %.400s", ssh_remote_ipaddr(ssh),

crypto/openssh/packet.c

1828

ssh_remote_port(ssh), reason, msg);

crypto/openssh/packet.c

1839

if (ssh->kex != NULL &&

crypto/openssh/packet.c

1840

(ssh->kex->flags & KEX_INITIAL) && ssh->kex->kex_strict)

crypto/openssh/packet.c

1848

if ((r = sshpkt_get_u8(ssh, NULL)) != 0 ||

crypto/openssh/packet.c

1849

(r = sshpkt_get_string(ssh, &msg, NULL)) != 0 ||

crypto/openssh/packet.c

1850

(r = sshpkt_get_string(ssh, NULL, NULL)) != 0) {

crypto/openssh/packet.c

1858

if ((r = sshpkt_get_u32(ssh, &seqnr)) != 0)

crypto/openssh/packet.c

1864

if ((r = sshpkt_get_string_direct(ssh, &d, &len)) != 0)

crypto/openssh/packet.c

1867

if (!ssh->state->after_authentication) {

crypto/openssh/packet.c

1871

if (ssh_packet_is_rekeying(ssh)) {

crypto/openssh/packet.c

1875

if ((r = sshpkt_start(ssh, SSH2_MSG_PONG)) != 0 ||

crypto/openssh/packet.c

1876

(r = sshpkt_put_string(ssh, d, len)) != 0 ||

crypto/openssh/packet.c

1877

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/packet.c

1881

if ((r = sshpkt_get_string_direct(ssh,

crypto/openssh/packet.c

1897

ssh_packet_process_incoming(struct ssh *ssh, const char *buf, u_int len)

crypto/openssh/packet.c

1899

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1905

if ((r = ssh_packet_stop_discard(ssh)) != 0)

crypto/openssh/packet.c

1919

ssh_packet_process_read(struct ssh *ssh, int fd)

crypto/openssh/packet.c

1921

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1933

if ((r = ssh_packet_stop_discard(ssh)) != 0)

crypto/openssh/packet.c

1943

ssh_packet_remaining(struct ssh *ssh)

crypto/openssh/packet.c

1945

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

crypto/openssh/packet.c

1957

ssh_packet_send_debug(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

1963

if ((ssh->compat & SSH_BUG_DEBUG))

crypto/openssh/packet.c

1972

if ((r = sshpkt_start(ssh, SSH2_MSG_DEBUG)) != 0 ||

crypto/openssh/packet.c

1973

(r = sshpkt_put_u8(ssh, 0)) != 0 || /* always display */

crypto/openssh/packet.c

1974

(r = sshpkt_put_cstring(ssh, buf)) != 0 ||

crypto/openssh/packet.c

1975

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/packet.c

1976

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/packet.c

1977

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

1982

sshpkt_fmt_connection_id(struct ssh *ssh, char *s, size_t l)

crypto/openssh/packet.c

1985

ssh->log_preamble ? ssh->log_preamble : "",

crypto/openssh/packet.c

1986

ssh->log_preamble ? " " : "",

crypto/openssh/packet.c

1987

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/packet.c

1994

sshpkt_vfatal(struct ssh *ssh, int r, const char *fmt, va_list ap)

crypto/openssh/packet.c

1999

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/packet.c

2003

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2006

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2008

ssh->state->server_side ? "from" : "to", remote_id);

crypto/openssh/packet.c

2010

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2014

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2023

if (ssh->kex && ssh->kex->failed_choice) {

crypto/openssh/packet.c

2024

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2028

ssh->kex->failed_choice);

crypto/openssh/packet.c

2033

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2036

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2040

ssh->state->server_side ? "from" : "to", remote_id);

crypto/openssh/packet.c

2045

sshpkt_fatal(struct ssh *ssh, int r, const char *fmt, ...)

crypto/openssh/packet.c

2050

sshpkt_vfatal(ssh, r, fmt, ap);

crypto/openssh/packet.c

2063

ssh_packet_disconnect(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

2078

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/packet.c

2090

if ((r = sshpkt_disconnect(ssh, "%s", buf)) != 0)

crypto/openssh/packet.c

2091

sshpkt_fatal(ssh, r, "%s", __func__);

crypto/openssh/packet.c

2093

if ((r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

2094

sshpkt_fatal(ssh, r, "%s", __func__);

crypto/openssh/packet.c

2097

ssh_packet_close(ssh);

crypto/openssh/packet.c

2106

ssh_packet_write_poll(struct ssh *ssh)

crypto/openssh/packet.c

2108

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2134

ssh_packet_write_wait(struct ssh *ssh)

crypto/openssh/packet.c

2139

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2142

if ((r = ssh_packet_write_poll(ssh)) != 0)

crypto/openssh/packet.c

2144

while (ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/packet.c

2172

if ((r = ssh_packet_write_poll(ssh)) != 0)

crypto/openssh/packet.c

2181

ssh_packet_have_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2183

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

crypto/openssh/packet.c

2189

ssh_packet_not_very_much_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2191

if (ssh->state->interactive_mode)

crypto/openssh/packet.c

2192

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

crypto/openssh/packet.c

2194

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

crypto/openssh/packet.c

2203

ssh_packet_interactive_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2205

return ssh->state->interactive_mode &&

crypto/openssh/packet.c

2206

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

crypto/openssh/packet.c

2210

ssh_packet_set_tos(struct ssh *ssh, int tos)

crypto/openssh/packet.c

2212

if (!ssh_packet_connection_is_on_socket(ssh) || tos == INT_MAX)

crypto/openssh/packet.c

2214

set_sock_tos(ssh->state->connection_in, tos);

crypto/openssh/packet.c

2220

ssh_packet_set_interactive(struct ssh *ssh, int interactive, int qos_interactive, int qos_bulk)

crypto/openssh/packet.c

2222

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2232

if (!ssh_packet_connection_is_on_socket(ssh))

crypto/openssh/packet.c

2235

ssh_packet_set_tos(ssh, interactive ? qos_interactive : qos_bulk);

crypto/openssh/packet.c

2241

ssh_packet_is_interactive(struct ssh *ssh)

crypto/openssh/packet.c

2243

return ssh->state->interactive_mode;

crypto/openssh/packet.c

2247

ssh_packet_set_maxsize(struct ssh *ssh, u_int s)

crypto/openssh/packet.c

2249

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2267

ssh_packet_inc_alive_timeouts(struct ssh *ssh)

crypto/openssh/packet.c

2269

return ++ssh->state->keep_alive_timeouts;

crypto/openssh/packet.c

2273

ssh_packet_set_alive_timeouts(struct ssh *ssh, int ka)

crypto/openssh/packet.c

2275

ssh->state->keep_alive_timeouts = ka;

crypto/openssh/packet.c

2279

ssh_packet_get_maxsize(struct ssh *ssh)

crypto/openssh/packet.c

2281

return ssh->state->max_packet_size;

crypto/openssh/packet.c

2285

ssh_packet_set_rekey_limits(struct ssh *ssh, u_int64_t bytes, u_int32_t seconds)

crypto/openssh/packet.c

2289

ssh->state->rekey_limit = bytes;

crypto/openssh/packet.c

229

struct ssh *

crypto/openssh/packet.c

2290

ssh->state->rekey_interval = seconds;

crypto/openssh/packet.c

2294

ssh_packet_get_rekey_timeout(struct ssh *ssh)

crypto/openssh/packet.c

2298

seconds = ssh->state->rekey_time + ssh->state->rekey_interval -

crypto/openssh/packet.c

2304

ssh_packet_set_server(struct ssh *ssh)

crypto/openssh/packet.c

2306

ssh->state->server_side = 1;

crypto/openssh/packet.c

2307

ssh->kex->server = 1; /* XXX unify? */

crypto/openssh/packet.c

2311

ssh_packet_set_authenticated(struct ssh *ssh)

crypto/openssh/packet.c

2313

ssh->state->after_authentication = 1;

crypto/openssh/packet.c

2317

ssh_packet_get_input(struct ssh *ssh)

crypto/openssh/packet.c

2319

return (void *)ssh->state->input;

crypto/openssh/packet.c

232

struct ssh *ssh = NULL;

crypto/openssh/packet.c

2323

ssh_packet_get_output(struct ssh *ssh)

crypto/openssh/packet.c

2325

return (void *)ssh->state->output;

crypto/openssh/packet.c

2330

ssh_packet_set_postauth(struct ssh *ssh)

crypto/openssh/packet.c

2336

ssh->state->after_authentication = 1;

crypto/openssh/packet.c

2337

ssh->state->rekeying = 0;

crypto/openssh/packet.c

2338

if ((r = ssh_packet_enable_delayed_compress(ssh)) != 0)

crypto/openssh/packet.c

235

if ((ssh = calloc(1, sizeof(*ssh))) == NULL ||

crypto/openssh/packet.c

2369

newkeys_to_blob(struct sshbuf *m, struct ssh *ssh, int mode)

crypto/openssh/packet.c

237

(ssh->kex = kex_new()) == NULL ||

crypto/openssh/packet.c

2379

if ((newkey = ssh->state->newkeys[mode]) == NULL)

crypto/openssh/packet.c

2384

cc = (mode == MODE_OUT) ? ssh->state->send_context :

crypto/openssh/packet.c

2385

ssh->state->receive_context;

crypto/openssh/packet.c

2413

ssh_packet_get_state(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/packet.c

2415

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2418

if ((r = kex_to_blob(m, ssh->kex)) != 0 ||

crypto/openssh/packet.c

2419

(r = newkeys_to_blob(m, ssh, MODE_OUT)) != 0 ||

crypto/openssh/packet.c

2420

(r = newkeys_to_blob(m, ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

244

TAILQ_INIT(&ssh->private_keys);

crypto/openssh/packet.c

2440

newkeys_from_blob(struct sshbuf *m, struct ssh *ssh, int mode)

crypto/openssh/packet.c

245

TAILQ_INIT(&ssh->public_keys);

crypto/openssh/packet.c

2496

ssh->kex->newkeys[mode] = newkey;

crypto/openssh/packet.c

2547

ssh_packet_set_state(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/packet.c

2549

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2554

if ((r = kex_from_blob(m, &ssh->kex)) != 0 ||

crypto/openssh/packet.c

2555

(r = newkeys_from_blob(m, ssh, MODE_OUT)) != 0 ||

crypto/openssh/packet.c

2556

(r = newkeys_from_blob(m, ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

257

ssh->state = state;

crypto/openssh/packet.c

2574

if ((r = ssh_set_newkeys(ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

2575

(r = ssh_set_newkeys(ssh, MODE_OUT)) != 0)

crypto/openssh/packet.c

2578

if ((r = ssh_packet_set_postauth(ssh)) != 0)

crypto/openssh/packet.c

258

return ssh;

crypto/openssh/packet.c

260

if (ssh) {

crypto/openssh/packet.c

2600

sshpkt_put(struct ssh *ssh, const void *v, size_t len)

crypto/openssh/packet.c

2602

return sshbuf_put(ssh->state->outgoing_packet, v, len);

crypto/openssh/packet.c

2606

sshpkt_putb(struct ssh *ssh, const struct sshbuf *b)

crypto/openssh/packet.c

2608

return sshbuf_putb(ssh->state->outgoing_packet, b);

crypto/openssh/packet.c

261

kex_free(ssh->kex);

crypto/openssh/packet.c

2612

sshpkt_put_u8(struct ssh *ssh, u_char val)

crypto/openssh/packet.c

2614

return sshbuf_put_u8(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

2618

sshpkt_put_u32(struct ssh *ssh, u_int32_t val)

crypto/openssh/packet.c

262

free(ssh);

crypto/openssh/packet.c

2620

return sshbuf_put_u32(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

2624

sshpkt_put_u64(struct ssh *ssh, u_int64_t val)

crypto/openssh/packet.c

2626

return sshbuf_put_u64(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

2630

sshpkt_put_string(struct ssh *ssh, const void *v, size_t len)

crypto/openssh/packet.c

2632

return sshbuf_put_string(ssh->state->outgoing_packet, v, len);

crypto/openssh/packet.c

2636

sshpkt_put_cstring(struct ssh *ssh, const void *v)

crypto/openssh/packet.c

2638

return sshbuf_put_cstring(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2642

sshpkt_put_stringb(struct ssh *ssh, const struct sshbuf *v)

crypto/openssh/packet.c

2644

return sshbuf_put_stringb(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2650

sshpkt_put_ec(struct ssh *ssh, const EC_POINT *v, const EC_GROUP *g)

crypto/openssh/packet.c

2652

return sshbuf_put_ec(ssh->state->outgoing_packet, v, g);

crypto/openssh/packet.c

2656

sshpkt_put_ec_pkey(struct ssh *ssh, EVP_PKEY *pkey)

crypto/openssh/packet.c

2658

return sshbuf_put_ec_pkey(ssh->state->outgoing_packet, pkey);

crypto/openssh/packet.c

2663

sshpkt_put_bignum2(struct ssh *ssh, const BIGNUM *v)

crypto/openssh/packet.c

2665

return sshbuf_put_bignum2(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2672

sshpkt_get(struct ssh *ssh, void *valp, size_t len)

crypto/openssh/packet.c

2674

return sshbuf_get(ssh->state->incoming_packet, valp, len);

crypto/openssh/packet.c

2678

sshpkt_get_u8(struct ssh *ssh, u_char *valp)

crypto/openssh/packet.c

2680

return sshbuf_get_u8(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2684

sshpkt_get_u32(struct ssh *ssh, u_int32_t *valp)

crypto/openssh/packet.c

2686

return sshbuf_get_u32(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2690

sshpkt_get_u64(struct ssh *ssh, u_int64_t *valp)

crypto/openssh/packet.c

2692

return sshbuf_get_u64(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2696

sshpkt_get_string(struct ssh *ssh, u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2698

return sshbuf_get_string(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2702

sshpkt_get_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2704

return sshbuf_get_string_direct(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2708

sshpkt_peek_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2710

return sshbuf_peek_string_direct(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2714

sshpkt_get_cstring(struct ssh *ssh, char **valp, size_t *lenp)

crypto/openssh/packet.c

2716

return sshbuf_get_cstring(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2720

sshpkt_getb_froms(struct ssh *ssh, struct sshbuf **valp)

crypto/openssh/packet.c

2722

return sshbuf_froms(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2728

sshpkt_get_ec(struct ssh *ssh, EC_POINT *v, const EC_GROUP *g)

crypto/openssh/packet.c

2730

return sshbuf_get_ec(ssh->state->incoming_packet, v, g);

crypto/openssh/packet.c

2735

sshpkt_get_bignum2(struct ssh *ssh, BIGNUM **valp)

crypto/openssh/packet.c

2737

return sshbuf_get_bignum2(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2742

sshpkt_get_end(struct ssh *ssh)

crypto/openssh/packet.c

2744

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

crypto/openssh/packet.c

275

ssh_packet_set_input_hook(struct ssh *ssh, ssh_packet_hook_fn *hook, void *ctx)

crypto/openssh/packet.c

2750

sshpkt_ptr(struct ssh *ssh, size_t *lenp)

crypto/openssh/packet.c

2753

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

crypto/openssh/packet.c

2754

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

crypto/openssh/packet.c

2760

sshpkt_start(struct ssh *ssh, u_char type)

crypto/openssh/packet.c

2767

sshbuf_reset(ssh->state->outgoing_packet);

crypto/openssh/packet.c

2768

return sshbuf_put(ssh->state->outgoing_packet, buf, sizeof(buf));

crypto/openssh/packet.c

277

ssh->state->hook_in = hook;

crypto/openssh/packet.c

2772

ssh_packet_send_mux(struct ssh *ssh)

crypto/openssh/packet.c

2774

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2779

if (ssh->kex)

crypto/openssh/packet.c

278

ssh->state->hook_in_ctx = ctx;

crypto/openssh/packet.c

2813

sshpkt_msg_ignore(struct ssh *ssh, u_int nbytes)

crypto/openssh/packet.c

2819

if ((r = sshpkt_start(ssh, SSH2_MSG_IGNORE)) != 0 ||

crypto/openssh/packet.c

2820

(r = sshpkt_put_u32(ssh, nbytes)) != 0)

crypto/openssh/packet.c

2825

if ((r = sshpkt_put_u8(ssh, (u_char)rnd & 0xff)) != 0)

crypto/openssh/packet.c

283

ssh_packet_is_rekeying(struct ssh *ssh)

crypto/openssh/packet.c

2835

sshpkt_send(struct ssh *ssh)

crypto/openssh/packet.c

2837

if (ssh->state && ssh->state->mux)

crypto/openssh/packet.c

2838

return ssh_packet_send_mux(ssh);

crypto/openssh/packet.c

2839

return ssh_packet_send2(ssh);

crypto/openssh/packet.c

2843

sshpkt_disconnect(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

285

return ssh->state->rekeying ||

crypto/openssh/packet.c

2854

if ((r = sshpkt_start(ssh, SSH2_MSG_DISCONNECT)) != 0 ||

crypto/openssh/packet.c

2855

(r = sshpkt_put_u32(ssh, SSH2_DISCONNECT_PROTOCOL_ERROR)) != 0 ||

crypto/openssh/packet.c

2856

(r = sshpkt_put_cstring(ssh, buf)) != 0 ||

crypto/openssh/packet.c

2857

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/packet.c

2858

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/packet.c

286

(ssh->kex != NULL && ssh->kex->done == 0);

crypto/openssh/packet.c

2865

sshpkt_add_padding(struct ssh *ssh, u_char pad)

crypto/openssh/packet.c

2867

ssh->state->extra_pad = pad;

crypto/openssh/packet.c

292

struct ssh *

crypto/openssh/packet.c

293

ssh_packet_set_connection(struct ssh *ssh, int fd_in, int fd_out)

crypto/openssh/packet.c

303

if (ssh == NULL)

crypto/openssh/packet.c

304

ssh = ssh_alloc_session_state();

crypto/openssh/packet.c

305

if (ssh == NULL) {

crypto/openssh/packet.c

309

state = ssh->state;

crypto/openssh/packet.c

317

free(ssh); /* XXX need ssh_free_session_state? */

crypto/openssh/packet.c

325

(void)ssh_remote_ipaddr(ssh);

crypto/openssh/packet.c

326

return ssh;

crypto/openssh/packet.c

330

ssh_packet_set_timeout(struct ssh *ssh, int timeout, int count)

crypto/openssh/packet.c

332

struct session_state *state = ssh->state;

crypto/openssh/packet.c

345

ssh_packet_set_mux(struct ssh *ssh)

crypto/openssh/packet.c

347

ssh->state->mux = 1;

crypto/openssh/packet.c

348

ssh->state->rekeying = 0;

crypto/openssh/packet.c

349

kex_free(ssh->kex);

crypto/openssh/packet.c

350

ssh->kex = NULL;

crypto/openssh/packet.c

354

ssh_packet_get_mux(struct ssh *ssh)

crypto/openssh/packet.c

356

return ssh->state->mux;

crypto/openssh/packet.c

360

ssh_packet_set_log_preamble(struct ssh *ssh, const char *fmt, ...)

crypto/openssh/packet.c

365

free(ssh->log_preamble);

crypto/openssh/packet.c

367

ssh->log_preamble = NULL;

crypto/openssh/packet.c

370

r = vasprintf(&ssh->log_preamble, fmt, args);

crypto/openssh/packet.c

372

if (r < 0 || ssh->log_preamble == NULL)

crypto/openssh/packet.c

379

ssh_packet_stop_discard(struct ssh *ssh)

crypto/openssh/packet.c

381

struct session_state *state = ssh->state;

crypto/openssh/packet.c

401

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/packet.c

406

ssh_packet_start_discard(struct ssh *ssh, struct sshenc *enc,

crypto/openssh/packet.c

409

struct session_state *state = ssh->state;

crypto/openssh/packet.c

413

if ((r = sshpkt_disconnect(ssh, "Packet corrupt")) != 0)

crypto/openssh/packet.c

426

return ssh_packet_stop_discard(ssh);

crypto/openssh/packet.c

434

ssh_packet_connection_is_on_socket(struct ssh *ssh)

crypto/openssh/packet.c

440

if (ssh == NULL || ssh->state == NULL)

crypto/openssh/packet.c

443

state = ssh->state;

crypto/openssh/packet.c

467

ssh_packet_get_bytes(struct ssh *ssh, u_int64_t *ibytes, u_int64_t *obytes)

crypto/openssh/packet.c

470

*ibytes = ssh->state->p_read.bytes;

crypto/openssh/packet.c

472

*obytes = ssh->state->p_send.bytes;

crypto/openssh/packet.c

476

ssh_packet_connection_af(struct ssh *ssh)

crypto/openssh/packet.c

478

return get_sock_af(ssh->state->connection_out);

crypto/openssh/packet.c

484

ssh_packet_set_nonblocking(struct ssh *ssh)

crypto/openssh/packet.c

487

set_nonblock(ssh->state->connection_in);

crypto/openssh/packet.c

489

if (ssh->state->connection_out != ssh->state->connection_in)

crypto/openssh/packet.c

490

set_nonblock(ssh->state->connection_out);

crypto/openssh/packet.c

496

ssh_packet_get_connection_in(struct ssh *ssh)

crypto/openssh/packet.c

498

return ssh->state->connection_in;

crypto/openssh/packet.c

504

ssh_packet_get_connection_out(struct ssh *ssh)

crypto/openssh/packet.c

506

return ssh->state->connection_out;

crypto/openssh/packet.c

515

ssh_remote_ipaddr(struct ssh *ssh)

crypto/openssh/packet.c

520

if (ssh->remote_ipaddr == NULL) {

crypto/openssh/packet.c

521

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/packet.c

522

sock = ssh->state->connection_in;

crypto/openssh/packet.c

523

ssh->remote_ipaddr = get_peer_ipaddr(sock);

crypto/openssh/packet.c

524

ssh->remote_port = get_peer_port(sock);

crypto/openssh/packet.c

525

ssh->local_ipaddr = get_local_ipaddr(sock);

crypto/openssh/packet.c

526

ssh->local_port = get_local_port(sock);

crypto/openssh/packet.c

528

ssh->remote_ipaddr = xstrdup("UNKNOWN");

crypto/openssh/packet.c

529

ssh->remote_port = 65535;

crypto/openssh/packet.c

530

ssh->local_ipaddr = xstrdup("UNKNOWN");

crypto/openssh/packet.c

531

ssh->local_port = 65535;

crypto/openssh/packet.c

534

return ssh->remote_ipaddr;

crypto/openssh/packet.c

547

ssh_remote_hostname(struct ssh *ssh)

crypto/openssh/packet.c

553

const char *ntop = ssh_remote_ipaddr(ssh);

crypto/openssh/packet.c

558

if (getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/packet.c

632

ssh_remote_port(struct ssh *ssh)

crypto/openssh/packet.c

634

(void)ssh_remote_ipaddr(ssh); /* Will lookup and cache. */

crypto/openssh/packet.c

635

return ssh->remote_port;

crypto/openssh/packet.c

644

ssh_local_ipaddr(struct ssh *ssh)

crypto/openssh/packet.c

646

(void)ssh_remote_ipaddr(ssh); /* Will lookup and cache. */

crypto/openssh/packet.c

647

return ssh->local_ipaddr;

crypto/openssh/packet.c

653

ssh_local_port(struct ssh *ssh)

crypto/openssh/packet.c

655

(void)ssh_remote_ipaddr(ssh); /* Will lookup and cache. */

crypto/openssh/packet.c

656

return ssh->local_port;

crypto/openssh/packet.c

661

ssh_packet_rdomain_in(struct ssh *ssh)

crypto/openssh/packet.c

663

if (ssh->rdomain_in != NULL)

crypto/openssh/packet.c

664

return ssh->rdomain_in;

crypto/openssh/packet.c

665

if (!ssh_packet_connection_is_on_socket(ssh))

crypto/openssh/packet.c

667

ssh->rdomain_in = get_rdomain(ssh->state->connection_in);

crypto/openssh/packet.c

668

return ssh->rdomain_in;

crypto/openssh/packet.c

674

ssh_packet_close_internal(struct ssh *ssh, int do_close)

crypto/openssh/packet.c

676

struct session_state *state = ssh->state;

crypto/openssh/packet.c

697

ssh_clear_newkeys(ssh, mode); /* next keys */

crypto/openssh/packet.c

731

free(ssh->local_ipaddr);

crypto/openssh/packet.c

732

ssh->local_ipaddr = NULL;

crypto/openssh/packet.c

733

free(ssh->remote_ipaddr);

crypto/openssh/packet.c

734

ssh->remote_ipaddr = NULL;

crypto/openssh/packet.c

735

free(ssh->state);

crypto/openssh/packet.c

736

ssh->state = NULL;

crypto/openssh/packet.c

737

kex_free(ssh->kex);

crypto/openssh/packet.c

738

ssh->kex = NULL;

crypto/openssh/packet.c

743

ssh_packet_close(struct ssh *ssh)

crypto/openssh/packet.c

745

ssh_packet_close_internal(ssh, 1);

crypto/openssh/packet.c

749

ssh_packet_clear_keys(struct ssh *ssh)

crypto/openssh/packet.c

751

ssh_packet_close_internal(ssh, 0);

crypto/openssh/packet.c

757

ssh_packet_set_protocol_flags(struct ssh *ssh, u_int protocol_flags)

crypto/openssh/packet.c

759

ssh->state->remote_protocol_flags = protocol_flags;

crypto/openssh/packet.c

765

ssh_packet_get_protocol_flags(struct ssh *ssh)

crypto/openssh/packet.c

767

return ssh->state->remote_protocol_flags;

crypto/openssh/packet.c

776

ssh_packet_init_compression(struct ssh *ssh)

crypto/openssh/packet.c

778

if (!ssh->state->compression_buffer &&

crypto/openssh/packet.c

779

((ssh->state->compression_buffer = sshbuf_new()) == NULL))

crypto/openssh/packet.c

786

start_compression_out(struct ssh *ssh, int level)

crypto/openssh/packet.c

791

if (ssh->state->compression_out_started == 1)

crypto/openssh/packet.c

792

deflateEnd(&ssh->state->compression_out_stream);

crypto/openssh/packet.c

793

switch (deflateInit(&ssh->state->compression_out_stream, level)) {

crypto/openssh/packet.c

795

ssh->state->compression_out_started = 1;

crypto/openssh/packet.c

806

start_compression_in(struct ssh *ssh)

crypto/openssh/packet.c

808

if (ssh->state->compression_in_started == 1)

crypto/openssh/packet.c

809

inflateEnd(&ssh->state->compression_in_stream);

crypto/openssh/packet.c

810

switch (inflateInit(&ssh->state->compression_in_stream)) {

crypto/openssh/packet.c

812

ssh->state->compression_in_started = 1;

crypto/openssh/packet.c

824

compress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

829

if (ssh->state->compression_out_started != 1)

crypto/openssh/packet.c

837

if ((ssh->state->compression_out_stream.next_in =

crypto/openssh/packet.c

840

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

crypto/openssh/packet.c

845

ssh->state->compression_out_stream.next_out = buf;

crypto/openssh/packet.c

846

ssh->state->compression_out_stream.avail_out = sizeof(buf);

crypto/openssh/packet.c

849

status = deflate(&ssh->state->compression_out_stream,

crypto/openssh/packet.c

857

ssh->state->compression_out_stream.avail_out)) != 0)

crypto/openssh/packet.c

862

ssh->state->compression_out_failures++;

crypto/openssh/packet.c

865

} while (ssh->state->compression_out_stream.avail_out == 0);

crypto/openssh/packet.c

870

uncompress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

875

if (ssh->state->compression_in_started != 1)

crypto/openssh/packet.c

878

if ((ssh->state->compression_in_stream.next_in =

crypto/openssh/packet.c

881

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

crypto/openssh/packet.c

885

ssh->state->compression_in_stream.next_out = buf;

crypto/openssh/packet.c

886

ssh->state->compression_in_stream.avail_out = sizeof(buf);

crypto/openssh/packet.c

888

status = inflate(&ssh->state->compression_in_stream,

crypto/openssh/packet.c

893

ssh->state->compression_in_stream.avail_out)) != 0)

crypto/openssh/packet.c

909

ssh->state->compression_in_failures++;

crypto/openssh/packet.c

919

start_compression_out(struct ssh *ssh, int level)

crypto/openssh/packet.c

925

start_compression_in(struct ssh *ssh)

crypto/openssh/packet.c

931

compress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

937

uncompress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

944

ssh_clear_newkeys(struct ssh *ssh, int mode)

crypto/openssh/packet.c

946

if (ssh->kex && ssh->kex->newkeys[mode]) {

crypto/openssh/packet.c

947

kex_free_newkeys(ssh->kex->newkeys[mode]);

crypto/openssh/packet.c

948

ssh->kex->newkeys[mode] = NULL;

crypto/openssh/packet.c

953

ssh_set_newkeys(struct ssh *ssh, int mode)

crypto/openssh/packet.c

955

struct session_state *state = ssh->state;

crypto/openssh/packet.c

992

if ((state->newkeys[mode] = ssh->kex->newkeys[mode]) == NULL)

crypto/openssh/packet.c

994

ssh->kex->newkeys[mode] = NULL;

crypto/openssh/packet.h

100

int ssh_packet_connection_af(struct ssh *);

crypto/openssh/packet.h

101

void ssh_packet_set_nonblocking(struct ssh *);

crypto/openssh/packet.h

102

int ssh_packet_get_connection_in(struct ssh *);

crypto/openssh/packet.h

103

int ssh_packet_get_connection_out(struct ssh *);

crypto/openssh/packet.h

104

void ssh_packet_close(struct ssh *);

crypto/openssh/packet.h

105

void ssh_packet_set_input_hook(struct ssh *, ssh_packet_hook_fn *, void *);

crypto/openssh/packet.h

106

void ssh_packet_clear_keys(struct ssh *);

crypto/openssh/packet.h

107

void ssh_clear_newkeys(struct ssh *, int);

crypto/openssh/packet.h

109

int ssh_packet_is_rekeying(struct ssh *);

crypto/openssh/packet.h

110

int ssh_packet_check_rekey(struct ssh *);

crypto/openssh/packet.h

111

void ssh_packet_set_protocol_flags(struct ssh *, u_int);

crypto/openssh/packet.h

112

u_int ssh_packet_get_protocol_flags(struct ssh *);

crypto/openssh/packet.h

113

void ssh_packet_set_tos(struct ssh *, int);

crypto/openssh/packet.h

114

void ssh_packet_set_interactive(struct ssh *, int, int, int);

crypto/openssh/packet.h

115

int ssh_packet_is_interactive(struct ssh *);

crypto/openssh/packet.h

116

void ssh_packet_set_server(struct ssh *);

crypto/openssh/packet.h

117

void ssh_packet_set_authenticated(struct ssh *);

crypto/openssh/packet.h

118

void ssh_packet_set_mux(struct ssh *);

crypto/openssh/packet.h

119

int ssh_packet_get_mux(struct ssh *);

crypto/openssh/packet.h

120

int ssh_packet_set_log_preamble(struct ssh *, const char *, ...)

crypto/openssh/packet.h

125

int ssh_packet_send2_wrapped(struct ssh *);

crypto/openssh/packet.h

126

int ssh_packet_send2(struct ssh *);

crypto/openssh/packet.h

128

int ssh_packet_read(struct ssh *);

crypto/openssh/packet.h

129

int ssh_packet_read_poll2(struct ssh *, u_char *, u_int32_t *seqnr_p);

crypto/openssh/packet.h

130

int ssh_packet_process_incoming(struct ssh *, const char *buf, u_int len);

crypto/openssh/packet.h

131

int ssh_packet_process_read(struct ssh *, int);

crypto/openssh/packet.h

132

int ssh_packet_read_seqnr(struct ssh *, u_char *, u_int32_t *seqnr_p);

crypto/openssh/packet.h

133

int ssh_packet_read_poll_seqnr(struct ssh *, u_char *, u_int32_t *seqnr_p);

crypto/openssh/packet.h

135

void ssh_packet_disconnect(struct ssh *, const char *fmt, ...)

crypto/openssh/packet.h

138

void ssh_packet_send_debug(struct ssh *, const char *fmt, ...) __attribute__((format(printf, 2, 3)));

crypto/openssh/packet.h

140

int ssh_set_newkeys(struct ssh *, int mode);

crypto/openssh/packet.h

141

void ssh_packet_get_bytes(struct ssh *, u_int64_t *, u_int64_t *);

crypto/openssh/packet.h

143

int ssh_packet_write_poll(struct ssh *);

crypto/openssh/packet.h

144

int ssh_packet_write_wait(struct ssh *);

crypto/openssh/packet.h

145

int ssh_packet_have_data_to_write(struct ssh *);

crypto/openssh/packet.h

146

int ssh_packet_not_very_much_data_to_write(struct ssh *);

crypto/openssh/packet.h

147

int ssh_packet_interactive_data_to_write(struct ssh *);

crypto/openssh/packet.h

149

int ssh_packet_connection_is_on_socket(struct ssh *);

crypto/openssh/packet.h

150

int ssh_packet_remaining(struct ssh *);

crypto/openssh/packet.h

152

void ssh_tty_make_modes(struct ssh *, int, struct termios *);

crypto/openssh/packet.h

153

void ssh_tty_parse_modes(struct ssh *, int);

crypto/openssh/packet.h

155

void ssh_packet_set_alive_timeouts(struct ssh *, int);

crypto/openssh/packet.h

156

int ssh_packet_inc_alive_timeouts(struct ssh *);

crypto/openssh/packet.h

157

int ssh_packet_set_maxsize(struct ssh *, u_int);

crypto/openssh/packet.h

158

u_int ssh_packet_get_maxsize(struct ssh *);

crypto/openssh/packet.h

160

int ssh_packet_get_state(struct ssh *, struct sshbuf *);

crypto/openssh/packet.h

161

int ssh_packet_set_state(struct ssh *, struct sshbuf *);

crypto/openssh/packet.h

163

const char *ssh_remote_ipaddr(struct ssh *);

crypto/openssh/packet.h

164

int ssh_remote_port(struct ssh *);

crypto/openssh/packet.h

165

const char *ssh_local_ipaddr(struct ssh *);

crypto/openssh/packet.h

166

int ssh_local_port(struct ssh *);

crypto/openssh/packet.h

167

const char *ssh_packet_rdomain_in(struct ssh *);

crypto/openssh/packet.h

168

char *ssh_remote_hostname(struct ssh *);

crypto/openssh/packet.h

170

void ssh_packet_set_rekey_limits(struct ssh *, u_int64_t, u_int32_t);

crypto/openssh/packet.h

171

time_t ssh_packet_get_rekey_timeout(struct ssh *);

crypto/openssh/packet.h

173

void *ssh_packet_get_input(struct ssh *);

crypto/openssh/packet.h

174

void *ssh_packet_get_output(struct ssh *);

crypto/openssh/packet.h

177

int sshpkt_start(struct ssh *ssh, u_char type);

crypto/openssh/packet.h

178

int sshpkt_send(struct ssh *ssh);

crypto/openssh/packet.h

179

int sshpkt_disconnect(struct ssh *, const char *fmt, ...)

crypto/openssh/packet.h

181

int sshpkt_add_padding(struct ssh *, u_char);

crypto/openssh/packet.h

182

void sshpkt_fatal(struct ssh *ssh, int r, const char *fmt, ...)

crypto/openssh/packet.h

185

int sshpkt_msg_ignore(struct ssh *, u_int);

crypto/openssh/packet.h

187

int sshpkt_put(struct ssh *ssh, const void *v, size_t len);

crypto/openssh/packet.h

188

int sshpkt_putb(struct ssh *ssh, const struct sshbuf *b);

crypto/openssh/packet.h

189

int sshpkt_put_u8(struct ssh *ssh, u_char val);

crypto/openssh/packet.h

190

int sshpkt_put_u32(struct ssh *ssh, u_int32_t val);

crypto/openssh/packet.h

191

int sshpkt_put_u64(struct ssh *ssh, u_int64_t val);

crypto/openssh/packet.h

192

int sshpkt_put_string(struct ssh *ssh, const void *v, size_t len);

crypto/openssh/packet.h

193

int sshpkt_put_cstring(struct ssh *ssh, const void *v);

crypto/openssh/packet.h

194

int sshpkt_put_stringb(struct ssh *ssh, const struct sshbuf *v);

crypto/openssh/packet.h

195

int sshpkt_put_ec(struct ssh *ssh, const EC_POINT *v, const EC_GROUP *g);

crypto/openssh/packet.h

196

int sshpkt_put_ec_pkey(struct ssh *ssh, EVP_PKEY *pkey);

crypto/openssh/packet.h

197

int sshpkt_put_bignum2(struct ssh *ssh, const BIGNUM *v);

crypto/openssh/packet.h

199

int sshpkt_get(struct ssh *ssh, void *valp, size_t len);

crypto/openssh/packet.h

200

int sshpkt_get_u8(struct ssh *ssh, u_char *valp);

crypto/openssh/packet.h

201

int sshpkt_get_u32(struct ssh *ssh, u_int32_t *valp);

crypto/openssh/packet.h

202

int sshpkt_get_u64(struct ssh *ssh, u_int64_t *valp);

crypto/openssh/packet.h

203

int sshpkt_get_string(struct ssh *ssh, u_char **valp, size_t *lenp);

crypto/openssh/packet.h

204

int sshpkt_get_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp);

crypto/openssh/packet.h

205

int sshpkt_peek_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp);

crypto/openssh/packet.h

206

int sshpkt_get_cstring(struct ssh *ssh, char **valp, size_t *lenp);

crypto/openssh/packet.h

207

int sshpkt_getb_froms(struct ssh *ssh, struct sshbuf **valp);

crypto/openssh/packet.h

208

int sshpkt_get_ec(struct ssh *ssh, EC_POINT *v, const EC_GROUP *g);

crypto/openssh/packet.h

209

int sshpkt_get_bignum2(struct ssh *ssh, BIGNUM **valp);

crypto/openssh/packet.h

210

int sshpkt_get_end(struct ssh *ssh);

crypto/openssh/packet.h

211

void sshpkt_fmt_connection_id(struct ssh *ssh, char *s, size_t l);

crypto/openssh/packet.h

212

const u_char *sshpkt_ptr(struct ssh *, size_t *lenp);

crypto/openssh/packet.h

93

typedef int (ssh_packet_hook_fn)(struct ssh *, struct sshbuf *,

crypto/openssh/packet.h

96

struct ssh *ssh_alloc_session_state(void);

crypto/openssh/packet.h

97

struct ssh *ssh_packet_set_connection(struct ssh *, int, int);

crypto/openssh/packet.h

98

void ssh_packet_set_timeout(struct ssh *, int, int);

crypto/openssh/packet.h

99

int ssh_packet_stop_discard(struct ssh *);

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

177

struct ssh *client = NULL, *server = NULL;

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

41

do_send_and_receive(struct ssh *from, struct ssh *to,

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

76

run_kex(struct test_state *ts, struct ssh *client, struct ssh *server)

crypto/openssh/regress/unittests/kex/test_kex.c

31

do_send_and_receive(struct ssh *from, struct ssh *to)

crypto/openssh/regress/unittests/kex/test_kex.c

57

run_kex(struct ssh *client, struct ssh *server)

crypto/openssh/regress/unittests/kex/test_kex.c

81

struct ssh *client = NULL, *server = NULL, *server2 = NULL;

crypto/openssh/regress/unittests/kex/test_proposal.c

102

ssh.kex = &kex;

crypto/openssh/regress/unittests/kex/test_proposal.c

106

for (ssh.compat = 0; ssh.compat < 0x40000000; ) {

crypto/openssh/regress/unittests/kex/test_proposal.c

107

kex_proposal_populate_entries(&ssh, prop, NULL, NULL,

crypto/openssh/regress/unittests/kex/test_proposal.c

110

kex_proposal_populate_entries(&ssh, prop, kexalgs,

crypto/openssh/regress/unittests/kex/test_proposal.c

113

if (ssh.compat == 0)

crypto/openssh/regress/unittests/kex/test_proposal.c

114

ssh.compat = 1;

crypto/openssh/regress/unittests/kex/test_proposal.c

116

ssh.compat <<= 1;

crypto/openssh/regress/unittests/kex/test_proposal.c

41

struct ssh ssh;

crypto/openssh/regress/unittests/kex/test_proposal.c

58

ssh.compat = tests[i].compat;

crypto/openssh/regress/unittests/kex/test_proposal.c

60

result = compat_kex_proposal(&ssh, tests[i].in);

crypto/openssh/regress/unittests/kex/test_proposal.c

66

result = compat_kex_proposal(&ssh, in);

crypto/openssh/regress/unittests/kex/test_proposal.c

72

result = compat_kex_proposal(&ssh, in);

crypto/openssh/regress/unittests/kex/test_proposal.c

81

result = compat_kex_proposal(&ssh, in);

crypto/openssh/regress/unittests/kex/test_proposal.c

94

struct ssh ssh;

crypto/openssh/servconf.h

49

struct ssh;

crypto/openssh/serverloop.c

107

client_alive_check(struct ssh *ssh)

crypto/openssh/serverloop.c

114

ssh_packet_inc_alive_timeouts(ssh) >

crypto/openssh/serverloop.c

116

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/serverloop.c

125

if ((channel_id = channel_find_open(ssh)) == -1) {

crypto/openssh/serverloop.c

126

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/serverloop.c

127

(r = sshpkt_put_cstring(ssh, "keepalive@openssh.com"))

crypto/openssh/serverloop.c

129

(r = sshpkt_put_u8(ssh, 1)) != 0) /* boolean: want reply */

crypto/openssh/serverloop.c

132

channel_request_start(ssh, channel_id,

crypto/openssh/serverloop.c

135

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/serverloop.c

145

wait_until_can_do_something(struct ssh *ssh,

crypto/openssh/serverloop.c

162

channel_prepare_poll(ssh, pfdp, npfd_allocp, npfd_activep, 2, &timeout);

crypto/openssh/serverloop.c

166

if (options.rekey_interval > 0 && !ssh_packet_is_rekeying(ssh)) {

crypto/openssh/serverloop.c

168

ssh_packet_get_rekey_timeout(ssh));

crypto/openssh/serverloop.c

176

if (channel_still_open(ssh) || unused_connection_expiry == 0) {

crypto/openssh/serverloop.c

208

(*pfdp)[1].events = ssh_packet_have_data_to_write(ssh) ? POLLOUT : 0;

crypto/openssh/serverloop.c

214

if (child_terminated && ssh_packet_not_very_much_data_to_write(ssh))

crypto/openssh/serverloop.c

237

client_alive_check(ssh);

crypto/openssh/serverloop.c

247

now > unused_connection_expiry && !channel_still_open(ssh)) {

crypto/openssh/serverloop.c

248

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/serverloop.c

259

process_input(struct ssh *ssh, int connection_in)

crypto/openssh/serverloop.c

263

if ((r = ssh_packet_process_read(ssh, connection_in)) == 0)

crypto/openssh/serverloop.c

270

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/serverloop.c

274

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/serverloop.c

285

process_output(struct ssh *ssh, int connection_out)

crypto/openssh/serverloop.c

290

if ((r = ssh_packet_write_poll(ssh)) != 0) {

crypto/openssh/serverloop.c

291

sshpkt_fatal(ssh, r, "%s: ssh_packet_write_poll",

crypto/openssh/serverloop.c

297

process_buffered_input_packets(struct ssh *ssh)

crypto/openssh/serverloop.c

299

ssh_dispatch_run_fatal(ssh, DISPATCH_NONBLOCK, NULL);

crypto/openssh/serverloop.c

303

collect_children(struct ssh *ssh)

crypto/openssh/serverloop.c

313

session_close_by_pid(ssh, pid, status);

crypto/openssh/serverloop.c

319

server_loop2(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/serverloop.c

333

connection_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/serverloop.c

334

connection_out = ssh_packet_get_connection_out(ssh);

crypto/openssh/serverloop.c

336

server_init_dispatch(ssh);

crypto/openssh/serverloop.c

339

process_buffered_input_packets(ssh);

crypto/openssh/serverloop.c

341

if (!ssh_packet_is_rekeying(ssh) &&

crypto/openssh/serverloop.c

342

ssh_packet_not_very_much_data_to_write(ssh))

crypto/openssh/serverloop.c

343

channel_output_poll(ssh);

crypto/openssh/serverloop.c

352

collect_children(ssh);

crypto/openssh/serverloop.c

353

wait_until_can_do_something(ssh, connection_in, connection_out,

crypto/openssh/serverloop.c

359

channel_after_poll(ssh, pfd, npfd_active);

crypto/openssh/serverloop.c

361

process_input(ssh, connection_in) < 0)

crypto/openssh/serverloop.c

364

if ((r = ssh_packet_check_rekey(ssh)) != 0)

crypto/openssh/serverloop.c

367

process_output(ssh, connection_out);

crypto/openssh/serverloop.c

369

collect_children(ssh);

crypto/openssh/serverloop.c

373

channel_free_all(ssh);

crypto/openssh/serverloop.c

376

session_destroy_all(ssh, NULL);

crypto/openssh/serverloop.c

380

server_input_keep_alive(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

388

ssh_packet_set_alive_timeouts(ssh, 0);

crypto/openssh/serverloop.c

393

server_request_direct_tcpip(struct ssh *ssh, int *reason, const char **errmsg)

crypto/openssh/serverloop.c

400

if ((r = sshpkt_get_cstring(ssh, &target, NULL)) != 0 ||

crypto/openssh/serverloop.c

401

(r = sshpkt_get_u32(ssh, &target_port)) != 0 ||

crypto/openssh/serverloop.c

402

(r = sshpkt_get_cstring(ssh, &originator, NULL)) != 0 ||

crypto/openssh/serverloop.c

403

(r = sshpkt_get_u32(ssh, &originator_port)) != 0 ||

crypto/openssh/serverloop.c

404

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

405

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

424

c = channel_connect_to_port(ssh, target, target_port,

crypto/openssh/serverloop.c

441

server_request_direct_streamlocal(struct ssh *ssh)

crypto/openssh/serverloop.c

452

if ((r = sshpkt_get_cstring(ssh, &target, NULL)) != 0 ||

crypto/openssh/serverloop.c

453

(r = sshpkt_get_cstring(ssh, &originator, NULL)) != 0 ||

crypto/openssh/serverloop.c

454

(r = sshpkt_get_u32(ssh, &originator_port)) != 0 ||

crypto/openssh/serverloop.c

455

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

456

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

469

c = channel_connect_to_path(ssh, target,

crypto/openssh/serverloop.c

484

server_request_tun(struct ssh *ssh)

crypto/openssh/serverloop.c

491

if ((r = sshpkt_get_u32(ssh, &mode)) != 0)

crypto/openssh/serverloop.c

492

sshpkt_fatal(ssh, r, "%s: parse mode", __func__);

crypto/openssh/serverloop.c

498

ssh_packet_send_debug(ssh, "Unsupported tunnel device mode.");

crypto/openssh/serverloop.c

502

ssh_packet_send_debug(ssh, "Server has rejected tunnel device "

crypto/openssh/serverloop.c

507

if ((r = sshpkt_get_u32(ssh, &tun)) != 0)

crypto/openssh/serverloop.c

508

sshpkt_fatal(ssh, r, "%s: parse device", __func__);

crypto/openssh/serverloop.c

524

c = channel_new(ssh, "tun", SSH_CHANNEL_OPEN, sock, sock, -1,

crypto/openssh/serverloop.c

529

channel_register_filter(ssh, c->self, sys_tun_infilter,

crypto/openssh/serverloop.c

548

ssh_packet_send_debug(ssh, "Failed to open the tunnel device.");

crypto/openssh/serverloop.c

553

server_request_session(struct ssh *ssh)

crypto/openssh/serverloop.c

559

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

560

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

563

ssh_packet_disconnect(ssh, "Possible attack: attempt to open a "

crypto/openssh/serverloop.c

573

c = channel_new(ssh, "session", SSH_CHANNEL_LARVAL,

crypto/openssh/serverloop.c

578

channel_free(ssh, c);

crypto/openssh/serverloop.c

581

channel_register_cleanup(ssh, c->self, session_close_by_channel, 0);

crypto/openssh/serverloop.c

586

server_input_channel_open(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

594

if ((r = sshpkt_get_cstring(ssh, &ctype, NULL)) != 0 ||

crypto/openssh/serverloop.c

595

(r = sshpkt_get_u32(ssh, &rchan)) != 0 ||

crypto/openssh/serverloop.c

596

(r = sshpkt_get_u32(ssh, &rwindow)) != 0 ||

crypto/openssh/serverloop.c

597

(r = sshpkt_get_u32(ssh, &rmaxpack)) != 0)

crypto/openssh/serverloop.c

598

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

603

c = server_request_session(ssh);

crypto/openssh/serverloop.c

605

c = server_request_direct_tcpip(ssh, &reason, &errmsg);

crypto/openssh/serverloop.c

607

c = server_request_direct_streamlocal(ssh);

crypto/openssh/serverloop.c

609

c = server_request_tun(ssh);

crypto/openssh/serverloop.c

618

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION)) != 0 ||

crypto/openssh/serverloop.c

619

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/serverloop.c

620

(r = sshpkt_put_u32(ssh, c->self)) != 0 ||

crypto/openssh/serverloop.c

621

(r = sshpkt_put_u32(ssh, c->local_window)) != 0 ||

crypto/openssh/serverloop.c

622

(r = sshpkt_put_u32(ssh, c->local_maxpacket)) != 0 ||

crypto/openssh/serverloop.c

623

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/serverloop.c

624

sshpkt_fatal(ssh, r,

crypto/openssh/serverloop.c

630

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE)) != 0 ||

crypto/openssh/serverloop.c

631

(r = sshpkt_put_u32(ssh, rchan)) != 0 ||

crypto/openssh/serverloop.c

632

(r = sshpkt_put_u32(ssh, reason)) != 0 ||

crypto/openssh/serverloop.c

633

(r = sshpkt_put_cstring(ssh, errmsg ? errmsg : "open failed")) != 0 ||

crypto/openssh/serverloop.c

634

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/serverloop.c

635

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/serverloop.c

636

sshpkt_fatal(ssh, r,

crypto/openssh/serverloop.c

645

server_input_hostkeys_prove(struct ssh *ssh, struct sshbuf **respp)

crypto/openssh/serverloop.c

659

ssh->kex->hostkey_alg)) == KEY_RSA)

crypto/openssh/serverloop.c

660

kex_rsa_sigalg = ssh->kex->hostkey_alg;

crypto/openssh/serverloop.c

661

while (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/serverloop.c

664

if ((r = sshpkt_get_string_direct(ssh, &blob, &blen)) != 0 ||

crypto/openssh/serverloop.c

673

if ((ndx = ssh->kex->host_key_index(key, 1, ssh)) == -1) {

crypto/openssh/serverloop.c

682

(key_pub = get_hostkey_public_by_index(ndx, ssh)) == NULL) {

crypto/openssh/serverloop.c

697

else if (ssh->kex->flags & KEX_RSA_SHA2_512_SUPPORTED)

crypto/openssh/serverloop.c

699

else if (ssh->kex->flags & KEX_RSA_SHA2_256_SUPPORTED)

crypto/openssh/serverloop.c

708

ssh->kex->session_id)) != 0 ||

crypto/openssh/serverloop.c

710

(r = ssh->kex->sign(ssh, key_prv, key_pub, &sig, &slen,

crypto/openssh/serverloop.c

730

server_input_global_request(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

744

if ((r = sshpkt_get_cstring(ssh, &rtype, NULL)) != 0 ||

crypto/openssh/serverloop.c

745

(r = sshpkt_get_u8(ssh, &want_reply)) != 0)

crypto/openssh/serverloop.c

746

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

751

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_host, NULL)) != 0 ||

crypto/openssh/serverloop.c

752

(r = sshpkt_get_u32(ssh, &port)) != 0)

crypto/openssh/serverloop.c

753

sshpkt_fatal(ssh, r, "%s: parse tcpip-forward", __func__);

crypto/openssh/serverloop.c

765

ssh_packet_send_debug(ssh, "Server has disabled port forwarding.");

crypto/openssh/serverloop.c

768

success = channel_setup_remote_fwd_listener(ssh, &fwd,

crypto/openssh/serverloop.c

777

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_host, NULL)) != 0 ||

crypto/openssh/serverloop.c

778

(r = sshpkt_get_u32(ssh, &port)) != 0)

crypto/openssh/serverloop.c

779

sshpkt_fatal(ssh, r, "%s: parse cancel-tcpip-forward", __func__);

crypto/openssh/serverloop.c

785

success = channel_cancel_rport_listener(ssh, &fwd);

crypto/openssh/serverloop.c

788

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_path, NULL)) != 0)

crypto/openssh/serverloop.c

789

sshpkt_fatal(ssh, r, "%s: parse streamlocal-forward@openssh.com", __func__);

crypto/openssh/serverloop.c

798

ssh_packet_send_debug(ssh, "Server has disabled "

crypto/openssh/serverloop.c

802

success = channel_setup_remote_fwd_listener(ssh,

crypto/openssh/serverloop.c

806

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_path, NULL)) != 0)

crypto/openssh/serverloop.c

807

sshpkt_fatal(ssh, r, "%s: parse cancel-streamlocal-forward@openssh.com", __func__);

crypto/openssh/serverloop.c

811

success = channel_cancel_rport_listener(ssh, &fwd);

crypto/openssh/serverloop.c

816

success = server_input_hostkeys_prove(ssh, &resp);

crypto/openssh/serverloop.c

820

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/serverloop.c

822

(success && resp != NULL && (r = sshpkt_putb(ssh, resp)) != 0) ||

crypto/openssh/serverloop.c

823

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/serverloop.c

824

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/serverloop.c

825

sshpkt_fatal(ssh, r, "%s: send reply", __func__);

crypto/openssh/serverloop.c

835

server_input_channel_req(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

843

if ((r = sshpkt_get_u32(ssh, &id)) != 0 ||

crypto/openssh/serverloop.c

844

(r = sshpkt_get_cstring(ssh, &rtype, NULL)) != 0 ||

crypto/openssh/serverloop.c

845

(r = sshpkt_get_u8(ssh, &want_reply)) != 0)

crypto/openssh/serverloop.c

846

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

851

if (id >= INT_MAX || (c = channel_lookup(ssh, (int)id)) == NULL) {

crypto/openssh/serverloop.c

852

ssh_packet_disconnect(ssh, "%s: unknown channel %d",

crypto/openssh/serverloop.c

856

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

857

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

858

chan_rcvd_eow(ssh, c);

crypto/openssh/serverloop.c

861

success = session_input_channel_req(ssh, c, rtype);

crypto/openssh/serverloop.c

865

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/serverloop.c

867

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/serverloop.c

868

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/serverloop.c

869

sshpkt_fatal(ssh, r, "%s: send reply", __func__);

crypto/openssh/serverloop.c

876

server_init_dispatch(struct ssh *ssh)

crypto/openssh/serverloop.c

879

ssh_dispatch_init(ssh, &dispatch_protocol_error);

crypto/openssh/serverloop.c

880

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);

crypto/openssh/serverloop.c

881

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_DATA, &channel_input_data);

crypto/openssh/serverloop.c

882

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);

crypto/openssh/serverloop.c

883

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);

crypto/openssh/serverloop.c

884

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN, &server_input_channel_open);

crypto/openssh/serverloop.c

885

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);

crypto/openssh/serverloop.c

886

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);

crypto/openssh/serverloop.c

887

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_REQUEST, &server_input_channel_req);

crypto/openssh/serverloop.c

888

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);

crypto/openssh/serverloop.c

889

ssh_dispatch_set(ssh, SSH2_MSG_GLOBAL_REQUEST, &server_input_global_request);

crypto/openssh/serverloop.c

891

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_SUCCESS, &server_input_keep_alive);

crypto/openssh/serverloop.c

892

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_FAILURE, &server_input_keep_alive);

crypto/openssh/serverloop.c

893

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_SUCCESS, &server_input_keep_alive);

crypto/openssh/serverloop.c

894

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_FAILURE, &server_input_keep_alive);

crypto/openssh/serverloop.c

896

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/serverloop.c

95

static void server_init_dispatch(struct ssh *);

crypto/openssh/serverloop.h

24

struct ssh;

crypto/openssh/serverloop.h

26

void server_loop2(struct ssh *, Authctxt *);

crypto/openssh/session.c

1172

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/session.c

1173

ssh_local_port(ssh));

crypto/openssh/session.c

1176

laddr = get_local_ipaddr(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1178

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/session.c

1179

laddr, ssh_local_port(ssh));

crypto/openssh/session.c

1207

do_rc_files(struct ssh *ssh, Session *s, const char *shell)

crypto/openssh/session.c

126

void session_set_fds(struct ssh *, Session *, int, int, int, int, int);

crypto/openssh/session.c

129

int session_setup_x11fwd(struct ssh *, Session *);

crypto/openssh/session.c

130

int do_exec_pty(struct ssh *, Session *, const char *);

crypto/openssh/session.c

131

int do_exec_no_pty(struct ssh *, Session *, const char *);

crypto/openssh/session.c

132

int do_exec(struct ssh *, Session *, const char *);

crypto/openssh/session.c

133

void do_login(struct ssh *, Session *, const char *);

crypto/openssh/session.c

134

void do_child(struct ssh *, Session *, const char *);

crypto/openssh/session.c

138

static void do_authenticated2(struct ssh *, Authctxt *);

crypto/openssh/session.c

140

static int session_pty_req(struct ssh *, Session *);

crypto/openssh/session.c

1473

child_close_fds(struct ssh *ssh)

crypto/openssh/session.c

1482

if (ssh_packet_get_connection_in(ssh) ==

crypto/openssh/session.c

1483

ssh_packet_get_connection_out(ssh))

crypto/openssh/session.c

1484

close(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1486

close(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1487

close(ssh_packet_get_connection_out(ssh));

crypto/openssh/session.c

1494

channel_close_all(ssh);

crypto/openssh/session.c

1521

do_child(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

1529

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/session.c

1532

ssh_packet_clear_keys(ssh);

crypto/openssh/session.c

1537

child_close_fds(ssh);

crypto/openssh/session.c

1582

env = do_setup_env(ssh, s, shell);

crypto/openssh/session.c

1595

child_close_fds(ssh);

crypto/openssh/session.c

1646

do_rc_files(ssh, s, shell);

crypto/openssh/session.c

1891

session_window_change_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1895

if ((r = sshpkt_get_u32(ssh, &s->col)) != 0 ||

crypto/openssh/session.c

1896

(r = sshpkt_get_u32(ssh, &s->row)) != 0 ||

crypto/openssh/session.c

1897

(r = sshpkt_get_u32(ssh, &s->xpixel)) != 0 ||

crypto/openssh/session.c

1898

(r = sshpkt_get_u32(ssh, &s->ypixel)) != 0 ||

crypto/openssh/session.c

1899

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

1900

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1906

session_pty_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1915

ssh_packet_disconnect(ssh, "Protocol error: you already have a pty.");

crypto/openssh/session.c

1919

if ((r = sshpkt_get_cstring(ssh, &s->term, NULL)) != 0 ||

crypto/openssh/session.c

1920

(r = sshpkt_get_u32(ssh, &s->col)) != 0 ||

crypto/openssh/session.c

1921

(r = sshpkt_get_u32(ssh, &s->row)) != 0 ||

crypto/openssh/session.c

1922

(r = sshpkt_get_u32(ssh, &s->xpixel)) != 0 ||

crypto/openssh/session.c

1923

(r = sshpkt_get_u32(ssh, &s->ypixel)) != 0)

crypto/openssh/session.c

1924

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1943

ssh_tty_parse_modes(ssh, s->ttyfd);

crypto/openssh/session.c

1945

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

1946

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

195

auth_input_request_forwarding(struct ssh *ssh, struct passwd * pw)

crypto/openssh/session.c

1956

session_subsystem_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1963

if ((r = sshpkt_get_cstring(ssh, &s->subsys, NULL)) != 0 ||

crypto/openssh/session.c

1964

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

1965

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1985

channel_set_xtype(ssh, s->chanid, type);

crypto/openssh/session.c

1987

success = do_exec(ssh, s, cmd) == 0;

crypto/openssh/session.c

2000

session_x11_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2010

if ((r = sshpkt_get_u8(ssh, &single_connection)) != 0 ||

crypto/openssh/session.c

2011

(r = sshpkt_get_cstring(ssh, &s->auth_proto, NULL)) != 0 ||

crypto/openssh/session.c

2012

(r = sshpkt_get_cstring(ssh, &s->auth_data, NULL)) != 0 ||

crypto/openssh/session.c

2013

(r = sshpkt_get_u32(ssh, &s->screen)) != 0 ||

crypto/openssh/session.c

2014

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2015

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2021

success = session_setup_x11fwd(ssh, s);

crypto/openssh/session.c

2036

session_shell_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2040

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2041

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2043

channel_set_xtype(ssh, s->chanid, "session:shell");

crypto/openssh/session.c

2045

return do_exec(ssh, s, NULL) == 0;

crypto/openssh/session.c

2049

session_exec_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2055

if ((r = sshpkt_get_cstring(ssh, &command, NULL)) != 0 ||

crypto/openssh/session.c

2056

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2057

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2059

channel_set_xtype(ssh, s->chanid, "session:command");

crypto/openssh/session.c

2061

success = do_exec(ssh, s, command) == 0;

crypto/openssh/session.c

2067

session_break_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2071

if ((r = sshpkt_get_u32(ssh, NULL)) != 0 || /* ignore */

crypto/openssh/session.c

2072

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2073

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2081

session_env_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2087

if ((r = sshpkt_get_cstring(ssh, &name, NULL)) != 0 ||

crypto/openssh/session.c

2088

(r = sshpkt_get_cstring(ssh, &val, NULL)) != 0 ||

crypto/openssh/session.c

2089

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2090

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

213

ssh_packet_send_debug(ssh, "Agent forwarding disabled: "

crypto/openssh/session.c

2142

session_signal_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2147

if ((r = sshpkt_get_cstring(ssh, &signame, NULL)) != 0 ||

crypto/openssh/session.c

2148

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/session.c

2184

session_auth_agent_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2189

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2190

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2201

return auth_input_request_forwarding(ssh, s->pw);

crypto/openssh/session.c

2206

session_input_channel_req(struct ssh *ssh, Channel *c, const char *rtype)

crypto/openssh/session.c

2223

success = session_shell_req(ssh, s);

crypto/openssh/session.c

2225

success = session_exec_req(ssh, s);

crypto/openssh/session.c

2227

success = session_pty_req(ssh, s);

crypto/openssh/session.c

2229

success = session_x11_req(ssh, s);

crypto/openssh/session.c

2231

success = session_auth_agent_req(ssh, s);

crypto/openssh/session.c

2233

success = session_subsystem_req(ssh, s);

crypto/openssh/session.c

2235

success = session_env_req(ssh, s);

crypto/openssh/session.c

2239

success = session_window_change_req(ssh, s);

crypto/openssh/session.c

2241

success = session_break_req(ssh, s);

crypto/openssh/session.c

2243

success = session_signal_req(ssh, s);

crypto/openssh/session.c

2250

session_set_fds(struct ssh *ssh, Session *s,

crypto/openssh/session.c

2259

channel_set_fds(ssh, s->chanid,

crypto/openssh/session.c

2330

session_close_x11(struct ssh *ssh, int id)

crypto/openssh/session.c

2334

if ((c = channel_by_id(ssh, id)) == NULL) {

crypto/openssh/session.c

2339

channel_cancel_cleanup(ssh, id);

crypto/openssh/session.c

2341

chan_mark_dead(ssh, c);

crypto/openssh/session.c

2346

session_close_single_x11(struct ssh *ssh, int id, int force, void *arg)

crypto/openssh/session.c

235

nc = channel_new(ssh, "auth-listener",

crypto/openssh/session.c

2352

channel_cancel_cleanup(ssh, id);

crypto/openssh/session.c

2363

session_close_x11(ssh, s->x11_chanids[i]);

crypto/openssh/session.c

2378

session_exit_message(struct ssh *ssh, Session *s, int status)

crypto/openssh/session.c

2384

if ((c = channel_lookup(ssh, s->chanid)) == NULL)

crypto/openssh/session.c

2388

channel_request_start(ssh, s->chanid, "exit-status", 0);

crypto/openssh/session.c

2389

if ((r = sshpkt_put_u32(ssh, WEXITSTATUS(status))) != 0 ||

crypto/openssh/session.c

2390

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/session.c

2391

sshpkt_fatal(ssh, r, "%s: exit reply", __func__);

crypto/openssh/session.c

2394

channel_request_start(ssh, s->chanid, "exit-signal", 0);

crypto/openssh/session.c

2398

if ((r = sshpkt_put_cstring(ssh, sig2name(WTERMSIG(status)))) != 0 ||

crypto/openssh/session.c

2399

(r = sshpkt_put_u8(ssh, WCOREDUMP(status)? 1 : 0)) != 0 ||

crypto/openssh/session.c

2400

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/session.c

2401

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/session.c

2402

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/session.c

2403

sshpkt_fatal(ssh, r, "%s: exit reply", __func__);

crypto/openssh/session.c

2408

ssh_packet_disconnect(ssh, "wait returned status %04x.",

crypto/openssh/session.c

2424

channel_register_cleanup(ssh, c->self, session_close_by_channel, 1);

crypto/openssh/session.c

2433

chan_write_failed(ssh, c);

crypto/openssh/session.c

2437

session_close(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2443

ssh_remote_ipaddr(ssh),

crypto/openssh/session.c

2444

ssh_remote_port(ssh),

crypto/openssh/session.c

2468

session_close_by_pid(struct ssh *ssh, pid_t pid, int status)

crypto/openssh/session.c

2476

session_exit_message(ssh, s, status);

crypto/openssh/session.c

2487

session_close_by_channel(struct ssh *ssh, int id, int force, void *arg)

crypto/openssh/session.c

2510

channel_cancel_cleanup(ssh, s->chanid);

crypto/openssh/session.c

2515

session_close_x11(ssh, s->x11_chanids[i]);

crypto/openssh/session.c

2521

session_close(ssh, s);

crypto/openssh/session.c

2525

session_destroy_all(struct ssh *ssh, void (*closefunc)(Session *))

crypto/openssh/session.c

2534

session_close(ssh, s);

crypto/openssh/session.c

2577

session_setup_x11fwd(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2585

ssh_packet_send_debug(ssh, "X11 forwarding disabled by key options.");

crypto/openssh/session.c

2594

ssh_packet_send_debug(ssh, "No xauth program; cannot forward X11.");

crypto/openssh/session.c

2601

if (x11_create_display_inet(ssh, options.x11_display_offset,

crypto/openssh/session.c

2608

channel_register_cleanup(ssh, s->x11_chanids[i],

crypto/openssh/session.c

2635

ssh_packet_send_debug(ssh, "Can't get IP address for X11 DISPLAY.");

crypto/openssh/session.c

2653

do_authenticated2(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

2655

server_loop2(ssh, authctxt);

crypto/openssh/session.c

2659

do_cleanup(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

2715

session_destroy_all(ssh, session_pty_cleanup2);

crypto/openssh/session.c

2721

session_get_remote_name_or_ip(struct ssh *ssh, u_int utmp_size, int use_dns)

crypto/openssh/session.c

2726

remote = auth_get_canonical_hostname(ssh, use_dns);

crypto/openssh/session.c

2728

remote = ssh_remote_ipaddr(ssh);

crypto/openssh/session.c

305

set_fwdpermit_from_authopts(struct ssh *ssh, const struct sshauthopt *opts)

crypto/openssh/session.c

312

channel_clear_permission(ssh, FORWARD_USER, FORWARD_LOCAL);

crypto/openssh/session.c

321

channel_add_permission(ssh,

crypto/openssh/session.c

327

channel_clear_permission(ssh, FORWARD_USER, FORWARD_REMOTE);

crypto/openssh/session.c

336

channel_add_permission(ssh,

crypto/openssh/session.c

344

do_authenticated(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

352

set_fwdpermit_from_authopts(ssh, auth_opts);

crypto/openssh/session.c

356

channel_disable_admin(ssh, FORWARD_LOCAL);

crypto/openssh/session.c

357

channel_disable_admin(ssh, FORWARD_REMOTE);

crypto/openssh/session.c

360

channel_disable_admin(ssh, FORWARD_LOCAL);

crypto/openssh/session.c

362

channel_permit_all(ssh, FORWARD_LOCAL);

crypto/openssh/session.c

364

channel_disable_admin(ssh, FORWARD_REMOTE);

crypto/openssh/session.c

366

channel_permit_all(ssh, FORWARD_REMOTE);

crypto/openssh/session.c

368

auth_debug_send(ssh);

crypto/openssh/session.c

372

do_authenticated2(ssh, authctxt);

crypto/openssh/session.c

374

do_cleanup(ssh, authctxt);

crypto/openssh/session.c

399

do_exec_no_pty(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

516

do_child(ssh, s, command);

crypto/openssh/session.c

528

ssh_packet_set_interactive(ssh, s->display != NULL,

crypto/openssh/session.c

544

session_set_fds(ssh, s, pin[1], pout[0], perr[0],

crypto/openssh/session.c

555

session_set_fds(ssh, s, inout[1], inout[1], err[1],

crypto/openssh/session.c

568

do_exec_pty(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

634

do_login(ssh, s, command);

crypto/openssh/session.c

640

do_child(ssh, s, command);

crypto/openssh/session.c

657

ssh_packet_set_interactive(ssh, 1,

crypto/openssh/session.c

659

session_set_fds(ssh, s, ptyfd, fdout, -1, 1, 1);

crypto/openssh/session.c

668

do_exec(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

714

ssh_remote_ipaddr(ssh),

crypto/openssh/session.c

715

ssh_remote_port(ssh),

crypto/openssh/session.c

730

ret = do_exec_pty(ssh, s, command);

crypto/openssh/session.c

732

ret = do_exec_no_pty(ssh, s, command);

crypto/openssh/session.c

748

do_login(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

759

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/session.c

760

if (getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/session.c

971

do_setup_env(struct ssh *ssh, Session *s, const char *shell)

crypto/openssh/session.h

66

void do_authenticated(struct ssh *, Authctxt *);

crypto/openssh/session.h

67

void do_cleanup(struct ssh *, Authctxt *);

crypto/openssh/session.h

71

int session_input_channel_req(struct ssh *, Channel *, const char *);

crypto/openssh/session.h

72

void session_close_by_pid(struct ssh *ssh, pid_t, int);

crypto/openssh/session.h

73

void session_close_by_channel(struct ssh *, int, int, void *);

crypto/openssh/session.h

74

void session_destroy_all(struct ssh *, void (*)(Session *));

crypto/openssh/session.h

79

void session_close(struct ssh *, Session *);

crypto/openssh/session.h

82

const char *session_get_remote_name_or_ip(struct ssh *, u_int, int);

crypto/openssh/ssh-keyscan.c

116

struct ssh *c_ssh; /* SSH-connection */

crypto/openssh/ssh-keyscan.c

210

key_print_wrapper(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/ssh-keyscan.c

214

if ((c = ssh_get_app_data(ssh)) != NULL)

crypto/openssh/ssh.c

1364

channel_set_af(ssh, options.address_family);

crypto/openssh/ssh.c

1676

ssh_packet_set_connection(ssh, sock, sock);

crypto/openssh/ssh.c

1677

ssh_packet_set_mux(ssh);

crypto/openssh/ssh.c

1699

channel_clear_timeouts(ssh);

crypto/openssh/ssh.c

1708

channel_add_timeout(ssh, cp, i);

crypto/openssh/ssh.c

1713

if (ssh_connect(ssh, host, options.host_arg, addrs, &hostaddr,

crypto/openssh/ssh.c

1721

ssh_packet_set_timeout(ssh, options.server_alive_interval,

crypto/openssh/ssh.c

1837

ssh_login(ssh, &sensitive_data, host, (struct sockaddr *)&hostaddr,

crypto/openssh/ssh.c

1870

exit_status = ssh_session2(ssh, cinfo);

crypto/openssh/ssh.c

1872

ssh_packet_close(ssh);

crypto/openssh/ssh.c

1955

ssh_confirm_remote_forward(struct ssh *ssh, int type, u_int32_t seq, void *ctxt)

crypto/openssh/ssh.c

196

static int ssh_session2(struct ssh *, const struct ssh_conn_info *);

crypto/openssh/ssh.c

1971

if ((r = sshpkt_get_u32(ssh, &port)) != 0)

crypto/openssh/ssh.c

1979

channel_update_permission(ssh,

crypto/openssh/ssh.c

1988

channel_update_permission(ssh,

crypto/openssh/ssh.c

1992

channel_update_permission(ssh, rfwd->handle, -1);

crypto/openssh/ssh.c

2017

client_cleanup_stdio_fwd(struct ssh *ssh, int id, int force, void *arg)

crypto/openssh/ssh.c

2024

ssh_stdio_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

2031

ssh_tun_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

2044

ssh_init_stdio_forwarding(struct ssh *ssh)

crypto/openssh/ssh.c

2058

if ((c = channel_connect_stdio_fwd(ssh, options.stdio_forward_host,

crypto/openssh/ssh.c

2062

channel_register_cleanup(ssh, c->self, client_cleanup_stdio_fwd, 0);

crypto/openssh/ssh.c

2063

channel_register_open_confirm(ssh, c->self, ssh_stdio_confirm, NULL);

crypto/openssh/ssh.c

2067

ssh_init_forward_permissions(struct ssh *ssh, const char *what, char **opens,

crypto/openssh/ssh.c

2075

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/ssh.c

2083

channel_disable_admin(ssh, where);

crypto/openssh/ssh.c

2096

channel_add_permission(ssh, FORWARD_ADM,

crypto/openssh/ssh.c

2103

ssh_init_forwarding(struct ssh *ssh, char **ifname)

crypto/openssh/ssh.c

2108

ssh_init_forward_permissions(ssh, "permitremoteopen",

crypto/openssh/ssh.c

2128

success += channel_setup_local_fwd_listener(ssh,

crypto/openssh/ssh.c

2150

channel_request_remote_forwarding(ssh,

crypto/openssh/ssh.c

2164

if ((*ifname = client_request_tun_fwd(ssh,

crypto/openssh/ssh.c

2195

ssh_session2_setup(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

2208

if (options.forward_x11 && client_x11_get_proto(ssh, display,

crypto/openssh/ssh.c

2214

x11_request_forwarding_with_spoofing(ssh, id, display, proto,

crypto/openssh/ssh.c

2216

client_expect_confirm(ssh, id, "X11 forwarding", CONFIRM_WARN);

crypto/openssh/ssh.c

2224

channel_request_start(ssh, id, "auth-agent-req@openssh.com", 0);

crypto/openssh/ssh.c

2225

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/ssh.c

2230

ssh_packet_set_interactive(ssh, interactive,

crypto/openssh/ssh.c

2236

client_session2_setup(ssh, id, tty_flag,

crypto/openssh/ssh.c

2243

ssh_session2_open(struct ssh *ssh)

crypto/openssh/ssh.c

2265

c = channel_new(ssh,

crypto/openssh/ssh.c

2272

channel_send_open(ssh, c->self);

crypto/openssh/ssh.c

2274

channel_register_open_confirm(ssh, c->self,

crypto/openssh/ssh.c

2281

ssh_session2(struct ssh *ssh, const struct ssh_conn_info *cinfo)

crypto/openssh/ssh.c

2288

ssh_init_stdio_forwarding(ssh);

crypto/openssh/ssh.c

2290

ssh_init_forwarding(ssh, &tun_fwd_ifname);

crypto/openssh/ssh.c

2304

if (!ssh_packet_get_mux(ssh))

crypto/openssh/ssh.c

2305

muxserver_listen(ssh);

crypto/openssh/ssh.c

2335

ssh_init_stdio_forwarding(ssh);

crypto/openssh/ssh.c

2338

id = ssh_session2_open(ssh);

crypto/openssh/ssh.c

2344

ssh_packet_set_interactive(ssh, interactive,

crypto/openssh/ssh.c

2350

(ssh->compat & SSH_NEW_OPENSSH)) {

crypto/openssh/ssh.c

2352

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/ssh.c

2353

(r = sshpkt_put_cstring(ssh,

crypto/openssh/ssh.c

2355

(r = sshpkt_put_u8(ssh, 0)) != 0 ||

crypto/openssh/ssh.c

2356

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/ssh.c

2387

return client_loop(ssh, tty_flag, tty_flag ?

crypto/openssh/ssh.c

675

struct ssh *ssh = NULL;

crypto/openssh/ssh.c

743

if ((ssh = ssh_alloc_session_state()) == NULL)

crypto/openssh/ssh.c

745

channel_init_channels(ssh);

crypto/openssh/ssh_api.c

101

if ((ssh = ssh_packet_set_connection(NULL, -1, -1)) == NULL)

crypto/openssh/ssh_api.c

104

ssh_packet_set_server(ssh);

crypto/openssh/ssh_api.c

108

kex_proposal_populate_entries(ssh, populated,

crypto/openssh/ssh_api.c

114

r = kex_ready(ssh, populated);

crypto/openssh/ssh_api.c

117

ssh_free(ssh);

crypto/openssh/ssh_api.c

121

ssh->kex->server = is_server;

crypto/openssh/ssh_api.c

124

ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_server;

crypto/openssh/ssh_api.c

125

ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_server;

crypto/openssh/ssh_api.c

126

ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_server;

crypto/openssh/ssh_api.c

127

ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_server;

crypto/openssh/ssh_api.c

128

ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_server;

crypto/openssh/ssh_api.c

129

ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_server;

crypto/openssh/ssh_api.c

130

ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_server;

crypto/openssh/ssh_api.c

132

ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_server;

crypto/openssh/ssh_api.c

135

ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_server;

crypto/openssh/ssh_api.c

136

ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_server;

crypto/openssh/ssh_api.c

137

ssh->kex->kex[KEX_KEM_MLKEM768X25519_SHA256] = kex_gen_server;

crypto/openssh/ssh_api.c

138

ssh->kex->load_host_public_key=&_ssh_host_public_key;

crypto/openssh/ssh_api.c

139

ssh->kex->load_host_private_key=&_ssh_host_private_key;

crypto/openssh/ssh_api.c

140

ssh->kex->sign=&_ssh_host_key_sign;

crypto/openssh/ssh_api.c

143

ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_client;

crypto/openssh/ssh_api.c

144

ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_client;

crypto/openssh/ssh_api.c

145

ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

146

ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

147

ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

148

ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;

crypto/openssh/ssh_api.c

149

ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;

crypto/openssh/ssh_api.c

151

ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_client;

crypto/openssh/ssh_api.c

154

ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

155

ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

156

ssh->kex->kex[KEX_KEM_MLKEM768X25519_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

157

ssh->kex->verify_host_key =&_ssh_verify_host_key;

crypto/openssh/ssh_api.c

159

*sshp = ssh;

crypto/openssh/ssh_api.c

164

ssh_free(struct ssh *ssh)

crypto/openssh/ssh_api.c

168

if (ssh == NULL)

crypto/openssh/ssh_api.c

175

while ((k = TAILQ_FIRST(&ssh->public_keys)) != NULL) {

crypto/openssh/ssh_api.c

176

TAILQ_REMOVE(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

177

if (ssh->kex && ssh->kex->server)

crypto/openssh/ssh_api.c

181

while ((k = TAILQ_FIRST(&ssh->private_keys)) != NULL) {

crypto/openssh/ssh_api.c

182

TAILQ_REMOVE(&ssh->private_keys, k, next);

crypto/openssh/ssh_api.c

185

ssh_packet_close(ssh);

crypto/openssh/ssh_api.c

186

free(ssh);

crypto/openssh/ssh_api.c

190

ssh_set_app_data(struct ssh *ssh, void *app_data)

crypto/openssh/ssh_api.c

192

ssh->app_data = app_data;

crypto/openssh/ssh_api.c

196

ssh_get_app_data(struct ssh *ssh)

crypto/openssh/ssh_api.c

198

return ssh->app_data;

crypto/openssh/ssh_api.c

203

ssh_add_hostkey(struct ssh *ssh, struct sshkey *key)

crypto/openssh/ssh_api.c

209

if (ssh->kex->server) {

crypto/openssh/ssh_api.c

219

TAILQ_INSERT_TAIL(&ssh->private_keys, k_prv, next);

crypto/openssh/ssh_api.c

223

TAILQ_INSERT_TAIL(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

229

TAILQ_INSERT_TAIL(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

237

ssh_set_verify_host_key_callback(struct ssh *ssh,

crypto/openssh/ssh_api.c

238

int (*cb)(struct sshkey *, struct ssh *))

crypto/openssh/ssh_api.c

240

if (cb == NULL || ssh->kex == NULL)

crypto/openssh/ssh_api.c

243

ssh->kex->verify_host_key = cb;

crypto/openssh/ssh_api.c

249

ssh_input_append(struct ssh *ssh, const u_char *data, size_t len)

crypto/openssh/ssh_api.c

251

return sshbuf_put(ssh_packet_get_input(ssh), data, len);

crypto/openssh/ssh_api.c

255

ssh_packet_next(struct ssh *ssh, u_char *typep)

crypto/openssh/ssh_api.c

266

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

crypto/openssh/ssh_api.c

267

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

crypto/openssh/ssh_api.c

268

return _ssh_exchange_banner(ssh);

crypto/openssh/ssh_api.c

281

if ((r = ssh_packet_read_poll2(ssh, &type, &seqnr)) != 0)

crypto/openssh/ssh_api.c

285

ssh->dispatch[type] != NULL) {

crypto/openssh/ssh_api.c

286

if ((r = (*ssh->dispatch[type])(type, seqnr, ssh)) != 0)

crypto/openssh/ssh_api.c

296

ssh_packet_payload(struct ssh *ssh, size_t *lenp)

crypto/openssh/ssh_api.c

298

return sshpkt_ptr(ssh, lenp);

crypto/openssh/ssh_api.c

302

ssh_packet_put(struct ssh *ssh, int type, const u_char *data, size_t len)

crypto/openssh/ssh_api.c

306

if ((r = sshpkt_start(ssh, type)) != 0 ||

crypto/openssh/ssh_api.c

307

(r = sshpkt_put(ssh, data, len)) != 0 ||

crypto/openssh/ssh_api.c

308

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/ssh_api.c

314

ssh_output_ptr(struct ssh *ssh, size_t *len)

crypto/openssh/ssh_api.c

316

struct sshbuf *output = ssh_packet_get_output(ssh);

crypto/openssh/ssh_api.c

323

ssh_output_consume(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

325

return sshbuf_consume(ssh_packet_get_output(ssh), len);

crypto/openssh/ssh_api.c

329

ssh_output_space(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

331

return (0 == sshbuf_check_reserve(ssh_packet_get_output(ssh), len));

crypto/openssh/ssh_api.c

335

ssh_input_space(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

337

return (0 == sshbuf_check_reserve(ssh_packet_get_input(ssh), len));

crypto/openssh/ssh_api.c

342

_ssh_read_banner(struct ssh *ssh, struct sshbuf *banner)

crypto/openssh/ssh_api.c

344

struct sshbuf *input = ssh_packet_get_input(ssh);

crypto/openssh/ssh_api.c

378

if (ssh->kex->server || ++n > SSH_MAX_PRE_BANNER_LINES) {

crypto/openssh/ssh_api.c

380

if ((r = sshbuf_put(ssh_packet_get_output(ssh),

crypto/openssh/ssh_api.c

408

compat_banner(ssh, remote_version);

crypto/openssh/ssh_api.c

42

int _ssh_exchange_banner(struct ssh *);

crypto/openssh/ssh_api.c

425

_ssh_send_banner(struct ssh *ssh, struct sshbuf *banner)

crypto/openssh/ssh_api.c

43

int _ssh_send_banner(struct ssh *, struct sshbuf *);

crypto/openssh/ssh_api.c

432

if ((r = sshbuf_putb(ssh_packet_get_output(ssh), banner)) != 0)

crypto/openssh/ssh_api.c

44

int _ssh_read_banner(struct ssh *, struct sshbuf *);

crypto/openssh/ssh_api.c

445

_ssh_exchange_banner(struct ssh *ssh)

crypto/openssh/ssh_api.c

447

struct kex *kex = ssh->kex;

crypto/openssh/ssh_api.c

45

int _ssh_order_hostkeyalgs(struct ssh *);

crypto/openssh/ssh_api.c

457

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

crypto/openssh/ssh_api.c

458

r = _ssh_send_banner(ssh, ssh->kex->server_version);

crypto/openssh/ssh_api.c

46

int _ssh_verify_host_key(struct sshkey *, struct ssh *);

crypto/openssh/ssh_api.c

460

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

crypto/openssh/ssh_api.c

461

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

crypto/openssh/ssh_api.c

462

r = _ssh_read_banner(ssh, ssh->kex->client_version);

crypto/openssh/ssh_api.c

464

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

crypto/openssh/ssh_api.c

465

r = _ssh_read_banner(ssh, ssh->kex->server_version);

crypto/openssh/ssh_api.c

467

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

crypto/openssh/ssh_api.c

468

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

crypto/openssh/ssh_api.c

469

r = _ssh_send_banner(ssh, ssh->kex->client_version);

crypto/openssh/ssh_api.c

47

struct sshkey *_ssh_host_public_key(int, int, struct ssh *);

crypto/openssh/ssh_api.c

474

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

crypto/openssh/ssh_api.c

475

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

crypto/openssh/ssh_api.c

476

if ((r = _ssh_order_hostkeyalgs(ssh)) != 0 ||

crypto/openssh/ssh_api.c

477

(r = kex_send_kexinit(ssh)) != 0)

crypto/openssh/ssh_api.c

48

struct sshkey *_ssh_host_private_key(int, int, struct ssh *);

crypto/openssh/ssh_api.c

484

_ssh_host_public_key(int type, int nid, struct ssh *ssh)

crypto/openssh/ssh_api.c

489

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

49

int _ssh_host_key_sign(struct ssh *, struct sshkey *, struct sshkey *,

crypto/openssh/ssh_api.c

499

_ssh_host_private_key(int type, int nid, struct ssh *ssh)

crypto/openssh/ssh_api.c

504

TAILQ_FOREACH(k, &ssh->private_keys, next) {

crypto/openssh/ssh_api.c

514

_ssh_verify_host_key(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/ssh_api.c

519

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

529

_ssh_order_hostkeyalgs(struct ssh *ssh)

crypto/openssh/ssh_api.c

538

if ((r = kex_buf2prop(ssh->kex->my, NULL, &proposal)) != 0)

crypto/openssh/ssh_api.c

555

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

571

debug2_f("orig/%d %s", ssh->kex->server, orig);

crypto/openssh/ssh_api.c

572

debug2_f("replace/%d %s", ssh->kex->server, replace);

crypto/openssh/ssh_api.c

576

r = kex_prop2buf(ssh->kex->my, proposal);

crypto/openssh/ssh_api.c

586

_ssh_host_key_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/ssh_api.c

591

alg, NULL, NULL, ssh->compat);

crypto/openssh/ssh_api.c

87

ssh_init(struct ssh **sshp, int is_server, struct kex_params *kex_params)

crypto/openssh/ssh_api.c

91

struct ssh *ssh;

crypto/openssh/ssh_api.h

103

int ssh_packet_put(struct ssh *ssh, int type, const u_char *data,

crypto/openssh/ssh_api.h

110

int ssh_input_space(struct ssh *ssh, size_t len);

crypto/openssh/ssh_api.h

115

int ssh_input_append(struct ssh *ssh, const u_char *data, size_t len);

crypto/openssh/ssh_api.h

121

int ssh_output_space(struct ssh *ssh, size_t len);

crypto/openssh/ssh_api.h

129

const u_char *ssh_output_ptr(struct ssh *ssh, size_t *len);

crypto/openssh/ssh_api.h

135

int ssh_output_consume(struct ssh *ssh, size_t len);

crypto/openssh/ssh_api.h

43

int ssh_init(struct ssh **, int is_server, struct kex_params *kex_params);

crypto/openssh/ssh_api.h

48

void ssh_free(struct ssh *);

crypto/openssh/ssh_api.h

53

void ssh_set_app_data(struct ssh *, void *);

crypto/openssh/ssh_api.h

54

void *ssh_get_app_data(struct ssh *);

crypto/openssh/ssh_api.h

64

int ssh_add_hostkey(struct ssh *ssh, struct sshkey *key);

crypto/openssh/ssh_api.h

72

int ssh_set_verify_host_key_callback(struct ssh *ssh,

crypto/openssh/ssh_api.h

73

int (*cb)(struct sshkey *, struct ssh *));

crypto/openssh/ssh_api.h

89

int ssh_packet_next(struct ssh *ssh, u_char *typep);

crypto/openssh/ssh_api.h

96

const u_char *ssh_packet_payload(struct ssh *ssh, size_t *lenp);

crypto/openssh/sshconnect.c

114

ssh_proxy_fdpass_connect(struct ssh *ssh, const char *host,

crypto/openssh/sshconnect.c

1600

ssh_login(struct ssh *ssh, Sensitive *sensitive, const char *orighost,

crypto/openssh/sshconnect.c

1616

if ((r = kex_exchange_identification(ssh, timeout_ms,

crypto/openssh/sshconnect.c

1618

sshpkt_fatal(ssh, r, "banner exchange");

crypto/openssh/sshconnect.c

1621

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshconnect.c

1626

ssh_kex2(ssh, host, hostaddr, port, cinfo);

crypto/openssh/sshconnect.c

1627

ssh_userauth2(ssh, local_user, server_user, host, sensitive);

crypto/openssh/sshconnect.c

186

if (ssh_packet_set_connection(ssh, sock, sock) == NULL)

crypto/openssh/sshconnect.c

196

ssh_proxy_connect(struct ssh *ssh, const char *host, const char *host_arg,

crypto/openssh/sshconnect.c

269

if (ssh_packet_set_connection(ssh, pout[0], pin[1]) == NULL)

crypto/openssh/sshconnect.c

448

ssh_connect_direct(struct ssh *ssh, const char *host, struct addrinfo *aitop,

crypto/openssh/sshconnect.c

548

if (ssh_packet_set_connection(ssh, sock, sock) == NULL)

crypto/openssh/sshconnect.c

555

ssh_connect(struct ssh *ssh, const char *host, const char *host_arg,

crypto/openssh/sshconnect.c

562

return ssh_connect_direct(ssh, host, addrs, hostaddr, port,

crypto/openssh/sshconnect.c

572

if ((ssh_packet_set_connection(ssh, in, out)) == NULL)

crypto/openssh/sshconnect.c

576

return ssh_proxy_fdpass_connect(ssh, host, host_arg, port,

crypto/openssh/sshconnect.c

579

return ssh_proxy_connect(ssh, host, host_arg, port,

crypto/openssh/sshconnect.h

51

struct ssh;

crypto/openssh/sshconnect.h

74

int ssh_connect(struct ssh *, const char *, const char *,

crypto/openssh/sshconnect.h

79

void ssh_login(struct ssh *, Sensitive *, const char *,

crypto/openssh/sshconnect.h

89

void ssh_kex2(struct ssh *ssh, char *, struct sockaddr *, u_short,

crypto/openssh/sshconnect.h

92

void ssh_userauth2(struct ssh *ssh, const char *, const char *,

crypto/openssh/sshconnect2.c

1004

if ((r = sshpkt_get_u32(ssh, NULL)) != 0 || /* maj */

crypto/openssh/sshconnect2.c

1005

(r = sshpkt_get_u32(ssh, NULL)) != 0 || /* min */

crypto/openssh/sshconnect2.c

1006

(r = sshpkt_get_cstring(ssh, &msg, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1007

(r = sshpkt_get_cstring(ssh, &lang, NULL)) != 0)

crypto/openssh/sshconnect2.c

1009

r = sshpkt_get_end(ssh);

crypto/openssh/sshconnect2.c

1019

userauth_none(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1021

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1025

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1026

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1027

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1028

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1029

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1035

userauth_passwd(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1037

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1051

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1052

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1053

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1054

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1055

(r = sshpkt_put_u8(ssh, 0)) != 0 ||

crypto/openssh/sshconnect2.c

1056

(r = sshpkt_put_cstring(ssh, password)) != 0 ||

crypto/openssh/sshconnect2.c

1057

(r = sshpkt_add_padding(ssh, 64)) != 0 ||

crypto/openssh/sshconnect2.c

1058

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1065

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

crypto/openssh/sshconnect2.c

1075

input_userauth_passwd_changereq(int type, u_int32_t seqnr, struct ssh *ssh)

crypto/openssh/sshconnect2.c

1077

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

1090

if ((r = sshpkt_get_cstring(ssh, &info, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1091

(r = sshpkt_get_cstring(ssh, &lang, NULL)) != 0)

crypto/openssh/sshconnect2.c

1095

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1096

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1097

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1098

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1099

(r = sshpkt_put_u8(ssh, 1)) != 0) /* additional info */

crypto/openssh/sshconnect2.c

1106

if ((r = sshpkt_put_cstring(ssh, password)) != 0)

crypto/openssh/sshconnect2.c

1132

if ((r = sshpkt_put_cstring(ssh, password)) != 0 ||

crypto/openssh/sshconnect2.c

1133

(r = sshpkt_add_padding(ssh, 64)) != 0 ||

crypto/openssh/sshconnect2.c

1134

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1137

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

crypto/openssh/sshconnect2.c

1156

key_sig_algorithm(struct ssh *ssh, const struct sshkey *key)

crypto/openssh/sshconnect2.c

1166

if (ssh == NULL || ssh->kex->server_sig_algs == NULL ||

crypto/openssh/sshconnect2.c

1168

(key->type == KEY_RSA_CERT && (ssh->compat & SSH_BUG_SIGTYPE))) {

crypto/openssh/sshconnect2.c

1178

server_sig_algs = ssh->kex->server_sig_algs;

crypto/openssh/sshconnect2.c

1179

if (key->type == KEY_RSA && (ssh->compat & SSH_BUG_SIGTYPE74))

crypto/openssh/sshconnect2.c

1311

sign_and_send_pubkey(struct ssh *ssh, Identity *id)

crypto/openssh/sshconnect2.c

1313

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1324

if ((ssh->kex->flags & KEX_HAS_PUBKEY_HOSTBOUND) != 0 &&

crypto/openssh/sshconnect2.c

1392

if ((alg = key_sig_algorithm(fallback_sigtype ? NULL : ssh,

crypto/openssh/sshconnect2.c

1402

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/sshconnect2.c

1403

if ((r = sshbuf_putb(b, ssh->kex->session_id)) != 0)

crypto/openssh/sshconnect2.c

1407

ssh->kex->session_id)) != 0)

crypto/openssh/sshconnect2.c

1421

if (ssh->kex->initial_hostkey == NULL) {

crypto/openssh/sshconnect2.c

1425

if ((r = sshkey_puts(ssh->kex->initial_hostkey, b)) != 0)

crypto/openssh/sshconnect2.c

1430

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

crypto/openssh/sshconnect2.c

1465

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1466

(r = sshpkt_putb(ssh, b)) != 0 ||

crypto/openssh/sshconnect2.c

1467

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1482

send_pubkey_test(struct ssh *ssh, Identity *id)

crypto/openssh/sshconnect2.c

1484

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1491

if ((alg = key_sig_algorithm(ssh, id->key)) == NULL) {

crypto/openssh/sshconnect2.c

1502

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);

crypto/openssh/sshconnect2.c

1504

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1505

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1506

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1507

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1508

(r = sshpkt_put_u8(ssh, have_sig)) != 0 ||

crypto/openssh/sshconnect2.c

1509

(r = sshpkt_put_cstring(ssh, alg)) != 0 ||

crypto/openssh/sshconnect2.c

1510

(r = sshpkt_put_string(ssh, blob, bloblen)) != 0 ||

crypto/openssh/sshconnect2.c

1511

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1631

get_agent_identities(struct ssh *ssh, int *agent_fdp,

crypto/openssh/sshconnect2.c

1642

if ((r = ssh_agent_bind_hostkey(agent_fd, ssh->kex->initial_hostkey,

crypto/openssh/sshconnect2.c

1643

ssh->kex->session_id, ssh->kex->initial_sig, 0)) == 0)

crypto/openssh/sshconnect2.c

1669

pubkey_prepare(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/sshconnect2.c

1731

if ((r = get_agent_identities(ssh, &agent_fd, &idlist)) == 0) {

crypto/openssh/sshconnect2.c

1804

} else if (ssh->kex->server_sig_algs != NULL &&

crypto/openssh/sshconnect2.c

1805

(cp = key_sig_algorithm(ssh, id->key)) == NULL) {

crypto/openssh/sshconnect2.c

1830

pubkey_cleanup(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1832

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1858

userauth_pubkey(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1860

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1867

pubkey_prepare(ssh, authctxt);

crypto/openssh/sshconnect2.c

1886

sent = send_pubkey_test(ssh, id);

crypto/openssh/sshconnect2.c

1892

sent = sign_and_send_pubkey(ssh, id);

crypto/openssh/sshconnect2.c

1908

userauth_kbdint(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1910

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1918

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_REQUEST, NULL);

crypto/openssh/sshconnect2.c

1923

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1924

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1925

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1926

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1927

(r = sshpkt_put_cstring(ssh, "")) != 0 || /* lang */

crypto/openssh/sshconnect2.c

1928

(r = sshpkt_put_cstring(ssh, options.kbd_interactive_devices ?

crypto/openssh/sshconnect2.c

1930

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1933

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);

crypto/openssh/sshconnect2.c

1941

input_userauth_info_req(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

1943

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

1957

if ((r = sshpkt_get_cstring(ssh, &name, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1958

(r = sshpkt_get_cstring(ssh, &inst, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1959

(r = sshpkt_get_cstring(ssh, &lang, NULL)) != 0)

crypto/openssh/sshconnect2.c

1966

if ((r = sshpkt_get_u32(ssh, &num_prompts)) != 0)

crypto/openssh/sshconnect2.c

1974

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE)) != 0 ||

crypto/openssh/sshconnect2.c

1975

(r = sshpkt_put_u32(ssh, num_prompts)) != 0)

crypto/openssh/sshconnect2.c

1980

if ((r = sshpkt_get_cstring(ssh, &prompt, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1981

(r = sshpkt_get_u8(ssh, &echo)) != 0)

crypto/openssh/sshconnect2.c

1988

if ((r = sshpkt_put_cstring(ssh, response)) != 0)

crypto/openssh/sshconnect2.c

1996

if ((r = sshpkt_get_end(ssh)) != 0 ||

crypto/openssh/sshconnect2.c

1997

(r = sshpkt_add_padding(ssh, 64)) != 0)

crypto/openssh/sshconnect2.c

1999

r = sshpkt_send(ssh);

crypto/openssh/sshconnect2.c

2012

ssh_keysign(struct ssh *ssh, struct sshkey *key, u_char **sigp, size_t *lenp,

crypto/openssh/sshconnect2.c

2019

int sock = ssh_packet_get_connection_in(ssh);

crypto/openssh/sshconnect2.c

2128

userauth_hostbased(struct ssh *ssh)

crypto/openssh/sshconnect2.c

2130

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

218

ssh_kex2(struct ssh *ssh, char *host, struct sockaddr *hostaddr, u_short port,

crypto/openssh/sshconnect2.c

2193

lname = get_local_name(ssh_packet_get_connection_in(ssh));

crypto/openssh/sshconnect2.c

2212

if ((r = sshbuf_put_stringb(b, ssh->kex->session_id)) != 0 ||

crypto/openssh/sshconnect2.c

2228

if ((r = ssh_keysign(ssh, private, &sig, &siglen,

crypto/openssh/sshconnect2.c

2234

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

2235

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

2236

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

2237

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

2238

(r = sshpkt_put_cstring(ssh, authctxt->active_ktype)) != 0 ||

crypto/openssh/sshconnect2.c

2239

(r = sshpkt_put_string(ssh, keyblob, keylen)) != 0 ||

crypto/openssh/sshconnect2.c

2240

(r = sshpkt_put_cstring(ssh, chost)) != 0 ||

crypto/openssh/sshconnect2.c

2241

(r = sshpkt_put_cstring(ssh, authctxt->local_user)) != 0 ||

crypto/openssh/sshconnect2.c

2242

(r = sshpkt_put_string(ssh, sig, siglen)) != 0 ||

crypto/openssh/sshconnect2.c

2243

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/sshconnect2.c

230

ssh_packet_set_rekey_limits(ssh, options.rekey_limit,

crypto/openssh/sshconnect2.c

253

kex_proposal_populate_entries(ssh, myproposal,

crypto/openssh/sshconnect2.c

261

if ((r = kex_setup(ssh, myproposal)) != 0)

crypto/openssh/sshconnect2.c

264

ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_client;

crypto/openssh/sshconnect2.c

265

ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_client;

crypto/openssh/sshconnect2.c

266

ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_client;

crypto/openssh/sshconnect2.c

267

ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_client;

crypto/openssh/sshconnect2.c

268

ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_client;

crypto/openssh/sshconnect2.c

269

ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;

crypto/openssh/sshconnect2.c

270

ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;

crypto/openssh/sshconnect2.c

272

ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_client;

crypto/openssh/sshconnect2.c

275

ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_client;

crypto/openssh/sshconnect2.c

276

ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_client;

crypto/openssh/sshconnect2.c

277

ssh->kex->kex[KEX_KEM_MLKEM768X25519_SHA256] = kex_gen_client;

crypto/openssh/sshconnect2.c

278

ssh->kex->verify_host_key=&verify_host_key_callback;

crypto/openssh/sshconnect2.c

280

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &ssh->kex->done);

crypto/openssh/sshconnect2.c

285

if ((r = sshpkt_start(ssh, SSH2_MSG_IGNORE)) != 0 ||

crypto/openssh/sshconnect2.c

286

(r = sshpkt_put_cstring(ssh, "markus")) != 0 ||

crypto/openssh/sshconnect2.c

287

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/sshconnect2.c

288

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/sshconnect2.c

344

int (*userauth)(struct ssh *ssh);

crypto/openssh/sshconnect2.c

345

void (*cleanup)(struct ssh *ssh);

crypto/openssh/sshconnect2.c

350

static int input_userauth_service_accept(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

351

static int input_userauth_success(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

352

static int input_userauth_failure(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

353

static int input_userauth_banner(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

354

static int input_userauth_error(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

355

static int input_userauth_info_req(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

356

static int input_userauth_pk_ok(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

357

static int input_userauth_passwd_changereq(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

359

static int userauth_none(struct ssh *);

crypto/openssh/sshconnect2.c

360

static int userauth_pubkey(struct ssh *);

crypto/openssh/sshconnect2.c

361

static int userauth_passwd(struct ssh *);

crypto/openssh/sshconnect2.c

362

static int userauth_kbdint(struct ssh *);

crypto/openssh/sshconnect2.c

363

static int userauth_hostbased(struct ssh *);

crypto/openssh/sshconnect2.c

366

static int userauth_gssapi(struct ssh *);

crypto/openssh/sshconnect2.c

367

static void userauth_gssapi_cleanup(struct ssh *);

crypto/openssh/sshconnect2.c

368

static int input_gssapi_response(int type, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

369

static int input_gssapi_token(int type, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

370

static int input_gssapi_error(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

371

static int input_gssapi_errtok(int, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

374

void userauth(struct ssh *, char *);

crypto/openssh/sshconnect2.c

376

static void pubkey_cleanup(struct ssh *);

crypto/openssh/sshconnect2.c

377

static int sign_and_send_pubkey(struct ssh *ssh, Identity *);

crypto/openssh/sshconnect2.c

378

static void pubkey_prepare(struct ssh *, Authctxt *);

crypto/openssh/sshconnect2.c

423

ssh_userauth2(struct ssh *ssh, const char *local_user,

crypto/openssh/sshconnect2.c

455

if ((r = sshpkt_start(ssh, SSH2_MSG_SERVICE_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

456

(r = sshpkt_put_cstring(ssh, "ssh-userauth")) != 0 ||

crypto/openssh/sshconnect2.c

457

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

460

ssh->authctxt = &authctxt;

crypto/openssh/sshconnect2.c

461

ssh_dispatch_init(ssh, &input_userauth_error);

crypto/openssh/sshconnect2.c

462

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, kex_input_ext_info);

crypto/openssh/sshconnect2.c

463

ssh_dispatch_set(ssh, SSH2_MSG_SERVICE_ACCEPT, &input_userauth_service_accept);

crypto/openssh/sshconnect2.c

464

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &authctxt.success); /* loop until success */

crypto/openssh/sshconnect2.c

465

pubkey_cleanup(ssh);

crypto/openssh/sshconnect2.c

474

ssh->authctxt = NULL;

crypto/openssh/sshconnect2.c

476

ssh_dispatch_range(ssh, SSH2_MSG_USERAUTH_MIN, SSH2_MSG_USERAUTH_MAX, NULL);

crypto/openssh/sshconnect2.c

480

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/sshconnect2.c

482

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/sshconnect2.c

491

input_userauth_service_accept(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

495

if (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/sshconnect2.c

498

if ((r = sshpkt_get_cstring(ssh, &reply, NULL)) != 0)

crypto/openssh/sshconnect2.c

505

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

510

userauth_none(ssh);

crypto/openssh/sshconnect2.c

513

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, ssh->kex->ext_info_s ?

crypto/openssh/sshconnect2.c

515

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);

crypto/openssh/sshconnect2.c

516

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);

crypto/openssh/sshconnect2.c

517

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);

crypto/openssh/sshconnect2.c

524

userauth(struct ssh *ssh, char *authlist)

crypto/openssh/sshconnect2.c

526

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

529

authctxt->method->cleanup(ssh);

crypto/openssh/sshconnect2.c

547

ssh_dispatch_range(ssh, SSH2_MSG_USERAUTH_PER_METHOD_MIN,

crypto/openssh/sshconnect2.c

551

if (method->userauth(ssh) != 0) {

crypto/openssh/sshconnect2.c

562

input_userauth_error(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

569

input_userauth_banner(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

576

if ((r = sshpkt_get_cstring(ssh, &msg, &len)) != 0 ||

crypto/openssh/sshconnect2.c

577

(r = sshpkt_get_cstring(ssh, NULL, NULL)) != 0)

crypto/openssh/sshconnect2.c

588

input_userauth_success(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

590

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

597

authctxt->method->cleanup(ssh);

crypto/openssh/sshconnect2.c

601

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, dispatch_protocol_error);

crypto/openssh/sshconnect2.c

607

input_userauth_success_unexpected(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

609

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

621

input_userauth_failure(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

623

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

630

if (sshpkt_get_cstring(ssh, &authlist, NULL) != 0 ||

crypto/openssh/sshconnect2.c

631

sshpkt_get_u8(ssh, &partial) != 0 ||

crypto/openssh/sshconnect2.c

632

sshpkt_get_end(ssh) != 0)

crypto/openssh/sshconnect2.c

643

userauth(ssh, authlist);

crypto/openssh/sshconnect2.c

681

input_userauth_pk_ok(int type, u_int32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

683

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

695

if ((r = sshpkt_get_cstring(ssh, &pkalg, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

696

(r = sshpkt_get_string(ssh, &pkblob, &blen)) != 0 ||

crypto/openssh/sshconnect2.c

697

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

738

sent = sign_and_send_pubkey(ssh, id);

crypto/openssh/sshconnect2.c

749

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

755

userauth_gssapi(struct ssh *ssh)

crypto/openssh/sshconnect2.c

757

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

788

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

789

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

790

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

791

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

792

(r = sshpkt_put_u32(ssh, 1)) != 0 ||

crypto/openssh/sshconnect2.c

793

(r = sshpkt_put_u32(ssh, (mech->length) + 2)) != 0 ||

crypto/openssh/sshconnect2.c

794

(r = sshpkt_put_u8(ssh, SSH_GSS_OIDTYPE)) != 0 ||

crypto/openssh/sshconnect2.c

795

(r = sshpkt_put_u8(ssh, mech->length)) != 0 ||

crypto/openssh/sshconnect2.c

796

(r = sshpkt_put(ssh, mech->elements, mech->length)) != 0 ||

crypto/openssh/sshconnect2.c

797

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

800

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_RESPONSE, &input_gssapi_response);

crypto/openssh/sshconnect2.c

801

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);

crypto/openssh/sshconnect2.c

802

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERROR, &input_gssapi_error);

crypto/openssh/sshconnect2.c

803

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);

crypto/openssh/sshconnect2.c

811

userauth_gssapi_cleanup(struct ssh *ssh)

crypto/openssh/sshconnect2.c

813

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

821

process_gssapi_token(struct ssh *ssh, gss_buffer_t recv_tok)

crypto/openssh/sshconnect2.c

823

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

839

if ((r = sshpkt_start(ssh, type)) != 0 ||

crypto/openssh/sshconnect2.c

840

(r = sshpkt_put_string(ssh, send_tok.value,

crypto/openssh/sshconnect2.c

842

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

851

if ((r = sshpkt_start(ssh,

crypto/openssh/sshconnect2.c

853

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

862

ssh->kex->session_id);

crypto/openssh/sshconnect2.c

871

if ((r = sshpkt_start(ssh,

crypto/openssh/sshconnect2.c

873

(r = sshpkt_put_string(ssh, mic.value,

crypto/openssh/sshconnect2.c

875

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

888

input_gssapi_response(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/sshconnect2.c

890

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

901

if ((r = sshpkt_get_string(ssh, &oidv, &oidlen)) != 0)

crypto/openssh/sshconnect2.c

908

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

915

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

918

if (GSS_ERROR(process_gssapi_token(ssh, GSS_C_NO_BUFFER))) {

crypto/openssh/sshconnect2.c

921

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

932

input_gssapi_token(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/sshconnect2.c

934

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

94

verify_host_key_callback(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/sshconnect2.c

944

if ((r = sshpkt_get_string(ssh, &p, &len)) != 0 ||

crypto/openssh/sshconnect2.c

945

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

950

status = process_gssapi_token(ssh, &recv_tok);

crypto/openssh/sshconnect2.c

954

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

964

input_gssapi_errtok(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/sshconnect2.c

966

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

979

if ((r = sshpkt_get_string(ssh, &p, &len)) != 0 ||

crypto/openssh/sshconnect2.c

980

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/sshconnect2.c

998

input_gssapi_error(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/sshd-auth.c

150

struct ssh *the_active_state;

crypto/openssh/sshd-auth.c

165

static void do_ssh2_kex(struct ssh *);

crypto/openssh/sshd-auth.c

292

get_hostkey_public_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-auth.c

331

get_hostkey_private_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-auth.c

344

get_hostkey_public_by_index(int ind, struct ssh *ssh)

crypto/openssh/sshd-auth.c

352

get_hostkey_index(struct sshkey *key, int compare, struct ssh *ssh)

crypto/openssh/sshd-auth.c

424

recv_privsep_state(struct ssh *ssh, struct sshbuf *conf,

crypto/openssh/sshd-auth.c

431

mm_get_state(ssh, &includes, conf, NULL, timing_secretp,

crypto/openssh/sshd-auth.c

446

struct ssh *ssh = NULL;

crypto/openssh/sshd-auth.c

571

connection_info = server_get_connection_info(ssh, 0, 0);

crypto/openssh/sshd-auth.c

660

if ((ssh = ssh_packet_set_connection(NULL, sock_in, sock_out)) == NULL)

crypto/openssh/sshd-auth.c

662

the_active_state = ssh;

crypto/openssh/sshd-auth.c

663

ssh_packet_set_server(ssh);

crypto/openssh/sshd-auth.c

664

pmonitor->m_pkex = &ssh->kex;

crypto/openssh/sshd-auth.c

670

recv_privsep_state(ssh, cfg, &timing_secret);

crypto/openssh/sshd-auth.c

756

channel_init_channels(ssh);

crypto/openssh/sshd-auth.c

757

channel_set_af(ssh, options.address_family);

crypto/openssh/sshd-auth.c

758

server_process_channel_timeouts(ssh);

crypto/openssh/sshd-auth.c

759

server_process_permitopen(ssh);

crypto/openssh/sshd-auth.c

761

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshd-auth.c

765

ssh->authctxt = authctxt;

crypto/openssh/sshd-auth.c

791

do_ssh2_kex(ssh);

crypto/openssh/sshd-auth.c

792

do_authentication2(ssh);

crypto/openssh/sshd-auth.c

797

mm_send_keystate(ssh, pmonitor);

crypto/openssh/sshd-auth.c

798

ssh_packet_clear_keys(ssh);

crypto/openssh/sshd-auth.c

803

sshd_hostkey_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/sshd-auth.c

808

if (mm_sshkey_sign(ssh, privkey, signature, slenp,

crypto/openssh/sshd-auth.c

810

ssh->compat) < 0)

crypto/openssh/sshd-auth.c

813

if (mm_sshkey_sign(ssh, pubkey, signature, slenp,

crypto/openssh/sshd-auth.c

815

ssh->compat) < 0)

crypto/openssh/sshd-auth.c

823

do_ssh2_kex(struct ssh *ssh)

crypto/openssh/sshd-auth.c

831

ssh_packet_set_rekey_limits(ssh, options.rekey_limit,

crypto/openssh/sshd-auth.c

838

kex_proposal_populate_entries(ssh, myproposal, options.kex_algorithms,

crypto/openssh/sshd-auth.c

844

if ((r = kex_setup(ssh, myproposal)) != 0)

crypto/openssh/sshd-auth.c

846

kex_set_server_sig_algs(ssh, options.pubkey_accepted_algos);

crypto/openssh/sshd-auth.c

847

kex = ssh->kex;

crypto/openssh/sshd-auth.c

869

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &kex->done);

crypto/openssh/sshd-auth.c

874

if ((r = sshpkt_start(ssh, SSH2_MSG_IGNORE)) != 0 ||

crypto/openssh/sshd-auth.c

875

(r = sshpkt_put_cstring(ssh, "markus")) != 0 ||

crypto/openssh/sshd-auth.c

876

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/sshd-auth.c

877

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/sshd-session.c

1210

if ((ssh = ssh_packet_set_connection(NULL, sock_in, sock_out)) == NULL)

crypto/openssh/sshd-session.c

1212

the_active_state = ssh;

crypto/openssh/sshd-session.c

1213

ssh_packet_set_server(ssh);

crypto/openssh/sshd-session.c

1215

check_ip_options(ssh);

crypto/openssh/sshd-session.c

1218

channel_init_channels(ssh);

crypto/openssh/sshd-session.c

1219

channel_set_af(ssh, options.address_family);

crypto/openssh/sshd-session.c

1220

server_process_channel_timeouts(ssh);

crypto/openssh/sshd-session.c

1221

server_process_permitopen(ssh);

crypto/openssh/sshd-session.c

1224

if (options.tcp_keep_alive && ssh_packet_connection_is_on_socket(ssh) &&

crypto/openssh/sshd-session.c

1228

if ((remote_port = ssh_remote_port(ssh)) < 0) {

crypto/openssh/sshd-session.c

1235

auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/sshd-session.c

1243

remote_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/sshd-session.c

1249

rdomain = ssh_packet_rdomain_in(ssh);

crypto/openssh/sshd-session.c

1254

remote_ip, remote_port, laddr, ssh_local_port(ssh),

crypto/openssh/sshd-session.c

1281

if ((r = kex_exchange_identification(ssh, -1,

crypto/openssh/sshd-session.c

1283

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL, "Banner exchange");

crypto/openssh/sshd-session.c

1284

sshpkt_fatal(ssh, r, "banner exchange");

crypto/openssh/sshd-session.c

1287

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshd-session.c

1291

ssh->authctxt = authctxt;

crypto/openssh/sshd-session.c

1305

if (privsep_preauth(ssh) != 1)

crypto/openssh/sshd-session.c

1328

set_process_rdomain(ssh, options.routing_domain);

crypto/openssh/sshd-session.c

1331

audit_event(ssh, SSH_AUTH_SUCCESS);

crypto/openssh/sshd-session.c

1344

do_pam_session(ssh);

crypto/openssh/sshd-session.c

1352

privsep_postauth(ssh, authctxt);

crypto/openssh/sshd-session.c

1355

ssh_packet_set_timeout(ssh, options.client_alive_interval,

crypto/openssh/sshd-session.c

1359

notify_hostkeys(ssh);

crypto/openssh/sshd-session.c

1362

do_authenticated(ssh, authctxt);

crypto/openssh/sshd-session.c

1365

ssh_packet_get_bytes(ssh, &ibytes, &obytes);

crypto/openssh/sshd-session.c

1377

mm_audit_event(ssh, SSH_CONNECTION_CLOSE);

crypto/openssh/sshd-session.c

1380

ssh_packet_close(ssh);

crypto/openssh/sshd-session.c

1388

sshd_hostkey_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/sshd-session.c

1393

if (mm_sshkey_sign(ssh, privkey, signature, slenp,

crypto/openssh/sshd-session.c

1395

ssh->compat) < 0)

crypto/openssh/sshd-session.c

1398

if (mm_sshkey_sign(ssh, pubkey, signature, slenp,

crypto/openssh/sshd-session.c

1400

ssh->compat) < 0)

crypto/openssh/sshd-session.c

183

struct ssh *the_active_state;

crypto/openssh/sshd-session.c

338

privsep_preauth(struct ssh *ssh)

crypto/openssh/sshd-session.c

346

pmonitor->m_pkex = &ssh->kex;

crypto/openssh/sshd-session.c

361

monitor_child_preauth(ssh, pmonitor);

crypto/openssh/sshd-session.c

397

if (ssh_packet_get_connection_in(ssh) != STDIN_FILENO &&

crypto/openssh/sshd-session.c

398

dup2(ssh_packet_get_connection_in(ssh), STDIN_FILENO) == -1)

crypto/openssh/sshd-session.c

400

if (ssh_packet_get_connection_out(ssh) != STDOUT_FILENO &&

crypto/openssh/sshd-session.c

401

dup2(ssh_packet_get_connection_out(ssh),

crypto/openssh/sshd-session.c

423

privsep_postauth(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/sshd-session.c

449

monitor_clear_keystate(ssh, pmonitor);

crypto/openssh/sshd-session.c

450

monitor_child_postauth(ssh, pmonitor);

crypto/openssh/sshd-session.c

471

monitor_apply_keystate(ssh, pmonitor);

crypto/openssh/sshd-session.c

477

ssh_packet_set_authenticated(ssh);

crypto/openssh/sshd-session.c

481

get_hostkey_by_type(int type, int nid, int need_private, struct ssh *ssh)

crypto/openssh/sshd-session.c

522

get_hostkey_public_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-session.c

524

return get_hostkey_by_type(type, nid, 0, ssh);

crypto/openssh/sshd-session.c

528

get_hostkey_private_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-session.c

530

return get_hostkey_by_type(type, nid, 1, ssh);

crypto/openssh/sshd-session.c

542

get_hostkey_public_by_index(int ind, struct ssh *ssh)

crypto/openssh/sshd-session.c

550

get_hostkey_index(struct sshkey *key, int compare, struct ssh *ssh)

crypto/openssh/sshd-session.c

577

notify_hostkeys(struct ssh *ssh)

crypto/openssh/sshd-session.c

586

if (ssh->compat & SSH_BUG_HOSTKEYS)

crypto/openssh/sshd-session.c

592

key = get_hostkey_public_by_index(i, ssh);

crypto/openssh/sshd-session.c

605

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/sshd-session.c

606

(r = sshpkt_put_cstring(ssh, "hostkeys-00@openssh.com")) != 0 ||

crypto/openssh/sshd-session.c

607

(r = sshpkt_put_u8(ssh, 0)) != 0) /* want reply */

crypto/openssh/sshd-session.c

608

sshpkt_fatal(ssh, r, "%s: start request", __func__);

crypto/openssh/sshd-session.c

614

if ((r = sshpkt_put_stringb(ssh, buf)) != 0)

crypto/openssh/sshd-session.c

615

sshpkt_fatal(ssh, r, "%s: append key", __func__);

crypto/openssh/sshd-session.c

621

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshd-session.c

622

sshpkt_fatal(ssh, r, "%s: send", __func__);

crypto/openssh/sshd-session.c

763

check_ip_options(struct ssh *ssh)

crypto/openssh/sshd-session.c

766

int sock_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/sshd-session.c

787

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh), text);

crypto/openssh/sshd-session.c

794

set_process_rdomain(struct ssh *ssh, const char *name)

crypto/openssh/sshd-session.c

802

if ((name = ssh_packet_rdomain_in(ssh)) == NULL)

crypto/openssh/sshd-session.c

816

if ((name = ssh_packet_rdomain_in(ssh)) == NULL)

crypto/openssh/sshd-session.c

838

struct ssh *ssh = NULL;

crypto/openssh/sshd-session.c

963

connection_info = server_get_connection_info(ssh, 0, 0);

crypto/openssh/ttymodes.c

279

ssh_tty_make_modes(struct ssh *ssh, int fd, struct termios *tiop)

crypto/openssh/ttymodes.c

319

if (OP == SSH_TTYMODE_IUTF8 && (ssh->compat & SSH_BUG_UTF8TTYMODE)) { \

crypto/openssh/ttymodes.c

333

(r = sshpkt_put_stringb(ssh, buf)) != 0)

crypto/openssh/ttymodes.c

343

ssh_tty_parse_modes(struct ssh *ssh, int fd)

crypto/openssh/ttymodes.c

353

if ((r = sshpkt_get_string_direct(ssh, &data, &len)) != 0)

sys/fs/pseudofs/pseudofs_vnops.c

628

struct sbuf_seek_helper *ssh;

sys/fs/pseudofs/pseudofs_vnops.c

632

ssh = arg;

sys/fs/pseudofs/pseudofs_vnops.c

633

uio = ssh->uio;

sys/fs/pseudofs/pseudofs_vnops.c

637

if (ssh->skip_bytes > 0) {

sys/fs/pseudofs/pseudofs_vnops.c

638

if (ssh->skip_bytes >= len) {

sys/fs/pseudofs/pseudofs_vnops.c

639

ssh->skip_bytes -= len;

sys/fs/pseudofs/pseudofs_vnops.c

643

data += ssh->skip_bytes;

sys/fs/pseudofs/pseudofs_vnops.c

644

len -= ssh->skip_bytes;

sys/fs/pseudofs/pseudofs_vnops.c

645

skipped = ssh->skip_bytes;

sys/fs/pseudofs/pseudofs_vnops.c

646

ssh->skip_bytes = 0;

sys/fs/pseudofs/pseudofs_vnops.c

678

struct sbuf_seek_helper ssh;

sys/fs/pseudofs/pseudofs_vnops.c

739

ssh.skip_bytes = uio->uio_offset;

sys/fs/pseudofs/pseudofs_vnops.c

740

ssh.uio = uio;

sys/fs/pseudofs/pseudofs_vnops.c

741

sbuf_set_drain(sb, pfs_sbuf_uio_drain, &ssh);