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

1060

start_pam(struct ssh *ssh)

crypto/openssh/auth-pam.c

1062

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

crypto/openssh/auth-pam.c

1067

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

crypto/openssh/auth-pam.c

1206

do_pam_session(struct ssh *ssh)

crypto/openssh/auth-pam.c

1222

auth_restrict_session(ssh);

crypto/openssh/auth-pam.c

687

sshpam_init(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/auth-pam.c

699

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth-pam.c

702

if (ssh == NULL) {

crypto/openssh/auth-pam.c

728

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

crypto/openssh/auth-pam.c

733

sshpam_rhost = xstrdup(auth_get_canonical_hostname(ssh,

crypto/openssh/auth-pam.c

736

ssh_packet_get_connection_in(ssh));

crypto/openssh/auth-pam.c

748

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

crypto/openssh/auth-pam.c

753

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/auth-pam.c

754

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

143

hostname = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth.c

144

ipaddr = ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

266

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

crypto/openssh/auth.c

269

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

crypto/openssh/auth.c

302

ssh_remote_ipaddr(ssh),

crypto/openssh/auth.c

303

ssh_remote_port(ssh),

crypto/openssh/auth.c

316

record_failed_login(ssh, authctxt->user,

crypto/openssh/auth.c

317

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

crypto/openssh/auth.c

320

audit_event(ssh, audit_classify_auth(method));

crypto/openssh/auth.c

327

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

crypto/openssh/auth.c

333

auth_maxtries_exceeded(struct ssh *ssh)

crypto/openssh/auth.c

335

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

crypto/openssh/auth.c

341

ssh_remote_ipaddr(ssh),

crypto/openssh/auth.c

342

ssh_remote_port(ssh));

crypto/openssh/auth.c

343

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

crypto/openssh/auth.c

351

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

crypto/openssh/auth.c

370

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth.c

462

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

crypto/openssh/auth.c

474

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

crypto/openssh/auth.c

481

server_process_permitopen(ssh);

crypto/openssh/auth.c

494

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

crypto/openssh/auth.c

496

record_failed_login(ssh, user,

crypto/openssh/auth.c

497

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

crypto/openssh/auth.c

500

audit_event(ssh, SSH_INVALID_USER);

crypto/openssh/auth.c

504

if (!allowed_user(ssh, pw))

crypto/openssh/auth.c

582

auth_debug_send(struct ssh *ssh)

crypto/openssh/auth.c

592

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

crypto/openssh/auth.c

646

auth_get_canonical_hostname(struct ssh *ssh, int use_dns)

crypto/openssh/auth.c

651

return ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

654

dnsname = ssh_remote_hostname(ssh);

crypto/openssh/auth.c

732

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

crypto/openssh/auth.c

747

auth_restrict_session(struct ssh *ssh)

crypto/openssh/auth.c

759

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

crypto/openssh/auth.c

99

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

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

105

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

crypto/openssh/auth2-pubkey.c

106

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

crypto/openssh/auth2-pubkey.c

107

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

crypto/openssh/auth2-pubkey.c

112

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

crypto/openssh/auth2-pubkey.c

115

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

crypto/openssh/auth2-pubkey.c

117

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

crypto/openssh/auth2-pubkey.c

186

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

crypto/openssh/auth2-pubkey.c

187

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

crypto/openssh/auth2-pubkey.c

191

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/auth2-pubkey.c

192

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

crypto/openssh/auth2-pubkey.c

196

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

crypto/openssh/auth2-pubkey.c

216

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

crypto/openssh/auth2-pubkey.c

223

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

crypto/openssh/auth2-pubkey.c

226

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

crypto/openssh/auth2-pubkey.c

227

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

crypto/openssh/auth2-pubkey.c

245

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/auth2-pubkey.c

246

ssh_remote_port(ssh));

crypto/openssh/auth2-pubkey.c

259

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/auth2-pubkey.c

260

ssh_remote_port(ssh));

crypto/openssh/auth2-pubkey.c

270

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

crypto/openssh/auth2-pubkey.c

285

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

crypto/openssh/auth2-pubkey.c

286

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

crypto/openssh/auth2-pubkey.c

288

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

crypto/openssh/auth2-pubkey.c

289

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

crypto/openssh/auth2-pubkey.c

290

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

crypto/openssh/auth2-pubkey.c

291

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

crypto/openssh/auth2-pubkey.c

297

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

crypto/openssh/auth2-pubkey.c

753

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

crypto/openssh/auth2-pubkey.c

770

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

crypto/openssh/auth2-pubkey.c

772

remote_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/auth2-pubkey.c

773

remote_host = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth2-pubkey.c

775

ssh_local_ipaddr(ssh), ssh_local_port(ssh),

crypto/openssh/auth2-pubkey.c

776

remote_ip, ssh_remote_port(ssh));

crypto/openssh/auth2-pubkey.c

89

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

crypto/openssh/auth2-pubkey.c

91

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/channels.c

101

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

crypto/openssh/channels.c

1037

channel_open_message(struct ssh *ssh)

crypto/openssh/channels.c

1050

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

crypto/openssh/channels.c

1051

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

crypto/openssh/channels.c

1096

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

crypto/openssh/channels.c

1100

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

crypto/openssh/channels.c

1101

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

crypto/openssh/channels.c

1102

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

crypto/openssh/channels.c

1103

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

crypto/openssh/channels.c

1104

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

crypto/openssh/channels.c

1110

channel_send_open(struct ssh *ssh, int id)

crypto/openssh/channels.c

1112

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1120

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

crypto/openssh/channels.c

1121

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

crypto/openssh/channels.c

1126

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

crypto/openssh/channels.c

1128

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1139

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

crypto/openssh/channels.c

1140

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

crypto/openssh/channels.c

1141

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

crypto/openssh/channels.c

1142

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

crypto/openssh/channels.c

1148

channel_register_status_confirm(struct ssh *ssh, int id,

crypto/openssh/channels.c

1154

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

crypto/openssh/channels.c

1165

channel_register_open_confirm(struct ssh *ssh, int id,

crypto/openssh/channels.c

1168

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1179

channel_register_cleanup(struct ssh *ssh, int id,

crypto/openssh/channels.c

1182

Channel *c = channel_by_id(ssh, id);

crypto/openssh/channels.c

1193

channel_cancel_cleanup(struct ssh *ssh, int id)

crypto/openssh/channels.c

1195

Channel *c = channel_by_id(ssh, id);

crypto/openssh/channels.c

1206

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

crypto/openssh/channels.c

1209

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1222

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

crypto/openssh/channels.c

1225

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1233

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

crypto/openssh/channels.c

1235

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

1238

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

crypto/openssh/channels.c

1239

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

crypto/openssh/channels.c

1240

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

crypto/openssh/channels.c

1241

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

crypto/openssh/channels.c

1246

channel_pre_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1252

channel_pre_connecting(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1259

channel_pre_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1277

chan_obuf_empty(ssh, c);

crypto/openssh/channels.c

1305

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

crypto/openssh/channels.c

1307

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

1372

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

crypto/openssh/channels.c

1376

chan_read_failed(ssh, c);

crypto/openssh/channels.c

1379

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

1384

chan_write_failed(ssh, c);

crypto/openssh/channels.c

1387

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

crypto/openssh/channels.c

1389

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

crypto/openssh/channels.c

1398

channel_pre_x11_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1400

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

crypto/openssh/channels.c

1406

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

1407

channel_pre_open(ssh, c);

crypto/openssh/channels.c

1413

channel_force_close(ssh, c, 0);

crypto/openssh/channels.c

1418

channel_pre_mux_client(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1427

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

1429

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

1436

chan_obuf_empty(ssh, c);

crypto/openssh/channels.c

1688

channel_connect_stdio_fwd(struct ssh *ssh,

crypto/openssh/channels.c

1696

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

crypto/openssh/channels.c

1705

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

crypto/openssh/channels.c

1706

port_open_helper(ssh, c, port_to_connect == PORT_STREAMLOCAL ?

crypto/openssh/channels.c

1714

channel_pre_dynamic(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1745

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

1755

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

crypto/openssh/channels.c

1761

rdynamic_close(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1764

channel_force_close(ssh, c, 0);

crypto/openssh/channels.c

1769

channel_before_prepare_io_rdynamic(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1782

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1803

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1809

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

crypto/openssh/channels.c

1810

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

crypto/openssh/channels.c

1811

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

crypto/openssh/channels.c

1812

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

crypto/openssh/channels.c

1819

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

crypto/openssh/channels.c

1821

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1827

channel_post_x11_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1844

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

crypto/openssh/channels.c

1845

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

1862

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

crypto/openssh/channels.c

1865

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

crypto/openssh/channels.c

1866

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

crypto/openssh/channels.c

1867

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

crypto/openssh/channels.c

1870

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

crypto/openssh/channels.c

1876

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

crypto/openssh/channels.c

1898

open_preamble(ssh, __func__, c, rtype);

crypto/openssh/channels.c

1901

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

crypto/openssh/channels.c

1902

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

crypto/openssh/channels.c

1906

if ((r = sshpkt_put_cstring(ssh, c->path)) != 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

1915

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

crypto/openssh/channels.c

1920

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

crypto/openssh/channels.c

1924

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

crypto/openssh/channels.c

1925

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

crypto/openssh/channels.c

1928

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

crypto/openssh/channels.c

1935

channel_set_x11_refuse_time(struct ssh *ssh, time_t refuse_time)

crypto/openssh/channels.c

1937

ssh->chanctxt->x11_refuse_time = refuse_time;

crypto/openssh/channels.c

1944

channel_post_port_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1987

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

crypto/openssh/channels.c

1995

port_open_helper(ssh, nc, rtype);

crypto/openssh/channels.c

2003

channel_post_auth_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2021

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

crypto/openssh/channels.c

2025

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

crypto/openssh/channels.c

2026

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

crypto/openssh/channels.c

2031

channel_post_connecting(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2054

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2058

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2060

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

crypto/openssh/channels.c

2061

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

crypto/openssh/channels.c

2062

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

crypto/openssh/channels.c

2063

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

crypto/openssh/channels.c

2064

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

crypto/openssh/channels.c

2082

rdynamic_close(ssh, c);

crypto/openssh/channels.c

2084

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2086

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

crypto/openssh/channels.c

2087

(r = sshpkt_put_u32(ssh,

crypto/openssh/channels.c

2089

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

crypto/openssh/channels.c

2090

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

crypto/openssh/channels.c

2091

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

crypto/openssh/channels.c

2093

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2103

channel_handle_rfd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2146

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

216

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

crypto/openssh/channels.c

2165

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2168

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2172

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2174

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

crypto/openssh/channels.c

2176

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2188

channel_handle_wfd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2203

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

crypto/openssh/channels.c

2206

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2208

chan_write_failed(ssh, c);

crypto/openssh/channels.c

222

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

crypto/openssh/channels.c

223

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

crypto/openssh/channels.c

2246

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2249

chan_write_failed(ssh, c);

crypto/openssh/channels.c

2253

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2264

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

crypto/openssh/channels.c

2265

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

crypto/openssh/channels.c

2279

channel_handle_efd_write(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2297

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

crypto/openssh/channels.c

2302

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2308

channel_handle_efd_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

231

channel_init_channels(struct ssh *ssh)

crypto/openssh/channels.c

2326

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

crypto/openssh/channels.c

2329

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2338

channel_handle_efd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2346

return channel_handle_efd_write(ssh, c);

crypto/openssh/channels.c

2349

return channel_handle_efd_read(ssh, c);

crypto/openssh/channels.c

2355

channel_check_window(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2367

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2369

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

crypto/openssh/channels.c

2370

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

crypto/openssh/channels.c

2371

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

crypto/openssh/channels.c

2383

channel_post_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2385

channel_handle_rfd(ssh, c);

crypto/openssh/channels.c

2386

channel_handle_wfd(ssh, c);

crypto/openssh/channels.c

2387

channel_handle_efd(ssh, c);

crypto/openssh/channels.c

2388

channel_check_window(ssh, c);

crypto/openssh/channels.c

2392

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

crypto/openssh/channels.c

2407

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2416

channel_post_mux_client_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

242

ssh->chanctxt = sc;

crypto/openssh/channels.c

2431

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

crypto/openssh/channels.c

2439

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

2442

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

crypto/openssh/channels.c

2444

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

crypto/openssh/channels.c

2446

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2452

channel_post_mux_client_write(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

246

channel_by_id(struct ssh *ssh, int id)

crypto/openssh/channels.c

2466

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2474

channel_post_mux_client(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2476

channel_post_mux_client_read(ssh, c);

crypto/openssh/channels.c

2477

channel_post_mux_client_write(ssh, c);

crypto/openssh/channels.c

2481

channel_post_mux_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

250

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

crypto/openssh/channels.c

2519

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

crypto/openssh/channels.c

2525

nc->mux_rcb(ssh, nc);

crypto/openssh/channels.c

254

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

crypto/openssh/channels.c

2572

channel_garbage_collect(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2577

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

crypto/openssh/channels.c

2581

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

crypto/openssh/channels.c

2587

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

crypto/openssh/channels.c

2590

channel_free(ssh, c);

crypto/openssh/channels.c

2596

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

crypto/openssh/channels.c

2598

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2610

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

crypto/openssh/channels.c

2620

channel_get_expiry(ssh, c) != 0 &&

crypto/openssh/channels.c

2621

now >= channel_get_expiry(ssh, c)) {

crypto/openssh/channels.c

2626

channel_force_close(ssh, c, 1);

crypto/openssh/channels.c

2629

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

crypto/openssh/channels.c

263

channel_by_remote_id(struct ssh *ssh, u_int remote_id)

crypto/openssh/channels.c

2633

channel_get_expiry(ssh, c) != 0) {

crypto/openssh/channels.c

2635

channel_get_expiry(ssh, c));

crypto/openssh/channels.c

2646

channel_garbage_collect(ssh, c);

crypto/openssh/channels.c

2657

channel_before_prepare_io(struct ssh *ssh)

crypto/openssh/channels.c

2659

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2668

channel_before_prepare_io_rdynamic(ssh, c);

crypto/openssh/channels.c

268

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

crypto/openssh/channels.c

269

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

crypto/openssh/channels.c

2792

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

crypto/openssh/channels.c

2795

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2798

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

crypto/openssh/channels.c

281

channel_lookup(struct ssh *ssh, int id)

crypto/openssh/channels.c

2817

channel_handler(ssh, CHAN_PRE, timeout);

crypto/openssh/channels.c

285

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

crypto/openssh/channels.c

2861

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

crypto/openssh/channels.c

2863

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2938

channel_handler(ssh, CHAN_POST, NULL);

crypto/openssh/channels.c

2946

channel_output_poll_input_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2966

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

2988

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

crypto/openssh/channels.c

2989

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

crypto/openssh/channels.c

2990

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

crypto/openssh/channels.c

2991

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

crypto/openssh/channels.c

3004

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

crypto/openssh/channels.c

3005

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

crypto/openssh/channels.c

3006

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

crypto/openssh/channels.c

3007

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

crypto/openssh/channels.c

3020

channel_output_poll_extended_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

3038

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

crypto/openssh/channels.c

3039

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

crypto/openssh/channels.c

3040

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

crypto/openssh/channels.c

3041

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

crypto/openssh/channels.c

3042

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

crypto/openssh/channels.c

3056

channel_output_poll(struct ssh *ssh)

crypto/openssh/channels.c

3058

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3084

ret |= channel_output_poll_input_open(ssh, c);

crypto/openssh/channels.c

3088

ret |= channel_output_poll_extended_read(ssh, c);

crypto/openssh/channels.c

310

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

crypto/openssh/channels.c

313

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3134

channel_proxy_downstream(struct ssh *ssh, Channel *downstream)

crypto/openssh/channels.c

3175

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

crypto/openssh/channels.c

3183

channel_free(ssh, c);

crypto/openssh/channels.c

3202

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

crypto/openssh/channels.c

3212

channel_free(ssh, c);

crypto/openssh/channels.c

3241

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

crypto/openssh/channels.c

3248

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

crypto/openssh/channels.c

3250

channel_free(ssh, c);

crypto/openssh/channels.c

3257

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

crypto/openssh/channels.c

3258

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

crypto/openssh/channels.c

3259

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

crypto/openssh/channels.c

3264

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

crypto/openssh/channels.c

3265

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

crypto/openssh/channels.c

3266

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

crypto/openssh/channels.c

3287

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

crypto/openssh/channels.c

331

channel_clear_timeouts(struct ssh *ssh)

crypto/openssh/channels.c

3326

cp = sshpkt_ptr(ssh, &len);

crypto/openssh/channels.c

333

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3355

channel_free(ssh, c);

crypto/openssh/channels.c

3368

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

crypto/openssh/channels.c

3373

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

crypto/openssh/channels.c

3375

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

crypto/openssh/channels.c

3379

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

crypto/openssh/channels.c

3386

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

crypto/openssh/channels.c

3388

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

crypto/openssh/channels.c

3391

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

crypto/openssh/channels.c

3392

ssh_packet_disconnect(ssh,

crypto/openssh/channels.c

3399

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

crypto/openssh/channels.c

3403

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

crypto/openssh/channels.c

3406

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

crypto/openssh/channels.c

3417

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

crypto/openssh/channels.c

3418

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

crypto/openssh/channels.c

3449

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

crypto/openssh/channels.c

345

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

crypto/openssh/channels.c

3467

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

crypto/openssh/channels.c

347

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3472

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

crypto/openssh/channels.c

3475

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

crypto/openssh/channels.c

3482

if (ssh->compat & SSH_BUG_EXTEOF)

crypto/openssh/channels.c

3486

ssh_packet_disconnect(ssh, "Received extended_data "

crypto/openssh/channels.c

3490

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

crypto/openssh/channels.c

3492

ssh_packet_disconnect(ssh, "Invalid extended_data message");

crypto/openssh/channels.c

3500

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

crypto/openssh/channels.c

3501

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

crypto/openssh/channels.c

3503

ssh_packet_disconnect(ssh, "Invalid extended_data message");

crypto/openssh/channels.c

3520

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

crypto/openssh/channels.c

3522

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

crypto/openssh/channels.c

3525

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

crypto/openssh/channels.c

3527

ssh_packet_disconnect(ssh, "Invalid ieof message");

crypto/openssh/channels.c

3530

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

crypto/openssh/channels.c

3532

chan_rcvd_ieof(ssh, c);

crypto/openssh/channels.c

3539

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

3545

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

crypto/openssh/channels.c

3547

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

crypto/openssh/channels.c

3550

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

crypto/openssh/channels.c

3552

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

crypto/openssh/channels.c

3554

ssh_packet_disconnect(ssh, "Invalid oclose message");

crypto/openssh/channels.c

3556

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

3561

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

crypto/openssh/channels.c

3563

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

crypto/openssh/channels.c

3567

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

crypto/openssh/channels.c

3570

ssh_packet_disconnect(ssh, "Received open confirmation for "

crypto/openssh/channels.c

3576

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

crypto/openssh/channels.c

3577

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

crypto/openssh/channels.c

3578

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

crypto/openssh/channels.c

3579

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

crypto/openssh/channels.c

3581

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

crypto/openssh/channels.c

3590

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

crypto/openssh/channels.c

3593

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

3616

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

crypto/openssh/channels.c

3618

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

crypto/openssh/channels.c

3623

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

crypto/openssh/channels.c

3626

ssh_packet_disconnect(ssh, "Received open failure for "

crypto/openssh/channels.c

3628

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

crypto/openssh/channels.c

3630

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

crypto/openssh/channels.c

3633

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

crypto/openssh/channels.c

3634

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

crypto/openssh/channels.c

3635

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

crypto/openssh/channels.c

3637

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

crypto/openssh/channels.c

3644

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

crypto/openssh/channels.c

3648

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

365

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

crypto/openssh/channels.c

3653

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

crypto/openssh/channels.c

3655

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

crypto/openssh/channels.c

3661

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

crypto/openssh/channels.c

3666

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

crypto/openssh/channels.c

3668

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

crypto/openssh/channels.c

3669

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

crypto/openssh/channels.c

3671

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

crypto/openssh/channels.c

3683

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

crypto/openssh/channels.c

3685

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

crypto/openssh/channels.c

369

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

crypto/openssh/channels.c

3690

ssh_packet_set_alive_timeouts(ssh, 0);

crypto/openssh/channels.c

3694

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

crypto/openssh/channels.c

3698

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

crypto/openssh/channels.c

3700

if (sshpkt_get_end(ssh) != 0)

crypto/openssh/channels.c

3701

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

crypto/openssh/channels.c

3704

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

crypto/openssh/channels.c

3713

channel_set_af(struct ssh *ssh, int af)

crypto/openssh/channels.c

3715

ssh->chanctxt->IPv4or6 = af;

crypto/openssh/channels.c

3735

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

crypto/openssh/channels.c

3746

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

crypto/openssh/channels.c

375

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

crypto/openssh/channels.c

3758

ssh_packet_send_debug(ssh,

crypto/openssh/channels.c

3789

channel_setup_fwd_listener_tcpip(struct ssh *ssh, int type,

crypto/openssh/channels.c

3818

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

crypto/openssh/channels.c

3828

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

crypto/openssh/channels.c

3835

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

crypto/openssh/channels.c

385

channel_set_used_time(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

387

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

crypto/openssh/channels.c

389

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

crypto/openssh/channels.c

3927

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

crypto/openssh/channels.c

3934

!(ssh->compat & SSH_BUG_DYNAMIC_RPORT))

crypto/openssh/channels.c

3947

channel_setup_fwd_listener_streamlocal(struct ssh *ssh, int type,

crypto/openssh/channels.c

397

channel_get_expiry(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

399

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4010

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

crypto/openssh/channels.c

4021

channel_cancel_rport_listener_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4027

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

crypto/openssh/channels.c

4028

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

crypto/openssh/channels.c

4033

channel_free(ssh, c);

crypto/openssh/channels.c

4042

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

crypto/openssh/channels.c

4047

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

crypto/openssh/channels.c

4048

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

crypto/openssh/channels.c

4055

channel_free(ssh, c);

crypto/openssh/channels.c

4064

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

crypto/openssh/channels.c

4067

return channel_cancel_rport_listener_streamlocal(ssh,

crypto/openssh/channels.c

4070

return channel_cancel_rport_listener_tcpip(ssh,

crypto/openssh/channels.c

4076

channel_cancel_lport_listener_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4082

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

crypto/openssh/channels.c

4084

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

crypto/openssh/channels.c

4085

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

crypto/openssh/channels.c

4103

channel_free(ssh, c);

crypto/openssh/channels.c

4112

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

crypto/openssh/channels.c

4122

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

crypto/openssh/channels.c

4123

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

crypto/openssh/channels.c

4130

channel_free(ssh, c);

crypto/openssh/channels.c

4139

channel_cancel_lport_listener(struct ssh *ssh,

crypto/openssh/channels.c

4143

return channel_cancel_lport_listener_streamlocal(ssh,

crypto/openssh/channels.c

4146

return channel_cancel_lport_listener_tcpip(ssh,

crypto/openssh/channels.c

4153

channel_setup_local_fwd_listener(struct ssh *ssh,

crypto/openssh/channels.c

4157

return channel_setup_fwd_listener_streamlocal(ssh,

crypto/openssh/channels.c

4160

return channel_setup_fwd_listener_tcpip(ssh,

crypto/openssh/channels.c

417

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

crypto/openssh/channels.c

4194

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

crypto/openssh/channels.c

4196

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4230

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

crypto/openssh/channels.c

4233

if (!check_rfwd_permission(ssh, fwd)) {

crypto/openssh/channels.c

4234

ssh_packet_send_debug(ssh, "port forwarding refused");

crypto/openssh/channels.c

4240

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/channels.c

4246

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/channels.c

4251

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/channels.c

4255

return channel_setup_fwd_listener_streamlocal(ssh,

crypto/openssh/channels.c

4258

return channel_setup_fwd_listener_tcpip(ssh,

crypto/openssh/channels.c

4286

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

crypto/openssh/channels.c

4294

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

crypto/openssh/channels.c

4295

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4297

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

crypto/openssh/channels.c

4298

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

crypto/openssh/channels.c

4299

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

crypto/openssh/channels.c

4300

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

crypto/openssh/channels.c

4303

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

crypto/openssh/channels.c

4304

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

crypto/openssh/channels.c

4305

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

crypto/openssh/channels.c

4306

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4308

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

crypto/openssh/channels.c

4309

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

crypto/openssh/channels.c

4310

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

crypto/openssh/channels.c

4333

idx = permission_set_add(ssh, FORWARD_USER, FORWARD_LOCAL,

crypto/openssh/channels.c

4402

channel_request_rforward_cancel_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4405

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4421

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

crypto/openssh/channels.c

4422

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

crypto/openssh/channels.c

4423

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

crypto/openssh/channels.c

4424

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

crypto/openssh/channels.c

4425

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

crypto/openssh/channels.c

4426

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

crypto/openssh/channels.c

4439

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

crypto/openssh/channels.c

4441

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4457

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

crypto/openssh/channels.c

4458

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4460

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

crypto/openssh/channels.c

4461

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

crypto/openssh/channels.c

4462

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

crypto/openssh/channels.c

4474

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

crypto/openssh/channels.c

4477

return channel_request_rforward_cancel_streamlocal(ssh,

crypto/openssh/channels.c

4480

return channel_request_rforward_cancel_tcpip(ssh,

crypto/openssh/channels.c

4492

channel_permit_all(struct ssh *ssh, int where)

crypto/openssh/channels.c

4494

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

crypto/openssh/channels.c

4504

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

crypto/openssh/channels.c

4508

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

crypto/openssh/channels.c

4516

permission_set_add(ssh, who, where,

crypto/openssh/channels.c

4526

channel_disable_admin(struct ssh *ssh, int where)

crypto/openssh/channels.c

4528

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/channels.c

4529

permission_set_add(ssh, FORWARD_ADM, where,

crypto/openssh/channels.c

4537

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

crypto/openssh/channels.c

4542

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

crypto/openssh/channels.c

4553

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

crypto/openssh/channels.c

4555

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

crypto/openssh/channels.c

4571

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

crypto/openssh/channels.c

4653

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

crypto/openssh/channels.c

4689

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

crypto/openssh/channels.c

4719

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

crypto/openssh/channels.c

4727

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

crypto/openssh/channels.c

4733

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

crypto/openssh/channels.c

4747

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

crypto/openssh/channels.c

4750

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4762

return rdynamic_connect_prepare(ssh,

crypto/openssh/channels.c

4764

return connect_to(ssh,

crypto/openssh/channels.c

4775

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

crypto/openssh/channels.c

4778

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

478

channel_set_used_time(ssh, NULL);

crypto/openssh/channels.c

4786

return connect_to(ssh,

crypto/openssh/channels.c

4798

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

crypto/openssh/channels.c

4801

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4834

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

crypto/openssh/channels.c

4841

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

crypto/openssh/channels.c

4848

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

crypto/openssh/channels.c

485

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

crypto/openssh/channels.c

4859

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

crypto/openssh/channels.c

4862

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

489

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4894

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

crypto/openssh/channels.c

4898

channel_send_window_changes(struct ssh *ssh)

crypto/openssh/channels.c

4900

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4911

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

crypto/openssh/channels.c

4912

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

crypto/openssh/channels.c

4913

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

crypto/openssh/channels.c

4914

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

crypto/openssh/channels.c

4915

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

crypto/openssh/channels.c

4916

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

crypto/openssh/channels.c

4923

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

crypto/openssh/channels.c

4928

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

crypto/openssh/channels.c

4937

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

crypto/openssh/channels.c

4938

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

crypto/openssh/channels.c

4939

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

crypto/openssh/channels.c

4940

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

crypto/openssh/channels.c

4941

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

crypto/openssh/channels.c

4948

rdynamic_connect_finish(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

4950

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4973

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

crypto/openssh/channels.c

4981

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

crypto/openssh/channels.c

4994

x11_create_display_inet(struct ssh *ssh, int x11_display_offset,

crypto/openssh/channels.c

5013

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

crypto/openssh/channels.c

5082

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

crypto/openssh/channels.c

5153

x11_connect_display(struct ssh *ssh)

crypto/openssh/channels.c

5235

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

crypto/openssh/channels.c

526

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

crypto/openssh/channels.c

5276

x11_request_forwarding_with_spoofing(struct ssh *ssh, int client_session_id,

crypto/openssh/channels.c

5279

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

5327

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

crypto/openssh/channels.c

5328

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

crypto/openssh/channels.c

5329

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

crypto/openssh/channels.c

5330

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

crypto/openssh/channels.c

5331

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

crypto/openssh/channels.c

5332

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

crypto/openssh/channels.c

5333

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

crypto/openssh/channels.c

536

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

crypto/openssh/channels.c

544

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

crypto/openssh/channels.c

594

channel_close_fds(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

598

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

crypto/openssh/channels.c

600

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

crypto/openssh/channels.c

602

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

crypto/openssh/channels.c

604

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

crypto/openssh/channels.c

636

permission_set_get(struct ssh *ssh, int where)

crypto/openssh/channels.c

638

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

654

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

crypto/openssh/channels.c

657

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

crypto/openssh/channels.c

675

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

crypto/openssh/channels.c

683

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

crypto/openssh/channels.c

702

mux_remove_remote_forwardings(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

704

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

718

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

crypto/openssh/channels.c

719

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

721

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

crypto/openssh/channels.c

722

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

724

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

crypto/openssh/channels.c

725

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

crypto/openssh/channels.c

734

channel_free(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

736

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

760

mux_remove_remote_forwardings(ssh, c);

crypto/openssh/channels.c

769

s = channel_open_message(ssh);

crypto/openssh/channels.c

774

channel_close_fds(ssh, c);

crypto/openssh/channels.c

789

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

crypto/openssh/channels.c

794

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

crypto/openssh/channels.c

800

channel_free_all(struct ssh *ssh)

crypto/openssh/channels.c

803

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

807

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

crypto/openssh/channels.c

833

channel_close_all(struct ssh *ssh)

crypto/openssh/channels.c

837

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

crypto/openssh/channels.c

838

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

crypto/openssh/channels.c

839

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

crypto/openssh/channels.c

846

channel_stop_listening(struct ssh *ssh)

crypto/openssh/channels.c

851

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

crypto/openssh/channels.c

852

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

crypto/openssh/channels.c

861

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

crypto/openssh/channels.c

862

channel_free(ssh, c);

crypto/openssh/channels.c

874

channel_not_very_much_buffered_data(struct ssh *ssh)

crypto/openssh/channels.c

877

u_int maxsize = ssh_packet_get_maxsize(ssh);

crypto/openssh/channels.c

880

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

crypto/openssh/channels.c

881

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

crypto/openssh/channels.c

895

channel_still_open(struct ssh *ssh)

crypto/openssh/channels.c

900

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

crypto/openssh/channels.c

901

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

crypto/openssh/channels.c

938

channel_tty_open(struct ssh *ssh)

crypto/openssh/channels.c

943

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

crypto/openssh/channels.c

944

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

crypto/openssh/channels.c

955

channel_find_open(struct ssh *ssh)

crypto/openssh/channels.c

960

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

crypto/openssh/channels.c

961

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

crypto/openssh/channels.h

115

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

crypto/openssh/channels.h

279

void channel_init_channels(struct ssh *ssh);

crypto/openssh/channels.h

283

Channel *channel_by_id(struct ssh *, int);

crypto/openssh/channels.h

284

Channel *channel_by_remote_id(struct ssh *, u_int);

crypto/openssh/channels.h

285

Channel *channel_lookup(struct ssh *, int);

crypto/openssh/channels.h

286

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

crypto/openssh/channels.h

288

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

crypto/openssh/channels.h

290

void channel_free(struct ssh *, Channel *);

crypto/openssh/channels.h

291

void channel_free_all(struct ssh *);

crypto/openssh/channels.h

292

void channel_stop_listening(struct ssh *);

crypto/openssh/channels.h

293

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

crypto/openssh/channels.h

294

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

crypto/openssh/channels.h

296

void channel_send_open(struct ssh *, int);

crypto/openssh/channels.h

297

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

crypto/openssh/channels.h

298

void channel_register_cleanup(struct ssh *, int,

crypto/openssh/channels.h

300

void channel_register_open_confirm(struct ssh *, int,

crypto/openssh/channels.h

302

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

crypto/openssh/channels.h

304

void channel_register_status_confirm(struct ssh *, int,

crypto/openssh/channels.h

306

void channel_cancel_cleanup(struct ssh *, int);

crypto/openssh/channels.h

307

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

crypto/openssh/channels.h

308

void channel_send_window_changes(struct ssh *);

crypto/openssh/channels.h

311

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

crypto/openssh/channels.h

312

void channel_clear_timeouts(struct ssh *);

crypto/openssh/channels.h

316

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

crypto/openssh/channels.h

317

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

crypto/openssh/channels.h

321

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

crypto/openssh/channels.h

322

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

crypto/openssh/channels.h

323

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

crypto/openssh/channels.h

324

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

crypto/openssh/channels.h

325

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

crypto/openssh/channels.h

326

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

crypto/openssh/channels.h

327

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

crypto/openssh/channels.h

328

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

crypto/openssh/channels.h

334

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

crypto/openssh/channels.h

336

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

crypto/openssh/channels.h

337

int channel_output_poll(struct ssh *);

crypto/openssh/channels.h

339

int channel_not_very_much_buffered_data(struct ssh *);

crypto/openssh/channels.h

340

void channel_close_all(struct ssh *);

crypto/openssh/channels.h

341

int channel_still_open(struct ssh *);

crypto/openssh/channels.h

342

int channel_tty_open(struct ssh *);

crypto/openssh/channels.h

344

char *channel_open_message(struct ssh *);

crypto/openssh/channels.h

345

int channel_find_open(struct ssh *);

crypto/openssh/channels.h

350

void channel_set_af(struct ssh *, int af);

crypto/openssh/channels.h

351

void channel_permit_all(struct ssh *, int);

crypto/openssh/channels.h

352

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

crypto/openssh/channels.h

353

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

crypto/openssh/channels.h

354

void channel_disable_admin(struct ssh *, int);

crypto/openssh/channels.h

355

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

crypto/openssh/channels.h

356

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

crypto/openssh/channels.h

358

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

crypto/openssh/channels.h

359

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

crypto/openssh/channels.h

361

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

crypto/openssh/channels.h

363

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

crypto/openssh/channels.h

365

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

crypto/openssh/channels.h

366

int channel_setup_local_fwd_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

368

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

crypto/openssh/channels.h

369

int channel_setup_remote_fwd_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

371

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

crypto/openssh/channels.h

372

int channel_cancel_lport_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

378

void channel_set_x11_refuse_time(struct ssh *, time_t);

crypto/openssh/channels.h

379

int x11_connect_display(struct ssh *);

crypto/openssh/channels.h

380

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

crypto/openssh/channels.h

381

void x11_request_forwarding_with_spoofing(struct ssh *, int,

crypto/openssh/channels.h

386

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

crypto/openssh/channels.h

387

void chan_mark_dead(struct ssh *, Channel *);

crypto/openssh/channels.h

391

void chan_rcvd_oclose(struct ssh *, Channel *);

crypto/openssh/channels.h

392

void chan_rcvd_eow(struct ssh *, Channel *);

crypto/openssh/channels.h

393

void chan_read_failed(struct ssh *, Channel *);

crypto/openssh/channels.h

394

void chan_ibuf_empty(struct ssh *, Channel *);

crypto/openssh/channels.h

395

void chan_rcvd_ieof(struct ssh *, Channel *);

crypto/openssh/channels.h

396

void chan_write_failed(struct ssh *, Channel *);

crypto/openssh/channels.h

397

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

1058

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

crypto/openssh/clientloop.c

1060

ok = channel_cancel_lport_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1063

ok = channel_cancel_lport_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1084

if (!channel_setup_local_fwd_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1090

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

crypto/openssh/clientloop.c

1170

process_escapes(struct ssh *ssh, Channel *c,

crypto/openssh/clientloop.c

1203

channel_force_close(ssh, c, 1);

crypto/openssh/clientloop.c

1241

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

crypto/openssh/clientloop.c

1242

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

crypto/openssh/clientloop.c

1243

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

crypto/openssh/clientloop.c

1248

if (ssh->compat & SSH_BUG_NOREKEY)

crypto/openssh/clientloop.c

1293

channel_stop_listening(ssh);

crypto/openssh/clientloop.c

1324

s = channel_open_message(ssh);

crypto/openssh/clientloop.c

1339

process_cmdline(ssh);

crypto/openssh/clientloop.c

1392

client_process_buffered_input_packets(struct ssh *ssh)

crypto/openssh/clientloop.c

1394

ssh_dispatch_run_fatal(ssh, DISPATCH_NONBLOCK, &quit_pending);

crypto/openssh/clientloop.c

1413

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

crypto/openssh/clientloop.c

1419

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

crypto/openssh/clientloop.c

1424

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

crypto/openssh/clientloop.c

1429

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

crypto/openssh/clientloop.c

1431

channel_cancel_cleanup(ssh, id);

crypto/openssh/clientloop.c

1443

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

crypto/openssh/clientloop.c

1496

connection_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/clientloop.c

1497

connection_out = ssh_packet_get_connection_out(ssh);

crypto/openssh/clientloop.c

1501

client_init_dispatch(ssh);

crypto/openssh/clientloop.c

1522

channel_register_filter(ssh, session_ident,

crypto/openssh/clientloop.c

1528

channel_register_cleanup(ssh, session_ident,

crypto/openssh/clientloop.c

1546

client_process_buffered_input_packets(ssh);

crypto/openssh/clientloop.c

1548

if (session_closed && !channel_still_open(ssh))

crypto/openssh/clientloop.c

1551

if (ssh_packet_is_rekeying(ssh)) {

crypto/openssh/clientloop.c

1556

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

crypto/openssh/clientloop.c

1564

if (ssh_packet_not_very_much_data_to_write(ssh))

crypto/openssh/clientloop.c

1565

channel_did_enqueue = channel_output_poll(ssh);

crypto/openssh/clientloop.c

1571

client_check_window_change(ssh);

crypto/openssh/clientloop.c

1581

client_wait_until_can_do_something(ssh, &pfd, &npfd_alloc,

crypto/openssh/clientloop.c

1591

channel_after_poll(ssh, pfd, npfd_active);

crypto/openssh/clientloop.c

1595

client_process_net_input(ssh);

crypto/openssh/clientloop.c

1601

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

crypto/openssh/clientloop.c

1609

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

crypto/openssh/clientloop.c

1610

sshpkt_fatal(ssh, r,

crypto/openssh/clientloop.c

1642

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

crypto/openssh/clientloop.c

1643

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

crypto/openssh/clientloop.c

1644

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

crypto/openssh/clientloop.c

1645

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

crypto/openssh/clientloop.c

1646

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

crypto/openssh/clientloop.c

1647

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

crypto/openssh/clientloop.c

1650

channel_free_all(ssh);

crypto/openssh/clientloop.c

1673

ssh_packet_get_bytes(ssh, &ibytes, &obytes);

crypto/openssh/clientloop.c

168

static void client_init_dispatch(struct ssh *ssh);

crypto/openssh/clientloop.c

1687

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

crypto/openssh/clientloop.c

1697

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

crypto/openssh/clientloop.c

1698

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

crypto/openssh/clientloop.c

1699

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

crypto/openssh/clientloop.c

1700

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

crypto/openssh/clientloop.c

1701

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

crypto/openssh/clientloop.c

1712

c = channel_connect_by_listen_address(ssh,

crypto/openssh/clientloop.c

1747

client_request_forwarded_streamlocal(struct ssh *ssh,

crypto/openssh/clientloop.c

1755

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

crypto/openssh/clientloop.c

1756

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

crypto/openssh/clientloop.c

1757

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

crypto/openssh/clientloop.c

1762

c = channel_connect_by_listen_path(ssh, listen_path,

crypto/openssh/clientloop.c

1769

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

crypto/openssh/clientloop.c

1787

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

crypto/openssh/clientloop.c

1788

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

crypto/openssh/clientloop.c

1789

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

crypto/openssh/clientloop.c

1796

sock = x11_connect_display(ssh);

crypto/openssh/clientloop.c

1799

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

crypto/openssh/clientloop.c

1807

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

crypto/openssh/clientloop.c

1828

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

crypto/openssh/clientloop.c

1829

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

crypto/openssh/clientloop.c

1834

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

crypto/openssh/clientloop.c

1843

client_request_tun_fwd(struct ssh *ssh, int tun_mode,

crypto/openssh/clientloop.c

1862

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

crypto/openssh/clientloop.c

1868

channel_register_filter(ssh, c->self, sys_tun_infilter,

crypto/openssh/clientloop.c

1873

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

crypto/openssh/clientloop.c

1875

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

crypto/openssh/clientloop.c

1876

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

crypto/openssh/clientloop.c

1877

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

crypto/openssh/clientloop.c

1878

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

crypto/openssh/clientloop.c

1879

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

crypto/openssh/clientloop.c

1880

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

crypto/openssh/clientloop.c

1881

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

crypto/openssh/clientloop.c

1882

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

crypto/openssh/clientloop.c

1883

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

crypto/openssh/clientloop.c

1890

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

crypto/openssh/clientloop.c

1899

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

crypto/openssh/clientloop.c

1900

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

crypto/openssh/clientloop.c

1901

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

crypto/openssh/clientloop.c

1902

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

crypto/openssh/clientloop.c

1909

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

crypto/openssh/clientloop.c

1912

c = client_request_forwarded_streamlocal(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1914

c = client_request_x11(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1916

c = client_request_agent(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1927

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

crypto/openssh/clientloop.c

1928

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

crypto/openssh/clientloop.c

1929

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

crypto/openssh/clientloop.c

1930

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

crypto/openssh/clientloop.c

1931

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

crypto/openssh/clientloop.c

1932

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

crypto/openssh/clientloop.c

1933

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

crypto/openssh/clientloop.c

1937

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

crypto/openssh/clientloop.c

1938

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

crypto/openssh/clientloop.c

1939

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

crypto/openssh/clientloop.c

1940

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

crypto/openssh/clientloop.c

1941

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

crypto/openssh/clientloop.c

1942

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

crypto/openssh/clientloop.c

1943

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

crypto/openssh/clientloop.c

1952

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

crypto/openssh/clientloop.c

1960

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

crypto/openssh/clientloop.c

1963

c = channel_lookup(ssh, id);

crypto/openssh/clientloop.c

1964

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

crypto/openssh/clientloop.c

1966

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

crypto/openssh/clientloop.c

1967

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

crypto/openssh/clientloop.c

1977

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

crypto/openssh/clientloop.c

1979

chan_rcvd_eow(ssh, c);

crypto/openssh/clientloop.c

1981

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

crypto/openssh/clientloop.c

1984

mux_exit_message(ssh, c, exitval);

crypto/openssh/clientloop.c

1995

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

crypto/openssh/clientloop.c

2001

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/clientloop.c

2003

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

crypto/openssh/clientloop.c

2004

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

crypto/openssh/clientloop.c

2005

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

crypto/openssh/clientloop.c

2329

client_global_hostkeys_prove_confirm(struct ssh *ssh, int type,

crypto/openssh/clientloop.c

2350

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

crypto/openssh/clientloop.c

2351

rsa_kexalg = ssh->kex->hostkey_alg;

crypto/openssh/clientloop.c

2368

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

crypto/openssh/clientloop.c

2372

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

crypto/openssh/clientloop.c

2414

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

crypto/openssh/clientloop.c

2433

client_input_hostkeys(struct ssh *ssh)

crypto/openssh/clientloop.c

245

set_control_persist_exit_time(struct ssh *ssh)

crypto/openssh/clientloop.c

2453

while (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/clientloop.c

2456

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

2599

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

crypto/openssh/clientloop.c

2600

(r = sshpkt_put_cstring(ssh,

crypto/openssh/clientloop.c

2602

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

crypto/openssh/clientloop.c

2611

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

crypto/openssh/clientloop.c

2614

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

crypto/openssh/clientloop.c

2639

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

crypto/openssh/clientloop.c

2645

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

crypto/openssh/clientloop.c

2646

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

crypto/openssh/clientloop.c

2651

success = client_input_hostkeys(ssh);

crypto/openssh/clientloop.c

2653

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

crypto/openssh/clientloop.c

2655

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

crypto/openssh/clientloop.c

2656

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

crypto/openssh/clientloop.c

2666

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

crypto/openssh/clientloop.c

2671

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

crypto/openssh/clientloop.c

2672

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

crypto/openssh/clientloop.c

2673

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

crypto/openssh/clientloop.c

2674

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

crypto/openssh/clientloop.c

2679

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

crypto/openssh/clientloop.c

2690

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

crypto/openssh/clientloop.c

2693

ssh_packet_set_interactive(ssh, want_tty,

crypto/openssh/clientloop.c

2703

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

crypto/openssh/clientloop.c

2704

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

crypto/openssh/clientloop.c

2705

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

crypto/openssh/clientloop.c

2707

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

crypto/openssh/clientloop.c

2708

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

crypto/openssh/clientloop.c

2709

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

crypto/openssh/clientloop.c

2710

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

crypto/openssh/clientloop.c

2714

ssh_tty_make_modes(ssh, -1, tiop);

crypto/openssh/clientloop.c

2715

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

crypto/openssh/clientloop.c

2745

client_send_env(ssh, id, name, val);

crypto/openssh/clientloop.c

2757

client_send_env(ssh, id, name, val);

crypto/openssh/clientloop.c

2768

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

crypto/openssh/clientloop.c

2769

client_expect_confirm(ssh, id, "subsystem",

crypto/openssh/clientloop.c

2774

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

crypto/openssh/clientloop.c

2775

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

crypto/openssh/clientloop.c

2777

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

crypto/openssh/clientloop.c

2778

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

crypto/openssh/clientloop.c

2781

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

crypto/openssh/clientloop.c

2782

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

crypto/openssh/clientloop.c

2783

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

crypto/openssh/clientloop.c

2792

client_init_dispatch(struct ssh *ssh)

crypto/openssh/clientloop.c

2794

ssh_dispatch_init(ssh, &dispatch_protocol_error);

crypto/openssh/clientloop.c

2796

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);

crypto/openssh/clientloop.c

2797

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_DATA, &channel_input_data);

crypto/openssh/clientloop.c

2798

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);

crypto/openssh/clientloop.c

2799

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);

crypto/openssh/clientloop.c

2800

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN, &client_input_channel_open);

crypto/openssh/clientloop.c

2801

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);

crypto/openssh/clientloop.c

2802

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);

crypto/openssh/clientloop.c

2803

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_REQUEST, &client_input_channel_req);

crypto/openssh/clientloop.c

2804

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);

crypto/openssh/clientloop.c

2805

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_SUCCESS, &channel_input_status_confirm);

crypto/openssh/clientloop.c

2806

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_FAILURE, &channel_input_status_confirm);

crypto/openssh/clientloop.c

2807

ssh_dispatch_set(ssh, SSH2_MSG_GLOBAL_REQUEST, &client_input_global_request);

crypto/openssh/clientloop.c

2810

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/clientloop.c

2813

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_FAILURE, &client_global_request_reply);

crypto/openssh/clientloop.c

2814

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

683

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

crypto/openssh/clientloop.c

695

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

crypto/openssh/clientloop.c

700

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

crypto/openssh/clientloop.c

701

!ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

708

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

crypto/openssh/clientloop.c

714

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

crypto/openssh/clientloop.c

722

set_control_persist_exit_time(ssh);

crypto/openssh/clientloop.c

727

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

crypto/openssh/clientloop.c

729

ssh_packet_get_rekey_timeout(ssh));

crypto/openssh/clientloop.c

759

server_alive_check(ssh);

crypto/openssh/clientloop.c

790

client_process_net_input(struct ssh *ssh)

crypto/openssh/clientloop.c

799

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

crypto/openssh/clientloop.c

814

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

crypto/openssh/clientloop.c

868

mux_tty_alloc_failed(ssh, c);

crypto/openssh/clientloop.c

870

chan_read_failed(ssh, c);

crypto/openssh/clientloop.c

871

chan_write_failed(ssh, c);

crypto/openssh/clientloop.c

878

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

crypto/openssh/clientloop.c

884

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

crypto/openssh/clientloop.c

892

channel_register_status_confirm(ssh, id, client_status_confirm,

crypto/openssh/clientloop.c

984

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

1016

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

crypto/openssh/kex.c

1052

ssh->dispatch_skip_packets = 1;

crypto/openssh/kex.c

1061

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

crypto/openssh/kex.c

1064

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

107

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

crypto/openssh/kex.c

1126

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

crypto/openssh/kex.c

1129

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1147

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

1165

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

crypto/openssh/kex.c

1167

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1177

kex->hostkey_nid, ssh);

crypto/openssh/kex.c

1179

kex->hostkey_nid, ssh);

crypto/openssh/kex.c

1186

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

crypto/openssh/kex.c

1188

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1198

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

crypto/openssh/kex.c

1217

send_error(struct ssh *ssh, char *msg)

crypto/openssh/kex.c

1221

if (!ssh->kex->server)

crypto/openssh/kex.c

1224

if (atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1226

atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1237

kex_exchange_identification(struct ssh *ssh, int timeout_ms,

crypto/openssh/kex.c

1244

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

crypto/openssh/kex.c

1245

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

crypto/openssh/kex.c

1246

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

crypto/openssh/kex.c

1247

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

crypto/openssh/kex.c

1264

if (atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1288

send_error(ssh, "No SSH identification string "

crypto/openssh/kex.c

1299

r = waitrfd(ssh_packet_get_connection_in(ssh),

crypto/openssh/kex.c

1302

send_error(ssh, "Timed out waiting "

crypto/openssh/kex.c

1316

len = atomicio(read, ssh_packet_get_connection_in(ssh),

crypto/openssh/kex.c

1360

if (ssh->kex->server) {

crypto/openssh/kex.c

1388

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

crypto/openssh/kex.c

1394

compat_banner(ssh, remote_version);

crypto/openssh/kex.c

1411

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

crypto/openssh/kex.c

1416

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

crypto/openssh/kex.c

1418

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/kex.c

1423

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

crypto/openssh/kex.c

1425

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

928

kex_choose_conf(struct ssh *ssh, uint32_t seq)

crypto/openssh/kex.c

930

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

967

ssh_packet_disconnect(ssh,

crypto/openssh/kex.c

97

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

crypto/openssh/kex.h

138

struct ssh;

crypto/openssh/kex.h

168

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

crypto/openssh/kex.h

169

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

crypto/openssh/kex.h

170

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

crypto/openssh/kex.h

171

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

crypto/openssh/kex.h

172

int (*sign)(struct ssh *, struct sshkey *, struct sshkey *,

crypto/openssh/kex.h

174

int (*kex[KEX_MAX])(struct ssh *);

crypto/openssh/kex.h

195

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

crypto/openssh/kex.h

199

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

crypto/openssh/kex.h

202

int kex_ready(struct ssh *, char *[PROPOSAL_MAX]);

crypto/openssh/kex.h

203

int kex_setup(struct ssh *, char *[PROPOSAL_MAX]);

crypto/openssh/kex.h

210

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

crypto/openssh/kex.h

211

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

crypto/openssh/kex.h

213

int kex_send_kexinit(struct ssh *);

crypto/openssh/kex.h

214

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

crypto/openssh/kex.h

215

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

crypto/openssh/kex.h

216

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

crypto/openssh/kex.h

217

int kex_derive_keys(struct ssh *, u_char *, u_int, const struct sshbuf *);

crypto/openssh/kex.h

218

int kex_send_newkeys(struct ssh *);

crypto/openssh/kex.h

219

int kex_start_rekex(struct ssh *);

crypto/openssh/kex.h

220

int kex_server_update_ext_info(struct ssh *);

crypto/openssh/kex.h

221

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

crypto/openssh/kex.h

223

int kexgex_client(struct ssh *);

crypto/openssh/kex.h

224

int kexgex_server(struct ssh *);

crypto/openssh/kex.h

225

int kex_gen_client(struct ssh *);

crypto/openssh/kex.h

226

int kex_gen_server(struct ssh *);

crypto/openssh/kexgen.c

101

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

129

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

crypto/openssh/kexgen.c

130

(r = sshpkt_put_stringb(ssh, kex->client_pub)) != 0 ||

crypto/openssh/kexgen.c

131

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

crypto/openssh/kexgen.c

134

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &input_kex_gen_reply);

crypto/openssh/kexgen.c

139

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

crypto/openssh/kexgen.c

141

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

152

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &kex_protocol_error);

crypto/openssh/kexgen.c

155

if ((r = sshpkt_getb_froms(ssh, &server_host_key_blob)) != 0)

crypto/openssh/kexgen.c

164

if ((r = kex_verify_host_key(ssh, server_host_key)) != 0)

crypto/openssh/kexgen.c

169

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

crypto/openssh/kexgen.c

170

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

crypto/openssh/kexgen.c

171

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

crypto/openssh/kexgen.c

218

kex->hostkey_alg, ssh->compat, NULL)) != 0)

crypto/openssh/kexgen.c

221

if ((r = kex_derive_keys(ssh, hash, hashlen, shared_secret)) != 0 ||

crypto/openssh/kexgen.c

222

(r = kex_send_newkeys(ssh)) != 0)

crypto/openssh/kexgen.c

258

kex_gen_server(struct ssh *ssh)

crypto/openssh/kexgen.c

261

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_INIT, &input_kex_gen_init);

crypto/openssh/kexgen.c

266

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

crypto/openssh/kexgen.c

268

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

279

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_INIT, &kex_protocol_error);

crypto/openssh/kexgen.c

281

if ((r = kex_load_hostkey(ssh, &server_host_private,

crypto/openssh/kexgen.c

285

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

crypto/openssh/kexgen.c

286

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

crypto/openssh/kexgen.c

342

if ((r = kex->sign(ssh, server_host_private, server_host_public,

crypto/openssh/kexgen.c

347

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

crypto/openssh/kexgen.c

348

(r = sshpkt_put_stringb(ssh, server_host_key_blob)) != 0 ||

crypto/openssh/kexgen.c

349

(r = sshpkt_put_stringb(ssh, server_pubkey)) != 0 ||

crypto/openssh/kexgen.c

350

(r = sshpkt_put_string(ssh, signature, slen)) != 0 ||

crypto/openssh/kexgen.c

351

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

crypto/openssh/kexgen.c

354

if ((r = kex_derive_keys(ssh, hash, hashlen, shared_secret)) != 0 ||

crypto/openssh/kexgen.c

355

(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

1662

record_failed_login(struct ssh *ssh, const char *username, const char *hostname,

crypto/openssh/loginrec.c

1705

if (ssh_packet_connection_is_on_socket(ssh) &&

crypto/openssh/loginrec.c

1706

getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/loginrec.h

131

void record_failed_login(struct ssh *, const char *, const char *,

crypto/openssh/loginrec.h

34

struct ssh;

crypto/openssh/monitor.c

1001

mm_answer_pam_start(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1006

start_pam(ssh);

crypto/openssh/monitor.c

1016

mm_answer_pam_account(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1039

mm_answer_pam_init_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1064

mm_answer_pam_query(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1105

mm_answer_pam_respond(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1147

mm_answer_pam_free_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

115

int mm_answer_moduli(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

116

int mm_answer_sign(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1167

mm_answer_keyallowed(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

117

int mm_answer_pwnamallow(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

118

int mm_answer_auth2_read_banner(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

119

int mm_answer_authserv(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1195

allowed = user_key_allowed(ssh, authctxt->pw, key,

crypto/openssh/monitor.c

120

int mm_answer_authpassword(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1207

allowed = hostbased_key_allowed(ssh, authctxt->pw,

crypto/openssh/monitor.c

121

int mm_answer_bsdauthquery(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

122

int mm_answer_bsdauthrespond(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

123

int mm_answer_keyallowed(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1239

auth_log(ssh, 0, 0, auth_method, NULL);

crypto/openssh/monitor.c

124

int mm_answer_keyverify(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

125

int mm_answer_pty(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1259

monitor_valid_userblob(struct ssh *ssh, const u_char *data, u_int datalen)

crypto/openssh/monitor.c

126

int mm_answer_pty_cleanup(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

127

int mm_answer_term(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1272

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/monitor.c

130

int mm_answer_pam_start(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

131

int mm_answer_pam_account(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

132

int mm_answer_pam_init_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

133

int mm_answer_pam_query(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1332

if (get_hostkey_index(hostkey, 1, ssh) == -1)

crypto/openssh/monitor.c

134

int mm_answer_pam_respond(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

135

int mm_answer_pam_free_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

139

int mm_answer_gss_setup_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

140

int mm_answer_gss_accept_ctx(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1409

mm_answer_keyverify(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

141

int mm_answer_gss_userok(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

142

int mm_answer_gss_checkmic(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1441

valid_data = monitor_valid_userblob(ssh, data, datalen);

crypto/openssh/monitor.c

146

int mm_answer_audit_event(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1463

sigalg, ssh->compat, &sig_details);

crypto/openssh/monitor.c

147

int mm_answer_audit_command(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1480

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

1481

ssh_remote_port(ssh));

crypto/openssh/monitor.c

1492

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

1493

ssh_remote_port(ssh));

crypto/openssh/monitor.c

1500

auth_activate_options(ssh, key_opts);

crypto/openssh/monitor.c

1526

mm_record_login(struct ssh *ssh, Session *s, struct passwd *pw)

crypto/openssh/monitor.c

1537

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/monitor.c

1538

if (getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/monitor.c

1546

session_get_remote_name_or_ip(ssh, utmp_len, options.use_dns),

crypto/openssh/monitor.c

1562

mm_answer_pty(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1590

mm_record_login(ssh, s, authctxt->pw);

crypto/openssh/monitor.c

1632

mm_answer_pty_cleanup(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1650

mm_answer_term(struct ssh *ssh, int sock, struct sshbuf *req)

crypto/openssh/monitor.c

1658

session_destroy_all(ssh, &mm_session_close);

crypto/openssh/monitor.c

1678

mm_answer_audit_event(struct ssh *ssh, int socket, struct sshbuf *m)

crypto/openssh/monitor.c

169

int (*f)(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1697

audit_event(ssh, event);

crypto/openssh/monitor.c

1707

mm_answer_audit_command(struct ssh *ssh, int socket, struct sshbuf *m)

crypto/openssh/monitor.c

1723

monitor_clear_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1725

ssh_clear_newkeys(ssh, MODE_IN);

crypto/openssh/monitor.c

1726

ssh_clear_newkeys(ssh, MODE_OUT);

crypto/openssh/monitor.c

1732

monitor_apply_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1738

if ((r = ssh_packet_set_state(ssh, child_state)) != 0)

crypto/openssh/monitor.c

1742

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

crypto/openssh/monitor.c

1744

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

crypto/openssh/monitor.c

1746

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

crypto/openssh/monitor.c

1748

if (memcmp(sshbuf_ptr(ssh->kex->session_id), session_id2,

crypto/openssh/monitor.c

1775

mm_get_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

181

static int monitor_read(struct ssh *, struct monitor *, struct mon_table *,

crypto/openssh/monitor.c

1847

mm_answer_gss_setup_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1880

mm_answer_gss_accept_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1914

mm_answer_gss_checkmic(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1945

mm_answer_gss_userok(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

266

monitor_child_preauth(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

279

authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/monitor.c

281

ssh->authctxt = authctxt;

crypto/openssh/monitor.c

297

authenticated = (monitor_read(ssh, pmonitor,

crypto/openssh/monitor.c

320

!auth_root_allowed(ssh, auth_method))

crypto/openssh/monitor.c

333

ssh, pmonitor->m_sendfd, m);

crypto/openssh/monitor.c

339

auth_log(ssh, authenticated, partial,

crypto/openssh/monitor.c

362

ssh->authctxt = NULL;

crypto/openssh/monitor.c

363

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

crypto/openssh/monitor.c

365

mm_get_keystate(ssh, pmonitor);

crypto/openssh/monitor.c

391

monitor_child_postauth(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

417

monitor_read(ssh, pmonitor, mon_dispatch, NULL);

crypto/openssh/monitor.c

473

monitor_read(struct ssh *ssh, struct monitor *pmonitor, struct mon_table *ent,

crypto/openssh/monitor.c

522

ret = (*ent->f)(ssh, pmonitor->m_sendfd, m);

crypto/openssh/monitor.c

572

mm_answer_moduli(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

612

mm_answer_sign(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

652

if ((key = get_hostkey_public_by_index(keyid, ssh)) == NULL)

crypto/openssh/monitor.c

680

} else if ((key = get_hostkey_public_by_index(keyid, ssh)) != NULL &&

crypto/openssh/monitor.c

743

mm_answer_pwnamallow(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

756

pwent = getpwnamallow(ssh, authctxt->user);

crypto/openssh/monitor.c

797

ssh_packet_set_log_preamble(ssh, "%suser %s",

crypto/openssh/monitor.c

828

int mm_answer_auth2_read_banner(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

844

mm_answer_authserv(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

893

mm_answer_authpassword(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

906

auth_password(ssh, passwd);

crypto/openssh/monitor.c

933

mm_answer_bsdauthquery(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

967

mm_answer_bsdauthrespond(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.h

68

struct ssh;

crypto/openssh/monitor.h

84

void monitor_child_preauth(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

85

void monitor_child_postauth(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

87

void monitor_clear_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

88

void monitor_apply_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

94

void mm_get_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor_wrap.c

1083

server_process_permitopen_list(struct ssh *ssh, int listen,

crypto/openssh/monitor_wrap.c

1092

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/monitor_wrap.c

1100

channel_disable_admin(ssh, where);

crypto/openssh/monitor_wrap.c

1113

channel_add_permission(ssh, FORWARD_ADM,

crypto/openssh/monitor_wrap.c

1123

server_process_permitopen(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

1125

server_process_permitopen_list(ssh, 0,

crypto/openssh/monitor_wrap.c

1127

server_process_permitopen_list(ssh, 1,

crypto/openssh/monitor_wrap.c

1132

server_process_channel_timeouts(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

1138

channel_clear_timeouts(ssh);

crypto/openssh/monitor_wrap.c

1145

channel_add_timeout(ssh, type, secs);

crypto/openssh/monitor_wrap.c

1151

server_get_connection_info(struct ssh *ssh, int populate, int use_dns)

crypto/openssh/monitor_wrap.c

1155

if (ssh == NULL || !populate)

crypto/openssh/monitor_wrap.c

1157

ci.host = use_dns ? ssh_remote_hostname(ssh) : ssh_remote_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1158

ci.address = ssh_remote_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1159

ci.laddress = ssh_local_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1160

ci.lport = ssh_local_port(ssh);

crypto/openssh/monitor_wrap.c

1161

ci.rdomain = ssh_packet_rdomain_in(ssh);

crypto/openssh/monitor_wrap.c

263

mm_sshkey_sign(struct ssh *ssh, struct sshkey *key, u_char **sigp, size_t *lenp,

crypto/openssh/monitor_wrap.c

269

u_int ndx = kex->host_key_index(key, 0, ssh);

crypto/openssh/monitor_wrap.c

293

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

crypto/openssh/monitor_wrap.c

345

mm_getpwnamallow(struct ssh *ssh, const char *username)

crypto/openssh/monitor_wrap.c

397

mm_decode_activate_server_options(ssh, m);

crypto/openssh/monitor_wrap.c

398

server_process_permitopen(ssh);

crypto/openssh/monitor_wrap.c

399

server_process_channel_timeouts(ssh);

crypto/openssh/monitor_wrap.c

400

kex_set_server_sig_algs(ssh, options.pubkey_accepted_algos);

crypto/openssh/monitor_wrap.c

457

mm_auth_password(struct ssh *ssh, char *password)

crypto/openssh/monitor_wrap.c

494

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

crypto/openssh/monitor_wrap.c

502

mm_hostbased_key_allowed(struct ssh *ssh, struct passwd *pw,

crypto/openssh/monitor_wrap.c

609

mm_send_keystate(struct ssh *ssh, struct monitor *monitor)

crypto/openssh/monitor_wrap.c

616

if ((r = ssh_packet_get_state(ssh, m)) != 0)

crypto/openssh/monitor_wrap.c

701

mm_start_pam(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

942

mm_audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/monitor_wrap.h

101

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

98

void server_process_permitopen(struct ssh *);

crypto/openssh/monitor_wrap.h

99

void server_process_channel_timeouts(struct ssh *ssh);

crypto/openssh/mux.c

1033

nc = channel_connect_stdio_fwd(ssh, chost, cport, new_fd[0], new_fd[1],

crypto/openssh/mux.c

1043

channel_register_cleanup(ssh, nc->self,

crypto/openssh/mux.c

1048

channel_register_open_confirm(ssh, nc->self, mux_stdio_confirm, cctx);

crypto/openssh/mux.c

1057

mux_stdio_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/mux.c

1066

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

crypto/openssh/mux.c

1068

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1103

mux_master_process_stop_listening(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

1120

channel_free(ssh, mux_listener_channel);

crypto/openssh/mux.c

1133

mux_master_process_proxy(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

1150

mux_master_read_cb(struct ssh *ssh, Channel *c)

crypto/openssh/mux.c

1164

channel_register_cleanup(ssh, c->self,

crypto/openssh/mux.c

1205

ret = mux_master_handlers[i].handler(ssh, rid,

crypto/openssh/mux.c

1226

mux_exit_message(struct ssh *ssh, Channel *c, int exitval)

crypto/openssh/mux.c

1234

if ((mux_chan = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1249

mux_tty_alloc_failed(struct ssh *ssh, Channel *c)

crypto/openssh/mux.c

1257

if ((mux_chan = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1272

muxserver_listen(struct ssh *ssh)

crypto/openssh/mux.c

1345

mux_listener_channel = channel_new(ssh, "mux listener",

crypto/openssh/mux.c

1356

mux_session_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/mux.c

1366

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

crypto/openssh/mux.c

1368

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1386

if (client_x11_get_proto(ssh, display, options.xauth_location,

crypto/openssh/mux.c

1392

x11_request_forwarding_with_spoofing(ssh, id,

crypto/openssh/mux.c

1395

client_expect_confirm(ssh, id, "X11 forwarding",

crypto/openssh/mux.c

1402

channel_request_start(ssh, id, "auth-agent-req@openssh.com", 0);

crypto/openssh/mux.c

1403

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

crypto/openssh/mux.c

1407

client_session2_setup(ssh, id, cctx->want_tty, cctx->want_subsys,

crypto/openssh/mux.c

151

static void mux_session_confirm(struct ssh *, int, int, void *);

crypto/openssh/mux.c

152

static void mux_stdio_confirm(struct ssh *, int, int, void *);

crypto/openssh/mux.c

154

static int mux_master_process_hello(struct ssh *, u_int,

crypto/openssh/mux.c

156

static int mux_master_process_new_session(struct ssh *, u_int,

crypto/openssh/mux.c

158

static int mux_master_process_alive_check(struct ssh *, u_int,

crypto/openssh/mux.c

160

static int mux_master_process_terminate(struct ssh *, u_int,

crypto/openssh/mux.c

162

static int mux_master_process_open_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

164

static int mux_master_process_close_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

166

static int mux_master_process_stdio_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

168

static int mux_master_process_stop_listening(struct ssh *, u_int,

crypto/openssh/mux.c

170

static int mux_master_process_proxy(struct ssh *, u_int,

crypto/openssh/mux.c

175

int (*handler)(struct ssh *, u_int, Channel *,

crypto/openssh/mux.c

192

mux_master_session_cleanup_cb(struct ssh *ssh, int cid, int force, void *unused)

crypto/openssh/mux.c

194

Channel *cc, *c = channel_by_id(ssh, cid);

crypto/openssh/mux.c

200

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

206

chan_rcvd_oclose(ssh, cc);

crypto/openssh/mux.c

208

channel_cancel_cleanup(ssh, c->self);

crypto/openssh/mux.c

213

mux_master_control_cleanup_cb(struct ssh *ssh, int cid, int force, void *unused)

crypto/openssh/mux.c

215

Channel *sc, *c = channel_by_id(ssh, cid);

crypto/openssh/mux.c

221

if ((sc = channel_by_id(ssh, c->remote_id)) == NULL)

crypto/openssh/mux.c

230

chan_mark_dead(ssh, sc);

crypto/openssh/mux.c

233

chan_read_failed(ssh, sc);

crypto/openssh/mux.c

235

chan_write_failed(ssh, sc);

crypto/openssh/mux.c

238

channel_cancel_cleanup(ssh, c->self);

crypto/openssh/mux.c

267

mux_master_process_hello(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

333

mux_master_process_new_session(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

461

nc = channel_new(ssh, "session", SSH_CHANNEL_OPENING,

crypto/openssh/mux.c

470

channel_register_filter(ssh, nc->self,

crypto/openssh/mux.c

479

channel_send_open(ssh, nc->self);

crypto/openssh/mux.c

480

channel_register_open_confirm(ssh, nc->self, mux_session_confirm, cctx);

crypto/openssh/mux.c

482

channel_register_cleanup(ssh, nc->self,

crypto/openssh/mux.c

490

mux_master_process_alive_check(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

507

mux_master_process_terminate(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

595

mux_confirm_remote_forward(struct ssh *ssh, int type, u_int32_t seq, void *ctxt)

crypto/openssh/mux.c

605

if ((c = channel_by_id(ssh, fctx->cid)) == NULL) {

crypto/openssh/mux.c

625

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

crypto/openssh/mux.c

642

channel_update_permission(ssh, rfwd->handle,

crypto/openssh/mux.c

650

channel_update_permission(ssh, rfwd->handle, -1);

crypto/openssh/mux.c

683

mux_master_process_open_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

807

if (!channel_setup_local_fwd_listener(ssh, &fwd,

crypto/openssh/mux.c

820

fwd.handle = channel_request_remote_forwarding(ssh, &fwd);

crypto/openssh/mux.c

848

mux_master_process_close_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

930

if (channel_request_rforward_cancel(ssh, found_fwd) == -1)

crypto/openssh/mux.c

934

if (channel_cancel_lport_listener(ssh, &fwd, fwd.connect_port,

crypto/openssh/mux.c

960

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

221

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

crypto/openssh/nchan.c

222

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

crypto/openssh/nchan.c

223

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

crypto/openssh/nchan.c

230

chan_send_eow2(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

240

if (!(ssh->compat & SSH_NEW_OPENSSH))

crypto/openssh/nchan.c

244

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

crypto/openssh/nchan.c

245

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

crypto/openssh/nchan.c

246

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

crypto/openssh/nchan.c

247

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

crypto/openssh/nchan.c

248

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

crypto/openssh/nchan.c

255

chan_rcvd_ieof(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

264

chan_obuf_empty(ssh, c);

crypto/openssh/nchan.c

268

chan_rcvd_oclose(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

294

chan_shutdown_read(ssh, c);

crypto/openssh/nchan.c

295

chan_shutdown_extended_read(ssh, c);

crypto/openssh/nchan.c

300

chan_send_eof2(ssh, c);

crypto/openssh/nchan.c

301

chan_shutdown_extended_read(ssh, c);

crypto/openssh/nchan.c

308

chan_write_failed(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

314

chan_shutdown_write(ssh, c);

crypto/openssh/nchan.c

316

chan_send_eow2(ssh, c);

crypto/openssh/nchan.c

327

chan_mark_dead(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

333

chan_is_dead(struct ssh *ssh, Channel *c, int do_send)

crypto/openssh/nchan.c

341

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

crypto/openssh/nchan.c

355

chan_send_close2(ssh, c);

crypto/openssh/nchan.c

375

chan_shutdown_write(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

391

if (channel_close_fd(ssh, c, &c->wfd) < 0) {

crypto/openssh/nchan.c

400

chan_shutdown_read(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

419

if (channel_close_fd(ssh, c, &c->rfd) < 0) {

crypto/openssh/nchan.c

428

chan_shutdown_extended_read(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

438

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/packet.c

1021

if ((r = ssh_packet_init_compression(ssh)) < 0)

crypto/openssh/packet.c

1024

if ((r = start_compression_out(ssh, 6)) != 0)

crypto/openssh/packet.c

1027

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

crypto/openssh/packet.c

1051

ssh_packet_need_rekeying(struct ssh *ssh, u_int outbound_packet_len)

crypto/openssh/packet.c

1053

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1061

if (ssh_packet_is_rekeying(ssh))

crypto/openssh/packet.c

1065

if (ssh->compat & SSH_BUG_NOREKEY)

crypto/openssh/packet.c

1098

ssh_packet_check_rekey(struct ssh *ssh)

crypto/openssh/packet.c

1100

if (!ssh_packet_need_rekeying(ssh, 0))

crypto/openssh/packet.c

1103

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1112

ssh_packet_enable_delayed_compress(struct ssh *ssh)

crypto/openssh/packet.c

1114

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1129

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

crypto/openssh/packet.c

1132

if ((r = start_compression_out(ssh, 6)) != 0)

crypto/openssh/packet.c

1135

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

crypto/openssh/packet.c

1164

ssh_packet_send2_wrapped(struct ssh *ssh)

crypto/openssh/packet.c

1166

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1201

if ((r = compress_buffer(ssh, state->outgoing_packet,

crypto/openssh/packet.c

1303

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

crypto/openssh/packet.c

1304

ssh_packet_disconnect(ssh, "outgoing sequence number "

crypto/openssh/packet.c

1310

if (!(ssh->compat & SSH_BUG_NOREKEY))

crypto/openssh/packet.c

1316

if (type == SSH2_MSG_NEWKEYS && ssh->kex->kex_strict) {

crypto/openssh/packet.c

1322

r = ssh_set_newkeys(ssh, MODE_OUT);

crypto/openssh/packet.c

1324

r = ssh_packet_enable_delayed_compress(ssh);

crypto/openssh/packet.c

1344

ssh_packet_send2(struct ssh *ssh)

crypto/openssh/packet.c

1346

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1355

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

crypto/openssh/packet.c

1380

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1389

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

crypto/openssh/packet.c

1403

if (ssh_packet_need_rekeying(ssh,

crypto/openssh/packet.c

1406

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1414

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

crypto/openssh/packet.c

1428

ssh_packet_read_seqnr(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1430

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1443

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

crypto/openssh/packet.c

1449

if ((r = ssh_packet_read_poll_seqnr(ssh, typep, seqnr_p)) != 0)

crypto/openssh/packet.c

1502

if ((r = ssh_packet_process_incoming(ssh, buf, len)) != 0)

crypto/openssh/packet.c

1510

ssh_packet_read(struct ssh *ssh)

crypto/openssh/packet.c

1515

if ((r = ssh_packet_read_seqnr(ssh, &type, NULL)) != 0)

crypto/openssh/packet.c

1521

ssh_packet_read_poll2_mux(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1523

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1528

if (ssh->kex)

crypto/openssh/packet.c

1559

ssh_packet_read_poll2(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1561

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1571

return ssh_packet_read_poll2_mux(ssh, typep, seqnr_p);

crypto/openssh/packet.c

1601

if ((r = sshpkt_disconnect(ssh, "Packet corrupt")) != 0)

crypto/openssh/packet.c

1631

return ssh_packet_start_discard(ssh, enc, mac, 0,

crypto/openssh/packet.c

1654

return ssh_packet_start_discard(ssh, enc, mac, 0,

crypto/openssh/packet.c

1701

return ssh_packet_start_discard(ssh, enc, mac,

crypto/openssh/packet.c

1714

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

crypto/openssh/packet.c

1715

ssh_packet_disconnect(ssh, "incoming sequence number "

crypto/openssh/packet.c

1721

if (!(ssh->compat & SSH_BUG_NOREKEY))

crypto/openssh/packet.c

1730

if ((r = sshpkt_disconnect(ssh,

crypto/openssh/packet.c

1732

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

crypto/openssh/packet.c

1746

if ((r = uncompress_buffer(ssh, state->incoming_packet,

crypto/openssh/packet.c

1765

if ((r = sshpkt_disconnect(ssh,

crypto/openssh/packet.c

1767

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

crypto/openssh/packet.c

1772

(r = state->hook_in(ssh, state->incoming_packet, typep,

crypto/openssh/packet.c

1776

r = ssh_packet_enable_delayed_compress(ssh);

crypto/openssh/packet.c

1785

if (*typep == SSH2_MSG_NEWKEYS && ssh->kex->kex_strict) {

crypto/openssh/packet.c

1790

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

crypto/openssh/packet.c

1797

ssh_packet_read_poll_seqnr(struct ssh *ssh, u_char *typep, u_int32_t *seqnr_p)

crypto/openssh/packet.c

1799

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1808

r = ssh_packet_read_poll2(ssh, typep, seqnr_p);

crypto/openssh/packet.c

1820

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

crypto/openssh/packet.c

1821

(r = sshpkt_get_string(ssh, &msg, NULL)) != 0)

crypto/openssh/packet.c

1824

do_log2(ssh->state->server_side &&

crypto/openssh/packet.c

1828

"%u: %.400s", ssh_remote_ipaddr(ssh),

crypto/openssh/packet.c

1829

ssh_remote_port(ssh), reason, msg);

crypto/openssh/packet.c

1840

if (ssh->kex != NULL &&

crypto/openssh/packet.c

1841

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

crypto/openssh/packet.c

1849

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

crypto/openssh/packet.c

1850

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

crypto/openssh/packet.c

1851

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

crypto/openssh/packet.c

1859

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

crypto/openssh/packet.c

1865

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

crypto/openssh/packet.c

1868

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

crypto/openssh/packet.c

1869

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

crypto/openssh/packet.c

1870

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

crypto/openssh/packet.c

1874

if ((r = sshpkt_get_string_direct(ssh,

crypto/openssh/packet.c

1890

ssh_packet_process_incoming(struct ssh *ssh, const char *buf, u_int len)

crypto/openssh/packet.c

1892

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1898

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

crypto/openssh/packet.c

1912

ssh_packet_process_read(struct ssh *ssh, int fd)

crypto/openssh/packet.c

1914

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1926

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

crypto/openssh/packet.c

1936

ssh_packet_remaining(struct ssh *ssh)

crypto/openssh/packet.c

1938

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

crypto/openssh/packet.c

1950

ssh_packet_send_debug(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

1956

if ((ssh->compat & SSH_BUG_DEBUG))

crypto/openssh/packet.c

1965

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

crypto/openssh/packet.c

1966

(r = sshpkt_put_u8(ssh, 0)) != 0 || /* always display */

crypto/openssh/packet.c

1967

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

crypto/openssh/packet.c

1968

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

crypto/openssh/packet.c

1969

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

crypto/openssh/packet.c

1970

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

crypto/openssh/packet.c

1975

sshpkt_fmt_connection_id(struct ssh *ssh, char *s, size_t l)

crypto/openssh/packet.c

1978

ssh->log_preamble ? ssh->log_preamble : "",

crypto/openssh/packet.c

1979

ssh->log_preamble ? " " : "",

crypto/openssh/packet.c

1980

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/packet.c

1987

sshpkt_vfatal(struct ssh *ssh, int r, const char *fmt, va_list ap)

crypto/openssh/packet.c

1992

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/packet.c

1996

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

1999

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2001

ssh->state->server_side ? "from" : "to", remote_id);

crypto/openssh/packet.c

2003

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2007

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2016

if (ssh->kex && ssh->kex->failed_choice) {

crypto/openssh/packet.c

2017

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2021

ssh->kex->failed_choice);

crypto/openssh/packet.c

2026

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2029

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2033

ssh->state->server_side ? "from" : "to", remote_id);

crypto/openssh/packet.c

2038

sshpkt_fatal(struct ssh *ssh, int r, const char *fmt, ...)

crypto/openssh/packet.c

2043

sshpkt_vfatal(ssh, r, fmt, ap);

crypto/openssh/packet.c

2056

ssh_packet_disconnect(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

2071

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/packet.c

2083

if ((r = sshpkt_disconnect(ssh, "%s", buf)) != 0)

crypto/openssh/packet.c

2084

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

crypto/openssh/packet.c

2086

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

crypto/openssh/packet.c

2087

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

crypto/openssh/packet.c

2090

ssh_packet_close(ssh);

crypto/openssh/packet.c

2099

ssh_packet_write_poll(struct ssh *ssh)

crypto/openssh/packet.c

2101

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2127

ssh_packet_write_wait(struct ssh *ssh)

crypto/openssh/packet.c

2132

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2135

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

crypto/openssh/packet.c

2137

while (ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/packet.c

2165

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

crypto/openssh/packet.c

2174

ssh_packet_have_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2176

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

crypto/openssh/packet.c

2182

ssh_packet_not_very_much_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2184

if (ssh->state->interactive_mode)

crypto/openssh/packet.c

2185

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

crypto/openssh/packet.c

2187

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

crypto/openssh/packet.c

2196

ssh_packet_interactive_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2198

return ssh->state->interactive_mode &&

crypto/openssh/packet.c

2199

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

crypto/openssh/packet.c

2203

ssh_packet_set_tos(struct ssh *ssh, int tos)

crypto/openssh/packet.c

2205

if (!ssh_packet_connection_is_on_socket(ssh) || tos == INT_MAX)

crypto/openssh/packet.c

2207

set_sock_tos(ssh->state->connection_in, tos);

crypto/openssh/packet.c

2213

ssh_packet_set_interactive(struct ssh *ssh, int interactive, int qos_interactive, int qos_bulk)

crypto/openssh/packet.c

2215

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2225

if (!ssh_packet_connection_is_on_socket(ssh))

crypto/openssh/packet.c

2228

ssh_packet_set_tos(ssh, interactive ? qos_interactive : qos_bulk);

crypto/openssh/packet.c

2234

ssh_packet_is_interactive(struct ssh *ssh)

crypto/openssh/packet.c

2236

return ssh->state->interactive_mode;

crypto/openssh/packet.c

2240

ssh_packet_set_maxsize(struct ssh *ssh, u_int s)

crypto/openssh/packet.c

2242

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2260

ssh_packet_inc_alive_timeouts(struct ssh *ssh)

crypto/openssh/packet.c

2262

return ++ssh->state->keep_alive_timeouts;

crypto/openssh/packet.c

2266

ssh_packet_set_alive_timeouts(struct ssh *ssh, int ka)

crypto/openssh/packet.c

2268

ssh->state->keep_alive_timeouts = ka;

crypto/openssh/packet.c

2272

ssh_packet_get_maxsize(struct ssh *ssh)

crypto/openssh/packet.c

2274

return ssh->state->max_packet_size;

crypto/openssh/packet.c

2278

ssh_packet_set_rekey_limits(struct ssh *ssh, u_int64_t bytes, u_int32_t seconds)

crypto/openssh/packet.c

2282

ssh->state->rekey_limit = bytes;

crypto/openssh/packet.c

2283

ssh->state->rekey_interval = seconds;

crypto/openssh/packet.c

2287

ssh_packet_get_rekey_timeout(struct ssh *ssh)

crypto/openssh/packet.c

229

struct ssh *

crypto/openssh/packet.c

2291

seconds = ssh->state->rekey_time + ssh->state->rekey_interval -

crypto/openssh/packet.c

2297

ssh_packet_set_server(struct ssh *ssh)

crypto/openssh/packet.c

2299

ssh->state->server_side = 1;

crypto/openssh/packet.c

2300

ssh->kex->server = 1; /* XXX unify? */

crypto/openssh/packet.c

2304

ssh_packet_set_authenticated(struct ssh *ssh)

crypto/openssh/packet.c

2306

ssh->state->after_authentication = 1;

crypto/openssh/packet.c

2310

ssh_packet_get_input(struct ssh *ssh)

crypto/openssh/packet.c

2312

return (void *)ssh->state->input;

crypto/openssh/packet.c

2316

ssh_packet_get_output(struct ssh *ssh)

crypto/openssh/packet.c

2318

return (void *)ssh->state->output;

crypto/openssh/packet.c

232

struct ssh *ssh = NULL;

crypto/openssh/packet.c

2323

ssh_packet_set_postauth(struct ssh *ssh)

crypto/openssh/packet.c

2329

ssh->state->after_authentication = 1;

crypto/openssh/packet.c

2330

ssh->state->rekeying = 0;

crypto/openssh/packet.c

2331

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

2362

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

2372

if ((newkey = ssh->state->newkeys[mode]) == NULL)

crypto/openssh/packet.c

2377

cc = (mode == MODE_OUT) ? ssh->state->send_context :

crypto/openssh/packet.c

2378

ssh->state->receive_context;

crypto/openssh/packet.c

2406

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

crypto/openssh/packet.c

2408

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2411

if ((r = kex_to_blob(m, ssh->kex)) != 0 ||

crypto/openssh/packet.c

2412

(r = newkeys_to_blob(m, ssh, MODE_OUT)) != 0 ||

crypto/openssh/packet.c

2413

(r = newkeys_to_blob(m, ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

2433

newkeys_from_blob(struct sshbuf *m, struct ssh *ssh, int mode)

crypto/openssh/packet.c

244

TAILQ_INIT(&ssh->private_keys);

crypto/openssh/packet.c

245

TAILQ_INIT(&ssh->public_keys);

crypto/openssh/packet.c

2489

ssh->kex->newkeys[mode] = newkey;

crypto/openssh/packet.c

2540

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

crypto/openssh/packet.c

2542

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2547

if ((r = kex_from_blob(m, &ssh->kex)) != 0 ||

crypto/openssh/packet.c

2548

(r = newkeys_from_blob(m, ssh, MODE_OUT)) != 0 ||

crypto/openssh/packet.c

2549

(r = newkeys_from_blob(m, ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

2567

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

crypto/openssh/packet.c

2568

(r = ssh_set_newkeys(ssh, MODE_OUT)) != 0)

crypto/openssh/packet.c

257

ssh->state = state;

crypto/openssh/packet.c

2571

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

crypto/openssh/packet.c

258

return ssh;

crypto/openssh/packet.c

2593

sshpkt_put(struct ssh *ssh, const void *v, size_t len)

crypto/openssh/packet.c

2595

return sshbuf_put(ssh->state->outgoing_packet, v, len);

crypto/openssh/packet.c

2599

sshpkt_putb(struct ssh *ssh, const struct sshbuf *b)

crypto/openssh/packet.c

260

if (ssh) {

crypto/openssh/packet.c

2601

return sshbuf_putb(ssh->state->outgoing_packet, b);

crypto/openssh/packet.c

2605

sshpkt_put_u8(struct ssh *ssh, u_char val)

crypto/openssh/packet.c

2607

return sshbuf_put_u8(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

261

kex_free(ssh->kex);

crypto/openssh/packet.c

2611

sshpkt_put_u32(struct ssh *ssh, u_int32_t val)

crypto/openssh/packet.c

2613

return sshbuf_put_u32(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

2617

sshpkt_put_u64(struct ssh *ssh, u_int64_t val)

crypto/openssh/packet.c

2619

return sshbuf_put_u64(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

262

free(ssh);

crypto/openssh/packet.c

2623

sshpkt_put_string(struct ssh *ssh, const void *v, size_t len)

crypto/openssh/packet.c

2625

return sshbuf_put_string(ssh->state->outgoing_packet, v, len);

crypto/openssh/packet.c

2629

sshpkt_put_cstring(struct ssh *ssh, const void *v)

crypto/openssh/packet.c

2631

return sshbuf_put_cstring(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2635

sshpkt_put_stringb(struct ssh *ssh, const struct sshbuf *v)

crypto/openssh/packet.c

2637

return sshbuf_put_stringb(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2641

sshpkt_getb_froms(struct ssh *ssh, struct sshbuf **valp)

crypto/openssh/packet.c

2643

return sshbuf_froms(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2649

sshpkt_put_ec(struct ssh *ssh, const EC_POINT *v, const EC_GROUP *g)

crypto/openssh/packet.c

2651

return sshbuf_put_ec(ssh->state->outgoing_packet, v, g);

crypto/openssh/packet.c

2657

sshpkt_put_bignum2(struct ssh *ssh, const BIGNUM *v)

crypto/openssh/packet.c

2659

return sshbuf_put_bignum2(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2666

sshpkt_get(struct ssh *ssh, void *valp, size_t len)

crypto/openssh/packet.c

2668

return sshbuf_get(ssh->state->incoming_packet, valp, len);

crypto/openssh/packet.c

2672

sshpkt_get_u8(struct ssh *ssh, u_char *valp)

crypto/openssh/packet.c

2674

return sshbuf_get_u8(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2678

sshpkt_get_u32(struct ssh *ssh, u_int32_t *valp)

crypto/openssh/packet.c

2680

return sshbuf_get_u32(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2684

sshpkt_get_u64(struct ssh *ssh, u_int64_t *valp)

crypto/openssh/packet.c

2686

return sshbuf_get_u64(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2690

sshpkt_get_string(struct ssh *ssh, u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2692

return sshbuf_get_string(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2696

sshpkt_get_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2698

return sshbuf_get_string_direct(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2702

sshpkt_peek_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2704

return sshbuf_peek_string_direct(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2708

sshpkt_get_cstring(struct ssh *ssh, char **valp, size_t *lenp)

crypto/openssh/packet.c

2710

return sshbuf_get_cstring(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2716

sshpkt_get_ec(struct ssh *ssh, EC_POINT *v, const EC_GROUP *g)

crypto/openssh/packet.c

2718

return sshbuf_get_ec(ssh->state->incoming_packet, v, g);

crypto/openssh/packet.c

2723

sshpkt_get_bignum2(struct ssh *ssh, BIGNUM **valp)

crypto/openssh/packet.c

2725

return sshbuf_get_bignum2(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2730

sshpkt_get_end(struct ssh *ssh)

crypto/openssh/packet.c

2732

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

crypto/openssh/packet.c

2738

sshpkt_ptr(struct ssh *ssh, size_t *lenp)

crypto/openssh/packet.c

2741

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

crypto/openssh/packet.c

2742

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

crypto/openssh/packet.c

2748

sshpkt_start(struct ssh *ssh, u_char type)

crypto/openssh/packet.c

275

ssh_packet_set_input_hook(struct ssh *ssh, ssh_packet_hook_fn *hook, void *ctx)

crypto/openssh/packet.c

2755

sshbuf_reset(ssh->state->outgoing_packet);

crypto/openssh/packet.c

2756

return sshbuf_put(ssh->state->outgoing_packet, buf, sizeof(buf));

crypto/openssh/packet.c

2760

ssh_packet_send_mux(struct ssh *ssh)

crypto/openssh/packet.c

2762

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2767

if (ssh->kex)

crypto/openssh/packet.c

277

ssh->state->hook_in = hook;

crypto/openssh/packet.c

278

ssh->state->hook_in_ctx = ctx;

crypto/openssh/packet.c

2801

sshpkt_msg_ignore(struct ssh *ssh, u_int nbytes)

crypto/openssh/packet.c

2807

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

crypto/openssh/packet.c

2808

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

crypto/openssh/packet.c

2813

if ((r = sshpkt_put_u8(ssh, (u_char)rnd & 0xff)) != 0)

crypto/openssh/packet.c

2823

sshpkt_send(struct ssh *ssh)

crypto/openssh/packet.c

2825

if (ssh->state && ssh->state->mux)

crypto/openssh/packet.c

2826

return ssh_packet_send_mux(ssh);

crypto/openssh/packet.c

2827

return ssh_packet_send2(ssh);

crypto/openssh/packet.c

283

ssh_packet_is_rekeying(struct ssh *ssh)

crypto/openssh/packet.c

2831

sshpkt_disconnect(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

2842

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

crypto/openssh/packet.c

2843

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

crypto/openssh/packet.c

2844

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

crypto/openssh/packet.c

2845

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

crypto/openssh/packet.c

2846

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

crypto/openssh/packet.c

285

return ssh->state->rekeying ||

crypto/openssh/packet.c

2853

sshpkt_add_padding(struct ssh *ssh, u_char pad)

crypto/openssh/packet.c

2855

ssh->state->extra_pad = pad;

crypto/openssh/packet.c

286

(ssh->kex != NULL && ssh->kex->done == 0);

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_get_connection_in(struct ssh *);

crypto/openssh/packet.h

101

int ssh_packet_get_connection_out(struct ssh *);

crypto/openssh/packet.h

102

void ssh_packet_close(struct ssh *);

crypto/openssh/packet.h

103

void ssh_packet_set_input_hook(struct ssh *, ssh_packet_hook_fn *, void *);

crypto/openssh/packet.h

104

void ssh_packet_clear_keys(struct ssh *);

crypto/openssh/packet.h

105

void ssh_clear_newkeys(struct ssh *, int);

crypto/openssh/packet.h

107

int ssh_packet_is_rekeying(struct ssh *);

crypto/openssh/packet.h

108

int ssh_packet_check_rekey(struct ssh *);

crypto/openssh/packet.h

109

void ssh_packet_set_protocol_flags(struct ssh *, u_int);

crypto/openssh/packet.h

110

u_int ssh_packet_get_protocol_flags(struct ssh *);

crypto/openssh/packet.h

111

void ssh_packet_set_tos(struct ssh *, int);

crypto/openssh/packet.h

112

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

crypto/openssh/packet.h

113

int ssh_packet_is_interactive(struct ssh *);

crypto/openssh/packet.h

114

void ssh_packet_set_server(struct ssh *);

crypto/openssh/packet.h

115

void ssh_packet_set_authenticated(struct ssh *);

crypto/openssh/packet.h

116

void ssh_packet_set_mux(struct ssh *);

crypto/openssh/packet.h

117

int ssh_packet_get_mux(struct ssh *);

crypto/openssh/packet.h

118

int ssh_packet_set_log_preamble(struct ssh *, const char *, ...)

crypto/openssh/packet.h

123

int ssh_packet_send2_wrapped(struct ssh *);

crypto/openssh/packet.h

124

int ssh_packet_send2(struct ssh *);

crypto/openssh/packet.h

126

int ssh_packet_read(struct ssh *);

crypto/openssh/packet.h

127

int ssh_packet_read_poll2(struct ssh *, u_char *, u_int32_t *seqnr_p);

crypto/openssh/packet.h

128

int ssh_packet_process_incoming(struct ssh *, const char *buf, u_int len);

crypto/openssh/packet.h

129

int ssh_packet_process_read(struct ssh *, int);

crypto/openssh/packet.h

130

int ssh_packet_read_seqnr(struct ssh *, u_char *, u_int32_t *seqnr_p);

crypto/openssh/packet.h

131

int ssh_packet_read_poll_seqnr(struct ssh *, u_char *, u_int32_t *seqnr_p);

crypto/openssh/packet.h

133

void ssh_packet_disconnect(struct ssh *, const char *fmt, ...)

crypto/openssh/packet.h

136

void ssh_packet_send_debug(struct ssh *, const char *fmt, ...) __attribute__((format(printf, 2, 3)));

crypto/openssh/packet.h

138

int ssh_set_newkeys(struct ssh *, int mode);

crypto/openssh/packet.h

139

void ssh_packet_get_bytes(struct ssh *, u_int64_t *, u_int64_t *);

crypto/openssh/packet.h

141

int ssh_packet_write_poll(struct ssh *);

crypto/openssh/packet.h

142

int ssh_packet_write_wait(struct ssh *);

crypto/openssh/packet.h

143

int ssh_packet_have_data_to_write(struct ssh *);

crypto/openssh/packet.h

144

int ssh_packet_not_very_much_data_to_write(struct ssh *);

crypto/openssh/packet.h

145

int ssh_packet_interactive_data_to_write(struct ssh *);

crypto/openssh/packet.h

147

int ssh_packet_connection_is_on_socket(struct ssh *);

crypto/openssh/packet.h

148

int ssh_packet_remaining(struct ssh *);

crypto/openssh/packet.h

150

void ssh_tty_make_modes(struct ssh *, int, struct termios *);

crypto/openssh/packet.h

151

void ssh_tty_parse_modes(struct ssh *, int);

crypto/openssh/packet.h

153

void ssh_packet_set_alive_timeouts(struct ssh *, int);

crypto/openssh/packet.h

154

int ssh_packet_inc_alive_timeouts(struct ssh *);

crypto/openssh/packet.h

155

int ssh_packet_set_maxsize(struct ssh *, u_int);

crypto/openssh/packet.h

156

u_int ssh_packet_get_maxsize(struct ssh *);

crypto/openssh/packet.h

158

int ssh_packet_get_state(struct ssh *, struct sshbuf *);

crypto/openssh/packet.h

159

int ssh_packet_set_state(struct ssh *, struct sshbuf *);

crypto/openssh/packet.h

161

const char *ssh_remote_ipaddr(struct ssh *);

crypto/openssh/packet.h

162

int ssh_remote_port(struct ssh *);

crypto/openssh/packet.h

163

const char *ssh_local_ipaddr(struct ssh *);

crypto/openssh/packet.h

164

int ssh_local_port(struct ssh *);

crypto/openssh/packet.h

165

const char *ssh_packet_rdomain_in(struct ssh *);

crypto/openssh/packet.h

166

char *ssh_remote_hostname(struct ssh *);

crypto/openssh/packet.h

168

void ssh_packet_set_rekey_limits(struct ssh *, u_int64_t, u_int32_t);

crypto/openssh/packet.h

169

time_t ssh_packet_get_rekey_timeout(struct ssh *);

crypto/openssh/packet.h

171

void *ssh_packet_get_input(struct ssh *);

crypto/openssh/packet.h

172

void *ssh_packet_get_output(struct ssh *);

crypto/openssh/packet.h

175

int sshpkt_start(struct ssh *ssh, u_char type);

crypto/openssh/packet.h

176

int sshpkt_send(struct ssh *ssh);

crypto/openssh/packet.h

177

int sshpkt_disconnect(struct ssh *, const char *fmt, ...)

crypto/openssh/packet.h

179

int sshpkt_add_padding(struct ssh *, u_char);

crypto/openssh/packet.h

180

void sshpkt_fatal(struct ssh *ssh, int r, const char *fmt, ...)

crypto/openssh/packet.h

183

int sshpkt_msg_ignore(struct ssh *, u_int);

crypto/openssh/packet.h

185

int sshpkt_put(struct ssh *ssh, const void *v, size_t len);

crypto/openssh/packet.h

186

int sshpkt_putb(struct ssh *ssh, const struct sshbuf *b);

crypto/openssh/packet.h

187

int sshpkt_put_u8(struct ssh *ssh, u_char val);

crypto/openssh/packet.h

188

int sshpkt_put_u32(struct ssh *ssh, u_int32_t val);

crypto/openssh/packet.h

189

int sshpkt_put_u64(struct ssh *ssh, u_int64_t val);

crypto/openssh/packet.h

190

int sshpkt_put_string(struct ssh *ssh, const void *v, size_t len);

crypto/openssh/packet.h

191

int sshpkt_put_cstring(struct ssh *ssh, const void *v);

crypto/openssh/packet.h

192

int sshpkt_put_stringb(struct ssh *ssh, const struct sshbuf *v);

crypto/openssh/packet.h

193

int sshpkt_put_ec(struct ssh *ssh, const EC_POINT *v, const EC_GROUP *g);

crypto/openssh/packet.h

194

int sshpkt_put_bignum2(struct ssh *ssh, const BIGNUM *v);

crypto/openssh/packet.h

196

int sshpkt_get(struct ssh *ssh, void *valp, size_t len);

crypto/openssh/packet.h

197

int sshpkt_get_u8(struct ssh *ssh, u_char *valp);

crypto/openssh/packet.h

198

int sshpkt_get_u32(struct ssh *ssh, u_int32_t *valp);

crypto/openssh/packet.h

199

int sshpkt_get_u64(struct ssh *ssh, u_int64_t *valp);

crypto/openssh/packet.h

200

int sshpkt_get_string(struct ssh *ssh, u_char **valp, size_t *lenp);

crypto/openssh/packet.h

201

int sshpkt_get_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp);

crypto/openssh/packet.h

202

int sshpkt_peek_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp);

crypto/openssh/packet.h

203

int sshpkt_get_cstring(struct ssh *ssh, char **valp, size_t *lenp);

crypto/openssh/packet.h

204

int sshpkt_getb_froms(struct ssh *ssh, struct sshbuf **valp);

crypto/openssh/packet.h

205

int sshpkt_get_ec(struct ssh *ssh, EC_POINT *v, const EC_GROUP *g);

crypto/openssh/packet.h

206

int sshpkt_get_bignum2(struct ssh *ssh, BIGNUM **valp);

crypto/openssh/packet.h

207

int sshpkt_get_end(struct ssh *ssh);

crypto/openssh/packet.h

208

void sshpkt_fmt_connection_id(struct ssh *ssh, char *s, size_t l);

crypto/openssh/packet.h

209

const u_char *sshpkt_ptr(struct ssh *, size_t *lenp);

crypto/openssh/packet.h

91

typedef int (ssh_packet_hook_fn)(struct ssh *, struct sshbuf *,

crypto/openssh/packet.h

94

struct ssh *ssh_alloc_session_state(void);

crypto/openssh/packet.h

95

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

crypto/openssh/packet.h

96

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

crypto/openssh/packet.h

97

int ssh_packet_stop_discard(struct ssh *);

crypto/openssh/packet.h

98

int ssh_packet_connection_af(struct ssh *);

crypto/openssh/packet.h

99

void ssh_packet_set_nonblocking(struct 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

707

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

crypto/openssh/serverloop.c

709

(r = ssh->kex->sign(ssh, key_prv, key_pub, &sig, &slen,

crypto/openssh/serverloop.c

729

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

crypto/openssh/serverloop.c

743

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

crypto/openssh/serverloop.c

744

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

crypto/openssh/serverloop.c

745

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

750

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_host, NULL)) != 0 ||

crypto/openssh/serverloop.c

751

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

crypto/openssh/serverloop.c

752

sshpkt_fatal(ssh, r, "%s: parse tcpip-forward", __func__);

crypto/openssh/serverloop.c

764

ssh_packet_send_debug(ssh, "Server has disabled port forwarding.");

crypto/openssh/serverloop.c

767

success = channel_setup_remote_fwd_listener(ssh, &fwd,

crypto/openssh/serverloop.c

776

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_host, NULL)) != 0 ||

crypto/openssh/serverloop.c

777

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

crypto/openssh/serverloop.c

778

sshpkt_fatal(ssh, r, "%s: parse cancel-tcpip-forward", __func__);

crypto/openssh/serverloop.c

784

success = channel_cancel_rport_listener(ssh, &fwd);

crypto/openssh/serverloop.c

787

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

crypto/openssh/serverloop.c

788

sshpkt_fatal(ssh, r, "%s: parse streamlocal-forward@openssh.com", __func__);

crypto/openssh/serverloop.c

797

ssh_packet_send_debug(ssh, "Server has disabled "

crypto/openssh/serverloop.c

801

success = channel_setup_remote_fwd_listener(ssh,

crypto/openssh/serverloop.c

805

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

crypto/openssh/serverloop.c

806

sshpkt_fatal(ssh, r, "%s: parse cancel-streamlocal-forward@openssh.com", __func__);

crypto/openssh/serverloop.c

810

success = channel_cancel_rport_listener(ssh, &fwd);

crypto/openssh/serverloop.c

815

success = server_input_hostkeys_prove(ssh, &resp);

crypto/openssh/serverloop.c

819

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/serverloop.c

821

(success && resp != NULL && (r = sshpkt_putb(ssh, resp)) != 0) ||

crypto/openssh/serverloop.c

822

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

crypto/openssh/serverloop.c

823

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

crypto/openssh/serverloop.c

824

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

crypto/openssh/serverloop.c

834

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

crypto/openssh/serverloop.c

842

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

crypto/openssh/serverloop.c

843

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

crypto/openssh/serverloop.c

844

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

crypto/openssh/serverloop.c

845

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

850

if (id >= INT_MAX || (c = channel_lookup(ssh, (int)id)) == NULL) {

crypto/openssh/serverloop.c

851

ssh_packet_disconnect(ssh, "%s: unknown channel %d",

crypto/openssh/serverloop.c

855

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

crypto/openssh/serverloop.c

856

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

857

chan_rcvd_eow(ssh, c);

crypto/openssh/serverloop.c

860

success = session_input_channel_req(ssh, c, rtype);

crypto/openssh/serverloop.c

864

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/serverloop.c

866

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

crypto/openssh/serverloop.c

867

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

crypto/openssh/serverloop.c

868

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

crypto/openssh/serverloop.c

875

server_init_dispatch(struct ssh *ssh)

crypto/openssh/serverloop.c

878

ssh_dispatch_init(ssh, &dispatch_protocol_error);

crypto/openssh/serverloop.c

879

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);

crypto/openssh/serverloop.c

880

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_DATA, &channel_input_data);

crypto/openssh/serverloop.c

881

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);

crypto/openssh/serverloop.c

882

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);

crypto/openssh/serverloop.c

883

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN, &server_input_channel_open);

crypto/openssh/serverloop.c

884

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);

crypto/openssh/serverloop.c

885

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);

crypto/openssh/serverloop.c

886

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_REQUEST, &server_input_channel_req);

crypto/openssh/serverloop.c

887

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);

crypto/openssh/serverloop.c

888

ssh_dispatch_set(ssh, SSH2_MSG_GLOBAL_REQUEST, &server_input_global_request);

crypto/openssh/serverloop.c

890

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_SUCCESS, &server_input_keep_alive);

crypto/openssh/serverloop.c

891

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_FAILURE, &server_input_keep_alive);

crypto/openssh/serverloop.c

892

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_SUCCESS, &server_input_keep_alive);

crypto/openssh/serverloop.c

893

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_FAILURE, &server_input_keep_alive);

crypto/openssh/serverloop.c

895

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

1155

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/session.c

1156

ssh_local_port(ssh));

crypto/openssh/session.c

1159

laddr = get_local_ipaddr(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1161

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/session.c

1162

laddr, ssh_local_port(ssh));

crypto/openssh/session.c

1190

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

1456

child_close_fds(struct ssh *ssh)

crypto/openssh/session.c

1465

if (ssh_packet_get_connection_in(ssh) ==

crypto/openssh/session.c

1466

ssh_packet_get_connection_out(ssh))

crypto/openssh/session.c

1467

close(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1469

close(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1470

close(ssh_packet_get_connection_out(ssh));

crypto/openssh/session.c

1477

channel_close_all(ssh);

crypto/openssh/session.c

1504

do_child(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

1512

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/session.c

1516

ssh_packet_clear_keys(ssh);

crypto/openssh/session.c

1521

child_close_fds(ssh);

crypto/openssh/session.c

1566

env = do_setup_env(ssh, s, shell);

crypto/openssh/session.c

1579

child_close_fds(ssh);

crypto/openssh/session.c

1630

do_rc_files(ssh, s, shell);

crypto/openssh/session.c

1875

session_window_change_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1879

if ((r = sshpkt_get_u32(ssh, &s->col)) != 0 ||

crypto/openssh/session.c

1880

(r = sshpkt_get_u32(ssh, &s->row)) != 0 ||

crypto/openssh/session.c

1881

(r = sshpkt_get_u32(ssh, &s->xpixel)) != 0 ||

crypto/openssh/session.c

1882

(r = sshpkt_get_u32(ssh, &s->ypixel)) != 0 ||

crypto/openssh/session.c

1883

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

crypto/openssh/session.c

1884

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1890

session_pty_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1899

ssh_packet_disconnect(ssh, "Protocol error: you already have a pty.");

crypto/openssh/session.c

1903

if ((r = sshpkt_get_cstring(ssh, &s->term, NULL)) != 0 ||

crypto/openssh/session.c

1904

(r = sshpkt_get_u32(ssh, &s->col)) != 0 ||

crypto/openssh/session.c

1905

(r = sshpkt_get_u32(ssh, &s->row)) != 0 ||

crypto/openssh/session.c

1906

(r = sshpkt_get_u32(ssh, &s->xpixel)) != 0 ||

crypto/openssh/session.c

1907

(r = sshpkt_get_u32(ssh, &s->ypixel)) != 0)

crypto/openssh/session.c

1908

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1927

ssh_tty_parse_modes(ssh, s->ttyfd);

crypto/openssh/session.c

1929

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

crypto/openssh/session.c

1930

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1940

session_subsystem_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1947

if ((r = sshpkt_get_cstring(ssh, &s->subsys, NULL)) != 0 ||

crypto/openssh/session.c

1948

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

crypto/openssh/session.c

1949

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

1969

channel_set_xtype(ssh, s->chanid, type);

crypto/openssh/session.c

1971

success = do_exec(ssh, s, cmd) == 0;

crypto/openssh/session.c

1984

session_x11_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1994

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

crypto/openssh/session.c

1995

(r = sshpkt_get_cstring(ssh, &s->auth_proto, NULL)) != 0 ||

crypto/openssh/session.c

1996

(r = sshpkt_get_cstring(ssh, &s->auth_data, NULL)) != 0 ||

crypto/openssh/session.c

1997

(r = sshpkt_get_u32(ssh, &s->screen)) != 0 ||

crypto/openssh/session.c

1998

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

crypto/openssh/session.c

1999

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2005

success = session_setup_x11fwd(ssh, s);

crypto/openssh/session.c

2020

session_shell_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2024

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

crypto/openssh/session.c

2025

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2027

channel_set_xtype(ssh, s->chanid, "session:shell");

crypto/openssh/session.c

2029

return do_exec(ssh, s, NULL) == 0;

crypto/openssh/session.c

2033

session_exec_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2039

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

crypto/openssh/session.c

2040

(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:command");

crypto/openssh/session.c

2045

success = do_exec(ssh, s, command) == 0;

crypto/openssh/session.c

2051

session_break_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2055

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

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

2065

session_env_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2071

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

crypto/openssh/session.c

2072

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

crypto/openssh/session.c

2073

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

crypto/openssh/session.c

2074

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2126

session_signal_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

213

ssh_packet_send_debug(ssh, "Agent forwarding disabled: "

crypto/openssh/session.c

2131

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

crypto/openssh/session.c

2132

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

crypto/openssh/session.c

2172

session_auth_agent_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2177

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

crypto/openssh/session.c

2178

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2188

return auth_input_request_forwarding(ssh, s->pw);

crypto/openssh/session.c

2193

session_input_channel_req(struct ssh *ssh, Channel *c, const char *rtype)

crypto/openssh/session.c

2210

success = session_shell_req(ssh, s);

crypto/openssh/session.c

2212

success = session_exec_req(ssh, s);

crypto/openssh/session.c

2214

success = session_pty_req(ssh, s);

crypto/openssh/session.c

2216

success = session_x11_req(ssh, s);

crypto/openssh/session.c

2218

success = session_auth_agent_req(ssh, s);

crypto/openssh/session.c

2220

success = session_subsystem_req(ssh, s);

crypto/openssh/session.c

2222

success = session_env_req(ssh, s);

crypto/openssh/session.c

2226

success = session_window_change_req(ssh, s);

crypto/openssh/session.c

2228

success = session_break_req(ssh, s);

crypto/openssh/session.c

2230

success = session_signal_req(ssh, s);

crypto/openssh/session.c

2237

session_set_fds(struct ssh *ssh, Session *s,

crypto/openssh/session.c

2246

channel_set_fds(ssh, s->chanid,

crypto/openssh/session.c

2317

session_close_x11(struct ssh *ssh, int id)

crypto/openssh/session.c

2321

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

crypto/openssh/session.c

2326

channel_cancel_cleanup(ssh, id);

crypto/openssh/session.c

2328

chan_mark_dead(ssh, c);

crypto/openssh/session.c

2333

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

crypto/openssh/session.c

2339

channel_cancel_cleanup(ssh, id);

crypto/openssh/session.c

235

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

crypto/openssh/session.c

2350

session_close_x11(ssh, s->x11_chanids[i]);

crypto/openssh/session.c

2365

session_exit_message(struct ssh *ssh, Session *s, int status)

crypto/openssh/session.c

2371

if ((c = channel_lookup(ssh, s->chanid)) == NULL)

crypto/openssh/session.c

2375

channel_request_start(ssh, s->chanid, "exit-status", 0);

crypto/openssh/session.c

2376

if ((r = sshpkt_put_u32(ssh, WEXITSTATUS(status))) != 0 ||

crypto/openssh/session.c

2377

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

crypto/openssh/session.c

2378

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

crypto/openssh/session.c

2381

channel_request_start(ssh, s->chanid, "exit-signal", 0);

crypto/openssh/session.c

2385

if ((r = sshpkt_put_cstring(ssh, sig2name(WTERMSIG(status)))) != 0 ||

crypto/openssh/session.c

2386

(r = sshpkt_put_u8(ssh, WCOREDUMP(status)? 1 : 0)) != 0 ||

crypto/openssh/session.c

2387

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

crypto/openssh/session.c

2388

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

crypto/openssh/session.c

2389

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

crypto/openssh/session.c

2390

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

crypto/openssh/session.c

2395

ssh_packet_disconnect(ssh, "wait returned status %04x.",

crypto/openssh/session.c

2411

channel_register_cleanup(ssh, c->self, session_close_by_channel, 1);

crypto/openssh/session.c

2420

chan_write_failed(ssh, c);

crypto/openssh/session.c

2424

session_close(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2430

ssh_remote_ipaddr(ssh),

crypto/openssh/session.c

2431

ssh_remote_port(ssh),

crypto/openssh/session.c

2455

session_close_by_pid(struct ssh *ssh, pid_t pid, int status)

crypto/openssh/session.c

2463

session_exit_message(ssh, s, status);

crypto/openssh/session.c

2474

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

crypto/openssh/session.c

2497

channel_cancel_cleanup(ssh, s->chanid);

crypto/openssh/session.c

2502

session_close_x11(ssh, s->x11_chanids[i]);

crypto/openssh/session.c

2508

session_close(ssh, s);

crypto/openssh/session.c

2512

session_destroy_all(struct ssh *ssh, void (*closefunc)(Session *))

crypto/openssh/session.c

2521

session_close(ssh, s);

crypto/openssh/session.c

2564

session_setup_x11fwd(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2572

ssh_packet_send_debug(ssh, "X11 forwarding disabled by key options.");

crypto/openssh/session.c

2581

ssh_packet_send_debug(ssh, "No xauth program; cannot forward X11.");

crypto/openssh/session.c

2588

if (x11_create_display_inet(ssh, options.x11_display_offset,

crypto/openssh/session.c

2595

channel_register_cleanup(ssh, s->x11_chanids[i],

crypto/openssh/session.c

2622

ssh_packet_send_debug(ssh, "Can't get IP address for X11 DISPLAY.");

crypto/openssh/session.c

2640

do_authenticated2(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

2642

server_loop2(ssh, authctxt);

crypto/openssh/session.c

2646

do_cleanup(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

2702

session_destroy_all(ssh, session_pty_cleanup2);

crypto/openssh/session.c

2708

session_get_remote_name_or_ip(struct ssh *ssh, u_int utmp_size, int use_dns)

crypto/openssh/session.c

2713

remote = auth_get_canonical_hostname(ssh, use_dns);

crypto/openssh/session.c

2715

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

1351

channel_set_af(ssh, options.address_family);

crypto/openssh/ssh.c

1597

ssh_packet_set_connection(ssh, sock, sock);

crypto/openssh/ssh.c

1598

ssh_packet_set_mux(ssh);

crypto/openssh/ssh.c

1620

channel_clear_timeouts(ssh);

crypto/openssh/ssh.c

1629

channel_add_timeout(ssh, cp, i);

crypto/openssh/ssh.c

1634

if (ssh_connect(ssh, host, options.host_arg, addrs, &hostaddr,

crypto/openssh/ssh.c

1642

ssh_packet_set_timeout(ssh, options.server_alive_interval,

crypto/openssh/ssh.c

1758

ssh_login(ssh, &sensitive_data, host, (struct sockaddr *)&hostaddr,

crypto/openssh/ssh.c

1791

exit_status = ssh_session2(ssh, cinfo);

crypto/openssh/ssh.c

1793

ssh_packet_close(ssh);

crypto/openssh/ssh.c

1876

ssh_confirm_remote_forward(struct ssh *ssh, int type, u_int32_t seq, void *ctxt)

crypto/openssh/ssh.c

1892

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

crypto/openssh/ssh.c

1900

channel_update_permission(ssh,

crypto/openssh/ssh.c

1909

channel_update_permission(ssh,

crypto/openssh/ssh.c

1913

channel_update_permission(ssh, rfwd->handle, -1);

crypto/openssh/ssh.c

1938

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

crypto/openssh/ssh.c

1945

ssh_stdio_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

195

static int ssh_session2(struct ssh *, const struct ssh_conn_info *);

crypto/openssh/ssh.c

1952

ssh_tun_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

1965

ssh_init_stdio_forwarding(struct ssh *ssh)

crypto/openssh/ssh.c

1979

if ((c = channel_connect_stdio_fwd(ssh, options.stdio_forward_host,

crypto/openssh/ssh.c

1983

channel_register_cleanup(ssh, c->self, client_cleanup_stdio_fwd, 0);

crypto/openssh/ssh.c

1984

channel_register_open_confirm(ssh, c->self, ssh_stdio_confirm, NULL);

crypto/openssh/ssh.c

1988

ssh_init_forward_permissions(struct ssh *ssh, const char *what, char **opens,

crypto/openssh/ssh.c

1996

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/ssh.c

2004

channel_disable_admin(ssh, where);

crypto/openssh/ssh.c

2017

channel_add_permission(ssh, FORWARD_ADM,

crypto/openssh/ssh.c

2024

ssh_init_forwarding(struct ssh *ssh, char **ifname)

crypto/openssh/ssh.c

2029

ssh_init_forward_permissions(ssh, "permitremoteopen",

crypto/openssh/ssh.c

2049

success += channel_setup_local_fwd_listener(ssh,

crypto/openssh/ssh.c

2071

channel_request_remote_forwarding(ssh,

crypto/openssh/ssh.c

2085

if ((*ifname = client_request_tun_fwd(ssh,

crypto/openssh/ssh.c

2116

ssh_session2_setup(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

2129

if (options.forward_x11 && client_x11_get_proto(ssh, display,

crypto/openssh/ssh.c

2135

x11_request_forwarding_with_spoofing(ssh, id, display, proto,

crypto/openssh/ssh.c

2137

client_expect_confirm(ssh, id, "X11 forwarding", CONFIRM_WARN);

crypto/openssh/ssh.c

2145

channel_request_start(ssh, id, "auth-agent-req@openssh.com", 0);

crypto/openssh/ssh.c

2146

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

crypto/openssh/ssh.c

2151

ssh_packet_set_interactive(ssh, interactive,

crypto/openssh/ssh.c

2157

client_session2_setup(ssh, id, tty_flag,

crypto/openssh/ssh.c

2164

ssh_session2_open(struct ssh *ssh)

crypto/openssh/ssh.c

2186

c = channel_new(ssh,

crypto/openssh/ssh.c

2193

channel_send_open(ssh, c->self);

crypto/openssh/ssh.c

2195

channel_register_open_confirm(ssh, c->self,

crypto/openssh/ssh.c

2202

ssh_session2(struct ssh *ssh, const struct ssh_conn_info *cinfo)

crypto/openssh/ssh.c

2209

ssh_init_stdio_forwarding(ssh);

crypto/openssh/ssh.c

2211

ssh_init_forwarding(ssh, &tun_fwd_ifname);

crypto/openssh/ssh.c

2225

if (!ssh_packet_get_mux(ssh))

crypto/openssh/ssh.c

2226

muxserver_listen(ssh);

crypto/openssh/ssh.c

2256

ssh_init_stdio_forwarding(ssh);

crypto/openssh/ssh.c

2259

id = ssh_session2_open(ssh);

crypto/openssh/ssh.c

2265

ssh_packet_set_interactive(ssh, interactive,

crypto/openssh/ssh.c

2271

(ssh->compat & SSH_NEW_OPENSSH)) {

crypto/openssh/ssh.c

2273

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

crypto/openssh/ssh.c

2274

(r = sshpkt_put_cstring(ssh,

crypto/openssh/ssh.c

2276

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

crypto/openssh/ssh.c

2277

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

crypto/openssh/ssh.c

2308

return client_loop(ssh, tty_flag, tty_flag ?

crypto/openssh/ssh.c

670

struct ssh *ssh = NULL;

crypto/openssh/ssh.c

737

if ((ssh = ssh_alloc_session_state()) == NULL)

crypto/openssh/ssh.c

739

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->load_host_public_key=&_ssh_host_public_key;

crypto/openssh/ssh_api.c

138

ssh->kex->load_host_private_key=&_ssh_host_private_key;

crypto/openssh/ssh_api.c

139

ssh->kex->sign=&_ssh_host_key_sign;

crypto/openssh/ssh_api.c

142

ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_client;

crypto/openssh/ssh_api.c

143

ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_client;

crypto/openssh/ssh_api.c

144

ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

145

ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

146

ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

147

ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;

crypto/openssh/ssh_api.c

148

ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;

crypto/openssh/ssh_api.c

150

ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_client;

crypto/openssh/ssh_api.c

153

ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

154

ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

155

ssh->kex->verify_host_key =&_ssh_verify_host_key;

crypto/openssh/ssh_api.c

157

*sshp = ssh;

crypto/openssh/ssh_api.c

162

ssh_free(struct ssh *ssh)

crypto/openssh/ssh_api.c

166

if (ssh == NULL)

crypto/openssh/ssh_api.c

173

while ((k = TAILQ_FIRST(&ssh->public_keys)) != NULL) {

crypto/openssh/ssh_api.c

174

TAILQ_REMOVE(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

175

if (ssh->kex && ssh->kex->server)

crypto/openssh/ssh_api.c

179

while ((k = TAILQ_FIRST(&ssh->private_keys)) != NULL) {

crypto/openssh/ssh_api.c

180

TAILQ_REMOVE(&ssh->private_keys, k, next);

crypto/openssh/ssh_api.c

183

ssh_packet_close(ssh);

crypto/openssh/ssh_api.c

184

free(ssh);

crypto/openssh/ssh_api.c

188

ssh_set_app_data(struct ssh *ssh, void *app_data)

crypto/openssh/ssh_api.c

190

ssh->app_data = app_data;

crypto/openssh/ssh_api.c

194

ssh_get_app_data(struct ssh *ssh)

crypto/openssh/ssh_api.c

196

return ssh->app_data;

crypto/openssh/ssh_api.c

201

ssh_add_hostkey(struct ssh *ssh, struct sshkey *key)

crypto/openssh/ssh_api.c

207

if (ssh->kex->server) {

crypto/openssh/ssh_api.c

217

TAILQ_INSERT_TAIL(&ssh->private_keys, k_prv, next);

crypto/openssh/ssh_api.c

221

TAILQ_INSERT_TAIL(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

227

TAILQ_INSERT_TAIL(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

235

ssh_set_verify_host_key_callback(struct ssh *ssh,

crypto/openssh/ssh_api.c

236

int (*cb)(struct sshkey *, struct ssh *))

crypto/openssh/ssh_api.c

238

if (cb == NULL || ssh->kex == NULL)

crypto/openssh/ssh_api.c

241

ssh->kex->verify_host_key = cb;

crypto/openssh/ssh_api.c

247

ssh_input_append(struct ssh *ssh, const u_char *data, size_t len)

crypto/openssh/ssh_api.c

249

return sshbuf_put(ssh_packet_get_input(ssh), data, len);

crypto/openssh/ssh_api.c

253

ssh_packet_next(struct ssh *ssh, u_char *typep)

crypto/openssh/ssh_api.c

264

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

crypto/openssh/ssh_api.c

265

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

crypto/openssh/ssh_api.c

266

return _ssh_exchange_banner(ssh);

crypto/openssh/ssh_api.c

279

if ((r = ssh_packet_read_poll2(ssh, &type, &seqnr)) != 0)

crypto/openssh/ssh_api.c

283

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

crypto/openssh/ssh_api.c

284

if ((r = (*ssh->dispatch[type])(type, seqnr, ssh)) != 0)

crypto/openssh/ssh_api.c

294

ssh_packet_payload(struct ssh *ssh, size_t *lenp)

crypto/openssh/ssh_api.c

296

return sshpkt_ptr(ssh, lenp);

crypto/openssh/ssh_api.c

300

ssh_packet_put(struct ssh *ssh, int type, const u_char *data, size_t len)

crypto/openssh/ssh_api.c

304

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

crypto/openssh/ssh_api.c

305

(r = sshpkt_put(ssh, data, len)) != 0 ||

crypto/openssh/ssh_api.c

306

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

crypto/openssh/ssh_api.c

312

ssh_output_ptr(struct ssh *ssh, size_t *len)

crypto/openssh/ssh_api.c

314

struct sshbuf *output = ssh_packet_get_output(ssh);

crypto/openssh/ssh_api.c

321

ssh_output_consume(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

323

return sshbuf_consume(ssh_packet_get_output(ssh), len);

crypto/openssh/ssh_api.c

327

ssh_output_space(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

329

return (0 == sshbuf_check_reserve(ssh_packet_get_output(ssh), len));

crypto/openssh/ssh_api.c

333

ssh_input_space(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

335

return (0 == sshbuf_check_reserve(ssh_packet_get_input(ssh), len));

crypto/openssh/ssh_api.c

340

_ssh_read_banner(struct ssh *ssh, struct sshbuf *banner)

crypto/openssh/ssh_api.c

342

struct sshbuf *input = ssh_packet_get_input(ssh);

crypto/openssh/ssh_api.c

376

if (ssh->kex->server || ++n > SSH_MAX_PRE_BANNER_LINES) {

crypto/openssh/ssh_api.c

378

if ((r = sshbuf_put(ssh_packet_get_output(ssh),

crypto/openssh/ssh_api.c

406

compat_banner(ssh, remote_version);

crypto/openssh/ssh_api.c

42

int _ssh_exchange_banner(struct ssh *);

crypto/openssh/ssh_api.c

423

_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

430

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

443

_ssh_exchange_banner(struct ssh *ssh)

crypto/openssh/ssh_api.c

445

struct kex *kex = ssh->kex;

crypto/openssh/ssh_api.c

45

int _ssh_order_hostkeyalgs(struct ssh *);

crypto/openssh/ssh_api.c

455

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

crypto/openssh/ssh_api.c

456

r = _ssh_send_banner(ssh, ssh->kex->server_version);

crypto/openssh/ssh_api.c

458

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

crypto/openssh/ssh_api.c

459

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

crypto/openssh/ssh_api.c

46

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

crypto/openssh/ssh_api.c

460

r = _ssh_read_banner(ssh, ssh->kex->client_version);

crypto/openssh/ssh_api.c

462

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

crypto/openssh/ssh_api.c

463

r = _ssh_read_banner(ssh, ssh->kex->server_version);

crypto/openssh/ssh_api.c

465

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

crypto/openssh/ssh_api.c

466

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

crypto/openssh/ssh_api.c

467

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

472

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

crypto/openssh/ssh_api.c

473

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

crypto/openssh/ssh_api.c

474

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

crypto/openssh/ssh_api.c

475

(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

482

_ssh_host_public_key(int type, int nid, struct ssh *ssh)

crypto/openssh/ssh_api.c

487

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

497

_ssh_host_private_key(int type, int nid, struct ssh *ssh)

crypto/openssh/ssh_api.c

502

TAILQ_FOREACH(k, &ssh->private_keys, next) {

crypto/openssh/ssh_api.c

512

_ssh_verify_host_key(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/ssh_api.c

517

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

527

_ssh_order_hostkeyalgs(struct ssh *ssh)

crypto/openssh/ssh_api.c

536

if ((r = kex_buf2prop(ssh->kex->my, NULL, &proposal)) != 0)

crypto/openssh/ssh_api.c

552

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

564

debug2_f("orig/%d %s", ssh->kex->server, orig);

crypto/openssh/ssh_api.c

565

debug2_f("replace/%d %s", ssh->kex->server, replace);

crypto/openssh/ssh_api.c

569

r = kex_prop2buf(ssh->kex->my, proposal);

crypto/openssh/ssh_api.c

579

_ssh_host_key_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/ssh_api.c

584

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

1591

ssh_login(struct ssh *ssh, Sensitive *sensitive, const char *orighost,

crypto/openssh/sshconnect.c

1607

if ((r = kex_exchange_identification(ssh, timeout_ms, NULL)) != 0)

crypto/openssh/sshconnect.c

1608

sshpkt_fatal(ssh, r, "banner exchange");

crypto/openssh/sshconnect.c

1611

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshconnect.c

1616

ssh_kex2(ssh, host, hostaddr, port, cinfo);

crypto/openssh/sshconnect.c

1617

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

539

if (ssh_packet_set_connection(ssh, sock, sock) == NULL)

crypto/openssh/sshconnect.c

546

ssh_connect(struct ssh *ssh, const char *host, const char *host_arg,

crypto/openssh/sshconnect.c

553

return ssh_connect_direct(ssh, host, addrs, hostaddr, port,

crypto/openssh/sshconnect.c

563

if ((ssh_packet_set_connection(ssh, in, out)) == NULL)

crypto/openssh/sshconnect.c

567

return ssh_proxy_fdpass_connect(ssh, host, host_arg, port,

crypto/openssh/sshconnect.c

570

return ssh_proxy_connect(ssh, host, host_arg, port,

crypto/openssh/sshconnect.h

51

struct ssh;

crypto/openssh/sshconnect.h

70

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

crypto/openssh/sshconnect.h

75

void ssh_login(struct ssh *, Sensitive *, const char *,

crypto/openssh/sshconnect.h

85

void ssh_kex2(struct ssh *ssh, char *, struct sockaddr *, u_short,

crypto/openssh/sshconnect.h

88

void ssh_userauth2(struct ssh *ssh, const char *, const char *,

crypto/openssh/sshconnect2.c

1000

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

crypto/openssh/sshconnect2.c

1001

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

crypto/openssh/sshconnect2.c

1002

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

crypto/openssh/sshconnect2.c

1003

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

crypto/openssh/sshconnect2.c

1005

r = sshpkt_get_end(ssh);

crypto/openssh/sshconnect2.c

1015

userauth_none(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1017

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

crypto/openssh/sshconnect2.c

1021

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

crypto/openssh/sshconnect2.c

1022

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1023

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1024

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1025

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

crypto/openssh/sshconnect2.c

1031

userauth_passwd(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1033

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

crypto/openssh/sshconnect2.c

1047

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

crypto/openssh/sshconnect2.c

1048

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1049

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1050

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1051

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

crypto/openssh/sshconnect2.c

1052

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

crypto/openssh/sshconnect2.c

1053

(r = sshpkt_add_padding(ssh, 64)) != 0 ||

crypto/openssh/sshconnect2.c

1054

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

crypto/openssh/sshconnect2.c

1061

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

crypto/openssh/sshconnect2.c

1071

input_userauth_passwd_changereq(int type, u_int32_t seqnr, struct ssh *ssh)

crypto/openssh/sshconnect2.c

1073

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

1086

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

crypto/openssh/sshconnect2.c

1087

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

crypto/openssh/sshconnect2.c

1091

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

crypto/openssh/sshconnect2.c

1092

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1093

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1094

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1095

(r = sshpkt_put_u8(ssh, 1)) != 0) /* additional info */

crypto/openssh/sshconnect2.c

1102

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

crypto/openssh/sshconnect2.c

1128

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

crypto/openssh/sshconnect2.c

1129

(r = sshpkt_add_padding(ssh, 64)) != 0 ||

crypto/openssh/sshconnect2.c

1130

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

crypto/openssh/sshconnect2.c

1133

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

crypto/openssh/sshconnect2.c

1152

key_sig_algorithm(struct ssh *ssh, const struct sshkey *key)

crypto/openssh/sshconnect2.c

1162

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

crypto/openssh/sshconnect2.c

1164

(key->type == KEY_RSA_CERT && (ssh->compat & SSH_BUG_SIGTYPE))) {

crypto/openssh/sshconnect2.c

1174

server_sig_algs = ssh->kex->server_sig_algs;

crypto/openssh/sshconnect2.c

1175

if (key->type == KEY_RSA && (ssh->compat & SSH_BUG_SIGTYPE74))

crypto/openssh/sshconnect2.c

1307

sign_and_send_pubkey(struct ssh *ssh, Identity *id)

crypto/openssh/sshconnect2.c

1309

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

crypto/openssh/sshconnect2.c

1320

if ((ssh->kex->flags & KEX_HAS_PUBKEY_HOSTBOUND) != 0 &&

crypto/openssh/sshconnect2.c

1388

if ((alg = key_sig_algorithm(fallback_sigtype ? NULL : ssh,

crypto/openssh/sshconnect2.c

1398

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/sshconnect2.c

1399

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

crypto/openssh/sshconnect2.c

1403

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

crypto/openssh/sshconnect2.c

1417

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

crypto/openssh/sshconnect2.c

1421

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

crypto/openssh/sshconnect2.c

1426

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

crypto/openssh/sshconnect2.c

1461

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

crypto/openssh/sshconnect2.c

1462

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

crypto/openssh/sshconnect2.c

1463

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

crypto/openssh/sshconnect2.c

1478

send_pubkey_test(struct ssh *ssh, Identity *id)

crypto/openssh/sshconnect2.c

1480

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

crypto/openssh/sshconnect2.c

1487

if ((alg = key_sig_algorithm(ssh, id->key)) == NULL) {

crypto/openssh/sshconnect2.c

1498

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);

crypto/openssh/sshconnect2.c

1500

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

crypto/openssh/sshconnect2.c

1501

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1502

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1503

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1504

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

crypto/openssh/sshconnect2.c

1505

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

crypto/openssh/sshconnect2.c

1506

(r = sshpkt_put_string(ssh, blob, bloblen)) != 0 ||

crypto/openssh/sshconnect2.c

1507

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

crypto/openssh/sshconnect2.c

1627

get_agent_identities(struct ssh *ssh, int *agent_fdp,

crypto/openssh/sshconnect2.c

1638

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

crypto/openssh/sshconnect2.c

1639

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

crypto/openssh/sshconnect2.c

1665

pubkey_prepare(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/sshconnect2.c

1727

if ((r = get_agent_identities(ssh, &agent_fd, &idlist)) == 0) {

crypto/openssh/sshconnect2.c

1800

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

crypto/openssh/sshconnect2.c

1801

(cp = key_sig_algorithm(ssh, id->key)) == NULL) {

crypto/openssh/sshconnect2.c

1826

pubkey_cleanup(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1828

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

crypto/openssh/sshconnect2.c

1854

userauth_pubkey(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1856

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

crypto/openssh/sshconnect2.c

1863

pubkey_prepare(ssh, authctxt);

crypto/openssh/sshconnect2.c

1882

sent = send_pubkey_test(ssh, id);

crypto/openssh/sshconnect2.c

1889

sent = sign_and_send_pubkey(ssh, id);

crypto/openssh/sshconnect2.c

1906

userauth_kbdint(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1908

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

crypto/openssh/sshconnect2.c

1916

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_REQUEST, NULL);

crypto/openssh/sshconnect2.c

1921

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

crypto/openssh/sshconnect2.c

1922

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1923

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1924

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1925

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

crypto/openssh/sshconnect2.c

1926

(r = sshpkt_put_cstring(ssh, options.kbd_interactive_devices ?

crypto/openssh/sshconnect2.c

1928

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

crypto/openssh/sshconnect2.c

1931

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);

crypto/openssh/sshconnect2.c

1939

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

crypto/openssh/sshconnect2.c

1941

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

1955

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

crypto/openssh/sshconnect2.c

1956

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

crypto/openssh/sshconnect2.c

1957

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

crypto/openssh/sshconnect2.c

1964

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

crypto/openssh/sshconnect2.c

1972

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

crypto/openssh/sshconnect2.c

1973

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

crypto/openssh/sshconnect2.c

1978

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

crypto/openssh/sshconnect2.c

1979

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

crypto/openssh/sshconnect2.c

1986

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

crypto/openssh/sshconnect2.c

1994

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

crypto/openssh/sshconnect2.c

1995

(r = sshpkt_add_padding(ssh, 64)) != 0)

crypto/openssh/sshconnect2.c

1997

r = sshpkt_send(ssh);

crypto/openssh/sshconnect2.c

2010

ssh_keysign(struct ssh *ssh, struct sshkey *key, u_char **sigp, size_t *lenp,

crypto/openssh/sshconnect2.c

2017

int sock = ssh_packet_get_connection_in(ssh);

crypto/openssh/sshconnect2.c

2126

userauth_hostbased(struct ssh *ssh)

crypto/openssh/sshconnect2.c

2128

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

2191

lname = get_local_name(ssh_packet_get_connection_in(ssh));

crypto/openssh/sshconnect2.c

2210

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

crypto/openssh/sshconnect2.c

2226

if ((r = ssh_keysign(ssh, private, &sig, &siglen,

crypto/openssh/sshconnect2.c

2232

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

crypto/openssh/sshconnect2.c

2233

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

2234

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

2235

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

2236

(r = sshpkt_put_cstring(ssh, authctxt->active_ktype)) != 0 ||

crypto/openssh/sshconnect2.c

2237

(r = sshpkt_put_string(ssh, keyblob, keylen)) != 0 ||

crypto/openssh/sshconnect2.c

2238

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

crypto/openssh/sshconnect2.c

2239

(r = sshpkt_put_cstring(ssh, authctxt->local_user)) != 0 ||

crypto/openssh/sshconnect2.c

2240

(r = sshpkt_put_string(ssh, sig, siglen)) != 0 ||

crypto/openssh/sshconnect2.c

2241

(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->verify_host_key=&verify_host_key_callback;

crypto/openssh/sshconnect2.c

279

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &ssh->kex->done);

crypto/openssh/sshconnect2.c

284

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

crypto/openssh/sshconnect2.c

285

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

crypto/openssh/sshconnect2.c

286

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

crypto/openssh/sshconnect2.c

287

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

crypto/openssh/sshconnect2.c

343

int (*userauth)(struct ssh *ssh);

crypto/openssh/sshconnect2.c

344

void (*cleanup)(struct ssh *ssh);

crypto/openssh/sshconnect2.c

349

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

crypto/openssh/sshconnect2.c

350

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

crypto/openssh/sshconnect2.c

351

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

crypto/openssh/sshconnect2.c

352

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

crypto/openssh/sshconnect2.c

353

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

crypto/openssh/sshconnect2.c

354

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

crypto/openssh/sshconnect2.c

355

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

crypto/openssh/sshconnect2.c

356

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

crypto/openssh/sshconnect2.c

358

static int userauth_none(struct ssh *);

crypto/openssh/sshconnect2.c

359

static int userauth_pubkey(struct ssh *);

crypto/openssh/sshconnect2.c

360

static int userauth_passwd(struct ssh *);

crypto/openssh/sshconnect2.c

361

static int userauth_kbdint(struct ssh *);

crypto/openssh/sshconnect2.c

362

static int userauth_hostbased(struct ssh *);

crypto/openssh/sshconnect2.c

365

static int userauth_gssapi(struct ssh *);

crypto/openssh/sshconnect2.c

366

static void userauth_gssapi_cleanup(struct ssh *);

crypto/openssh/sshconnect2.c

367

static int input_gssapi_response(int type, u_int32_t, struct ssh *);

crypto/openssh/sshconnect2.c

368

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

crypto/openssh/sshconnect2.c

369

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

crypto/openssh/sshconnect2.c

370

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

crypto/openssh/sshconnect2.c

373

void userauth(struct ssh *, char *);

crypto/openssh/sshconnect2.c

375

static void pubkey_cleanup(struct ssh *);

crypto/openssh/sshconnect2.c

376

static int sign_and_send_pubkey(struct ssh *ssh, Identity *);

crypto/openssh/sshconnect2.c

377

static void pubkey_prepare(struct ssh *, Authctxt *);

crypto/openssh/sshconnect2.c

422

ssh_userauth2(struct ssh *ssh, const char *local_user,

crypto/openssh/sshconnect2.c

454

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

crypto/openssh/sshconnect2.c

455

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

crypto/openssh/sshconnect2.c

456

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

crypto/openssh/sshconnect2.c

459

ssh->authctxt = &authctxt;

crypto/openssh/sshconnect2.c

460

ssh_dispatch_init(ssh, &input_userauth_error);

crypto/openssh/sshconnect2.c

461

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, kex_input_ext_info);

crypto/openssh/sshconnect2.c

462

ssh_dispatch_set(ssh, SSH2_MSG_SERVICE_ACCEPT, &input_userauth_service_accept);

crypto/openssh/sshconnect2.c

463

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &authctxt.success); /* loop until success */

crypto/openssh/sshconnect2.c

464

pubkey_cleanup(ssh);

crypto/openssh/sshconnect2.c

473

ssh->authctxt = NULL;

crypto/openssh/sshconnect2.c

475

ssh_dispatch_range(ssh, SSH2_MSG_USERAUTH_MIN, SSH2_MSG_USERAUTH_MAX, NULL);

crypto/openssh/sshconnect2.c

479

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/sshconnect2.c

481

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/sshconnect2.c

490

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

crypto/openssh/sshconnect2.c

494

if (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/sshconnect2.c

497

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

crypto/openssh/sshconnect2.c

504

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

crypto/openssh/sshconnect2.c

509

userauth_none(ssh);

crypto/openssh/sshconnect2.c

512

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, ssh->kex->ext_info_s ?

crypto/openssh/sshconnect2.c

514

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);

crypto/openssh/sshconnect2.c

515

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);

crypto/openssh/sshconnect2.c

516

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);

crypto/openssh/sshconnect2.c

523

userauth(struct ssh *ssh, char *authlist)

crypto/openssh/sshconnect2.c

525

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

crypto/openssh/sshconnect2.c

528

authctxt->method->cleanup(ssh);

crypto/openssh/sshconnect2.c

546

ssh_dispatch_range(ssh, SSH2_MSG_USERAUTH_PER_METHOD_MIN,

crypto/openssh/sshconnect2.c

550

if (method->userauth(ssh) != 0) {

crypto/openssh/sshconnect2.c

561

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

crypto/openssh/sshconnect2.c

568

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

crypto/openssh/sshconnect2.c

575

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

crypto/openssh/sshconnect2.c

576

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

crypto/openssh/sshconnect2.c

587

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

crypto/openssh/sshconnect2.c

589

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

596

authctxt->method->cleanup(ssh);

crypto/openssh/sshconnect2.c

600

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, dispatch_protocol_error);

crypto/openssh/sshconnect2.c

606

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

crypto/openssh/sshconnect2.c

608

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

620

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

crypto/openssh/sshconnect2.c

622

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

629

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

crypto/openssh/sshconnect2.c

630

sshpkt_get_u8(ssh, &partial) != 0 ||

crypto/openssh/sshconnect2.c

631

sshpkt_get_end(ssh) != 0)

crypto/openssh/sshconnect2.c

642

userauth(ssh, authlist);

crypto/openssh/sshconnect2.c

680

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

crypto/openssh/sshconnect2.c

682

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

694

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

crypto/openssh/sshconnect2.c

695

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

crypto/openssh/sshconnect2.c

696

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

crypto/openssh/sshconnect2.c

734

sent = sign_and_send_pubkey(ssh, id);

crypto/openssh/sshconnect2.c

745

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

751

userauth_gssapi(struct ssh *ssh)

crypto/openssh/sshconnect2.c

753

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

crypto/openssh/sshconnect2.c

784

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

crypto/openssh/sshconnect2.c

785

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

786

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

787

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

788

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

crypto/openssh/sshconnect2.c

789

(r = sshpkt_put_u32(ssh, (mech->length) + 2)) != 0 ||

crypto/openssh/sshconnect2.c

790

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

crypto/openssh/sshconnect2.c

791

(r = sshpkt_put_u8(ssh, mech->length)) != 0 ||

crypto/openssh/sshconnect2.c

792

(r = sshpkt_put(ssh, mech->elements, mech->length)) != 0 ||

crypto/openssh/sshconnect2.c

793

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

crypto/openssh/sshconnect2.c

796

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_RESPONSE, &input_gssapi_response);

crypto/openssh/sshconnect2.c

797

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);

crypto/openssh/sshconnect2.c

798

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERROR, &input_gssapi_error);

crypto/openssh/sshconnect2.c

799

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);

crypto/openssh/sshconnect2.c

807

userauth_gssapi_cleanup(struct ssh *ssh)

crypto/openssh/sshconnect2.c

809

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

crypto/openssh/sshconnect2.c

817

process_gssapi_token(struct ssh *ssh, gss_buffer_t recv_tok)

crypto/openssh/sshconnect2.c

819

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

835

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

crypto/openssh/sshconnect2.c

836

(r = sshpkt_put_string(ssh, send_tok.value,

crypto/openssh/sshconnect2.c

838

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

crypto/openssh/sshconnect2.c

847

if ((r = sshpkt_start(ssh,

crypto/openssh/sshconnect2.c

849

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

crypto/openssh/sshconnect2.c

858

ssh->kex->session_id);

crypto/openssh/sshconnect2.c

867

if ((r = sshpkt_start(ssh,

crypto/openssh/sshconnect2.c

869

(r = sshpkt_put_string(ssh, mic.value,

crypto/openssh/sshconnect2.c

871

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

crypto/openssh/sshconnect2.c

884

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

crypto/openssh/sshconnect2.c

886

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

897

if ((r = sshpkt_get_string(ssh, &oidv, &oidlen)) != 0)

crypto/openssh/sshconnect2.c

904

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

911

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

crypto/openssh/sshconnect2.c

914

if (GSS_ERROR(process_gssapi_token(ssh, GSS_C_NO_BUFFER))) {

crypto/openssh/sshconnect2.c

917

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

928

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

crypto/openssh/sshconnect2.c

930

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

94

verify_host_key_callback(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/sshconnect2.c

940

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

crypto/openssh/sshconnect2.c

941

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

crypto/openssh/sshconnect2.c

946

status = process_gssapi_token(ssh, &recv_tok);

crypto/openssh/sshconnect2.c

950

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

960

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

crypto/openssh/sshconnect2.c

962

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

975

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

crypto/openssh/sshconnect2.c

976

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/sshconnect2.c

994

input_gssapi_error(int type, u_int32_t plen, struct ssh *ssh)

crypto/openssh/sshd-session.c

1224

if ((ssh = ssh_packet_set_connection(NULL, sock_in, sock_out)) == NULL)

crypto/openssh/sshd-session.c

1226

the_active_state = ssh;

crypto/openssh/sshd-session.c

1227

ssh_packet_set_server(ssh);

crypto/openssh/sshd-session.c

1229

check_ip_options(ssh);

crypto/openssh/sshd-session.c

1232

channel_init_channels(ssh);

crypto/openssh/sshd-session.c

1233

channel_set_af(ssh, options.address_family);

crypto/openssh/sshd-session.c

1234

server_process_channel_timeouts(ssh);

crypto/openssh/sshd-session.c

1235

server_process_permitopen(ssh);

crypto/openssh/sshd-session.c

1238

if (options.tcp_keep_alive && ssh_packet_connection_is_on_socket(ssh) &&

crypto/openssh/sshd-session.c

1242

if ((remote_port = ssh_remote_port(ssh)) < 0) {

crypto/openssh/sshd-session.c

1252

remote_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/sshd-session.c

1258

rdomain = ssh_packet_rdomain_in(ssh);

crypto/openssh/sshd-session.c

1263

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

sshpkt_fatal(ssh, r, "banner exchange");

crypto/openssh/sshd-session.c

1285

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshd-session.c

1289

ssh->authctxt = authctxt;

crypto/openssh/sshd-session.c

1303

if (privsep_preauth(ssh) == 1)

crypto/openssh/sshd-session.c

1308

do_ssh2_kex(ssh);

crypto/openssh/sshd-session.c

1309

do_authentication2(ssh);

crypto/openssh/sshd-session.c

1314

mm_send_keystate(ssh, pmonitor);

crypto/openssh/sshd-session.c

1315

ssh_packet_clear_keys(ssh);

crypto/openssh/sshd-session.c

1334

set_process_rdomain(ssh, options.routing_domain);

crypto/openssh/sshd-session.c

1337

audit_event(ssh, SSH_AUTH_SUCCESS);

crypto/openssh/sshd-session.c

1350

do_pam_session(ssh);

crypto/openssh/sshd-session.c

1358

privsep_postauth(ssh, authctxt);

crypto/openssh/sshd-session.c

1361

ssh_packet_set_timeout(ssh, options.client_alive_interval,

crypto/openssh/sshd-session.c

1365

notify_hostkeys(ssh);

crypto/openssh/sshd-session.c

1368

do_authenticated(ssh, authctxt);

crypto/openssh/sshd-session.c

1371

ssh_packet_get_bytes(ssh, &ibytes, &obytes);

crypto/openssh/sshd-session.c

1383

mm_audit_event(ssh, SSH_CONNECTION_CLOSE);

crypto/openssh/sshd-session.c

1386

ssh_packet_close(ssh);

crypto/openssh/sshd-session.c

1394

sshd_hostkey_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/sshd-session.c

1399

if (mm_sshkey_sign(ssh, privkey, signature, slenp,

crypto/openssh/sshd-session.c

1401

ssh->compat) < 0)

crypto/openssh/sshd-session.c

1404

if (mm_sshkey_sign(ssh, pubkey, signature, slenp,

crypto/openssh/sshd-session.c

1406

ssh->compat) < 0)

crypto/openssh/sshd-session.c

1414

do_ssh2_kex(struct ssh *ssh)

crypto/openssh/sshd-session.c

1422

ssh_packet_set_rekey_limits(ssh, options.rekey_limit,

crypto/openssh/sshd-session.c

1429

kex_proposal_populate_entries(ssh, myproposal, options.kex_algorithms,

crypto/openssh/sshd-session.c

1435

if ((r = kex_setup(ssh, myproposal)) != 0)

crypto/openssh/sshd-session.c

1437

kex_set_server_sig_algs(ssh, options.pubkey_accepted_algos);

crypto/openssh/sshd-session.c

1438

kex = ssh->kex;

crypto/openssh/sshd-session.c

1459

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &kex->done);

crypto/openssh/sshd-session.c

1464

if ((r = sshpkt_start(ssh, SSH2_MSG_IGNORE)) != 0 ||

crypto/openssh/sshd-session.c

1465

(r = sshpkt_put_cstring(ssh, "markus")) != 0 ||

crypto/openssh/sshd-session.c

1466

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/sshd-session.c

1467

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/sshd-session.c

179

struct ssh *the_active_state;

crypto/openssh/sshd-session.c

196

static void do_ssh2_kex(struct ssh *);

crypto/openssh/sshd-session.c

322

privsep_preauth(struct ssh *ssh)

crypto/openssh/sshd-session.c

331

pmonitor->m_pkex = &ssh->kex;

crypto/openssh/sshd-session.c

350

monitor_child_preauth(ssh, pmonitor);

crypto/openssh/sshd-session.c

389

privsep_postauth(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/sshd-session.c

415

monitor_clear_keystate(ssh, pmonitor);

crypto/openssh/sshd-session.c

416

monitor_child_postauth(ssh, pmonitor);

crypto/openssh/sshd-session.c

437

monitor_apply_keystate(ssh, pmonitor);

crypto/openssh/sshd-session.c

443

ssh_packet_set_authenticated(ssh);

crypto/openssh/sshd-session.c

520

get_hostkey_by_type(int type, int nid, int need_private, struct ssh *ssh)

crypto/openssh/sshd-session.c

561

get_hostkey_public_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-session.c

563

return get_hostkey_by_type(type, nid, 0, ssh);

crypto/openssh/sshd-session.c

567

get_hostkey_private_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-session.c

569

return get_hostkey_by_type(type, nid, 1, ssh);

crypto/openssh/sshd-session.c

581

get_hostkey_public_by_index(int ind, struct ssh *ssh)

crypto/openssh/sshd-session.c

589

get_hostkey_index(struct sshkey *key, int compare, struct ssh *ssh)

crypto/openssh/sshd-session.c

616

notify_hostkeys(struct ssh *ssh)

crypto/openssh/sshd-session.c

625

if (ssh->compat & SSH_BUG_HOSTKEYS)

crypto/openssh/sshd-session.c

631

key = get_hostkey_public_by_index(i, ssh);

crypto/openssh/sshd-session.c

644

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/sshd-session.c

645

(r = sshpkt_put_cstring(ssh, "hostkeys-00@openssh.com")) != 0 ||

crypto/openssh/sshd-session.c

646

(r = sshpkt_put_u8(ssh, 0)) != 0) /* want reply */

crypto/openssh/sshd-session.c

647

sshpkt_fatal(ssh, r, "%s: start request", __func__);

crypto/openssh/sshd-session.c

653

if ((r = sshpkt_put_stringb(ssh, buf)) != 0)

crypto/openssh/sshd-session.c

654

sshpkt_fatal(ssh, r, "%s: append key", __func__);

crypto/openssh/sshd-session.c

660

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshd-session.c

661

sshpkt_fatal(ssh, r, "%s: send", __func__);

crypto/openssh/sshd-session.c

794

check_ip_options(struct ssh *ssh)

crypto/openssh/sshd-session.c

797

int sock_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/sshd-session.c

818

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh), text);

crypto/openssh/sshd-session.c

826

set_process_rdomain(struct ssh *ssh, const char *name)

crypto/openssh/sshd-session.c

834

if ((name = ssh_packet_rdomain_in(ssh)) == NULL)

crypto/openssh/sshd-session.c

848

if ((name = ssh_packet_rdomain_in(ssh)) == NULL)

crypto/openssh/sshd-session.c

870

struct ssh *ssh = NULL;

crypto/openssh/sshd-session.c

994

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)

lib/libssh/openbsd-compat/port-net.c

309

sys_tun_infilter(struct ssh *ssh, struct Channel *c, char *buf, int _len)

lib/libssh/openbsd-compat/port-net.c

353

sys_tun_outfilter(struct ssh *ssh, struct Channel *c,

lib/libssh/openbsd-compat/port-net.h

21

struct ssh;

lib/libssh/openbsd-compat/port-net.h

30

int sys_tun_infilter(struct ssh *, struct Channel *, char *, int);

lib/libssh/openbsd-compat/port-net.h

31

u_char *sys_tun_outfilter(struct ssh *, struct Channel *, u_char **, size_t *);

libexec/sshd-session/auth-passwd-custom.c

42

sys_auth_passwd(struct ssh *ssh, const char *password)

libexec/sshd-session/auth-passwd-custom.c

44

Authctxt *authctxt = ssh->authctxt;