crypto/openssh/audit-bsm.c

395

audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/audit-linux.c

102

audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/audit-linux.c

119

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

1050

start_pam(struct ssh *ssh)

crypto/openssh/auth-pam.c

1052

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

crypto/openssh/auth-pam.c

1057

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

crypto/openssh/auth-pam.c

1116

do_pam_session(struct ssh *ssh)

crypto/openssh/auth-pam.c

1132

auth_restrict_session(ssh);

crypto/openssh/auth-pam.c

704

sshpam_init(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/auth-pam.c

715

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth-pam.c

717

if (sshpam_handle == NULL && ssh == NULL)

crypto/openssh/auth-pam.c

738

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

crypto/openssh/auth-pam.c

743

sshpam_rhost = xstrdup(auth_get_canonical_hostname(ssh,

crypto/openssh/auth-pam.c

746

ssh_packet_get_connection_in(ssh));

crypto/openssh/auth-pam.c

758

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

crypto/openssh/auth-pam.c

763

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/auth-pam.c

764

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

142

hostname = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth.c

143

ipaddr = ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

265

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

crypto/openssh/auth.c

268

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

crypto/openssh/auth.c

290

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_OK,

crypto/openssh/auth.c

305

ssh_remote_ipaddr(ssh),

crypto/openssh/auth.c

306

ssh_remote_port(ssh),

crypto/openssh/auth.c

319

record_failed_login(ssh, authctxt->user,

crypto/openssh/auth.c

320

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

crypto/openssh/auth.c

323

audit_event(ssh, audit_classify_auth(method));

crypto/openssh/auth.c

330

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

crypto/openssh/auth.c

336

auth_maxtries_exceeded(struct ssh *ssh)

crypto/openssh/auth.c

338

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

crypto/openssh/auth.c

340

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

crypto/openssh/auth.c

345

ssh_remote_ipaddr(ssh),

crypto/openssh/auth.c

346

ssh_remote_port(ssh));

crypto/openssh/auth.c

347

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

crypto/openssh/auth.c

355

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

crypto/openssh/auth.c

374

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth.c

466

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

crypto/openssh/auth.c

481

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

crypto/openssh/auth.c

489

server_process_permitopen(ssh);

crypto/openssh/auth.c

501

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

crypto/openssh/auth.c

503

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

crypto/openssh/auth.c

505

record_failed_login(ssh, user,

crypto/openssh/auth.c

506

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

crypto/openssh/auth.c

509

audit_event(ssh, SSH_INVALID_USER);

crypto/openssh/auth.c

513

if (!allowed_user(ssh, pw))

crypto/openssh/auth.c

521

from_host = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth.c

522

from_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

610

auth_debug_send(struct ssh *ssh)

crypto/openssh/auth.c

620

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

crypto/openssh/auth.c

674

auth_get_canonical_hostname(struct ssh *ssh, int use_dns)

crypto/openssh/auth.c

679

return ssh_remote_ipaddr(ssh);

crypto/openssh/auth.c

682

dnsname = ssh_remote_hostname(ssh);

crypto/openssh/auth.c

760

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

crypto/openssh/auth.c

776

auth_restrict_session(struct ssh *ssh)

crypto/openssh/auth.c

788

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

crypto/openssh/auth.c

98

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

186

int auth2_challenge(struct ssh *, char *);

crypto/openssh/auth.h

187

void auth2_challenge_stop(struct ssh *);

crypto/openssh/auth.h

191

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

crypto/openssh/auth.h

192

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

crypto/openssh/auth.h

199

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

crypto/openssh/auth.h

207

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

crypto/openssh/auth.h

208

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

crypto/openssh/auth.h

209

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

crypto/openssh/auth.h

210

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

crypto/openssh/auth.h

211

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

crypto/openssh/auth.h

215

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

crypto/openssh/auth.h

216

void auth_restrict_session(struct ssh *);

crypto/openssh/auth.h

222

void auth_debug_send(struct ssh *);

crypto/openssh/auth.h

241

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

crypto/openssh/auth.h

45

struct ssh;

crypto/openssh/auth2-chall.c

197

auth2_challenge(struct ssh *ssh, char *devs)

crypto/openssh/auth2-chall.c

199

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

208

return auth2_challenge_start(ssh);

crypto/openssh/auth2-chall.c

213

auth2_challenge_stop(struct ssh *ssh)

crypto/openssh/auth2-chall.c

215

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

217

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE, NULL);

crypto/openssh/auth2-chall.c

226

auth2_challenge_start(struct ssh *ssh)

crypto/openssh/auth2-chall.c

228

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

235

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

242

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

245

if (send_userauth_info_request(ssh) == 0) {

crypto/openssh/auth2-chall.c

246

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

249

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE,

crypto/openssh/auth2-chall.c

257

send_userauth_info_request(struct ssh *ssh)

crypto/openssh/auth2-chall.c

259

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

269

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

crypto/openssh/auth2-chall.c

270

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

crypto/openssh/auth2-chall.c

271

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

crypto/openssh/auth2-chall.c

272

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

crypto/openssh/auth2-chall.c

273

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

crypto/openssh/auth2-chall.c

276

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

crypto/openssh/auth2-chall.c

277

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

crypto/openssh/auth2-chall.c

280

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

crypto/openssh/auth2-chall.c

281

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

crypto/openssh/auth2-chall.c

294

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

crypto/openssh/auth2-chall.c

296

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-chall.c

314

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

crypto/openssh/auth2-chall.c

323

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

crypto/openssh/auth2-chall.c

327

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

crypto/openssh/auth2-chall.c

345

if (send_userauth_info_request(ssh) == 1)

crypto/openssh/auth2-chall.c

355

auth2_challenge_stop(ssh);

crypto/openssh/auth2-chall.c

359

auth2_challenge_start(ssh);

crypto/openssh/auth2-chall.c

365

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, uint32_t, struct ssh *);

crypto/openssh/auth2-gss.c

125

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

crypto/openssh/auth2-gss.c

126

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

crypto/openssh/auth2-gss.c

127

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

crypto/openssh/auth2-gss.c

132

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);

crypto/openssh/auth2-gss.c

133

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);

crypto/openssh/auth2-gss.c

140

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

crypto/openssh/auth2-gss.c

142

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

155

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

crypto/openssh/auth2-gss.c

156

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

crypto/openssh/auth2-gss.c

168

if ((r = sshpkt_start(ssh,

crypto/openssh/auth2-gss.c

170

(r = sshpkt_put_string(ssh, send_tok.value,

crypto/openssh/auth2-gss.c

172

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

crypto/openssh/auth2-gss.c

179

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth2-gss.c

181

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

182

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, 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,

crypto/openssh/auth2-gss.c

198

ssh_dispatch_set(ssh,

crypto/openssh/auth2-gss.c

202

ssh_dispatch_set(ssh,

crypto/openssh/auth2-gss.c

214

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

crypto/openssh/auth2-gss.c

216

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

225

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

crypto/openssh/auth2-gss.c

226

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

crypto/openssh/auth2-gss.c

232

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/auth2-gss.c

234

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

235

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);

crypto/openssh/auth2-gss.c

236

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC, NULL);

crypto/openssh/auth2-gss.c

237

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);

crypto/openssh/auth2-gss.c

238

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

crypto/openssh/auth2-gss.c

249

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

crypto/openssh/auth2-gss.c

251

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

263

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

crypto/openssh/auth2-gss.c

271

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

272

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);

crypto/openssh/auth2-gss.c

273

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC, NULL);

crypto/openssh/auth2-gss.c

274

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);

crypto/openssh/auth2-gss.c

275

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

crypto/openssh/auth2-gss.c

280

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

crypto/openssh/auth2-gss.c

282

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2-gss.c

296

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

crypto/openssh/auth2-gss.c

303

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

crypto/openssh/auth2-gss.c

321

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2-gss.c

322

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, NULL);

crypto/openssh/auth2-gss.c

323

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_MIC, NULL);

crypto/openssh/auth2-gss.c

324

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);

crypto/openssh/auth2-gss.c

325

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

crypto/openssh/auth2-gss.c

56

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

crypto/openssh/auth2-gss.c

57

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

crypto/openssh/auth2-gss.c

58

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

crypto/openssh/auth2-gss.c

59

static int input_gssapi_errtok(int, uint32_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

131

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

crypto/openssh/auth2-hostbased.c

150

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

crypto/openssh/auth2-hostbased.c

153

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

crypto/openssh/auth2-hostbased.c

171

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

crypto/openssh/auth2-hostbased.c

182

resolvedname = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth2-hostbased.c

183

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

54

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

crypto/openssh/auth2-none.c

59

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

crypto/openssh/auth2-none.c

62

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

104

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

crypto/openssh/auth2-pubkey.c

105

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

crypto/openssh/auth2-pubkey.c

106

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

crypto/openssh/auth2-pubkey.c

111

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

crypto/openssh/auth2-pubkey.c

114

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

crypto/openssh/auth2-pubkey.c

116

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

790

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

crypto/openssh/auth2-pubkey.c

807

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

crypto/openssh/auth2-pubkey.c

809

remote_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/auth2-pubkey.c

810

remote_host = auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/auth2-pubkey.c

812

ssh_local_ipaddr(ssh), ssh_local_port(ssh),

crypto/openssh/auth2-pubkey.c

813

remote_ip, ssh_remote_port(ssh));

crypto/openssh/auth2-pubkey.c

88

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

crypto/openssh/auth2-pubkey.c

90

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, uint32_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

275

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

crypto/openssh/auth2.c

277

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2.c

286

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

crypto/openssh/auth2.c

287

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

crypto/openssh/auth2.c

288

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

crypto/openssh/auth2.c

297

auth_maxtries_exceeded(ssh);

crypto/openssh/auth2.c

300

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

crypto/openssh/auth2.c

312

mm_audit_event(ssh, SSH_INVALID_USER);

crypto/openssh/auth2.c

317

mm_start_pam(ssh);

crypto/openssh/auth2.c

319

ssh_packet_set_log_preamble(ssh, "%suser %s",

crypto/openssh/auth2.c

323

userauth_banner(ssh);

crypto/openssh/auth2.c

324

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

crypto/openssh/auth2.c

327

ssh_packet_disconnect(ssh,

crypto/openssh/auth2.c

331

ssh_packet_disconnect(ssh, "Change of username or service "

crypto/openssh/auth2.c

336

auth2_challenge_stop(ssh);

crypto/openssh/auth2.c

340

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, NULL);

crypto/openssh/auth2.c

341

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_EXCHANGE_COMPLETE, NULL);

crypto/openssh/auth2.c

352

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

crypto/openssh/auth2.c

357

userauth_finish(ssh, authenticated, method, NULL);

crypto/openssh/auth2.c

367

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

crypto/openssh/auth2.c

370

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/auth2.c

391

!auth_root_allowed(ssh, method)) {

crypto/openssh/auth2.c

394

mm_audit_event(ssh, SSH_LOGIN_ROOT_DENIED);

crypto/openssh/auth2.c

406

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

crypto/openssh/auth2.c

424

userauth_send_banner(ssh, sshbuf_ptr(loginmsg));

crypto/openssh/auth2.c

425

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

crypto/openssh/auth2.c

426

sshpkt_fatal(ssh, r,

crypto/openssh/auth2.c

439

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_REQUEST,

crypto/openssh/auth2.c

441

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

crypto/openssh/auth2.c

442

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

crypto/openssh/auth2.c

443

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

crypto/openssh/auth2.c

447

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

crypto/openssh/auth2.c

455

mm_audit_event(ssh, SSH_LOGIN_EXCEED_MAXTRIES);

crypto/openssh/auth2.c

457

auth_maxtries_exceeded(ssh);

crypto/openssh/auth2.c

462

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

crypto/openssh/auth2.c

463

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

crypto/openssh/auth2.c

464

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

crypto/openssh/auth2.c

465

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

crypto/openssh/auth2.c

466

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

crypto/openssh/auth2.c

91

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

crypto/openssh/auth2.c

92

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

crypto/openssh/blocklist.c

91

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

crypto/openssh/blocklist.c

94

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

crypto/openssh/blocklist.c

96

ssh_packet_get_connection_in(ssh), msg);

crypto/openssh/blocklist_client.h

48

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

crypto/openssh/blocklist_client.h

51

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

crypto/openssh/blocklist_client.h

56

#define BLOCKLIST_NOTIFY(ssh,x,msg)

crypto/openssh/channels.c

1007

channel_find_open(struct ssh *ssh)

crypto/openssh/channels.c

1012

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

crypto/openssh/channels.c

1013

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

crypto/openssh/channels.c

1093

channel_open_message(struct ssh *ssh)

crypto/openssh/channels.c

1106

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

crypto/openssh/channels.c

1107

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

crypto/openssh/channels.c

1152

channel_report_open(struct ssh *ssh, int level)

crypto/openssh/channels.c

1156

sshpkt_fmt_connection_id(ssh, ident, sizeof(ident));

crypto/openssh/channels.c

1158

open = oopen = channel_open_message(ssh);

crypto/openssh/channels.c

1167

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

crypto/openssh/channels.c

1171

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

crypto/openssh/channels.c

1172

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

crypto/openssh/channels.c

1173

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

crypto/openssh/channels.c

1174

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

crypto/openssh/channels.c

1175

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

crypto/openssh/channels.c

1181

channel_send_open(struct ssh *ssh, int id)

crypto/openssh/channels.c

1183

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1191

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

crypto/openssh/channels.c

1192

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

crypto/openssh/channels.c

1197

channel_request_start(struct ssh *ssh, int id, const char *service,

crypto/openssh/channels.c

1200

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1211

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

crypto/openssh/channels.c

1212

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

crypto/openssh/channels.c

1213

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

crypto/openssh/channels.c

1214

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

crypto/openssh/channels.c

1220

channel_register_status_confirm(struct ssh *ssh, int id,

crypto/openssh/channels.c

1226

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

crypto/openssh/channels.c

1237

channel_register_open_confirm(struct ssh *ssh, int id,

crypto/openssh/channels.c

1240

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1251

channel_register_cleanup(struct ssh *ssh, int id,

crypto/openssh/channels.c

1254

Channel *c = channel_by_id(ssh, id);

crypto/openssh/channels.c

1265

channel_cancel_cleanup(struct ssh *ssh, int id)

crypto/openssh/channels.c

1267

Channel *c = channel_by_id(ssh, id);

crypto/openssh/channels.c

1278

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

crypto/openssh/channels.c

1281

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1294

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

crypto/openssh/channels.c

1297

Channel *c = channel_lookup(ssh, id);

crypto/openssh/channels.c

1305

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

crypto/openssh/channels.c

1307

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

1310

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

crypto/openssh/channels.c

1311

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

crypto/openssh/channels.c

1312

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

crypto/openssh/channels.c

1313

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

crypto/openssh/channels.c

1318

channel_pre_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1324

channel_pre_connecting(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1331

channel_pre_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1349

chan_obuf_empty(ssh, c);

crypto/openssh/channels.c

1377

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

crypto/openssh/channels.c

1379

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

1449

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

crypto/openssh/channels.c

1453

chan_read_failed(ssh, c);

crypto/openssh/channels.c

1456

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

1461

chan_write_failed(ssh, c);

crypto/openssh/channels.c

1464

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

crypto/openssh/channels.c

1466

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

crypto/openssh/channels.c

1475

channel_pre_x11_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1477

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

crypto/openssh/channels.c

1483

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

1484

channel_pre_open(ssh, c);

crypto/openssh/channels.c

1490

channel_force_close(ssh, c, 0);

crypto/openssh/channels.c

1495

channel_pre_mux_client(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1504

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

1506

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

1513

chan_obuf_empty(ssh, c);

crypto/openssh/channels.c

1771

channel_connect_stdio_fwd(struct ssh *ssh,

crypto/openssh/channels.c

1779

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

crypto/openssh/channels.c

1788

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

crypto/openssh/channels.c

1789

port_open_helper(ssh, c, port_to_connect == PORT_STREAMLOCAL ?

crypto/openssh/channels.c

1797

channel_pre_dynamic(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1829

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

1839

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

crypto/openssh/channels.c

1845

rdynamic_close(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1848

channel_force_close(ssh, c, 0);

crypto/openssh/channels.c

1853

channel_before_prepare_io_rdynamic(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1866

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1887

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1893

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

crypto/openssh/channels.c

1894

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

crypto/openssh/channels.c

1895

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

crypto/openssh/channels.c

1896

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

crypto/openssh/channels.c

1903

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

crypto/openssh/channels.c

1905

rdynamic_close(ssh, c);

crypto/openssh/channels.c

1911

channel_post_x11_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

1928

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

crypto/openssh/channels.c

1929

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

1946

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

crypto/openssh/channels.c

1949

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

crypto/openssh/channels.c

1950

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

crypto/openssh/channels.c

1951

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

crypto/openssh/channels.c

1954

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

crypto/openssh/channels.c

1960

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

crypto/openssh/channels.c

1982

open_preamble(ssh, __func__, c, rtype);

crypto/openssh/channels.c

1985

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

crypto/openssh/channels.c

1986

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

crypto/openssh/channels.c

1990

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

crypto/openssh/channels.c

1994

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

crypto/openssh/channels.c

1998

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

crypto/openssh/channels.c

1999

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

crypto/openssh/channels.c

2004

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

crypto/openssh/channels.c

2008

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

crypto/openssh/channels.c

2009

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

crypto/openssh/channels.c

2012

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

crypto/openssh/channels.c

2019

channel_set_x11_refuse_time(struct ssh *ssh, time_t refuse_time)

crypto/openssh/channels.c

2021

ssh->chanctxt->x11_refuse_time = refuse_time;

crypto/openssh/channels.c

2028

channel_post_port_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2071

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

crypto/openssh/channels.c

2079

port_open_helper(ssh, nc, rtype);

crypto/openssh/channels.c

2087

channel_post_auth_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2105

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

crypto/openssh/channels.c

2109

open_preamble(ssh, __func__, nc,

crypto/openssh/channels.c

2111

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

crypto/openssh/channels.c

2116

channel_post_connecting(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

213

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

crypto/openssh/channels.c

2139

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2143

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2145

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

crypto/openssh/channels.c

2146

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

crypto/openssh/channels.c

2147

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

crypto/openssh/channels.c

2148

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

crypto/openssh/channels.c

2149

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

crypto/openssh/channels.c

2167

rdynamic_close(ssh, c);

crypto/openssh/channels.c

2169

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2171

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

crypto/openssh/channels.c

2172

(r = sshpkt_put_u32(ssh,

crypto/openssh/channels.c

2174

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

crypto/openssh/channels.c

2175

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

crypto/openssh/channels.c

2176

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

crypto/openssh/channels.c

2178

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2188

channel_handle_rfd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

219

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

crypto/openssh/channels.c

220

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

crypto/openssh/channels.c

2231

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2250

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2253

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2257

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2259

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

crypto/openssh/channels.c

2261

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2273

channel_handle_wfd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

228

channel_init_channels(struct ssh *ssh)

crypto/openssh/channels.c

2288

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

crypto/openssh/channels.c

2291

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2293

chan_write_failed(ssh, c);

crypto/openssh/channels.c

2331

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2334

chan_write_failed(ssh, c);

crypto/openssh/channels.c

2338

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2349

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

crypto/openssh/channels.c

2350

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

crypto/openssh/channels.c

2364

channel_handle_efd_write(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2382

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

crypto/openssh/channels.c

2387

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2393

channel_handle_efd_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

241

ssh->chanctxt = sc;

crypto/openssh/channels.c

2411

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

crypto/openssh/channels.c

2414

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

2423

channel_handle_efd(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2431

return channel_handle_efd_write(ssh, c);

crypto/openssh/channels.c

2434

return channel_handle_efd_read(ssh, c);

crypto/openssh/channels.c

2440

channel_check_window(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

245

channel_by_id(struct ssh *ssh, int id)

crypto/openssh/channels.c

2452

if ((r = sshpkt_start(ssh,

crypto/openssh/channels.c

2454

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

crypto/openssh/channels.c

2455

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

crypto/openssh/channels.c

2456

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

crypto/openssh/channels.c

2468

channel_post_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2470

channel_handle_rfd(ssh, c);

crypto/openssh/channels.c

2471

channel_handle_wfd(ssh, c);

crypto/openssh/channels.c

2472

channel_handle_efd(ssh, c);

crypto/openssh/channels.c

2473

channel_check_window(ssh, c);

crypto/openssh/channels.c

2477

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

crypto/openssh/channels.c

249

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

crypto/openssh/channels.c

2492

chan_read_failed(ssh, c);

crypto/openssh/channels.c

2501

channel_post_mux_client_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2516

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

crypto/openssh/channels.c

2524

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

2527

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

crypto/openssh/channels.c

2529

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

crypto/openssh/channels.c

253

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

crypto/openssh/channels.c

2531

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2537

channel_post_mux_client_write(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2551

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

2559

channel_post_mux_client(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2561

channel_post_mux_client_read(ssh, c);

crypto/openssh/channels.c

2562

channel_post_mux_client_write(ssh, c);

crypto/openssh/channels.c

2566

channel_post_mux_listener(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2604

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

crypto/openssh/channels.c

2610

nc->mux_rcb(ssh, nc);

crypto/openssh/channels.c

262

channel_by_remote_id(struct ssh *ssh, u_int remote_id)

crypto/openssh/channels.c

2657

channel_garbage_collect(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

2662

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

crypto/openssh/channels.c

2666

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

crypto/openssh/channels.c

267

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

crypto/openssh/channels.c

2672

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

crypto/openssh/channels.c

2675

channel_free(ssh, c);

crypto/openssh/channels.c

268

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

crypto/openssh/channels.c

2681

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

crypto/openssh/channels.c

2683

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2698

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

crypto/openssh/channels.c

2708

channel_get_expiry(ssh, c) != 0 &&

crypto/openssh/channels.c

2709

now >= channel_get_expiry(ssh, c)) {

crypto/openssh/channels.c

2714

channel_force_close(ssh, c, 1);

crypto/openssh/channels.c

2717

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

crypto/openssh/channels.c

2721

channel_get_expiry(ssh, c) != 0) {

crypto/openssh/channels.c

2723

channel_get_expiry(ssh, c));

crypto/openssh/channels.c

2734

channel_garbage_collect(ssh, c);

crypto/openssh/channels.c

2745

channel_before_prepare_io(struct ssh *ssh)

crypto/openssh/channels.c

2747

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2756

channel_before_prepare_io_rdynamic(ssh, c);

crypto/openssh/channels.c

280

channel_lookup(struct ssh *ssh, int id)

crypto/openssh/channels.c

284

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

crypto/openssh/channels.c

2880

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

crypto/openssh/channels.c

2883

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

2886

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

crypto/openssh/channels.c

2905

channel_handler(ssh, CHAN_PRE, timeout);

crypto/openssh/channels.c

2949

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

crypto/openssh/channels.c

2951

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3026

channel_handler(ssh, CHAN_POST, NULL);

crypto/openssh/channels.c

3034

channel_output_poll_input_open(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

3054

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

3076

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

crypto/openssh/channels.c

3077

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

crypto/openssh/channels.c

3078

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

crypto/openssh/channels.c

3079

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

crypto/openssh/channels.c

309

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

crypto/openssh/channels.c

3092

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

crypto/openssh/channels.c

3093

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

crypto/openssh/channels.c

3094

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

crypto/openssh/channels.c

3095

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

crypto/openssh/channels.c

3108

channel_output_poll_extended_read(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

312

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3126

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

crypto/openssh/channels.c

3127

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

crypto/openssh/channels.c

3128

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

crypto/openssh/channels.c

3129

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

crypto/openssh/channels.c

3130

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

crypto/openssh/channels.c

3144

channel_output_poll(struct ssh *ssh)

crypto/openssh/channels.c

3146

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3172

ret |= channel_output_poll_input_open(ssh, c);

crypto/openssh/channels.c

3176

ret |= channel_output_poll_extended_read(ssh, c);

crypto/openssh/channels.c

3222

channel_proxy_downstream(struct ssh *ssh, Channel *downstream)

crypto/openssh/channels.c

3263

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

crypto/openssh/channels.c

3271

channel_free(ssh, c);

crypto/openssh/channels.c

3290

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

crypto/openssh/channels.c

330

channel_clear_timeouts(struct ssh *ssh)

crypto/openssh/channels.c

3300

channel_free(ssh, c);

crypto/openssh/channels.c

332

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3329

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

crypto/openssh/channels.c

3336

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

crypto/openssh/channels.c

3338

channel_free(ssh, c);

crypto/openssh/channels.c

3345

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

crypto/openssh/channels.c

3346

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

crypto/openssh/channels.c

3347

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

crypto/openssh/channels.c

3352

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

crypto/openssh/channels.c

3353

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

crypto/openssh/channels.c

3354

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

crypto/openssh/channels.c

3375

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

crypto/openssh/channels.c

3414

cp = sshpkt_ptr(ssh, &len);

crypto/openssh/channels.c

344

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

crypto/openssh/channels.c

3443

channel_free(ssh, c);

crypto/openssh/channels.c

3456

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

crypto/openssh/channels.c

346

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3461

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

crypto/openssh/channels.c

3463

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

crypto/openssh/channels.c

3467

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

crypto/openssh/channels.c

3474

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

crypto/openssh/channels.c

3476

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

crypto/openssh/channels.c

3479

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

crypto/openssh/channels.c

3480

ssh_packet_disconnect(ssh,

crypto/openssh/channels.c

3487

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

crypto/openssh/channels.c

3491

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

crypto/openssh/channels.c

3494

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

crypto/openssh/channels.c

3505

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

crypto/openssh/channels.c

3506

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

crypto/openssh/channels.c

3540

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

crypto/openssh/channels.c

3558

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

crypto/openssh/channels.c

3563

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

crypto/openssh/channels.c

3566

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

crypto/openssh/channels.c

3573

if (ssh->compat & SSH_BUG_EXTEOF)

crypto/openssh/channels.c

3577

ssh_packet_disconnect(ssh, "Received extended_data "

crypto/openssh/channels.c

358

channel_classify(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

3581

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

crypto/openssh/channels.c

3583

ssh_packet_disconnect(ssh, "Invalid extended_data message");

crypto/openssh/channels.c

3591

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

crypto/openssh/channels.c

3592

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

crypto/openssh/channels.c

3594

ssh_packet_disconnect(ssh, "Invalid extended_data message");

crypto/openssh/channels.c

360

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

3611

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

crypto/openssh/channels.c

3613

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

crypto/openssh/channels.c

3616

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

crypto/openssh/channels.c

3618

ssh_packet_disconnect(ssh, "Invalid ieof message");

crypto/openssh/channels.c

3621

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

crypto/openssh/channels.c

3623

chan_rcvd_ieof(ssh, c);

crypto/openssh/channels.c

3630

chan_ibuf_empty(ssh, c);

crypto/openssh/channels.c

3636

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

crypto/openssh/channels.c

3638

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

crypto/openssh/channels.c

3641

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

crypto/openssh/channels.c

3643

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

crypto/openssh/channels.c

3645

ssh_packet_disconnect(ssh, "Invalid oclose message");

crypto/openssh/channels.c

3647

chan_rcvd_oclose(ssh, c);

crypto/openssh/channels.c

3652

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

crypto/openssh/channels.c

3654

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

crypto/openssh/channels.c

3658

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

crypto/openssh/channels.c

3661

ssh_packet_disconnect(ssh, "Received open confirmation for "

crypto/openssh/channels.c

3667

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

crypto/openssh/channels.c

3668

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

crypto/openssh/channels.c

3669

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

crypto/openssh/channels.c

3670

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

crypto/openssh/channels.c

3672

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

crypto/openssh/channels.c

3681

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

crypto/openssh/channels.c

3684

channel_set_used_time(ssh, c);

crypto/openssh/channels.c

3707

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

crypto/openssh/channels.c

3709

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

crypto/openssh/channels.c

3714

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

crypto/openssh/channels.c

3717

ssh_packet_disconnect(ssh, "Received open failure for "

crypto/openssh/channels.c

3719

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

crypto/openssh/channels.c

3721

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

crypto/openssh/channels.c

3724

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

crypto/openssh/channels.c

3725

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

crypto/openssh/channels.c

3726

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

crypto/openssh/channels.c

3728

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

crypto/openssh/channels.c

3735

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

crypto/openssh/channels.c

3739

chan_mark_dead(ssh, c);

crypto/openssh/channels.c

3744

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

crypto/openssh/channels.c

3746

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

crypto/openssh/channels.c

3752

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

crypto/openssh/channels.c

3757

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

crypto/openssh/channels.c

3759

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

crypto/openssh/channels.c

3760

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

crypto/openssh/channels.c

3762

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

crypto/openssh/channels.c

3774

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

crypto/openssh/channels.c

3776

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

crypto/openssh/channels.c

3781

ssh_packet_set_alive_timeouts(ssh, 0);

crypto/openssh/channels.c

3785

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

crypto/openssh/channels.c

3789

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

crypto/openssh/channels.c

379

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

crypto/openssh/channels.c

3791

if (sshpkt_get_end(ssh) != 0)

crypto/openssh/channels.c

3792

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

crypto/openssh/channels.c

3795

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

crypto/openssh/channels.c

3804

channel_set_af(struct ssh *ssh, int af)

crypto/openssh/channels.c

3806

ssh->chanctxt->IPv4or6 = af;

crypto/openssh/channels.c

3826

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

crypto/openssh/channels.c

383

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

crypto/openssh/channels.c

3837

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

crypto/openssh/channels.c

3849

ssh_packet_send_debug(ssh,

crypto/openssh/channels.c

3880

channel_setup_fwd_listener_tcpip(struct ssh *ssh, int type,

crypto/openssh/channels.c

389

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

crypto/openssh/channels.c

390

channel_classify(ssh, c);

crypto/openssh/channels.c

3909

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

crypto/openssh/channels.c

3919

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

crypto/openssh/channels.c

3926

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

crypto/openssh/channels.c

400

channel_set_used_time(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

4018

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

crypto/openssh/channels.c

402

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

crypto/openssh/channels.c

4025

!(ssh->compat & SSH_BUG_DYNAMIC_RPORT))

crypto/openssh/channels.c

4038

channel_setup_fwd_listener_streamlocal(struct ssh *ssh, int type,

crypto/openssh/channels.c

404

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

crypto/openssh/channels.c

4101

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

crypto/openssh/channels.c

4112

channel_cancel_rport_listener_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4118

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

crypto/openssh/channels.c

4119

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

crypto/openssh/channels.c

412

channel_get_expiry(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

4124

channel_free(ssh, c);

crypto/openssh/channels.c

4133

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

crypto/openssh/channels.c

4138

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

crypto/openssh/channels.c

4139

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

crypto/openssh/channels.c

414

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4146

channel_free(ssh, c);

crypto/openssh/channels.c

4155

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

crypto/openssh/channels.c

4158

return channel_cancel_rport_listener_streamlocal(ssh,

crypto/openssh/channels.c

4161

return channel_cancel_rport_listener_tcpip(ssh,

crypto/openssh/channels.c

4167

channel_cancel_lport_listener_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4173

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

crypto/openssh/channels.c

4175

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

crypto/openssh/channels.c

4176

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

crypto/openssh/channels.c

4194

channel_free(ssh, c);

crypto/openssh/channels.c

4203

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

crypto/openssh/channels.c

4213

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

crypto/openssh/channels.c

4214

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

crypto/openssh/channels.c

4221

channel_free(ssh, c);

crypto/openssh/channels.c

4230

channel_cancel_lport_listener(struct ssh *ssh,

crypto/openssh/channels.c

4234

return channel_cancel_lport_listener_streamlocal(ssh,

crypto/openssh/channels.c

4237

return channel_cancel_lport_listener_tcpip(ssh,

crypto/openssh/channels.c

4244

channel_setup_local_fwd_listener(struct ssh *ssh,

crypto/openssh/channels.c

4248

return channel_setup_fwd_listener_streamlocal(ssh,

crypto/openssh/channels.c

4251

return channel_setup_fwd_listener_tcpip(ssh,

crypto/openssh/channels.c

4285

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

crypto/openssh/channels.c

4287

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

429

channel_has_bulk(struct ssh *ssh)

crypto/openssh/channels.c

431

return ssh->chanctxt != NULL && ssh->chanctxt->nbulk != 0;

crypto/openssh/channels.c

4321

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

crypto/openssh/channels.c

4324

if (!check_rfwd_permission(ssh, fwd)) {

crypto/openssh/channels.c

4325

ssh_packet_send_debug(ssh, "port forwarding refused");

crypto/openssh/channels.c

4331

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/channels.c

4337

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/channels.c

4342

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/channels.c

4346

return channel_setup_fwd_listener_streamlocal(ssh,

crypto/openssh/channels.c

4349

return channel_setup_fwd_listener_tcpip(ssh,

crypto/openssh/channels.c

4377

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

crypto/openssh/channels.c

4385

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

crypto/openssh/channels.c

4386

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4388

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

crypto/openssh/channels.c

4389

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

crypto/openssh/channels.c

439

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

crypto/openssh/channels.c

4390

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

crypto/openssh/channels.c

4391

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

crypto/openssh/channels.c

4394

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

crypto/openssh/channels.c

4395

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

crypto/openssh/channels.c

4396

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

crypto/openssh/channels.c

4397

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4399

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

crypto/openssh/channels.c

4400

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

crypto/openssh/channels.c

4401

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

crypto/openssh/channels.c

4424

idx = permission_set_add(ssh, FORWARD_USER, FORWARD_LOCAL,

crypto/openssh/channels.c

4493

channel_request_rforward_cancel_tcpip(struct ssh *ssh,

crypto/openssh/channels.c

4496

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4512

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

crypto/openssh/channels.c

4513

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

crypto/openssh/channels.c

4514

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

crypto/openssh/channels.c

4515

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

crypto/openssh/channels.c

4516

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

crypto/openssh/channels.c

4517

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

crypto/openssh/channels.c

4530

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

crypto/openssh/channels.c

4532

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4548

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

crypto/openssh/channels.c

4549

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

4551

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

crypto/openssh/channels.c

4552

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

crypto/openssh/channels.c

4553

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

crypto/openssh/channels.c

4565

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

crypto/openssh/channels.c

4568

return channel_request_rforward_cancel_streamlocal(ssh,

crypto/openssh/channels.c

4571

return channel_request_rforward_cancel_tcpip(ssh,

crypto/openssh/channels.c

4583

channel_permit_all(struct ssh *ssh, int where)

crypto/openssh/channels.c

4585

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

crypto/openssh/channels.c

4595

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

crypto/openssh/channels.c

4599

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

crypto/openssh/channels.c

4607

permission_set_add(ssh, who, where,

crypto/openssh/channels.c

4617

channel_disable_admin(struct ssh *ssh, int where)

crypto/openssh/channels.c

4619

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/channels.c

4620

permission_set_add(ssh, FORWARD_ADM, where,

crypto/openssh/channels.c

4628

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

crypto/openssh/channels.c

4633

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

crypto/openssh/channels.c

4647

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

crypto/openssh/channels.c

4649

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

crypto/openssh/channels.c

4665

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

crypto/openssh/channels.c

4747

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

crypto/openssh/channels.c

4782

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

crypto/openssh/channels.c

4812

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

crypto/openssh/channels.c

4820

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

crypto/openssh/channels.c

4826

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

crypto/openssh/channels.c

4840

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

crypto/openssh/channels.c

4843

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4855

return rdynamic_connect_prepare(ssh,

crypto/openssh/channels.c

4857

return connect_to(ssh,

crypto/openssh/channels.c

4868

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

crypto/openssh/channels.c

4871

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4879

return connect_to(ssh,

crypto/openssh/channels.c

4891

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

crypto/openssh/channels.c

4894

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4927

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

crypto/openssh/channels.c

4934

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

crypto/openssh/channels.c

4941

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

crypto/openssh/channels.c

4952

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

crypto/openssh/channels.c

4955

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

4987

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

crypto/openssh/channels.c

4991

channel_send_window_changes(struct ssh *ssh)

crypto/openssh/channels.c

4993

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

500

channel_set_used_time(ssh, NULL);

crypto/openssh/channels.c

5004

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

crypto/openssh/channels.c

5005

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

crypto/openssh/channels.c

5006

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

crypto/openssh/channels.c

5007

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

crypto/openssh/channels.c

5008

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

crypto/openssh/channels.c

5009

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

crypto/openssh/channels.c

501

channel_classify(ssh, c);

crypto/openssh/channels.c

5016

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

crypto/openssh/channels.c

5021

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

crypto/openssh/channels.c

5030

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

crypto/openssh/channels.c

5031

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

crypto/openssh/channels.c

5032

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

crypto/openssh/channels.c

5033

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

crypto/openssh/channels.c

5034

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

crypto/openssh/channels.c

5041

rdynamic_connect_finish(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

5043

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

5066

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

crypto/openssh/channels.c

5074

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

crypto/openssh/channels.c

508

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

crypto/openssh/channels.c

5087

x11_create_display_inet(struct ssh *ssh, int x11_display_offset,

crypto/openssh/channels.c

5106

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

crypto/openssh/channels.c

512

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

5175

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

crypto/openssh/channels.c

5246

x11_connect_display(struct ssh *ssh)

crypto/openssh/channels.c

5329

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

crypto/openssh/channels.c

5370

x11_request_forwarding_with_spoofing(struct ssh *ssh, int client_session_id,

crypto/openssh/channels.c

5373

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

5421

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

crypto/openssh/channels.c

5422

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

crypto/openssh/channels.c

5423

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

crypto/openssh/channels.c

5424

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

crypto/openssh/channels.c

5425

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

crypto/openssh/channels.c

5426

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

crypto/openssh/channels.c

5427

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

crypto/openssh/channels.c

5436

x11_channel_used_recently(struct ssh *ssh) {

crypto/openssh/channels.c

5441

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

crypto/openssh/channels.c

5442

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

crypto/openssh/channels.c

549

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

crypto/openssh/channels.c

559

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

crypto/openssh/channels.c

561

channel_classify(ssh, c);

crypto/openssh/channels.c

568

channel_set_tty(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

571

channel_classify(ssh, c);

crypto/openssh/channels.c

575

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

crypto/openssh/channels.c

625

channel_close_fds(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

629

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

crypto/openssh/channels.c

631

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

crypto/openssh/channels.c

633

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

crypto/openssh/channels.c

635

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

crypto/openssh/channels.c

667

permission_set_get(struct ssh *ssh, int where)

crypto/openssh/channels.c

669

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

685

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

crypto/openssh/channels.c

688

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

crypto/openssh/channels.c

706

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

crypto/openssh/channels.c

714

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

crypto/openssh/channels.c

733

mux_remove_remote_forwardings(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

735

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

749

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

crypto/openssh/channels.c

750

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

752

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

crypto/openssh/channels.c

753

(r = sshpkt_put_cstring(ssh,

crypto/openssh/channels.c

755

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

crypto/openssh/channels.c

756

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

crypto/openssh/channels.c

765

channel_free(struct ssh *ssh, Channel *c)

crypto/openssh/channels.c

767

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

791

mux_remove_remote_forwardings(ssh, c);

crypto/openssh/channels.c

800

s = channel_open_message(ssh);

crypto/openssh/channels.c

805

channel_close_fds(ssh, c);

crypto/openssh/channels.c

820

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

crypto/openssh/channels.c

825

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

crypto/openssh/channels.c

831

channel_free_all(struct ssh *ssh)

crypto/openssh/channels.c

834

struct ssh_channels *sc = ssh->chanctxt;

crypto/openssh/channels.c

838

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

crypto/openssh/channels.c

860

channel_free_channels(struct ssh *ssh)

crypto/openssh/channels.c

864

if (ssh == NULL || ssh->chanctxt == NULL)

crypto/openssh/channels.c

866

channel_free_all(ssh);

crypto/openssh/channels.c

867

channel_clear_permission(ssh, FORWARD_USER, FORWARD_LOCAL);

crypto/openssh/channels.c

868

channel_clear_permission(ssh, FORWARD_USER, FORWARD_REMOTE);

crypto/openssh/channels.c

869

channel_clear_permission(ssh, FORWARD_ADM, FORWARD_LOCAL);

crypto/openssh/channels.c

870

channel_clear_permission(ssh, FORWARD_ADM, FORWARD_REMOTE);

crypto/openssh/channels.c

871

sc = ssh->chanctxt;

crypto/openssh/channels.c

877

ssh->chanctxt = NULL;

crypto/openssh/channels.c

885

channel_close_all(struct ssh *ssh)

crypto/openssh/channels.c

889

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

crypto/openssh/channels.c

890

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

crypto/openssh/channels.c

891

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

crypto/openssh/channels.c

898

channel_stop_listening(struct ssh *ssh)

crypto/openssh/channels.c

903

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

crypto/openssh/channels.c

904

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

crypto/openssh/channels.c

913

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

crypto/openssh/channels.c

914

channel_free(ssh, c);

crypto/openssh/channels.c

926

channel_not_very_much_buffered_data(struct ssh *ssh)

crypto/openssh/channels.c

929

u_int maxsize = ssh_packet_get_maxsize(ssh);

crypto/openssh/channels.c

932

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

crypto/openssh/channels.c

933

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

crypto/openssh/channels.c

94

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

crypto/openssh/channels.c

947

channel_still_open(struct ssh *ssh)

crypto/openssh/channels.c

952

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

crypto/openssh/channels.c

953

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

crypto/openssh/channels.c

990

channel_tty_open(struct ssh *ssh)

crypto/openssh/channels.c

995

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

crypto/openssh/channels.c

996

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

crypto/openssh/channels.h

102

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

crypto/openssh/channels.h

103

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

crypto/openssh/channels.h

120

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

crypto/openssh/channels.h

289

void channel_init_channels(struct ssh *ssh);

crypto/openssh/channels.h

290

void channel_free_channels(struct ssh *ssh);

crypto/openssh/channels.h

294

Channel *channel_by_id(struct ssh *, int);

crypto/openssh/channels.h

295

Channel *channel_by_remote_id(struct ssh *, u_int);

crypto/openssh/channels.h

296

Channel *channel_lookup(struct ssh *, int);

crypto/openssh/channels.h

297

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

crypto/openssh/channels.h

299

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

crypto/openssh/channels.h

301

void channel_set_tty(struct ssh *, Channel *);

crypto/openssh/channels.h

302

void channel_free(struct ssh *, Channel *);

crypto/openssh/channels.h

303

void channel_free_all(struct ssh *);

crypto/openssh/channels.h

304

void channel_stop_listening(struct ssh *);

crypto/openssh/channels.h

305

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

crypto/openssh/channels.h

306

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

crypto/openssh/channels.h

308

void channel_send_open(struct ssh *, int);

crypto/openssh/channels.h

309

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

crypto/openssh/channels.h

310

void channel_register_cleanup(struct ssh *, int,

crypto/openssh/channels.h

312

void channel_register_open_confirm(struct ssh *, int,

crypto/openssh/channels.h

314

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

crypto/openssh/channels.h

316

void channel_register_status_confirm(struct ssh *, int,

crypto/openssh/channels.h

318

void channel_cancel_cleanup(struct ssh *, int);

crypto/openssh/channels.h

319

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

crypto/openssh/channels.h

320

void channel_send_window_changes(struct ssh *);

crypto/openssh/channels.h

321

int channel_has_bulk(struct ssh *);

crypto/openssh/channels.h

324

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

crypto/openssh/channels.h

325

void channel_clear_timeouts(struct ssh *);

crypto/openssh/channels.h

329

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

crypto/openssh/channels.h

330

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

crypto/openssh/channels.h

334

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

crypto/openssh/channels.h

335

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

crypto/openssh/channels.h

336

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

crypto/openssh/channels.h

337

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

crypto/openssh/channels.h

338

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

crypto/openssh/channels.h

339

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

crypto/openssh/channels.h

340

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

crypto/openssh/channels.h

341

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

crypto/openssh/channels.h

347

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

crypto/openssh/channels.h

349

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

crypto/openssh/channels.h

350

int channel_output_poll(struct ssh *);

crypto/openssh/channels.h

352

int channel_not_very_much_buffered_data(struct ssh *);

crypto/openssh/channels.h

353

void channel_close_all(struct ssh *);

crypto/openssh/channels.h

354

int channel_still_open(struct ssh *);

crypto/openssh/channels.h

355

int channel_tty_open(struct ssh *);

crypto/openssh/channels.h

357

char *channel_open_message(struct ssh *);

crypto/openssh/channels.h

358

void channel_report_open(struct ssh *, int);

crypto/openssh/channels.h

359

int channel_find_open(struct ssh *);

crypto/openssh/channels.h

364

void channel_set_af(struct ssh *, int af);

crypto/openssh/channels.h

365

void channel_permit_all(struct ssh *, int);

crypto/openssh/channels.h

366

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

crypto/openssh/channels.h

367

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

crypto/openssh/channels.h

368

void channel_disable_admin(struct ssh *, int);

crypto/openssh/channels.h

369

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

crypto/openssh/channels.h

370

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

crypto/openssh/channels.h

372

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

crypto/openssh/channels.h

373

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

crypto/openssh/channels.h

375

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

crypto/openssh/channels.h

377

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

crypto/openssh/channels.h

379

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

crypto/openssh/channels.h

380

int channel_setup_local_fwd_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

382

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

crypto/openssh/channels.h

383

int channel_setup_remote_fwd_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

385

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

crypto/openssh/channels.h

386

int channel_cancel_lport_listener(struct ssh *, struct Forward *,

crypto/openssh/channels.h

392

void channel_set_x11_refuse_time(struct ssh *, time_t);

crypto/openssh/channels.h

393

int x11_connect_display(struct ssh *);

crypto/openssh/channels.h

394

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

crypto/openssh/channels.h

395

void x11_request_forwarding_with_spoofing(struct ssh *, int,

crypto/openssh/channels.h

397

int x11_channel_used_recently(struct ssh *ssh);

crypto/openssh/channels.h

401

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

crypto/openssh/channels.h

402

void chan_mark_dead(struct ssh *, Channel *);

crypto/openssh/channels.h

405

void client_channel_reqest_agent_forwarding(struct ssh *, int);

crypto/openssh/channels.h

409

void chan_rcvd_oclose(struct ssh *, Channel *);

crypto/openssh/channels.h

410

void chan_rcvd_eow(struct ssh *, Channel *);

crypto/openssh/channels.h

411

void chan_read_failed(struct ssh *, Channel *);

crypto/openssh/channels.h

412

void chan_ibuf_empty(struct ssh *, Channel *);

crypto/openssh/channels.h

413

void chan_rcvd_ieof(struct ssh *, Channel *);

crypto/openssh/channels.h

414

void chan_write_failed(struct ssh *, Channel *);

crypto/openssh/channels.h

415

void chan_obuf_empty(struct ssh *, Channel *);

crypto/openssh/channels.h

90

struct ssh;

crypto/openssh/channels.h

94

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

crypto/openssh/channels.h

95

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

crypto/openssh/channels.h

96

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

crypto/openssh/channels.h

97

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

crypto/openssh/channels.h

98

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

crypto/openssh/clientloop.c

1057

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

crypto/openssh/clientloop.c

1059

ok = channel_cancel_lport_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1062

ok = channel_cancel_lport_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1083

if (!channel_setup_local_fwd_listener(ssh, &fwd,

crypto/openssh/clientloop.c

1089

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

1251

s = connection_info_message(ssh);

crypto/openssh/clientloop.c

1258

if (ssh->compat & SSH_BUG_NOREKEY)

crypto/openssh/clientloop.c

1303

channel_stop_listening(ssh);

crypto/openssh/clientloop.c

1334

s = channel_open_message(ssh);

crypto/openssh/clientloop.c

1349

process_cmdline(ssh);

crypto/openssh/clientloop.c

1402

client_process_buffered_input_packets(struct ssh *ssh)

crypto/openssh/clientloop.c

1404

ssh_dispatch_run_fatal(ssh, DISPATCH_NONBLOCK, &quit_pending);

crypto/openssh/clientloop.c

1423

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

crypto/openssh/clientloop.c

1429

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

crypto/openssh/clientloop.c

1434

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

crypto/openssh/clientloop.c

1439

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

crypto/openssh/clientloop.c

1441

channel_cancel_cleanup(ssh, id);

crypto/openssh/clientloop.c

1453

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

crypto/openssh/clientloop.c

1508

connection_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/clientloop.c

1509

connection_out = ssh_packet_get_connection_out(ssh);

crypto/openssh/clientloop.c

1513

client_init_dispatch(ssh);

crypto/openssh/clientloop.c

1537

channel_register_filter(ssh, session_ident,

crypto/openssh/clientloop.c

1543

channel_register_cleanup(ssh, session_ident,

crypto/openssh/clientloop.c

1565

client_process_buffered_input_packets(ssh);

crypto/openssh/clientloop.c

1567

if (session_closed && !channel_still_open(ssh))

crypto/openssh/clientloop.c

157

static void client_init_dispatch(struct ssh *ssh);

crypto/openssh/clientloop.c

1570

if (ssh_packet_is_rekeying(ssh)) {

crypto/openssh/clientloop.c

1575

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

crypto/openssh/clientloop.c

1583

if (ssh_packet_not_very_much_data_to_write(ssh))

crypto/openssh/clientloop.c

1584

channel_did_enqueue = channel_output_poll(ssh);

crypto/openssh/clientloop.c

1590

client_check_window_change(ssh);

crypto/openssh/clientloop.c

1601

sshpkt_fmt_connection_id(ssh, ident, sizeof(ident));

crypto/openssh/clientloop.c

1608

client_wait_until_can_do_something(ssh, &pfd, &npfd_alloc,

crypto/openssh/clientloop.c

1618

channel_after_poll(ssh, pfd, npfd_active);

crypto/openssh/clientloop.c

1622

client_process_net_input(ssh);

crypto/openssh/clientloop.c

1628

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

crypto/openssh/clientloop.c

1636

if (interactive != !channel_has_bulk(ssh)) {

crypto/openssh/clientloop.c

1637

interactive = !channel_has_bulk(ssh);

crypto/openssh/clientloop.c

1640

ssh_packet_set_interactive(ssh, interactive);

crypto/openssh/clientloop.c

1642

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

crypto/openssh/clientloop.c

1643

sshpkt_fatal(ssh, r,

crypto/openssh/clientloop.c

1675

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

crypto/openssh/clientloop.c

1676

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

crypto/openssh/clientloop.c

1677

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

crypto/openssh/clientloop.c

1678

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

crypto/openssh/clientloop.c

1679

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

crypto/openssh/clientloop.c

1680

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

crypto/openssh/clientloop.c

1683

channel_free_all(ssh);

crypto/openssh/clientloop.c

1706

ssh_packet_get_bytes(ssh, &ibytes, &obytes);

crypto/openssh/clientloop.c

1720

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

crypto/openssh/clientloop.c

1730

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

crypto/openssh/clientloop.c

1731

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

crypto/openssh/clientloop.c

1732

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

crypto/openssh/clientloop.c

1733

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

crypto/openssh/clientloop.c

1734

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

crypto/openssh/clientloop.c

1745

c = channel_connect_by_listen_address(ssh,

crypto/openssh/clientloop.c

1780

client_request_forwarded_streamlocal(struct ssh *ssh,

crypto/openssh/clientloop.c

1788

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

crypto/openssh/clientloop.c

1789

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

crypto/openssh/clientloop.c

1790

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

crypto/openssh/clientloop.c

1795

c = channel_connect_by_listen_path(ssh, listen_path,

crypto/openssh/clientloop.c

1802

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

crypto/openssh/clientloop.c

1820

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

crypto/openssh/clientloop.c

1821

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

crypto/openssh/clientloop.c

1822

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

crypto/openssh/clientloop.c

1829

sock = x11_connect_display(ssh);

crypto/openssh/clientloop.c

1832

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

crypto/openssh/clientloop.c

1840

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

crypto/openssh/clientloop.c

1861

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

crypto/openssh/clientloop.c

1862

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

crypto/openssh/clientloop.c

1867

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

crypto/openssh/clientloop.c

1876

client_request_tun_fwd(struct ssh *ssh, int tun_mode,

crypto/openssh/clientloop.c

1895

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

crypto/openssh/clientloop.c

1901

channel_register_filter(ssh, c->self, sys_tun_infilter,

crypto/openssh/clientloop.c

1906

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

crypto/openssh/clientloop.c

1908

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

crypto/openssh/clientloop.c

1909

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

crypto/openssh/clientloop.c

1910

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

crypto/openssh/clientloop.c

1911

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

crypto/openssh/clientloop.c

1912

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

crypto/openssh/clientloop.c

1913

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

crypto/openssh/clientloop.c

1914

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

crypto/openssh/clientloop.c

1915

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

crypto/openssh/clientloop.c

1916

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

crypto/openssh/clientloop.c

1923

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

crypto/openssh/clientloop.c

1932

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

crypto/openssh/clientloop.c

1933

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

crypto/openssh/clientloop.c

1934

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

crypto/openssh/clientloop.c

1935

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

crypto/openssh/clientloop.c

1942

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

crypto/openssh/clientloop.c

1945

c = client_request_forwarded_streamlocal(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1947

c = client_request_x11(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1950

c = client_request_agent(ssh, ctype, rchan);

crypto/openssh/clientloop.c

1961

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

crypto/openssh/clientloop.c

1962

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

crypto/openssh/clientloop.c

1963

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

crypto/openssh/clientloop.c

1964

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

crypto/openssh/clientloop.c

1965

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

crypto/openssh/clientloop.c

1966

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

crypto/openssh/clientloop.c

1967

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

crypto/openssh/clientloop.c

1971

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

crypto/openssh/clientloop.c

1972

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

crypto/openssh/clientloop.c

1973

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

crypto/openssh/clientloop.c

1974

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

crypto/openssh/clientloop.c

1975

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

crypto/openssh/clientloop.c

1976

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

crypto/openssh/clientloop.c

1977

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

crypto/openssh/clientloop.c

1986

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

crypto/openssh/clientloop.c

1994

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

crypto/openssh/clientloop.c

1997

c = channel_lookup(ssh, id);

crypto/openssh/clientloop.c

1998

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

crypto/openssh/clientloop.c

2000

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

crypto/openssh/clientloop.c

2001

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

crypto/openssh/clientloop.c

2011

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

crypto/openssh/clientloop.c

2013

chan_rcvd_eow(ssh, c);

crypto/openssh/clientloop.c

2015

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

crypto/openssh/clientloop.c

2018

mux_exit_message(ssh, c, exitval);

crypto/openssh/clientloop.c

2029

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

crypto/openssh/clientloop.c

2035

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/clientloop.c

2037

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

crypto/openssh/clientloop.c

2038

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

crypto/openssh/clientloop.c

2039

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

crypto/openssh/clientloop.c

2363

client_global_hostkeys_prove_confirm(struct ssh *ssh, int type,

crypto/openssh/clientloop.c

2384

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

crypto/openssh/clientloop.c

2385

rsa_kexalg = ssh->kex->hostkey_alg;

crypto/openssh/clientloop.c

2402

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

crypto/openssh/clientloop.c

2406

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

crypto/openssh/clientloop.c

243

set_control_persist_exit_time(struct ssh *ssh)

crypto/openssh/clientloop.c

2448

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

crypto/openssh/clientloop.c

2468

client_input_hostkeys(struct ssh *ssh)

crypto/openssh/clientloop.c

2488

while (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/clientloop.c

249

} else if (channel_still_open(ssh)) {

crypto/openssh/clientloop.c

2491

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

crypto/openssh/clientloop.c

2634

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

crypto/openssh/clientloop.c

2635

(r = sshpkt_put_cstring(ssh,

crypto/openssh/clientloop.c

2637

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

crypto/openssh/clientloop.c

2646

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

crypto/openssh/clientloop.c

2649

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

crypto/openssh/clientloop.c

2674

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

crypto/openssh/clientloop.c

2680

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

crypto/openssh/clientloop.c

2681

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

crypto/openssh/clientloop.c

2686

success = client_input_hostkeys(ssh);

crypto/openssh/clientloop.c

2688

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

crypto/openssh/clientloop.c

2690

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

crypto/openssh/clientloop.c

2691

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

crypto/openssh/clientloop.c

2701

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

crypto/openssh/clientloop.c

2706

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

crypto/openssh/clientloop.c

2707

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

crypto/openssh/clientloop.c

2708

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

crypto/openssh/clientloop.c

2709

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

crypto/openssh/clientloop.c

2714

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

crypto/openssh/clientloop.c

2725

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

crypto/openssh/clientloop.c

2735

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

crypto/openssh/clientloop.c

2736

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

crypto/openssh/clientloop.c

2737

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

crypto/openssh/clientloop.c

2739

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

crypto/openssh/clientloop.c

2740

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

crypto/openssh/clientloop.c

2741

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

crypto/openssh/clientloop.c

2742

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

crypto/openssh/clientloop.c

2746

ssh_tty_make_modes(ssh, -1, tiop);

crypto/openssh/clientloop.c

2747

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

crypto/openssh/clientloop.c

2777

client_send_env(ssh, id, name, val);

crypto/openssh/clientloop.c

2789

client_send_env(ssh, id, name, val);

crypto/openssh/clientloop.c

2801

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

crypto/openssh/clientloop.c

2802

client_expect_confirm(ssh, id, "subsystem",

crypto/openssh/clientloop.c

2807

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

crypto/openssh/clientloop.c

2808

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

crypto/openssh/clientloop.c

2811

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

crypto/openssh/clientloop.c

2812

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

crypto/openssh/clientloop.c

2815

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

crypto/openssh/clientloop.c

2816

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

crypto/openssh/clientloop.c

2817

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

crypto/openssh/clientloop.c

2821

channel_set_xtype(ssh, id, type);

crypto/openssh/clientloop.c

2830

client_channel_reqest_agent_forwarding(struct ssh *ssh, int id)

crypto/openssh/clientloop.c

2835

if (ssh->kex != NULL && (ssh->kex->flags & KEX_HAS_NEWAGENT) != 0)

crypto/openssh/clientloop.c

2838

channel_request_start(ssh, id, req, 0);

crypto/openssh/clientloop.c

2839

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

crypto/openssh/clientloop.c

2844

client_init_dispatch(struct ssh *ssh)

crypto/openssh/clientloop.c

2846

ssh_dispatch_init(ssh, &dispatch_protocol_error);

crypto/openssh/clientloop.c

2848

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);

crypto/openssh/clientloop.c

2849

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_DATA, &channel_input_data);

crypto/openssh/clientloop.c

2850

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);

crypto/openssh/clientloop.c

2851

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);

crypto/openssh/clientloop.c

2852

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN, &client_input_channel_open);

crypto/openssh/clientloop.c

2853

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);

crypto/openssh/clientloop.c

2854

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);

crypto/openssh/clientloop.c

2855

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_REQUEST, &client_input_channel_req);

crypto/openssh/clientloop.c

2856

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);

crypto/openssh/clientloop.c

2857

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_SUCCESS, &channel_input_status_confirm);

crypto/openssh/clientloop.c

2858

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_FAILURE, &channel_input_status_confirm);

crypto/openssh/clientloop.c

2859

ssh_dispatch_set(ssh, SSH2_MSG_GLOBAL_REQUEST, &client_input_global_request);

crypto/openssh/clientloop.c

2862

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/clientloop.c

2865

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_FAILURE, &client_global_request_reply);

crypto/openssh/clientloop.c

2866

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_SUCCESS, &client_global_request_reply);

crypto/openssh/clientloop.c

287

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

crypto/openssh/clientloop.c

382

channel_set_x11_refuse_time(ssh,

crypto/openssh/clientloop.c

458

client_check_window_change(struct ssh *ssh)

crypto/openssh/clientloop.c

464

channel_send_window_changes(ssh);

crypto/openssh/clientloop.c

468

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

crypto/openssh/clientloop.c

475

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

crypto/openssh/clientloop.c

481

ssh_packet_set_alive_timeouts(ssh, 0);

crypto/openssh/clientloop.c

493

server_alive_check(struct ssh *ssh)

crypto/openssh/clientloop.c

497

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

crypto/openssh/clientloop.c

501

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

crypto/openssh/clientloop.c

502

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

crypto/openssh/clientloop.c

503

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

crypto/openssh/clientloop.c

504

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

crypto/openssh/clientloop.c

513

send_chaff(struct ssh *ssh)

crypto/openssh/clientloop.c

517

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

crypto/openssh/clientloop.c

525

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

crypto/openssh/clientloop.c

526

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

crypto/openssh/clientloop.c

527

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

crypto/openssh/clientloop.c

574

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

crypto/openssh/clientloop.c

590

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

crypto/openssh/clientloop.c

593

} else if (ssh_packet_is_rekeying(ssh)) {

crypto/openssh/clientloop.c

596

} else if (!ssh_packet_interactive_data_to_write(ssh) &&

crypto/openssh/clientloop.c

597

ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

601

ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

609

!ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

611

if (send_chaff(ssh))

crypto/openssh/clientloop.c

631

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

crypto/openssh/clientloop.c

632

channel_did_enqueue && ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

663

return x11_channel_used_recently(ssh);

crypto/openssh/clientloop.c

682

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

crypto/openssh/clientloop.c

694

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

crypto/openssh/clientloop.c

699

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

crypto/openssh/clientloop.c

700

!ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/clientloop.c

707

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

crypto/openssh/clientloop.c

713

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

crypto/openssh/clientloop.c

721

set_control_persist_exit_time(ssh);

crypto/openssh/clientloop.c

726

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

crypto/openssh/clientloop.c

728

ssh_packet_get_rekey_timeout(ssh));

crypto/openssh/clientloop.c

758

server_alive_check(ssh);

crypto/openssh/clientloop.c

789

client_process_net_input(struct ssh *ssh)

crypto/openssh/clientloop.c

798

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

crypto/openssh/clientloop.c

813

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

crypto/openssh/clientloop.c

867

mux_tty_alloc_failed(ssh, c);

crypto/openssh/clientloop.c

869

chan_read_failed(ssh, c);

crypto/openssh/clientloop.c

870

chan_write_failed(ssh, c);

crypto/openssh/clientloop.c

877

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

crypto/openssh/clientloop.c

883

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

crypto/openssh/clientloop.c

891

channel_register_status_confirm(ssh, id, client_status_confirm,

crypto/openssh/clientloop.c

983

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, uint32_t, void *);

crypto/openssh/clientloop.h

63

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

crypto/openssh/clientloop.h

81

void muxserver_listen(struct ssh *);

crypto/openssh/clientloop.h

83

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

crypto/openssh/clientloop.h

84

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, uint32_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, uint32_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, uint32_t, struct ssh *);

crypto/openssh/dispatch.h

41

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

crypto/openssh/dispatch.h

42

int dispatch_protocol_ignore(int, uint32_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

1024

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

crypto/openssh/kex.c

103

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

crypto/openssh/kex.c

1060

ssh->dispatch_skip_packets = 1;

crypto/openssh/kex.c

1069

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

crypto/openssh/kex.c

1072

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

111

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

crypto/openssh/kex.c

1134

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

crypto/openssh/kex.c

1137

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1155

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

crypto/openssh/kex.c

1173

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

crypto/openssh/kex.c

1175

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1185

kex->hostkey_nid, ssh);

crypto/openssh/kex.c

1187

kex->hostkey_nid, ssh);

crypto/openssh/kex.c

1194

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

crypto/openssh/kex.c

1196

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

1206

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

crypto/openssh/kex.c

1225

send_error(struct ssh *ssh, char *msg)

crypto/openssh/kex.c

1229

if (!ssh->kex->server)

crypto/openssh/kex.c

1232

if (atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1234

atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1245

kex_exchange_identification(struct ssh *ssh, int timeout_ms,

crypto/openssh/kex.c

1252

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

crypto/openssh/kex.c

1253

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

crypto/openssh/kex.c

1254

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

crypto/openssh/kex.c

1255

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

crypto/openssh/kex.c

1272

if (atomicio(vwrite, ssh_packet_get_connection_out(ssh),

crypto/openssh/kex.c

1296

send_error(ssh, "No SSH identification string "

crypto/openssh/kex.c

1307

r = waitrfd(ssh_packet_get_connection_in(ssh),

crypto/openssh/kex.c

1310

send_error(ssh, "Timed out waiting "

crypto/openssh/kex.c

1324

len = atomicio(read, ssh_packet_get_connection_in(ssh),

crypto/openssh/kex.c

1368

if (ssh->kex->server) {

crypto/openssh/kex.c

1396

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

crypto/openssh/kex.c

1402

compat_banner(ssh, remote_version);

crypto/openssh/kex.c

1419

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

crypto/openssh/kex.c

1424

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

crypto/openssh/kex.c

1426

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/kex.c

1431

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

crypto/openssh/kex.c

1433

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/kex.c

232

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

crypto/openssh/kex.c

237

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

crypto/openssh/kex.c

238

ssh_packet_disconnect(ssh, "strict KEX violation: "

crypto/openssh/kex.c

242

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

crypto/openssh/kex.c

243

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

crypto/openssh/kex.c

244

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

crypto/openssh/kex.c

250

kex_reset_dispatch(struct ssh *ssh)

crypto/openssh/kex.c

252

ssh_dispatch_range(ssh, SSH2_MSG_TRANSPORT_MIN,

crypto/openssh/kex.c

257

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

crypto/openssh/kex.c

272

free(ssh->kex->server_sig_algs);

crypto/openssh/kex.c

273

ssh->kex->server_sig_algs = NULL;

crypto/openssh/kex.c

281

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

crypto/openssh/kex.c

282

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

crypto/openssh/kex.c

284

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

crypto/openssh/kex.c

288

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

crypto/openssh/kex.c

289

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

crypto/openssh/kex.c

293

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

crypto/openssh/kex.c

297

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

crypto/openssh/kex.c

298

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

crypto/openssh/kex.c

302

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

crypto/openssh/kex.c

317

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

crypto/openssh/kex.c

334

kex_maybe_send_ext_info(struct ssh *ssh)

crypto/openssh/kex.c

339

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

crypto/openssh/kex.c

341

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

crypto/openssh/kex.c

347

if (ssh->kex->ext_info_c &&

crypto/openssh/kex.c

348

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

crypto/openssh/kex.c

350

if (ssh->kex->ext_info_s &&

crypto/openssh/kex.c

351

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

crypto/openssh/kex.c

356

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

crypto/openssh/kex.c

357

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

crypto/openssh/kex.c

358

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

crypto/openssh/kex.c

371

kex_server_update_ext_info(struct ssh *ssh)

crypto/openssh/kex.c

375

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

crypto/openssh/kex.c

379

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

crypto/openssh/kex.c

380

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

crypto/openssh/kex.c

381

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

crypto/openssh/kex.c

382

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

crypto/openssh/kex.c

383

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

crypto/openssh/kex.c

391

kex_send_newkeys(struct ssh *ssh)

crypto/openssh/kex.c

395

kex_reset_dispatch(ssh);

crypto/openssh/kex.c

396

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

crypto/openssh/kex.c

397

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

crypto/openssh/kex.c

400

ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_input_newkeys);

crypto/openssh/kex.c

401

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

crypto/openssh/kex.c

425

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

crypto/openssh/kex.c

438

free(ssh->kex->server_sig_algs);

crypto/openssh/kex.c

439

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

crypto/openssh/kex.c

440

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

crypto/openssh/kex.c

442

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

crypto/openssh/kex.c

446

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

crypto/openssh/kex.c

448

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

crypto/openssh/kex.c

452

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

crypto/openssh/kex.c

454

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

crypto/openssh/kex.c

465

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

crypto/openssh/kex.c

471

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

crypto/openssh/kex.c

481

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

crypto/openssh/kex.c

483

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

494

return dispatch_protocol_error(type, seq, ssh);

crypto/openssh/kex.c

496

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &kex_protocol_error);

crypto/openssh/kex.c

497

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

crypto/openssh/kex.c

502

return dispatch_protocol_error(type, seq, ssh);

crypto/openssh/kex.c

505

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

crypto/openssh/kex.c

507

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

crypto/openssh/kex.c

513

if ((r = kex_ext_info_server_parse(ssh, name,

crypto/openssh/kex.c

517

if ((r = kex_ext_info_client_parse(ssh, name,

crypto/openssh/kex.c

524

return sshpkt_get_end(ssh);

crypto/openssh/kex.c

528

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

crypto/openssh/kex.c

530

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

536

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, &kex_input_ext_info);

crypto/openssh/kex.c

537

ssh_dispatch_set(ssh, SSH2_MSG_NEWKEYS, &kex_protocol_error);

crypto/openssh/kex.c

538

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/kex.c

539

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

crypto/openssh/kex.c

541

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

crypto/openssh/kex.c

556

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

crypto/openssh/kex.c

574

kex_send_kexinit(struct ssh *ssh)

crypto/openssh/kex.c

577

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

600

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

crypto/openssh/kex.c

601

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

crypto/openssh/kex.c

602

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

crypto/openssh/kex.c

612

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

crypto/openssh/kex.c

614

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

628

ssh_packet_disconnect(ssh,

crypto/openssh/kex.c

632

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_protocol_error);

crypto/openssh/kex.c

633

ptr = sshpkt_ptr(ssh, &dlen);

crypto/openssh/kex.c

639

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

crypto/openssh/kex.c

64

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

crypto/openssh/kex.c

645

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

crypto/openssh/kex.c

65

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

crypto/openssh/kex.c

660

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

crypto/openssh/kex.c

661

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

crypto/openssh/kex.c

662

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

crypto/openssh/kex.c

666

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

crypto/openssh/kex.c

668

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

crypto/openssh/kex.c

672

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

crypto/openssh/kex.c

759

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

crypto/openssh/kex.c

763

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

crypto/openssh/kex.c

765

ssh->kex->flags = KEX_INITIAL;

crypto/openssh/kex.c

766

kex_reset_dispatch(ssh);

crypto/openssh/kex.c

767

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/kex.c

772

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

crypto/openssh/kex.c

776

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

crypto/openssh/kex.c

778

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

crypto/openssh/kex.c

779

kex_free(ssh->kex);

crypto/openssh/kex.c

780

ssh->kex = NULL;

crypto/openssh/kex.c

791

kex_start_rekex(struct ssh *ssh)

crypto/openssh/kex.c

793

if (ssh->kex == NULL) {

crypto/openssh/kex.c

797

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

crypto/openssh/kex.c

801

ssh->kex->done = 0;

crypto/openssh/kex.c

802

return kex_send_kexinit(ssh);

crypto/openssh/kex.c

828

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

crypto/openssh/kex.c

87

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

crypto/openssh/kex.c

93

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

crypto/openssh/kex.c

936

kex_choose_conf(struct ssh *ssh, uint32_t seq)

crypto/openssh/kex.c

938

struct kex *kex = ssh->kex;

crypto/openssh/kex.c

975

ssh_packet_disconnect(ssh,

crypto/openssh/kex.h

145

struct ssh;

crypto/openssh/kex.h

175

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

crypto/openssh/kex.h

176

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

crypto/openssh/kex.h

177

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

crypto/openssh/kex.h

178

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

crypto/openssh/kex.h

179

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

crypto/openssh/kex.h

181

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

crypto/openssh/kex.h

204

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

crypto/openssh/kex.h

208

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

crypto/openssh/kex.h

211

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

crypto/openssh/kex.h

212

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

crypto/openssh/kex.h

219

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

crypto/openssh/kex.h

220

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

crypto/openssh/kex.h

222

int kex_send_kexinit(struct ssh *);

crypto/openssh/kex.h

223

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

crypto/openssh/kex.h

224

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

crypto/openssh/kex.h

225

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

crypto/openssh/kex.h

226

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

crypto/openssh/kex.h

227

int kex_send_newkeys(struct ssh *);

crypto/openssh/kex.h

228

int kex_start_rekex(struct ssh *);

crypto/openssh/kex.h

229

int kex_server_update_ext_info(struct ssh *);

crypto/openssh/kex.h

230

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

crypto/openssh/kex.h

232

int kexgex_client(struct ssh *);

crypto/openssh/kex.h

233

int kexgex_server(struct ssh *);

crypto/openssh/kex.h

234

int kex_gen_client(struct ssh *);

crypto/openssh/kex.h

235

int kex_gen_server(struct ssh *);

crypto/openssh/kexgen.c

101

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

132

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

crypto/openssh/kexgen.c

133

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

crypto/openssh/kexgen.c

134

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

crypto/openssh/kexgen.c

137

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &input_kex_gen_reply);

crypto/openssh/kexgen.c

142

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

crypto/openssh/kexgen.c

144

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

155

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_REPLY, &kex_protocol_error);

crypto/openssh/kexgen.c

158

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

crypto/openssh/kexgen.c

167

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

crypto/openssh/kexgen.c

172

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

crypto/openssh/kexgen.c

173

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

crypto/openssh/kexgen.c

174

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

crypto/openssh/kexgen.c

225

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

crypto/openssh/kexgen.c

228

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

crypto/openssh/kexgen.c

229

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

crypto/openssh/kexgen.c

267

kex_gen_server(struct ssh *ssh)

crypto/openssh/kexgen.c

270

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_INIT, &input_kex_gen_init);

crypto/openssh/kexgen.c

275

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

crypto/openssh/kexgen.c

277

struct kex *kex = ssh->kex;

crypto/openssh/kexgen.c

288

ssh_dispatch_set(ssh, SSH2_MSG_KEX_ECDH_INIT, &kex_protocol_error);

crypto/openssh/kexgen.c

290

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

crypto/openssh/kexgen.c

294

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

crypto/openssh/kexgen.c

295

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

crypto/openssh/kexgen.c

355

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

crypto/openssh/kexgen.c

360

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

crypto/openssh/kexgen.c

361

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

crypto/openssh/kexgen.c

362

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

crypto/openssh/kexgen.c

363

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

crypto/openssh/kexgen.c

364

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

crypto/openssh/kexgen.c

367

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

crypto/openssh/kexgen.c

368

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

crypto/openssh/kexgen.c

44

static int input_kex_gen_init(int, uint32_t, struct ssh *);

crypto/openssh/kexgen.c

45

static int input_kex_gen_reply(int type, uint32_t seq, struct ssh *ssh);

crypto/openssh/kexgen.c

99

kex_gen_client(struct ssh *ssh)

crypto/openssh/kexgexc.c

102

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP, &kex_protocol_error);

crypto/openssh/kexgexc.c

104

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

crypto/openssh/kexgexc.c

105

(r = sshpkt_get_bignum2(ssh, &g)) != 0 ||

crypto/openssh/kexgexc.c

106

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

crypto/openssh/kexgexc.c

123

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

crypto/openssh/kexgexc.c

124

(r = sshpkt_put_bignum2(ssh, pub_key)) != 0 ||

crypto/openssh/kexgexc.c

125

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

crypto/openssh/kexgexc.c

135

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REPLY, &input_kex_dh_gex_reply);

crypto/openssh/kexgexc.c

144

input_kex_dh_gex_reply(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/kexgexc.c

146

struct kex *kex = ssh->kex;

crypto/openssh/kexgexc.c

158

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REPLY, &kex_protocol_error);

crypto/openssh/kexgexc.c

161

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

crypto/openssh/kexgexc.c

169

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

crypto/openssh/kexgexc.c

172

if ((r = sshpkt_get_bignum2(ssh, &dh_server_pub)) != 0 ||

crypto/openssh/kexgexc.c

173

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

crypto/openssh/kexgexc.c

174

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

crypto/openssh/kexgexc.c

182

if (ssh->compat & SSH_OLD_DHGEX)

crypto/openssh/kexgexc.c

205

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

crypto/openssh/kexgexc.c

208

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

crypto/openssh/kexgexc.c

209

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

crypto/openssh/kexgexc.c

55

static int input_kex_dh_gex_group(int, uint32_t, struct ssh *);

crypto/openssh/kexgexc.c

56

static int input_kex_dh_gex_reply(int, uint32_t, struct ssh *);

crypto/openssh/kexgexc.c

59

kexgex_client(struct ssh *ssh)

crypto/openssh/kexgexc.c

61

struct kex *kex = ssh->kex;

crypto/openssh/kexgexc.c

70

if (ssh->compat & SSH_BUG_DHGEX_LARGE)

crypto/openssh/kexgexc.c

73

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

crypto/openssh/kexgexc.c

74

(r = sshpkt_put_u32(ssh, kex->min)) != 0 ||

crypto/openssh/kexgexc.c

75

(r = sshpkt_put_u32(ssh, kex->nbits)) != 0 ||

crypto/openssh/kexgexc.c

76

(r = sshpkt_put_u32(ssh, kex->max)) != 0 ||

crypto/openssh/kexgexc.c

77

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

crypto/openssh/kexgexc.c

86

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_GROUP,

crypto/openssh/kexgexc.c

94

input_kex_dh_gex_group(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/kexgexc.c

96

struct kex *kex = ssh->kex;

crypto/openssh/kexgexs.c

102

(void)sshpkt_disconnect(ssh, "no matching DH grp found");

crypto/openssh/kexgexs.c

108

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

crypto/openssh/kexgexs.c

109

(r = sshpkt_put_bignum2(ssh, dh_p)) != 0 ||

crypto/openssh/kexgexs.c

110

(r = sshpkt_put_bignum2(ssh, dh_g)) != 0 ||

crypto/openssh/kexgexs.c

111

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

crypto/openssh/kexgexs.c

119

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_INIT, &input_kex_dh_gex_init);

crypto/openssh/kexgexs.c

126

input_kex_dh_gex_init(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/kexgexs.c

128

struct kex *kex = ssh->kex;

crypto/openssh/kexgexs.c

140

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_INIT, &kex_protocol_error);

crypto/openssh/kexgexs.c

142

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

crypto/openssh/kexgexs.c

147

if ((r = sshpkt_get_bignum2(ssh, &dh_client_pub)) != 0 ||

crypto/openssh/kexgexs.c

148

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

crypto/openssh/kexgexs.c

183

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

crypto/openssh/kexgexs.c

188

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

crypto/openssh/kexgexs.c

189

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

crypto/openssh/kexgexs.c

190

(r = sshpkt_put_bignum2(ssh, pub_key)) != 0 || /* f */

crypto/openssh/kexgexs.c

191

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

crypto/openssh/kexgexs.c

192

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

crypto/openssh/kexgexs.c

195

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

crypto/openssh/kexgexs.c

196

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

crypto/openssh/kexgexs.c

57

static int input_kex_dh_gex_request(int, uint32_t, struct ssh *);

crypto/openssh/kexgexs.c

58

static int input_kex_dh_gex_init(int, uint32_t, struct ssh *);

crypto/openssh/kexgexs.c

61

kexgex_server(struct ssh *ssh)

crypto/openssh/kexgexs.c

63

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST,

crypto/openssh/kexgexs.c

70

input_kex_dh_gex_request(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/kexgexs.c

72

struct kex *kex = ssh->kex;

crypto/openssh/kexgexs.c

78

ssh_dispatch_set(ssh, SSH2_MSG_KEX_DH_GEX_REQUEST, &kex_protocol_error);

crypto/openssh/kexgexs.c

80

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

crypto/openssh/kexgexs.c

81

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

crypto/openssh/kexgexs.c

82

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

crypto/openssh/kexgexs.c

83

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

crypto/openssh/loginrec.c

1708

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

crypto/openssh/loginrec.c

1745

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/loginrec.c

1746

(void)getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/loginrec.h

135

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

crypto/openssh/loginrec.h

34

struct ssh;

crypto/openssh/monitor.c

1008

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

crypto/openssh/monitor.c

1021

auth_password(ssh, passwd);

crypto/openssh/monitor.c

1047

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

crypto/openssh/monitor.c

1081

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

crypto/openssh/monitor.c

110

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

crypto/openssh/monitor.c

111

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

crypto/openssh/monitor.c

1115

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

crypto/openssh/monitor.c

112

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

crypto/openssh/monitor.c

1120

start_pam(ssh);

crypto/openssh/monitor.c

113

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

crypto/openssh/monitor.c

1130

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

crypto/openssh/monitor.c

114

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

crypto/openssh/monitor.c

115

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

crypto/openssh/monitor.c

1154

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

crypto/openssh/monitor.c

116

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

crypto/openssh/monitor.c

117

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

crypto/openssh/monitor.c

1179

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

crypto/openssh/monitor.c

118

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

crypto/openssh/monitor.c

119

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

crypto/openssh/monitor.c

120

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

crypto/openssh/monitor.c

121

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

crypto/openssh/monitor.c

122

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

crypto/openssh/monitor.c

1220

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

crypto/openssh/monitor.c

123

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

crypto/openssh/monitor.c

124

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

crypto/openssh/monitor.c

1262

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

crypto/openssh/monitor.c

127

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

crypto/openssh/monitor.c

128

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

crypto/openssh/monitor.c

1282

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

crypto/openssh/monitor.c

129

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

crypto/openssh/monitor.c

130

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

crypto/openssh/monitor.c

131

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

crypto/openssh/monitor.c

1310

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

crypto/openssh/monitor.c

132

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

crypto/openssh/monitor.c

1322

allowed = hostbased_key_allowed(ssh, authctxt->pw,

crypto/openssh/monitor.c

1354

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

crypto/openssh/monitor.c

136

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

crypto/openssh/monitor.c

137

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

crypto/openssh/monitor.c

1374

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

crypto/openssh/monitor.c

138

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

crypto/openssh/monitor.c

1387

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/monitor.c

139

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

crypto/openssh/monitor.c

143

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

crypto/openssh/monitor.c

144

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

crypto/openssh/monitor.c

1447

if (get_hostkey_index(hostkey, 1, ssh) == -1)

crypto/openssh/monitor.c

1524

mm_answer_keyverify(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1556

valid_data = monitor_valid_userblob(ssh, data, datalen);

crypto/openssh/monitor.c

1578

sigalg, ssh->compat, &sig_details);

crypto/openssh/monitor.c

1595

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

1596

ssh_remote_port(ssh));

crypto/openssh/monitor.c

1607

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

1608

ssh_remote_port(ssh));

crypto/openssh/monitor.c

1615

auth_activate_options(ssh, key_opts);

crypto/openssh/monitor.c

1641

mm_record_login(struct ssh *ssh, Session *s, struct passwd *pw)

crypto/openssh/monitor.c

1652

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/monitor.c

1653

if (getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/monitor.c

1661

session_get_remote_name_or_ip(ssh, utmp_len, options.use_dns),

crypto/openssh/monitor.c

1677

mm_answer_pty(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

168

int (*f)(struct ssh *, int, struct sshbuf *);

crypto/openssh/monitor.c

1705

mm_record_login(ssh, s, authctxt->pw);

crypto/openssh/monitor.c

1747

mm_answer_pty_cleanup(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

1765

mm_answer_term(struct ssh *ssh, int sock, struct sshbuf *req)

crypto/openssh/monitor.c

1773

session_destroy_all(ssh, &mm_session_close);

crypto/openssh/monitor.c

1793

mm_answer_audit_event(struct ssh *ssh, int socket, struct sshbuf *m)

crypto/openssh/monitor.c

180

static int monitor_read(struct ssh *, struct monitor *, struct mon_table *,

crypto/openssh/monitor.c

1812

audit_event(ssh, event);

crypto/openssh/monitor.c

1822

mm_answer_audit_command(struct ssh *ssh, int socket, struct sshbuf *m)

crypto/openssh/monitor.c

1838

monitor_clear_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1840

ssh_clear_newkeys(ssh, MODE_IN);

crypto/openssh/monitor.c

1841

ssh_clear_newkeys(ssh, MODE_OUT);

crypto/openssh/monitor.c

1847

monitor_apply_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1853

if ((r = ssh_packet_set_state(ssh, child_state)) != 0)

crypto/openssh/monitor.c

1857

if ((kex = ssh->kex) == NULL)

crypto/openssh/monitor.c

1859

if (session_id2_len != sshbuf_len(ssh->kex->session_id)) {

crypto/openssh/monitor.c

1861

sshbuf_len(ssh->kex->session_id), session_id2_len);

crypto/openssh/monitor.c

1863

if (memcmp(sshbuf_ptr(ssh->kex->session_id), session_id2,

crypto/openssh/monitor.c

1891

mm_get_keystate(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

1968

mm_answer_gss_setup_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

2001

mm_answer_gss_accept_ctx(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

2035

mm_answer_gss_checkmic(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

2066

mm_answer_gss_userok(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

268

monitor_child_preauth(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

281

authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/monitor.c

283

ssh->authctxt = authctxt;

crypto/openssh/monitor.c

301

authenticated = (monitor_read(ssh, pmonitor,

crypto/openssh/monitor.c

324

!auth_root_allowed(ssh, auth_method))

crypto/openssh/monitor.c

337

ssh, pmonitor->m_sendfd, m);

crypto/openssh/monitor.c

343

auth_log(ssh, authenticated, partial,

crypto/openssh/monitor.c

353

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL,

crypto/openssh/monitor.c

362

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL,

crypto/openssh/monitor.c

367

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL,

crypto/openssh/monitor.c

374

ssh->authctxt = NULL;

crypto/openssh/monitor.c

375

ssh_packet_set_log_preamble(ssh, "user %s", authctxt->user);

crypto/openssh/monitor.c

377

mm_get_keystate(ssh, pmonitor);

crypto/openssh/monitor.c

421

monitor_child_postauth(struct ssh *ssh, struct monitor *pmonitor)

crypto/openssh/monitor.c

448

monitor_read(ssh, pmonitor, mon_dispatch, NULL);

crypto/openssh/monitor.c

505

monitor_read(struct ssh *ssh, struct monitor *pmonitor, struct mon_table *ent,

crypto/openssh/monitor.c

554

ret = (*ent->f)(ssh, pmonitor->m_sendfd, m);

crypto/openssh/monitor.c

603

mm_answer_state(struct ssh *ssh, int sock, struct sshbuf *unused)

crypto/openssh/monitor.c

641

(r = sshbuf_put_stringb(m, ssh->kex->server_version)) != 0 ||

crypto/openssh/monitor.c

642

(r = sshbuf_put_stringb(m, ssh->kex->client_version)) != 0)

crypto/openssh/monitor.c

665

mm_answer_moduli(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

704

mm_answer_setcompat(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

710

if ((r = sshbuf_get_u32(m, &ssh->compat)) != 0)

crypto/openssh/monitor.c

718

mm_answer_sign(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

742

if ((keyid = get_hostkey_index(pubkey, 1, ssh)) == -1)

crypto/openssh/monitor.c

765

if ((key = get_hostkey_public_by_index(keyid, ssh)) == NULL)

crypto/openssh/monitor.c

793

} else if ((key = get_hostkey_public_by_index(keyid, ssh)) != NULL &&

crypto/openssh/monitor.c

844

mm_answer_pwnamallow(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

861

pwent = getpwnamallow(ssh, authctxt->user);

crypto/openssh/monitor.c

903

ssh_packet_set_log_preamble(ssh, "%suser %s",

crypto/openssh/monitor.c

910

authctxt->user, ssh_remote_ipaddr(ssh),

crypto/openssh/monitor.c

911

ssh_remote_port(ssh));

crypto/openssh/monitor.c

943

int mm_answer_auth2_read_banner(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.c

959

mm_answer_authserv(struct ssh *ssh, int sock, struct sshbuf *m)

crypto/openssh/monitor.h

70

struct ssh;

crypto/openssh/monitor.h

86

void monitor_child_preauth(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

87

void monitor_child_postauth(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

89

void monitor_clear_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

90

void monitor_apply_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor.h

99

void mm_get_keystate(struct ssh *, struct monitor *);

crypto/openssh/monitor_wrap.c

1118

server_process_permitopen_list(struct ssh *ssh, int listen,

crypto/openssh/monitor_wrap.c

1127

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/monitor_wrap.c

1135

channel_disable_admin(ssh, where);

crypto/openssh/monitor_wrap.c

1148

channel_add_permission(ssh, FORWARD_ADM,

crypto/openssh/monitor_wrap.c

1158

server_process_permitopen(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

1160

server_process_permitopen_list(ssh, 0,

crypto/openssh/monitor_wrap.c

1162

server_process_permitopen_list(ssh, 1,

crypto/openssh/monitor_wrap.c

1167

server_process_channel_timeouts(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

1173

channel_clear_timeouts(ssh);

crypto/openssh/monitor_wrap.c

1180

channel_add_timeout(ssh, type, secs);

crypto/openssh/monitor_wrap.c

1186

server_get_connection_info(struct ssh *ssh, int populate, int use_dns)

crypto/openssh/monitor_wrap.c

1190

if (ssh == NULL || !populate)

crypto/openssh/monitor_wrap.c

1192

ci.host = use_dns ? ssh_remote_hostname(ssh) : ssh_remote_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1193

ci.address = ssh_remote_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1194

ci.laddress = ssh_local_ipaddr(ssh);

crypto/openssh/monitor_wrap.c

1195

ci.lport = ssh_local_port(ssh);

crypto/openssh/monitor_wrap.c

1196

ci.rdomain = ssh_packet_rdomain_in(ssh);

crypto/openssh/monitor_wrap.c

258

mm_sshkey_setcompat(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

266

if ((r = sshbuf_put_u32(m, ssh->compat)) != 0)

crypto/openssh/monitor_wrap.c

273

mm_sshkey_sign(struct ssh *ssh, struct sshkey *key, u_char **sigp, size_t *lenp,

crypto/openssh/monitor_wrap.c

303

mm_decode_activate_server_options(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/monitor_wrap.c

331

mm_getpwnamallow(struct ssh *ssh, const char *username)

crypto/openssh/monitor_wrap.c

383

mm_decode_activate_server_options(ssh, m);

crypto/openssh/monitor_wrap.c

384

server_process_permitopen(ssh);

crypto/openssh/monitor_wrap.c

385

server_process_channel_timeouts(ssh);

crypto/openssh/monitor_wrap.c

386

kex_set_server_sig_algs(ssh, options.pubkey_accepted_algos);

crypto/openssh/monitor_wrap.c

443

mm_auth_password(struct ssh *ssh, char *password)

crypto/openssh/monitor_wrap.c

480

mm_user_key_allowed(struct ssh *ssh, struct passwd *pw, struct sshkey *key,

crypto/openssh/monitor_wrap.c

488

mm_hostbased_key_allowed(struct ssh *ssh, struct passwd *pw,

crypto/openssh/monitor_wrap.c

595

mm_send_keystate(struct ssh *ssh, struct monitor *monitor)

crypto/openssh/monitor_wrap.c

602

if ((r = ssh_packet_get_state(ssh, m)) != 0)

crypto/openssh/monitor_wrap.c

687

mm_start_pam(struct ssh *ssh)

crypto/openssh/monitor_wrap.c

853

mm_get_state(struct ssh *ssh,

crypto/openssh/monitor_wrap.c

877

(r = sshbuf_get_stringb(m, ssh->kex->server_version)) != 0 ||

crypto/openssh/monitor_wrap.c

878

(r = sshbuf_get_stringb(m, ssh->kex->client_version)) != 0)

crypto/openssh/monitor_wrap.c

977

mm_audit_event(struct ssh *ssh, ssh_audit_event_t event)

crypto/openssh/monitor_wrap.h

100

void mm_get_state(struct ssh *, struct ServerOptions *,

crypto/openssh/monitor_wrap.h

109

void server_process_permitopen(struct ssh *);

crypto/openssh/monitor_wrap.h

110

void server_process_channel_timeouts(struct ssh *ssh);

crypto/openssh/monitor_wrap.h

112

server_get_connection_info(struct ssh *, int, int);

crypto/openssh/monitor_wrap.h

37

struct ssh;

crypto/openssh/monitor_wrap.h

49

void mm_sshkey_setcompat(struct ssh *);

crypto/openssh/monitor_wrap.h

50

int mm_sshkey_sign(struct ssh *, struct sshkey *, u_char **, size_t *,

crypto/openssh/monitor_wrap.h

54

struct passwd *mm_getpwnamallow(struct ssh *, const char *);

crypto/openssh/monitor_wrap.h

56

int mm_auth_password(struct ssh *, char *);

crypto/openssh/monitor_wrap.h

59

int mm_user_key_allowed(struct ssh *ssh, struct passwd *, struct sshkey *, int,

crypto/openssh/monitor_wrap.h

61

int mm_hostbased_key_allowed(struct ssh *, struct passwd *, const char *,

crypto/openssh/monitor_wrap.h

66

void mm_decode_activate_server_options(struct ssh *ssh, struct sshbuf *m);

crypto/openssh/monitor_wrap.h

77

void mm_start_pam(struct ssh *ssh);

crypto/openssh/monitor_wrap.h

87

void mm_audit_event(struct ssh *, ssh_audit_event_t);

crypto/openssh/monitor_wrap.h

96

void mm_send_keystate(struct ssh *, struct monitor*);

crypto/openssh/mux.c

1068

nc = channel_connect_stdio_fwd(ssh, chost, cport, new_fd[0], new_fd[1],

crypto/openssh/mux.c

1078

channel_register_cleanup(ssh, nc->self,

crypto/openssh/mux.c

1083

channel_register_open_confirm(ssh, nc->self, mux_stdio_confirm, cctx);

crypto/openssh/mux.c

1092

mux_stdio_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/mux.c

1101

if ((c = channel_by_id(ssh, id)) == NULL)

crypto/openssh/mux.c

1103

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1138

mux_master_process_stop_listening(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

1155

channel_free(ssh, mux_listener_channel);

crypto/openssh/mux.c

1168

mux_master_process_proxy(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

1195

mux_master_read_cb(struct ssh *ssh, Channel *c)

crypto/openssh/mux.c

1209

channel_register_cleanup(ssh, c->self,

crypto/openssh/mux.c

1253

ret = mux_master_handlers[i].handler(ssh, rid,

crypto/openssh/mux.c

1274

mux_exit_message(struct ssh *ssh, Channel *c, int exitval)

crypto/openssh/mux.c

1282

if ((mux_chan = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1297

mux_tty_alloc_failed(struct ssh *ssh, Channel *c)

crypto/openssh/mux.c

1305

if ((mux_chan = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

1320

muxserver_listen(struct ssh *ssh)

crypto/openssh/mux.c

138

static void mux_session_confirm(struct ssh *, int, int, void *);

crypto/openssh/mux.c

139

static void mux_stdio_confirm(struct ssh *, int, int, void *);

crypto/openssh/mux.c

1393

mux_listener_channel = channel_new(ssh, "mux listener",

crypto/openssh/mux.c

1404

mux_session_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/mux.c

141

static int mux_master_process_hello(struct ssh *, u_int,

crypto/openssh/mux.c

1414

if ((c = channel_by_id(ssh, id)) == NULL)

crypto/openssh/mux.c

1416

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

143

static int mux_master_process_new_session(struct ssh *, u_int,

crypto/openssh/mux.c

1434

if (client_x11_get_proto(ssh, display, options.xauth_location,

crypto/openssh/mux.c

1440

x11_request_forwarding_with_spoofing(ssh, id,

crypto/openssh/mux.c

1443

client_expect_confirm(ssh, id, "X11 forwarding",

crypto/openssh/mux.c

1449

client_channel_reqest_agent_forwarding(ssh, id);

crypto/openssh/mux.c

145

static int mux_master_process_alive_check(struct ssh *, u_int,

crypto/openssh/mux.c

1451

client_session2_setup(ssh, id, cctx->want_tty, cctx->want_subsys,

crypto/openssh/mux.c

147

static int mux_master_process_terminate(struct ssh *, u_int,

crypto/openssh/mux.c

149

static int mux_master_process_open_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

151

static int mux_master_process_close_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

153

static int mux_master_process_stdio_fwd(struct ssh *, u_int,

crypto/openssh/mux.c

155

static int mux_master_process_stop_listening(struct ssh *, u_int,

crypto/openssh/mux.c

157

static int mux_master_process_proxy(struct ssh *, u_int,

crypto/openssh/mux.c

159

static int mux_master_process_ext_info(struct ssh *, u_int,

crypto/openssh/mux.c

164

int (*handler)(struct ssh *, u_int, Channel *,

crypto/openssh/mux.c

182

mux_master_session_cleanup_cb(struct ssh *ssh, int cid, int force, void *unused)

crypto/openssh/mux.c

184

Channel *cc, *c = channel_by_id(ssh, cid);

crypto/openssh/mux.c

190

if ((cc = channel_by_id(ssh, c->ctl_chan)) == NULL)

crypto/openssh/mux.c

196

chan_rcvd_oclose(ssh, cc);

crypto/openssh/mux.c

198

channel_cancel_cleanup(ssh, c->self);

crypto/openssh/mux.c

203

mux_master_control_cleanup_cb(struct ssh *ssh, int cid, int force, void *unused)

crypto/openssh/mux.c

205

Channel *sc, *c = channel_by_id(ssh, cid);

crypto/openssh/mux.c

211

if ((sc = channel_by_id(ssh, c->ctl_child_id)) == NULL)

crypto/openssh/mux.c

220

chan_mark_dead(ssh, sc);

crypto/openssh/mux.c

223

chan_read_failed(ssh, sc);

crypto/openssh/mux.c

225

chan_write_failed(ssh, sc);

crypto/openssh/mux.c

228

channel_cancel_cleanup(ssh, c->self);

crypto/openssh/mux.c

257

mux_master_process_hello(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

328

mux_master_process_new_session(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

456

nc = channel_new(ssh, "session", SSH_CHANNEL_OPENING,

crypto/openssh/mux.c

460

channel_set_tty(ssh, nc);

crypto/openssh/mux.c

467

channel_register_filter(ssh, nc->self,

crypto/openssh/mux.c

476

channel_send_open(ssh, nc->self);

crypto/openssh/mux.c

477

channel_register_open_confirm(ssh, nc->self, mux_session_confirm, cctx);

crypto/openssh/mux.c

479

channel_register_cleanup(ssh, nc->self,

crypto/openssh/mux.c

487

mux_master_process_alive_check(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

505

mux_master_process_ext_info(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

518

if ((msg = connection_info_message(ssh)) == NULL)

crypto/openssh/mux.c

522

if ((msg = channel_open_message(ssh)) == NULL)

crypto/openssh/mux.c

541

mux_master_process_terminate(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

629

mux_confirm_remote_forward(struct ssh *ssh, int type, uint32_t seq, void *ctxt)

crypto/openssh/mux.c

639

if ((c = channel_by_id(ssh, fctx->cid)) == NULL) {

crypto/openssh/mux.c

659

if ((r = sshpkt_get_u32(ssh, &port)) != 0)

crypto/openssh/mux.c

676

channel_update_permission(ssh, rfwd->handle,

crypto/openssh/mux.c

684

channel_update_permission(ssh, rfwd->handle, -1);

crypto/openssh/mux.c

718

mux_master_process_open_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

842

if (!channel_setup_local_fwd_listener(ssh, &fwd,

crypto/openssh/mux.c

855

fwd.handle = channel_request_remote_forwarding(ssh, &fwd);

crypto/openssh/mux.c

883

mux_master_process_close_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/mux.c

965

if (channel_request_rforward_cancel(ssh, found_fwd) == -1)

crypto/openssh/mux.c

969

if (channel_cancel_lport_listener(ssh, &fwd, fwd.connect_port,

crypto/openssh/mux.c

995

mux_master_process_stdio_fwd(struct ssh *ssh, u_int rid,

crypto/openssh/nchan.c

111

chan_read_failed(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

116

chan_shutdown_read(ssh, c);

crypto/openssh/nchan.c

127

chan_ibuf_empty(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

138

chan_send_eof2(ssh, c);

crypto/openssh/nchan.c

149

chan_obuf_empty(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

159

chan_shutdown_write(ssh, c);

crypto/openssh/nchan.c

170

chan_rcvd_eow(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

175

chan_shutdown_read(ssh, c);

crypto/openssh/nchan.c

182

chan_send_eof2(struct ssh *ssh, Channel *c)

crypto/openssh/nchan.c

191

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_EOF)) != 0 ||

crypto/openssh/nchan.c

192

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/nchan.c

193

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/nchan.c

205

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

75

static void chan_send_eof2(struct ssh *, Channel *);

crypto/openssh/nchan.c

76

static void chan_send_eow2(struct ssh *, Channel *);

crypto/openssh/nchan.c

79

static void chan_shutdown_write(struct ssh *, Channel *);

crypto/openssh/nchan.c

80

static void chan_shutdown_read(struct ssh *, Channel *);

crypto/openssh/nchan.c

81

static void chan_shutdown_extended_read(struct ssh *, Channel *);

crypto/openssh/openbsd-compat/port-aix.c

176

sys_auth_passwd(struct ssh *ssh, const char *password)

crypto/openssh/openbsd-compat/port-aix.c

178

Authctxt *ctxt = ssh->authctxt;

crypto/openssh/openbsd-compat/port-aix.c

316

record_failed_login(struct ssh *ssh, const char *user, const char *hostname,

crypto/openssh/openbsd-compat/port-aix.h

33

struct ssh;

crypto/openssh/openbsd-compat/port-net.c

309

sys_tun_infilter(struct ssh *ssh, struct Channel *c, char *buf, int _len)

crypto/openssh/openbsd-compat/port-net.c

353

sys_tun_outfilter(struct ssh *ssh, struct Channel *c,

crypto/openssh/openbsd-compat/port-net.h

21

struct ssh;

crypto/openssh/openbsd-compat/port-net.h

30

int sys_tun_infilter(struct ssh *, struct Channel *, char *, int);

crypto/openssh/openbsd-compat/port-net.h

31

u_char *sys_tun_outfilter(struct ssh *, struct Channel *, u_char **, size_t *);

crypto/openssh/openbsd-compat/port-uw.c

53

sys_auth_passwd(struct ssh *ssh, const char *password)

crypto/openssh/openbsd-compat/port-uw.c

55

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/packet.c

1017

if ((state->newkeys[mode] = ssh->kex->newkeys[mode]) == NULL)

crypto/openssh/packet.c

1019

ssh->kex->newkeys[mode] = NULL;

crypto/openssh/packet.c

1045

if ((r = ssh_packet_init_compression(ssh)) < 0)

crypto/openssh/packet.c

1048

if ((r = start_compression_out(ssh, 6)) != 0)

crypto/openssh/packet.c

1051

if ((r = start_compression_in(ssh)) != 0)

crypto/openssh/packet.c

1083

ssh_packet_check_rekey_blocklimit(struct ssh *ssh, u_int packet_len, int hard)

crypto/openssh/packet.c

1085

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1113

ssh_packet_need_rekeying(struct ssh *ssh, u_int outbound_packet_len)

crypto/openssh/packet.c

1115

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1122

if (ssh_packet_is_rekeying(ssh))

crypto/openssh/packet.c

1137

return ssh_packet_check_rekey_blocklimit(ssh, outbound_packet_len, 0);

crypto/openssh/packet.c

1142

ssh_packet_check_rekey_preauth(struct ssh *ssh, u_int outgoing_packet_len)

crypto/openssh/packet.c

1144

if (ssh->state->after_authentication)

crypto/openssh/packet.c

1147

if (ssh_packet_check_rekey_blocklimit(ssh, 0, 1)) {

crypto/openssh/packet.c

1155

ssh_packet_check_rekey(struct ssh *ssh)

crypto/openssh/packet.c

1159

if ((r = ssh_packet_check_rekey_preauth(ssh, 0)) != 0)

crypto/openssh/packet.c

1161

if (!ssh_packet_need_rekeying(ssh, 0))

crypto/openssh/packet.c

1164

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1173

ssh_packet_enable_delayed_compress(struct ssh *ssh)

crypto/openssh/packet.c

1175

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1190

if ((r = ssh_packet_init_compression(ssh)) != 0)

crypto/openssh/packet.c

1193

if ((r = start_compression_out(ssh, 6)) != 0)

crypto/openssh/packet.c

1196

if ((r = start_compression_in(ssh)) != 0)

crypto/openssh/packet.c

1225

ssh_packet_send2_wrapped(struct ssh *ssh)

crypto/openssh/packet.c

1227

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1262

if ((r = compress_buffer(ssh, state->outgoing_packet,

crypto/openssh/packet.c

1364

if ((ssh->kex->flags & KEX_INITIAL) != 0) {

crypto/openssh/packet.c

1365

ssh_packet_disconnect(ssh, "outgoing sequence number "

crypto/openssh/packet.c

1376

if (type == SSH2_MSG_NEWKEYS && ssh->kex->kex_strict) {

crypto/openssh/packet.c

1382

r = ssh_set_newkeys(ssh, MODE_OUT);

crypto/openssh/packet.c

1384

r = ssh_packet_enable_delayed_compress(ssh);

crypto/openssh/packet.c

1404

ssh_packet_send2(struct ssh *ssh)

crypto/openssh/packet.c

1406

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1415

ssh_packet_need_rekeying(ssh, sshbuf_len(state->outgoing_packet));

crypto/openssh/packet.c

1419

(r = ssh_packet_check_rekey_preauth(ssh, 0)) != 0)

crypto/openssh/packet.c

1445

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1454

if ((r = ssh_packet_send2_wrapped(ssh)) != 0)

crypto/openssh/packet.c

1468

if (ssh_packet_need_rekeying(ssh,

crypto/openssh/packet.c

1471

return kex_start_rekex(ssh);

crypto/openssh/packet.c

1479

if ((r = ssh_packet_send2_wrapped(ssh)) != 0)

crypto/openssh/packet.c

1493

ssh_packet_read_seqnr(struct ssh *ssh, u_char *typep, uint32_t *seqnr_p)

crypto/openssh/packet.c

1495

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1508

if ((r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

1514

if ((r = ssh_packet_read_poll_seqnr(ssh, typep, seqnr_p)) != 0)

crypto/openssh/packet.c

1567

if ((r = ssh_packet_process_incoming(ssh, buf, len)) != 0)

crypto/openssh/packet.c

1575

ssh_packet_read(struct ssh *ssh)

crypto/openssh/packet.c

1580

if ((r = ssh_packet_read_seqnr(ssh, &type, NULL)) != 0)

crypto/openssh/packet.c

1586

ssh_packet_read_poll2_mux(struct ssh *ssh, u_char *typep, uint32_t *seqnr_p)

crypto/openssh/packet.c

1588

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1593

if (ssh->kex)

crypto/openssh/packet.c

1624

ssh_packet_read_poll2(struct ssh *ssh, u_char *typep, uint32_t *seqnr_p)

crypto/openssh/packet.c

1626

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1636

return ssh_packet_read_poll2_mux(ssh, typep, seqnr_p);

crypto/openssh/packet.c

1666

if ((r = sshpkt_disconnect(ssh, "Packet corrupt")) != 0)

crypto/openssh/packet.c

1696

return ssh_packet_start_discard(ssh, enc, mac, 0,

crypto/openssh/packet.c

1719

return ssh_packet_start_discard(ssh, enc, mac, 0,

crypto/openssh/packet.c

1766

return ssh_packet_start_discard(ssh, enc, mac,

crypto/openssh/packet.c

1779

if ((ssh->kex->flags & KEX_INITIAL) != 0) {

crypto/openssh/packet.c

1780

ssh_packet_disconnect(ssh, "incoming sequence number "

crypto/openssh/packet.c

1794

if ((r = sshpkt_disconnect(ssh,

crypto/openssh/packet.c

1796

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

1810

if ((r = uncompress_buffer(ssh, state->incoming_packet,

crypto/openssh/packet.c

1829

if ((r = sshpkt_disconnect(ssh,

crypto/openssh/packet.c

1831

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

1836

(r = state->hook_in(ssh, state->incoming_packet, typep,

crypto/openssh/packet.c

1840

r = ssh_packet_enable_delayed_compress(ssh);

crypto/openssh/packet.c

1849

if (*typep == SSH2_MSG_NEWKEYS && ssh->kex->kex_strict) {

crypto/openssh/packet.c

1854

if ((r = ssh_packet_check_rekey(ssh)) != 0)

crypto/openssh/packet.c

1861

ssh_packet_read_poll_seqnr(struct ssh *ssh, u_char *typep, uint32_t *seqnr_p)

crypto/openssh/packet.c

1863

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1872

r = ssh_packet_read_poll2(ssh, typep, seqnr_p);

crypto/openssh/packet.c

1884

if ((r = sshpkt_get_u32(ssh, &reason)) != 0 ||

crypto/openssh/packet.c

1885

(r = sshpkt_get_string(ssh, &msg, NULL)) != 0)

crypto/openssh/packet.c

1888

do_log2(ssh->state->server_side &&

crypto/openssh/packet.c

1892

"%u: %.400s", ssh_remote_ipaddr(ssh),

crypto/openssh/packet.c

1893

ssh_remote_port(ssh), reason, msg);

crypto/openssh/packet.c

1904

if (ssh->kex != NULL &&

crypto/openssh/packet.c

1905

(ssh->kex->flags & KEX_INITIAL) && ssh->kex->kex_strict)

crypto/openssh/packet.c

1913

if ((r = sshpkt_get_u8(ssh, NULL)) != 0 ||

crypto/openssh/packet.c

1914

(r = sshpkt_get_string(ssh, &msg, NULL)) != 0 ||

crypto/openssh/packet.c

1915

(r = sshpkt_get_string(ssh, NULL, NULL)) != 0) {

crypto/openssh/packet.c

1923

if ((r = sshpkt_get_u32(ssh, &seqnr)) != 0)

crypto/openssh/packet.c

1929

if ((r = sshpkt_get_string_direct(ssh, &d, &len)) != 0)

crypto/openssh/packet.c

1932

if (!ssh->state->after_authentication) {

crypto/openssh/packet.c

1936

if (ssh_packet_is_rekeying(ssh)) {

crypto/openssh/packet.c

1940

if ((r = sshpkt_start(ssh, SSH2_MSG_PONG)) != 0 ||

crypto/openssh/packet.c

1941

(r = sshpkt_put_string(ssh, d, len)) != 0 ||

crypto/openssh/packet.c

1942

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/packet.c

1946

if ((r = sshpkt_get_string_direct(ssh,

crypto/openssh/packet.c

1952

if (ssh->kex != NULL &&

crypto/openssh/packet.c

1953

(ssh->kex->flags & KEX_INIT_RECVD) != 0 &&

crypto/openssh/packet.c

1969

ssh_packet_process_incoming(struct ssh *ssh, const char *buf, u_int len)

crypto/openssh/packet.c

1971

struct session_state *state = ssh->state;

crypto/openssh/packet.c

1977

if ((r = ssh_packet_stop_discard(ssh)) != 0)

crypto/openssh/packet.c

1991

ssh_packet_process_read(struct ssh *ssh, int fd)

crypto/openssh/packet.c

1993

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2005

if ((r = ssh_packet_stop_discard(ssh)) != 0)

crypto/openssh/packet.c

2015

ssh_packet_remaining(struct ssh *ssh)

crypto/openssh/packet.c

2017

return sshbuf_len(ssh->state->incoming_packet);

crypto/openssh/packet.c

2029

ssh_packet_send_debug(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

2035

if ((ssh->compat & SSH_BUG_DEBUG))

crypto/openssh/packet.c

2044

if ((r = sshpkt_start(ssh, SSH2_MSG_DEBUG)) != 0 ||

crypto/openssh/packet.c

2045

(r = sshpkt_put_u8(ssh, 0)) != 0 || /* always display */

crypto/openssh/packet.c

2046

(r = sshpkt_put_cstring(ssh, buf)) != 0 ||

crypto/openssh/packet.c

2047

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/packet.c

2048

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/packet.c

2049

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

2054

sshpkt_fmt_connection_id(struct ssh *ssh, char *s, size_t l)

crypto/openssh/packet.c

2057

ssh->log_preamble ? ssh->log_preamble : "",

crypto/openssh/packet.c

2058

ssh->log_preamble ? " " : "",

crypto/openssh/packet.c

2059

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/packet.c

2066

sshpkt_vfatal(struct ssh *ssh, int r, const char *fmt, va_list ap)

crypto/openssh/packet.c

2071

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/packet.c

2075

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2078

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2080

ssh->state->server_side ? "from" : "to", remote_id);

crypto/openssh/packet.c

2082

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2086

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2095

if (ssh->kex && ssh->kex->failed_choice) {

crypto/openssh/packet.c

2096

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2100

ssh->kex->failed_choice);

crypto/openssh/packet.c

2105

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2108

ssh_packet_clear_keys(ssh);

crypto/openssh/packet.c

2112

ssh->state->server_side ? "from" : "to", remote_id);

crypto/openssh/packet.c

2117

sshpkt_fatal(struct ssh *ssh, int r, const char *fmt, ...)

crypto/openssh/packet.c

2122

sshpkt_vfatal(ssh, r, fmt, ap);

crypto/openssh/packet.c

2135

ssh_packet_disconnect(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

2142

if (ssh->state->disconnecting)

crypto/openssh/packet.c

2144

ssh->state->disconnecting = 1;

crypto/openssh/packet.c

2150

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/packet.c

2162

if ((r = sshpkt_disconnect(ssh, "%s", buf)) != 0)

crypto/openssh/packet.c

2163

sshpkt_fatal(ssh, r, "%s", __func__);

crypto/openssh/packet.c

2165

if ((r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/packet.c

2166

sshpkt_fatal(ssh, r, "%s", __func__);

crypto/openssh/packet.c

2169

ssh_packet_close(ssh);

crypto/openssh/packet.c

2178

ssh_packet_write_poll(struct ssh *ssh)

crypto/openssh/packet.c

2180

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2206

ssh_packet_write_wait(struct ssh *ssh)

crypto/openssh/packet.c

2211

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2214

if ((r = ssh_packet_write_poll(ssh)) != 0)

crypto/openssh/packet.c

2216

while (ssh_packet_have_data_to_write(ssh)) {

crypto/openssh/packet.c

2244

if ((r = ssh_packet_write_poll(ssh)) != 0)

crypto/openssh/packet.c

2253

ssh_packet_have_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2255

return sshbuf_len(ssh->state->output) != 0;

crypto/openssh/packet.c

2261

ssh_packet_not_very_much_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2263

if (ssh->state->interactive_mode)

crypto/openssh/packet.c

2264

return sshbuf_len(ssh->state->output) < 16384;

crypto/openssh/packet.c

2266

return sshbuf_len(ssh->state->output) < 128 * 1024;

crypto/openssh/packet.c

2275

ssh_packet_interactive_data_to_write(struct ssh *ssh)

crypto/openssh/packet.c

2277

return ssh->state->interactive_mode &&

crypto/openssh/packet.c

2278

sshbuf_len(ssh->state->output) < 256;

crypto/openssh/packet.c

2282

apply_qos(struct ssh *ssh)

crypto/openssh/packet.c

2284

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2288

if (!ssh_packet_connection_is_on_socket(ssh))

crypto/openssh/packet.c

2294

set_sock_tos(ssh->state->connection_in, qos);

crypto/openssh/packet.c

2299

ssh_packet_set_interactive(struct ssh *ssh, int interactive)

crypto/openssh/packet.c

2301

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2304

apply_qos(ssh);

crypto/openssh/packet.c

2309

ssh_packet_set_qos(struct ssh *ssh, int qos_interactive, int qos_other)

crypto/openssh/packet.c

2311

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2315

apply_qos(ssh);

crypto/openssh/packet.c

2319

ssh_packet_set_maxsize(struct ssh *ssh, u_int s)

crypto/openssh/packet.c

2321

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2339

ssh_packet_inc_alive_timeouts(struct ssh *ssh)

crypto/openssh/packet.c

2341

return ++ssh->state->keep_alive_timeouts;

crypto/openssh/packet.c

2345

ssh_packet_set_alive_timeouts(struct ssh *ssh, int ka)

crypto/openssh/packet.c

2347

ssh->state->keep_alive_timeouts = ka;

crypto/openssh/packet.c

235

struct ssh *

crypto/openssh/packet.c

2351

ssh_packet_get_maxsize(struct ssh *ssh)

crypto/openssh/packet.c

2353

return ssh->state->max_packet_size;

crypto/openssh/packet.c

2357

ssh_packet_set_rekey_limits(struct ssh *ssh, uint64_t bytes, uint32_t seconds)

crypto/openssh/packet.c

2361

ssh->state->rekey_limit = bytes;

crypto/openssh/packet.c

2362

ssh->state->rekey_interval = seconds;

crypto/openssh/packet.c

2366

ssh_packet_get_rekey_timeout(struct ssh *ssh)

crypto/openssh/packet.c

2370

seconds = ssh->state->rekey_time + ssh->state->rekey_interval -

crypto/openssh/packet.c

2376

ssh_packet_set_server(struct ssh *ssh)

crypto/openssh/packet.c

2378

ssh->state->server_side = 1;

crypto/openssh/packet.c

2379

ssh->kex->server = 1; /* XXX unify? */

crypto/openssh/packet.c

238

struct ssh *ssh = NULL;

crypto/openssh/packet.c

2383

ssh_packet_set_authenticated(struct ssh *ssh)

crypto/openssh/packet.c

2385

ssh->state->after_authentication = 1;

crypto/openssh/packet.c

2389

ssh_packet_get_input(struct ssh *ssh)

crypto/openssh/packet.c

2391

return (void *)ssh->state->input;

crypto/openssh/packet.c

2395

ssh_packet_get_output(struct ssh *ssh)

crypto/openssh/packet.c

2397

return (void *)ssh->state->output;

crypto/openssh/packet.c

2402

ssh_packet_set_postauth(struct ssh *ssh)

crypto/openssh/packet.c

2408

ssh->state->after_authentication = 1;

crypto/openssh/packet.c

2409

ssh->state->rekeying = 0;

crypto/openssh/packet.c

241

if ((ssh = calloc(1, sizeof(*ssh))) == NULL ||

crypto/openssh/packet.c

2410

if ((r = ssh_packet_enable_delayed_compress(ssh)) != 0)

crypto/openssh/packet.c

243

(ssh->kex = kex_new()) == NULL ||

crypto/openssh/packet.c

2441

newkeys_to_blob(struct sshbuf *m, struct ssh *ssh, int mode)

crypto/openssh/packet.c

2451

if ((newkey = ssh->state->newkeys[mode]) == NULL)

crypto/openssh/packet.c

2456

cc = (mode == MODE_OUT) ? ssh->state->send_context :

crypto/openssh/packet.c

2457

ssh->state->receive_context;

crypto/openssh/packet.c

2485

ssh_packet_get_state(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/packet.c

2487

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2491

if ((r = kex_to_blob(m, ssh->kex)) != 0 ||

crypto/openssh/packet.c

2492

(r = newkeys_to_blob(m, ssh, MODE_OUT)) != 0 ||

crypto/openssh/packet.c

2493

(r = newkeys_to_blob(m, ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

250

TAILQ_INIT(&ssh->private_keys);

crypto/openssh/packet.c

251

TAILQ_INIT(&ssh->public_keys);

crypto/openssh/packet.c

2516

newkeys_from_blob(struct sshbuf *m, struct ssh *ssh, int mode)

crypto/openssh/packet.c

2579

ssh->kex->newkeys[mode] = newkey;

crypto/openssh/packet.c

2634

ssh_packet_set_state(struct ssh *ssh, struct sshbuf *m)

crypto/openssh/packet.c

2636

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2642

if ((r = kex_from_blob(m, &ssh->kex)) != 0 ||

crypto/openssh/packet.c

2643

(r = newkeys_from_blob(m, ssh, MODE_OUT)) != 0 ||

crypto/openssh/packet.c

2644

(r = newkeys_from_blob(m, ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

265

ssh->state = state;

crypto/openssh/packet.c

266

return ssh;

crypto/openssh/packet.c

2662

if ((r = ssh_set_newkeys(ssh, MODE_IN)) != 0 ||

crypto/openssh/packet.c

2663

(r = ssh_set_newkeys(ssh, MODE_OUT)) != 0)

crypto/openssh/packet.c

2666

if ((r = ssh_packet_set_postauth(ssh)) != 0)

crypto/openssh/packet.c

268

if (ssh) {

crypto/openssh/packet.c

269

kex_free(ssh->kex);

crypto/openssh/packet.c

2698

sshpkt_put(struct ssh *ssh, const void *v, size_t len)

crypto/openssh/packet.c

270

free(ssh);

crypto/openssh/packet.c

2700

return sshbuf_put(ssh->state->outgoing_packet, v, len);

crypto/openssh/packet.c

2704

sshpkt_putb(struct ssh *ssh, const struct sshbuf *b)

crypto/openssh/packet.c

2706

return sshbuf_putb(ssh->state->outgoing_packet, b);

crypto/openssh/packet.c

2710

sshpkt_put_u8(struct ssh *ssh, u_char val)

crypto/openssh/packet.c

2712

return sshbuf_put_u8(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

2716

sshpkt_put_u32(struct ssh *ssh, uint32_t val)

crypto/openssh/packet.c

2718

return sshbuf_put_u32(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

2722

sshpkt_put_u64(struct ssh *ssh, uint64_t val)

crypto/openssh/packet.c

2724

return sshbuf_put_u64(ssh->state->outgoing_packet, val);

crypto/openssh/packet.c

2728

sshpkt_put_string(struct ssh *ssh, const void *v, size_t len)

crypto/openssh/packet.c

2730

return sshbuf_put_string(ssh->state->outgoing_packet, v, len);

crypto/openssh/packet.c

2734

sshpkt_put_cstring(struct ssh *ssh, const void *v)

crypto/openssh/packet.c

2736

return sshbuf_put_cstring(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2740

sshpkt_put_stringb(struct ssh *ssh, const struct sshbuf *v)

crypto/openssh/packet.c

2742

return sshbuf_put_stringb(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2748

sshpkt_put_ec(struct ssh *ssh, const EC_POINT *v, const EC_GROUP *g)

crypto/openssh/packet.c

2750

return sshbuf_put_ec(ssh->state->outgoing_packet, v, g);

crypto/openssh/packet.c

2754

sshpkt_put_ec_pkey(struct ssh *ssh, EVP_PKEY *pkey)

crypto/openssh/packet.c

2756

return sshbuf_put_ec_pkey(ssh->state->outgoing_packet, pkey);

crypto/openssh/packet.c

2761

sshpkt_put_bignum2(struct ssh *ssh, const BIGNUM *v)

crypto/openssh/packet.c

2763

return sshbuf_put_bignum2(ssh->state->outgoing_packet, v);

crypto/openssh/packet.c

2770

sshpkt_get(struct ssh *ssh, void *valp, size_t len)

crypto/openssh/packet.c

2772

return sshbuf_get(ssh->state->incoming_packet, valp, len);

crypto/openssh/packet.c

2776

sshpkt_get_u8(struct ssh *ssh, u_char *valp)

crypto/openssh/packet.c

2778

return sshbuf_get_u8(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2782

sshpkt_get_u32(struct ssh *ssh, uint32_t *valp)

crypto/openssh/packet.c

2784

return sshbuf_get_u32(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2788

sshpkt_get_u64(struct ssh *ssh, uint64_t *valp)

crypto/openssh/packet.c

2790

return sshbuf_get_u64(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2794

sshpkt_get_string(struct ssh *ssh, u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2796

return sshbuf_get_string(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2800

sshpkt_get_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2802

return sshbuf_get_string_direct(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2806

sshpkt_peek_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp)

crypto/openssh/packet.c

2808

return sshbuf_peek_string_direct(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2812

sshpkt_get_cstring(struct ssh *ssh, char **valp, size_t *lenp)

crypto/openssh/packet.c

2814

return sshbuf_get_cstring(ssh->state->incoming_packet, valp, lenp);

crypto/openssh/packet.c

2818

sshpkt_getb_froms(struct ssh *ssh, struct sshbuf **valp)

crypto/openssh/packet.c

2820

return sshbuf_froms(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2826

sshpkt_get_ec(struct ssh *ssh, EC_POINT *v, const EC_GROUP *g)

crypto/openssh/packet.c

2828

return sshbuf_get_ec(ssh->state->incoming_packet, v, g);

crypto/openssh/packet.c

283

ssh_packet_set_input_hook(struct ssh *ssh, ssh_packet_hook_fn *hook, void *ctx)

crypto/openssh/packet.c

2833

sshpkt_get_bignum2(struct ssh *ssh, BIGNUM **valp)

crypto/openssh/packet.c

2835

return sshbuf_get_bignum2(ssh->state->incoming_packet, valp);

crypto/openssh/packet.c

2840

sshpkt_get_end(struct ssh *ssh)

crypto/openssh/packet.c

2842

if (sshbuf_len(ssh->state->incoming_packet) > 0)

crypto/openssh/packet.c

2848

sshpkt_ptr(struct ssh *ssh, size_t *lenp)

crypto/openssh/packet.c

285

ssh->state->hook_in = hook;

crypto/openssh/packet.c

2851

*lenp = sshbuf_len(ssh->state->incoming_packet);

crypto/openssh/packet.c

2852

return sshbuf_ptr(ssh->state->incoming_packet);

crypto/openssh/packet.c

2858

sshpkt_start(struct ssh *ssh, u_char type)

crypto/openssh/packet.c

286

ssh->state->hook_in_ctx = ctx;

crypto/openssh/packet.c

2865

sshbuf_reset(ssh->state->outgoing_packet);

crypto/openssh/packet.c

2866

return sshbuf_put(ssh->state->outgoing_packet, buf, sizeof(buf));

crypto/openssh/packet.c

2870

ssh_packet_send_mux(struct ssh *ssh)

crypto/openssh/packet.c

2872

struct session_state *state = ssh->state;

crypto/openssh/packet.c

2877

if (ssh->kex)

crypto/openssh/packet.c

291

ssh_packet_is_rekeying(struct ssh *ssh)

crypto/openssh/packet.c

2911

sshpkt_msg_ignore(struct ssh *ssh, u_int nbytes)

crypto/openssh/packet.c

2917

if ((r = sshpkt_start(ssh, SSH2_MSG_IGNORE)) != 0 ||

crypto/openssh/packet.c

2918

(r = sshpkt_put_u32(ssh, nbytes)) != 0)

crypto/openssh/packet.c

2923

if ((r = sshpkt_put_u8(ssh, (u_char)rnd & 0xff)) != 0)

crypto/openssh/packet.c

293

return ssh->state->rekeying ||

crypto/openssh/packet.c

2933

sshpkt_send(struct ssh *ssh)

crypto/openssh/packet.c

2935

if (ssh->state && ssh->state->mux)

crypto/openssh/packet.c

2936

return ssh_packet_send_mux(ssh);

crypto/openssh/packet.c

2937

return ssh_packet_send2(ssh);

crypto/openssh/packet.c

294

(ssh->kex != NULL && ssh->kex->done == 0);

crypto/openssh/packet.c

2941

sshpkt_disconnect(struct ssh *ssh, const char *fmt,...)

crypto/openssh/packet.c

2952

if ((r = sshpkt_start(ssh, SSH2_MSG_DISCONNECT)) != 0 ||

crypto/openssh/packet.c

2953

(r = sshpkt_put_u32(ssh, SSH2_DISCONNECT_PROTOCOL_ERROR)) != 0 ||

crypto/openssh/packet.c

2954

(r = sshpkt_put_cstring(ssh, buf)) != 0 ||

crypto/openssh/packet.c

2955

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/packet.c

2956

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/packet.c

2963

sshpkt_add_padding(struct ssh *ssh, u_char pad)

crypto/openssh/packet.c

2965

ssh->state->extra_pad = pad;

crypto/openssh/packet.c

300

struct ssh *

crypto/openssh/packet.c

3001

comp_status_message(struct ssh *ssh)

crypto/openssh/packet.c

3005

struct session_state *state = ssh->state;

crypto/openssh/packet.c

301

ssh_packet_set_connection(struct ssh *ssh, int fd_in, int fd_out)

crypto/openssh/packet.c

3039

connection_info_message(struct ssh *ssh)

crypto/openssh/packet.c

305

int r, wasnull = ssh == NULL;

crypto/openssh/packet.c

3050

if (ssh == NULL)

crypto/openssh/packet.c

3052

state = ssh->state;

crypto/openssh/packet.c

3053

kex = ssh->kex;

crypto/openssh/packet.c

3057

if (ssh_local_port(ssh) != 65535 ||

crypto/openssh/packet.c

3058

strcmp(ssh_local_ipaddr(ssh), "UNKNOWN") != 0) {

crypto/openssh/packet.c

3060

ssh_local_ipaddr(ssh), ssh_local_port(ssh),

crypto/openssh/packet.c

3061

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/packet.c

3066

nk_in = ssh->state->newkeys[MODE_IN];

crypto/openssh/packet.c

3067

nk_out = ssh->state->newkeys[MODE_OUT];

crypto/openssh/packet.c

3068

stats_in = format_traffic_stats(&ssh->state->p_read);

crypto/openssh/packet.c

3069

stats_out = format_traffic_stats(&ssh->state->p_send);

crypto/openssh/packet.c

3101

comp_info = comp_status_message(ssh);

crypto/openssh/packet.c

311

if (ssh == NULL)

crypto/openssh/packet.c

312

ssh = ssh_alloc_session_state();

crypto/openssh/packet.c

313

if (ssh == NULL) {

crypto/openssh/packet.c

317

state = ssh->state;

crypto/openssh/packet.c

327

free(ssh); /* XXX need ssh_free_session_state? */

crypto/openssh/packet.c

335

(void)ssh_remote_ipaddr(ssh);

crypto/openssh/packet.c

336

return ssh;

crypto/openssh/packet.c

340

ssh_packet_set_timeout(struct ssh *ssh, int timeout, int count)

crypto/openssh/packet.c

342

struct session_state *state = ssh->state;

crypto/openssh/packet.c

355

ssh_packet_set_mux(struct ssh *ssh)

crypto/openssh/packet.c

357

ssh->state->mux = 1;

crypto/openssh/packet.c

358

ssh->state->rekeying = 0;

crypto/openssh/packet.c

359

kex_free(ssh->kex);

crypto/openssh/packet.c

360

ssh->kex = NULL;

crypto/openssh/packet.c

364

ssh_packet_get_mux(struct ssh *ssh)

crypto/openssh/packet.c

366

return ssh->state->mux;

crypto/openssh/packet.c

370

ssh_packet_set_log_preamble(struct ssh *ssh, const char *fmt, ...)

crypto/openssh/packet.c

375

free(ssh->log_preamble);

crypto/openssh/packet.c

377

ssh->log_preamble = NULL;

crypto/openssh/packet.c

380

r = vasprintf(&ssh->log_preamble, fmt, args);

crypto/openssh/packet.c

382

if (r < 0 || ssh->log_preamble == NULL)

crypto/openssh/packet.c

389

ssh_packet_stop_discard(struct ssh *ssh)

crypto/openssh/packet.c

391

struct session_state *state = ssh->state;

crypto/openssh/packet.c

411

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/packet.c

416

ssh_packet_start_discard(struct ssh *ssh, struct sshenc *enc,

crypto/openssh/packet.c

419

struct session_state *state = ssh->state;

crypto/openssh/packet.c

423

if ((r = sshpkt_disconnect(ssh, "Packet corrupt")) != 0)

crypto/openssh/packet.c

436

return ssh_packet_stop_discard(ssh);

crypto/openssh/packet.c

444

ssh_packet_connection_is_on_socket(struct ssh *ssh)

crypto/openssh/packet.c

450

if (ssh == NULL || ssh->state == NULL)

crypto/openssh/packet.c

453

state = ssh->state;

crypto/openssh/packet.c

477

ssh_packet_get_bytes(struct ssh *ssh, uint64_t *ibytes, uint64_t *obytes)

crypto/openssh/packet.c

480

*ibytes = ssh->state->p_read.bytes;

crypto/openssh/packet.c

482

*obytes = ssh->state->p_send.bytes;

crypto/openssh/packet.c

486

ssh_packet_connection_af(struct ssh *ssh)

crypto/openssh/packet.c

488

return get_sock_af(ssh->state->connection_out);

crypto/openssh/packet.c

494

ssh_packet_set_nonblocking(struct ssh *ssh)

crypto/openssh/packet.c

497

set_nonblock(ssh->state->connection_in);

crypto/openssh/packet.c

499

if (ssh->state->connection_out != ssh->state->connection_in)

crypto/openssh/packet.c

500

set_nonblock(ssh->state->connection_out);

crypto/openssh/packet.c

506

ssh_packet_get_connection_in(struct ssh *ssh)

crypto/openssh/packet.c

508

return ssh->state->connection_in;

crypto/openssh/packet.c

514

ssh_packet_get_connection_out(struct ssh *ssh)

crypto/openssh/packet.c

516

return ssh->state->connection_out;

crypto/openssh/packet.c

525

ssh_remote_ipaddr(struct ssh *ssh)

crypto/openssh/packet.c

530

if (ssh->remote_ipaddr == NULL) {

crypto/openssh/packet.c

531

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/packet.c

532

sock = ssh->state->connection_in;

crypto/openssh/packet.c

533

ssh->remote_ipaddr = get_peer_ipaddr(sock);

crypto/openssh/packet.c

534

ssh->remote_port = get_peer_port(sock);

crypto/openssh/packet.c

535

ssh->local_ipaddr = get_local_ipaddr(sock);

crypto/openssh/packet.c

536

ssh->local_port = get_local_port(sock);

crypto/openssh/packet.c

538

ssh->remote_ipaddr = xstrdup("UNKNOWN");

crypto/openssh/packet.c

539

ssh->remote_port = 65535;

crypto/openssh/packet.c

540

ssh->local_ipaddr = xstrdup("UNKNOWN");

crypto/openssh/packet.c

541

ssh->local_port = 65535;

crypto/openssh/packet.c

544

return ssh->remote_ipaddr;

crypto/openssh/packet.c

557

ssh_remote_hostname(struct ssh *ssh)

crypto/openssh/packet.c

563

const char *ntop = ssh_remote_ipaddr(ssh);

crypto/openssh/packet.c

568

if (getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/packet.c

642

ssh_remote_port(struct ssh *ssh)

crypto/openssh/packet.c

644

(void)ssh_remote_ipaddr(ssh); /* Will lookup and cache. */

crypto/openssh/packet.c

645

return ssh->remote_port;

crypto/openssh/packet.c

654

ssh_local_ipaddr(struct ssh *ssh)

crypto/openssh/packet.c

656

(void)ssh_remote_ipaddr(ssh); /* Will lookup and cache. */

crypto/openssh/packet.c

657

return ssh->local_ipaddr;

crypto/openssh/packet.c

663

ssh_local_port(struct ssh *ssh)

crypto/openssh/packet.c

665

(void)ssh_remote_ipaddr(ssh); /* Will lookup and cache. */

crypto/openssh/packet.c

666

return ssh->local_port;

crypto/openssh/packet.c

671

ssh_packet_rdomain_in(struct ssh *ssh)

crypto/openssh/packet.c

673

if (ssh->rdomain_in != NULL)

crypto/openssh/packet.c

674

return ssh->rdomain_in;

crypto/openssh/packet.c

675

if (!ssh_packet_connection_is_on_socket(ssh))

crypto/openssh/packet.c

677

ssh->rdomain_in = get_rdomain(ssh->state->connection_in);

crypto/openssh/packet.c

678

return ssh->rdomain_in;

crypto/openssh/packet.c

684

ssh_packet_close_internal(struct ssh *ssh, int do_close)

crypto/openssh/packet.c

686

struct session_state *state = ssh->state;

crypto/openssh/packet.c

713

ssh_clear_newkeys(ssh, mode); /* next keys */

crypto/openssh/packet.c

747

free(ssh->local_ipaddr);

crypto/openssh/packet.c

748

ssh->local_ipaddr = NULL;

crypto/openssh/packet.c

749

free(ssh->remote_ipaddr);

crypto/openssh/packet.c

750

ssh->remote_ipaddr = NULL;

crypto/openssh/packet.c

751

free(ssh->state);

crypto/openssh/packet.c

752

ssh->state = NULL;

crypto/openssh/packet.c

753

kex_free(ssh->kex);

crypto/openssh/packet.c

754

ssh->kex = NULL;

crypto/openssh/packet.c

759

ssh_packet_free(struct ssh *ssh)

crypto/openssh/packet.c

761

ssh_packet_close_internal(ssh, 1);

crypto/openssh/packet.c

762

freezero(ssh, sizeof(*ssh));

crypto/openssh/packet.c

766

ssh_packet_close(struct ssh *ssh)

crypto/openssh/packet.c

768

ssh_packet_close_internal(ssh, 1);

crypto/openssh/packet.c

772

ssh_packet_clear_keys(struct ssh *ssh)

crypto/openssh/packet.c

774

ssh_packet_close_internal(ssh, 0);

crypto/openssh/packet.c

780

ssh_packet_set_protocol_flags(struct ssh *ssh, u_int protocol_flags)

crypto/openssh/packet.c

782

ssh->state->remote_protocol_flags = protocol_flags;

crypto/openssh/packet.c

788

ssh_packet_get_protocol_flags(struct ssh *ssh)

crypto/openssh/packet.c

790

return ssh->state->remote_protocol_flags;

crypto/openssh/packet.c

799

ssh_packet_init_compression(struct ssh *ssh)

crypto/openssh/packet.c

801

if (!ssh->state->compression_buffer &&

crypto/openssh/packet.c

802

((ssh->state->compression_buffer = sshbuf_new()) == NULL))

crypto/openssh/packet.c

809

start_compression_out(struct ssh *ssh, int level)

crypto/openssh/packet.c

814

if (ssh->state->compression_out_started == 1)

crypto/openssh/packet.c

815

deflateEnd(&ssh->state->compression_out_stream);

crypto/openssh/packet.c

816

switch (deflateInit(&ssh->state->compression_out_stream, level)) {

crypto/openssh/packet.c

818

ssh->state->compression_out_started = 1;

crypto/openssh/packet.c

829

start_compression_in(struct ssh *ssh)

crypto/openssh/packet.c

831

if (ssh->state->compression_in_started == 1)

crypto/openssh/packet.c

832

inflateEnd(&ssh->state->compression_in_stream);

crypto/openssh/packet.c

833

switch (inflateInit(&ssh->state->compression_in_stream)) {

crypto/openssh/packet.c

835

ssh->state->compression_in_started = 1;

crypto/openssh/packet.c

847

compress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

852

if (ssh->state->compression_out_started != 1)

crypto/openssh/packet.c

860

if ((ssh->state->compression_out_stream.next_in =

crypto/openssh/packet.c

863

ssh->state->compression_out_stream.avail_in = sshbuf_len(in);

crypto/openssh/packet.c

868

ssh->state->compression_out_stream.next_out = buf;

crypto/openssh/packet.c

869

ssh->state->compression_out_stream.avail_out = sizeof(buf);

crypto/openssh/packet.c

872

status = deflate(&ssh->state->compression_out_stream,

crypto/openssh/packet.c

880

ssh->state->compression_out_stream.avail_out)) != 0)

crypto/openssh/packet.c

885

ssh->state->compression_out_failures++;

crypto/openssh/packet.c

888

} while (ssh->state->compression_out_stream.avail_out == 0);

crypto/openssh/packet.c

893

uncompress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

898

if (ssh->state->compression_in_started != 1)

crypto/openssh/packet.c

901

if ((ssh->state->compression_in_stream.next_in =

crypto/openssh/packet.c

904

ssh->state->compression_in_stream.avail_in = sshbuf_len(in);

crypto/openssh/packet.c

908

ssh->state->compression_in_stream.next_out = buf;

crypto/openssh/packet.c

909

ssh->state->compression_in_stream.avail_out = sizeof(buf);

crypto/openssh/packet.c

911

status = inflate(&ssh->state->compression_in_stream,

crypto/openssh/packet.c

916

ssh->state->compression_in_stream.avail_out)) != 0)

crypto/openssh/packet.c

932

ssh->state->compression_in_failures++;

crypto/openssh/packet.c

942

start_compression_out(struct ssh *ssh, int level)

crypto/openssh/packet.c

948

start_compression_in(struct ssh *ssh)

crypto/openssh/packet.c

954

compress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

960

uncompress_buffer(struct ssh *ssh, struct sshbuf *in, struct sshbuf *out)

crypto/openssh/packet.c

967

ssh_clear_newkeys(struct ssh *ssh, int mode)

crypto/openssh/packet.c

969

if (ssh->kex && ssh->kex->newkeys[mode]) {

crypto/openssh/packet.c

970

kex_free_newkeys(ssh->kex->newkeys[mode]);

crypto/openssh/packet.c

971

ssh->kex->newkeys[mode] = NULL;

crypto/openssh/packet.c

976

ssh_set_newkeys(struct ssh *ssh, int mode)

crypto/openssh/packet.c

978

struct session_state *state = ssh->state;

crypto/openssh/packet.h

100

int ssh_packet_stop_discard(struct ssh *);

crypto/openssh/packet.h

101

int ssh_packet_connection_af(struct ssh *);

crypto/openssh/packet.h

102

void ssh_packet_set_nonblocking(struct ssh *);

crypto/openssh/packet.h

103

int ssh_packet_get_connection_in(struct ssh *);

crypto/openssh/packet.h

104

int ssh_packet_get_connection_out(struct ssh *);

crypto/openssh/packet.h

105

void ssh_packet_free(struct ssh *);

crypto/openssh/packet.h

106

void ssh_packet_close(struct ssh *);

crypto/openssh/packet.h

107

void ssh_packet_set_input_hook(struct ssh *, ssh_packet_hook_fn *, void *);

crypto/openssh/packet.h

108

void ssh_packet_clear_keys(struct ssh *);

crypto/openssh/packet.h

109

void ssh_clear_newkeys(struct ssh *, int);

crypto/openssh/packet.h

111

int ssh_packet_is_rekeying(struct ssh *);

crypto/openssh/packet.h

112

int ssh_packet_check_rekey(struct ssh *);

crypto/openssh/packet.h

113

void ssh_packet_set_protocol_flags(struct ssh *, u_int);

crypto/openssh/packet.h

114

u_int ssh_packet_get_protocol_flags(struct ssh *);

crypto/openssh/packet.h

115

void ssh_packet_set_interactive(struct ssh *, int);

crypto/openssh/packet.h

116

void ssh_packet_set_qos(struct ssh *, int, int);

crypto/openssh/packet.h

117

void ssh_packet_set_server(struct ssh *);

crypto/openssh/packet.h

118

void ssh_packet_set_authenticated(struct ssh *);

crypto/openssh/packet.h

119

void ssh_packet_set_mux(struct ssh *);

crypto/openssh/packet.h

120

int ssh_packet_get_mux(struct ssh *);

crypto/openssh/packet.h

121

int ssh_packet_set_log_preamble(struct ssh *, const char *, ...)

crypto/openssh/packet.h

126

int ssh_packet_send2_wrapped(struct ssh *);

crypto/openssh/packet.h

127

int ssh_packet_send2(struct ssh *);

crypto/openssh/packet.h

129

int ssh_packet_read(struct ssh *);

crypto/openssh/packet.h

130

int ssh_packet_read_poll2(struct ssh *, u_char *, uint32_t *seqnr_p);

crypto/openssh/packet.h

131

int ssh_packet_process_incoming(struct ssh *, const char *buf, u_int len);

crypto/openssh/packet.h

132

int ssh_packet_process_read(struct ssh *, int);

crypto/openssh/packet.h

133

int ssh_packet_read_seqnr(struct ssh *, u_char *, uint32_t *seqnr_p);

crypto/openssh/packet.h

134

int ssh_packet_read_poll_seqnr(struct ssh *, u_char *, uint32_t *seqnr_p);

crypto/openssh/packet.h

136

void ssh_packet_disconnect(struct ssh *, const char *fmt, ...)

crypto/openssh/packet.h

139

void ssh_packet_send_debug(struct ssh *, const char *fmt, ...) __attribute__((format(printf, 2, 3)));

crypto/openssh/packet.h

141

int ssh_set_newkeys(struct ssh *, int mode);

crypto/openssh/packet.h

142

void ssh_packet_get_bytes(struct ssh *, uint64_t *, uint64_t *);

crypto/openssh/packet.h

144

int ssh_packet_write_poll(struct ssh *);

crypto/openssh/packet.h

145

int ssh_packet_write_wait(struct ssh *);

crypto/openssh/packet.h

146

int ssh_packet_have_data_to_write(struct ssh *);

crypto/openssh/packet.h

147

int ssh_packet_not_very_much_data_to_write(struct ssh *);

crypto/openssh/packet.h

148

int ssh_packet_interactive_data_to_write(struct ssh *);

crypto/openssh/packet.h

150

int ssh_packet_connection_is_on_socket(struct ssh *);

crypto/openssh/packet.h

151

int ssh_packet_remaining(struct ssh *);

crypto/openssh/packet.h

153

void ssh_tty_make_modes(struct ssh *, int, struct termios *);

crypto/openssh/packet.h

154

void ssh_tty_parse_modes(struct ssh *, int);

crypto/openssh/packet.h

156

void ssh_packet_set_alive_timeouts(struct ssh *, int);

crypto/openssh/packet.h

157

int ssh_packet_inc_alive_timeouts(struct ssh *);

crypto/openssh/packet.h

158

int ssh_packet_set_maxsize(struct ssh *, u_int);

crypto/openssh/packet.h

159

u_int ssh_packet_get_maxsize(struct ssh *);

crypto/openssh/packet.h

161

int ssh_packet_get_state(struct ssh *, struct sshbuf *);

crypto/openssh/packet.h

162

int ssh_packet_set_state(struct ssh *, struct sshbuf *);

crypto/openssh/packet.h

164

const char *ssh_remote_ipaddr(struct ssh *);

crypto/openssh/packet.h

165

int ssh_remote_port(struct ssh *);

crypto/openssh/packet.h

166

const char *ssh_local_ipaddr(struct ssh *);

crypto/openssh/packet.h

167

int ssh_local_port(struct ssh *);

crypto/openssh/packet.h

168

const char *ssh_packet_rdomain_in(struct ssh *);

crypto/openssh/packet.h

169

char *ssh_remote_hostname(struct ssh *);

crypto/openssh/packet.h

171

void ssh_packet_set_rekey_limits(struct ssh *, uint64_t, uint32_t);

crypto/openssh/packet.h

172

time_t ssh_packet_get_rekey_timeout(struct ssh *);

crypto/openssh/packet.h

174

void *ssh_packet_get_input(struct ssh *);

crypto/openssh/packet.h

175

void *ssh_packet_get_output(struct ssh *);

crypto/openssh/packet.h

178

int sshpkt_start(struct ssh *ssh, u_char type);

crypto/openssh/packet.h

179

int sshpkt_send(struct ssh *ssh);

crypto/openssh/packet.h

180

int sshpkt_disconnect(struct ssh *, const char *fmt, ...)

crypto/openssh/packet.h

182

int sshpkt_add_padding(struct ssh *, u_char);

crypto/openssh/packet.h

183

void sshpkt_fatal(struct ssh *ssh, int r, const char *fmt, ...)

crypto/openssh/packet.h

186

int sshpkt_msg_ignore(struct ssh *, u_int);

crypto/openssh/packet.h

188

int sshpkt_put(struct ssh *ssh, const void *v, size_t len);

crypto/openssh/packet.h

189

int sshpkt_putb(struct ssh *ssh, const struct sshbuf *b);

crypto/openssh/packet.h

190

int sshpkt_put_u8(struct ssh *ssh, u_char val);

crypto/openssh/packet.h

191

int sshpkt_put_u32(struct ssh *ssh, uint32_t val);

crypto/openssh/packet.h

192

int sshpkt_put_u64(struct ssh *ssh, uint64_t val);

crypto/openssh/packet.h

193

int sshpkt_put_string(struct ssh *ssh, const void *v, size_t len);

crypto/openssh/packet.h

194

int sshpkt_put_cstring(struct ssh *ssh, const void *v);

crypto/openssh/packet.h

195

int sshpkt_put_stringb(struct ssh *ssh, const struct sshbuf *v);

crypto/openssh/packet.h

196

int sshpkt_put_ec(struct ssh *ssh, const EC_POINT *v, const EC_GROUP *g);

crypto/openssh/packet.h

197

int sshpkt_put_ec_pkey(struct ssh *ssh, EVP_PKEY *pkey);

crypto/openssh/packet.h

198

int sshpkt_put_bignum2(struct ssh *ssh, const BIGNUM *v);

crypto/openssh/packet.h

200

int sshpkt_get(struct ssh *ssh, void *valp, size_t len);

crypto/openssh/packet.h

201

int sshpkt_get_u8(struct ssh *ssh, u_char *valp);

crypto/openssh/packet.h

202

int sshpkt_get_u32(struct ssh *ssh, uint32_t *valp);

crypto/openssh/packet.h

203

int sshpkt_get_u64(struct ssh *ssh, uint64_t *valp);

crypto/openssh/packet.h

204

int sshpkt_get_string(struct ssh *ssh, u_char **valp, size_t *lenp);

crypto/openssh/packet.h

205

int sshpkt_get_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp);

crypto/openssh/packet.h

206

int sshpkt_peek_string_direct(struct ssh *ssh, const u_char **valp, size_t *lenp);

crypto/openssh/packet.h

207

int sshpkt_get_cstring(struct ssh *ssh, char **valp, size_t *lenp);

crypto/openssh/packet.h

208

int sshpkt_getb_froms(struct ssh *ssh, struct sshbuf **valp);

crypto/openssh/packet.h

209

int sshpkt_get_ec(struct ssh *ssh, EC_POINT *v, const EC_GROUP *g);

crypto/openssh/packet.h

210

int sshpkt_get_bignum2(struct ssh *ssh, BIGNUM **valp);

crypto/openssh/packet.h

211

int sshpkt_get_end(struct ssh *ssh);

crypto/openssh/packet.h

212

void sshpkt_fmt_connection_id(struct ssh *ssh, char *s, size_t l);

crypto/openssh/packet.h

213

const u_char *sshpkt_ptr(struct ssh *, size_t *lenp);

crypto/openssh/packet.h

214

char *connection_info_message(struct ssh *ssh);

crypto/openssh/packet.h

94

typedef int (ssh_packet_hook_fn)(struct ssh *, struct sshbuf *,

crypto/openssh/packet.h

97

struct ssh *ssh_alloc_session_state(void);

crypto/openssh/packet.h

98

struct ssh *ssh_packet_set_connection(struct ssh *, int, int);

crypto/openssh/packet.h

99

void ssh_packet_set_timeout(struct ssh *, int, int);

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

177

struct ssh *client = NULL, *server = NULL;

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

41

do_send_and_receive(struct ssh *from, struct ssh *to,

crypto/openssh/regress/misc/fuzz-harness/kex_fuzz.cc

76

run_kex(struct test_state *ts, struct ssh *client, struct ssh *server)

crypto/openssh/regress/unittests/kex/test_kex.c

30

do_send_and_receive(struct ssh *from, struct ssh *to)

crypto/openssh/regress/unittests/kex/test_kex.c

56

run_kex(struct ssh *client, struct ssh *server)

crypto/openssh/regress/unittests/kex/test_kex.c

81

struct ssh *client = NULL, *server = NULL, *server2 = NULL;

crypto/openssh/regress/unittests/kex/test_proposal.c

100

ssh.kex = &kex;

crypto/openssh/regress/unittests/kex/test_proposal.c

104

for (ssh.compat = 0; ssh.compat < 0x40000000; ) {

crypto/openssh/regress/unittests/kex/test_proposal.c

105

kex_proposal_populate_entries(&ssh, prop, NULL, NULL,

crypto/openssh/regress/unittests/kex/test_proposal.c

108

kex_proposal_populate_entries(&ssh, prop, kexalgs,

crypto/openssh/regress/unittests/kex/test_proposal.c

111

if (ssh.compat == 0)

crypto/openssh/regress/unittests/kex/test_proposal.c

112

ssh.compat = 1;

crypto/openssh/regress/unittests/kex/test_proposal.c

114

ssh.compat <<= 1;

crypto/openssh/regress/unittests/kex/test_proposal.c

39

struct ssh ssh;

crypto/openssh/regress/unittests/kex/test_proposal.c

56

ssh.compat = tests[i].compat;

crypto/openssh/regress/unittests/kex/test_proposal.c

58

result = compat_kex_proposal(&ssh, tests[i].in);

crypto/openssh/regress/unittests/kex/test_proposal.c

64

result = compat_kex_proposal(&ssh, in);

crypto/openssh/regress/unittests/kex/test_proposal.c

70

result = compat_kex_proposal(&ssh, in);

crypto/openssh/regress/unittests/kex/test_proposal.c

79

result = compat_kex_proposal(&ssh, in);

crypto/openssh/regress/unittests/kex/test_proposal.c

92

struct ssh ssh;

crypto/openssh/servconf.h

60

struct ssh;

crypto/openssh/serverloop.c

112

client_alive_check(struct ssh *ssh)

crypto/openssh/serverloop.c

119

ssh_packet_inc_alive_timeouts(ssh) >

crypto/openssh/serverloop.c

121

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/serverloop.c

130

if ((channel_id = channel_find_open(ssh)) == -1) {

crypto/openssh/serverloop.c

131

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/serverloop.c

132

(r = sshpkt_put_cstring(ssh, "keepalive@openssh.com"))

crypto/openssh/serverloop.c

134

(r = sshpkt_put_u8(ssh, 1)) != 0) /* boolean: want reply */

crypto/openssh/serverloop.c

137

channel_request_start(ssh, channel_id,

crypto/openssh/serverloop.c

140

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/serverloop.c

150

wait_until_can_do_something(struct ssh *ssh,

crypto/openssh/serverloop.c

167

channel_prepare_poll(ssh, pfdp, npfd_allocp, npfd_activep, 2, &timeout);

crypto/openssh/serverloop.c

171

if (options.rekey_interval > 0 && !ssh_packet_is_rekeying(ssh)) {

crypto/openssh/serverloop.c

173

ssh_packet_get_rekey_timeout(ssh));

crypto/openssh/serverloop.c

181

if (channel_still_open(ssh))

crypto/openssh/serverloop.c

216

(*pfdp)[1].events = ssh_packet_have_data_to_write(ssh) ? POLLOUT : 0;

crypto/openssh/serverloop.c

222

if (child_terminated && ssh_packet_not_very_much_data_to_write(ssh))

crypto/openssh/serverloop.c

245

client_alive_check(ssh);

crypto/openssh/serverloop.c

255

now > unused_connection_expiry && !channel_still_open(ssh)) {

crypto/openssh/serverloop.c

256

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/serverloop.c

267

process_input(struct ssh *ssh, int connection_in)

crypto/openssh/serverloop.c

271

if ((r = ssh_packet_process_read(ssh, connection_in)) == 0)

crypto/openssh/serverloop.c

278

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh));

crypto/openssh/serverloop.c

282

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/serverloop.c

293

process_output(struct ssh *ssh, int connection_out)

crypto/openssh/serverloop.c

299

if (interactive != !channel_has_bulk(ssh)) {

crypto/openssh/serverloop.c

300

interactive = !channel_has_bulk(ssh);

crypto/openssh/serverloop.c

303

ssh_packet_set_interactive(ssh, interactive);

crypto/openssh/serverloop.c

305

if ((r = ssh_packet_write_poll(ssh)) != 0) {

crypto/openssh/serverloop.c

306

sshpkt_fatal(ssh, r, "%s: ssh_packet_write_poll",

crypto/openssh/serverloop.c

312

process_buffered_input_packets(struct ssh *ssh)

crypto/openssh/serverloop.c

314

ssh_dispatch_run_fatal(ssh, DISPATCH_NONBLOCK, NULL);

crypto/openssh/serverloop.c

318

collect_children(struct ssh *ssh)

crypto/openssh/serverloop.c

328

session_close_by_pid(ssh, pid, status);

crypto/openssh/serverloop.c

334

server_loop2(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/serverloop.c

354

connection_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/serverloop.c

355

connection_out = ssh_packet_get_connection_out(ssh);

crypto/openssh/serverloop.c

357

server_init_dispatch(ssh);

crypto/openssh/serverloop.c

360

process_buffered_input_packets(ssh);

crypto/openssh/serverloop.c

362

if (!ssh_packet_is_rekeying(ssh) &&

crypto/openssh/serverloop.c

363

ssh_packet_not_very_much_data_to_write(ssh))

crypto/openssh/serverloop.c

364

channel_output_poll(ssh);

crypto/openssh/serverloop.c

373

collect_children(ssh);

crypto/openssh/serverloop.c

376

channel_report_open(ssh, SYSLOG_LEVEL_INFO);

crypto/openssh/serverloop.c

378

wait_until_can_do_something(ssh, connection_in, connection_out,

crypto/openssh/serverloop.c

384

channel_after_poll(ssh, pfd, npfd_active);

crypto/openssh/serverloop.c

386

process_input(ssh, connection_in) < 0)

crypto/openssh/serverloop.c

389

if ((r = ssh_packet_check_rekey(ssh)) != 0)

crypto/openssh/serverloop.c

392

process_output(ssh, connection_out);

crypto/openssh/serverloop.c

394

collect_children(ssh);

crypto/openssh/serverloop.c

398

channel_free_all(ssh);

crypto/openssh/serverloop.c

401

session_destroy_all(ssh, NULL);

crypto/openssh/serverloop.c

405

server_input_keep_alive(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

413

ssh_packet_set_alive_timeouts(ssh, 0);

crypto/openssh/serverloop.c

418

server_request_direct_tcpip(struct ssh *ssh, int *reason, const char **errmsg)

crypto/openssh/serverloop.c

425

if ((r = sshpkt_get_cstring(ssh, &target, NULL)) != 0 ||

crypto/openssh/serverloop.c

426

(r = sshpkt_get_u32(ssh, &target_port)) != 0 ||

crypto/openssh/serverloop.c

427

(r = sshpkt_get_cstring(ssh, &originator, NULL)) != 0 ||

crypto/openssh/serverloop.c

428

(r = sshpkt_get_u32(ssh, &originator_port)) != 0 ||

crypto/openssh/serverloop.c

429

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

430

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

449

c = channel_connect_to_port(ssh, target, target_port,

crypto/openssh/serverloop.c

466

server_request_direct_streamlocal(struct ssh *ssh)

crypto/openssh/serverloop.c

477

if ((r = sshpkt_get_cstring(ssh, &target, NULL)) != 0 ||

crypto/openssh/serverloop.c

478

(r = sshpkt_get_cstring(ssh, &originator, NULL)) != 0 ||

crypto/openssh/serverloop.c

479

(r = sshpkt_get_u32(ssh, &originator_port)) != 0 ||

crypto/openssh/serverloop.c

480

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

481

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

494

c = channel_connect_to_path(ssh, target,

crypto/openssh/serverloop.c

509

server_request_tun(struct ssh *ssh)

crypto/openssh/serverloop.c

516

if ((r = sshpkt_get_u32(ssh, &mode)) != 0)

crypto/openssh/serverloop.c

517

sshpkt_fatal(ssh, r, "%s: parse mode", __func__);

crypto/openssh/serverloop.c

523

ssh_packet_send_debug(ssh, "Unsupported tunnel device mode.");

crypto/openssh/serverloop.c

527

ssh_packet_send_debug(ssh, "Server has rejected tunnel device "

crypto/openssh/serverloop.c

532

if ((r = sshpkt_get_u32(ssh, &tun)) != 0)

crypto/openssh/serverloop.c

533

sshpkt_fatal(ssh, r, "%s: parse device", __func__);

crypto/openssh/serverloop.c

549

c = channel_new(ssh, "tun", SSH_CHANNEL_OPEN, sock, sock, -1,

crypto/openssh/serverloop.c

554

channel_register_filter(ssh, c->self, sys_tun_infilter,

crypto/openssh/serverloop.c

573

ssh_packet_send_debug(ssh, "Failed to open the tunnel device.");

crypto/openssh/serverloop.c

578

server_request_session(struct ssh *ssh)

crypto/openssh/serverloop.c

584

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

585

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

588

ssh_packet_disconnect(ssh, "Possible attack: attempt to open a "

crypto/openssh/serverloop.c

598

c = channel_new(ssh, "session", SSH_CHANNEL_LARVAL,

crypto/openssh/serverloop.c

603

channel_free(ssh, c);

crypto/openssh/serverloop.c

606

channel_register_cleanup(ssh, c->self, session_close_by_channel, 0);

crypto/openssh/serverloop.c

611

server_input_channel_open(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

619

if ((r = sshpkt_get_cstring(ssh, &ctype, NULL)) != 0 ||

crypto/openssh/serverloop.c

620

(r = sshpkt_get_u32(ssh, &rchan)) != 0 ||

crypto/openssh/serverloop.c

621

(r = sshpkt_get_u32(ssh, &rwindow)) != 0 ||

crypto/openssh/serverloop.c

622

(r = sshpkt_get_u32(ssh, &rmaxpack)) != 0)

crypto/openssh/serverloop.c

623

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

628

c = server_request_session(ssh);

crypto/openssh/serverloop.c

630

c = server_request_direct_tcpip(ssh, &reason, &errmsg);

crypto/openssh/serverloop.c

632

c = server_request_direct_streamlocal(ssh);

crypto/openssh/serverloop.c

634

c = server_request_tun(ssh);

crypto/openssh/serverloop.c

643

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION)) != 0 ||

crypto/openssh/serverloop.c

644

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/serverloop.c

645

(r = sshpkt_put_u32(ssh, c->self)) != 0 ||

crypto/openssh/serverloop.c

646

(r = sshpkt_put_u32(ssh, c->local_window)) != 0 ||

crypto/openssh/serverloop.c

647

(r = sshpkt_put_u32(ssh, c->local_maxpacket)) != 0 ||

crypto/openssh/serverloop.c

648

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/serverloop.c

649

sshpkt_fatal(ssh, r,

crypto/openssh/serverloop.c

655

if ((r = sshpkt_start(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE)) != 0 ||

crypto/openssh/serverloop.c

656

(r = sshpkt_put_u32(ssh, rchan)) != 0 ||

crypto/openssh/serverloop.c

657

(r = sshpkt_put_u32(ssh, reason)) != 0 ||

crypto/openssh/serverloop.c

658

(r = sshpkt_put_cstring(ssh, errmsg ? errmsg : "open failed")) != 0 ||

crypto/openssh/serverloop.c

659

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/serverloop.c

660

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/serverloop.c

661

sshpkt_fatal(ssh, r,

crypto/openssh/serverloop.c

670

server_input_hostkeys_prove(struct ssh *ssh, struct sshbuf **respp)

crypto/openssh/serverloop.c

684

ssh->kex->hostkey_alg)) == KEY_RSA)

crypto/openssh/serverloop.c

685

kex_rsa_sigalg = ssh->kex->hostkey_alg;

crypto/openssh/serverloop.c

686

while (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/serverloop.c

689

if ((r = sshpkt_get_string_direct(ssh, &blob, &blen)) != 0 ||

crypto/openssh/serverloop.c

698

if ((ndx = ssh->kex->host_key_index(key, 1, ssh)) == -1) {

crypto/openssh/serverloop.c

707

(key_pub = get_hostkey_public_by_index(ndx, ssh)) == NULL) {

crypto/openssh/serverloop.c

722

else if (ssh->kex->flags & KEX_RSA_SHA2_512_SUPPORTED)

crypto/openssh/serverloop.c

724

else if (ssh->kex->flags & KEX_RSA_SHA2_256_SUPPORTED)

crypto/openssh/serverloop.c

733

ssh->kex->session_id)) != 0 ||

crypto/openssh/serverloop.c

735

(r = ssh->kex->sign(ssh, key_prv, key_pub, &sig, &slen,

crypto/openssh/serverloop.c

755

server_input_global_request(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

769

if ((r = sshpkt_get_cstring(ssh, &rtype, NULL)) != 0 ||

crypto/openssh/serverloop.c

770

(r = sshpkt_get_u8(ssh, &want_reply)) != 0)

crypto/openssh/serverloop.c

771

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

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 tcpip-forward", __func__);

crypto/openssh/serverloop.c

790

ssh_packet_send_debug(ssh, "Server has disabled port forwarding.");

crypto/openssh/serverloop.c

793

success = channel_setup_remote_fwd_listener(ssh, &fwd,

crypto/openssh/serverloop.c

802

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_host, NULL)) != 0 ||

crypto/openssh/serverloop.c

803

(r = sshpkt_get_u32(ssh, &port)) != 0)

crypto/openssh/serverloop.c

804

sshpkt_fatal(ssh, r, "%s: parse cancel-tcpip-forward", __func__);

crypto/openssh/serverloop.c

810

success = channel_cancel_rport_listener(ssh, &fwd);

crypto/openssh/serverloop.c

813

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_path, NULL)) != 0)

crypto/openssh/serverloop.c

814

sshpkt_fatal(ssh, r, "%s: parse streamlocal-forward@openssh.com", __func__);

crypto/openssh/serverloop.c

823

ssh_packet_send_debug(ssh, "Server has disabled "

crypto/openssh/serverloop.c

827

success = channel_setup_remote_fwd_listener(ssh,

crypto/openssh/serverloop.c

831

if ((r = sshpkt_get_cstring(ssh, &fwd.listen_path, NULL)) != 0)

crypto/openssh/serverloop.c

832

sshpkt_fatal(ssh, r, "%s: parse cancel-streamlocal-forward@openssh.com", __func__);

crypto/openssh/serverloop.c

836

success = channel_cancel_rport_listener(ssh, &fwd);

crypto/openssh/serverloop.c

841

success = server_input_hostkeys_prove(ssh, &resp);

crypto/openssh/serverloop.c

845

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/serverloop.c

847

(success && resp != NULL && (r = sshpkt_putb(ssh, resp)) != 0) ||

crypto/openssh/serverloop.c

848

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/serverloop.c

849

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/serverloop.c

850

sshpkt_fatal(ssh, r, "%s: send reply", __func__);

crypto/openssh/serverloop.c

860

server_input_channel_req(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/serverloop.c

868

if ((r = sshpkt_get_u32(ssh, &id)) != 0 ||

crypto/openssh/serverloop.c

869

(r = sshpkt_get_cstring(ssh, &rtype, NULL)) != 0 ||

crypto/openssh/serverloop.c

870

(r = sshpkt_get_u8(ssh, &want_reply)) != 0)

crypto/openssh/serverloop.c

871

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

876

if (id >= INT_MAX || (c = channel_lookup(ssh, (int)id)) == NULL) {

crypto/openssh/serverloop.c

877

ssh_packet_disconnect(ssh, "%s: unknown channel %d",

crypto/openssh/serverloop.c

881

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/serverloop.c

882

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/serverloop.c

883

chan_rcvd_eow(ssh, c);

crypto/openssh/serverloop.c

886

success = session_input_channel_req(ssh, c, rtype);

crypto/openssh/serverloop.c

890

if ((r = sshpkt_start(ssh, success ?

crypto/openssh/serverloop.c

892

(r = sshpkt_put_u32(ssh, c->remote_id)) != 0 ||

crypto/openssh/serverloop.c

893

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/serverloop.c

894

sshpkt_fatal(ssh, r, "%s: send reply", __func__);

crypto/openssh/serverloop.c

901

server_init_dispatch(struct ssh *ssh)

crypto/openssh/serverloop.c

904

ssh_dispatch_init(ssh, &dispatch_protocol_error);

crypto/openssh/serverloop.c

905

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_CLOSE, &channel_input_oclose);

crypto/openssh/serverloop.c

906

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_DATA, &channel_input_data);

crypto/openssh/serverloop.c

907

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EOF, &channel_input_ieof);

crypto/openssh/serverloop.c

908

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_EXTENDED_DATA, &channel_input_extended_data);

crypto/openssh/serverloop.c

909

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN, &server_input_channel_open);

crypto/openssh/serverloop.c

910

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_CONFIRMATION, &channel_input_open_confirmation);

crypto/openssh/serverloop.c

911

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_OPEN_FAILURE, &channel_input_open_failure);

crypto/openssh/serverloop.c

912

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_REQUEST, &server_input_channel_req);

crypto/openssh/serverloop.c

913

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_WINDOW_ADJUST, &channel_input_window_adjust);

crypto/openssh/serverloop.c

914

ssh_dispatch_set(ssh, SSH2_MSG_GLOBAL_REQUEST, &server_input_global_request);

crypto/openssh/serverloop.c

916

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_SUCCESS, &server_input_keep_alive);

crypto/openssh/serverloop.c

917

ssh_dispatch_set(ssh, SSH2_MSG_CHANNEL_FAILURE, &server_input_keep_alive);

crypto/openssh/serverloop.c

918

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_SUCCESS, &server_input_keep_alive);

crypto/openssh/serverloop.c

919

ssh_dispatch_set(ssh, SSH2_MSG_REQUEST_FAILURE, &server_input_keep_alive);

crypto/openssh/serverloop.c

92

static void server_init_dispatch(struct ssh *);

crypto/openssh/serverloop.c

921

ssh_dispatch_set(ssh, SSH2_MSG_KEXINIT, &kex_input_kexinit);

crypto/openssh/serverloop.h

24

struct ssh;

crypto/openssh/serverloop.h

26

void server_loop2(struct ssh *, Authctxt *);

crypto/openssh/session.c

1141

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/session.c

1142

ssh_local_port(ssh));

crypto/openssh/session.c

1145

laddr = get_local_ipaddr(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1147

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/session.c

1148

laddr, ssh_local_port(ssh));

crypto/openssh/session.c

1176

do_rc_files(struct ssh *ssh, Session *s, const char *shell)

crypto/openssh/session.c

122

void session_set_fds(struct ssh *, Session *, int, int, int, int, int);

crypto/openssh/session.c

125

int session_setup_x11fwd(struct ssh *, Session *);

crypto/openssh/session.c

126

int do_exec_pty(struct ssh *, Session *, const char *);

crypto/openssh/session.c

127

int do_exec_no_pty(struct ssh *, Session *, const char *);

crypto/openssh/session.c

128

int do_exec(struct ssh *, Session *, const char *);

crypto/openssh/session.c

129

void do_login(struct ssh *, Session *, const char *);

crypto/openssh/session.c

130

void do_child(struct ssh *, Session *, const char *);

crypto/openssh/session.c

134

static void do_authenticated2(struct ssh *, Authctxt *);

crypto/openssh/session.c

136

static int session_pty_req(struct ssh *, Session *);

crypto/openssh/session.c

1442

child_close_fds(struct ssh *ssh)

crypto/openssh/session.c

1451

if (ssh_packet_get_connection_in(ssh) ==

crypto/openssh/session.c

1452

ssh_packet_get_connection_out(ssh))

crypto/openssh/session.c

1453

close(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1455

close(ssh_packet_get_connection_in(ssh));

crypto/openssh/session.c

1456

close(ssh_packet_get_connection_out(ssh));

crypto/openssh/session.c

1463

channel_close_all(ssh);

crypto/openssh/session.c

1490

do_child(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

1498

sshpkt_fmt_connection_id(ssh, remote_id, sizeof(remote_id));

crypto/openssh/session.c

1501

ssh_packet_clear_keys(ssh);

crypto/openssh/session.c

1506

child_close_fds(ssh);

crypto/openssh/session.c

1551

env = do_setup_env(ssh, s, shell);

crypto/openssh/session.c

1564

child_close_fds(ssh);

crypto/openssh/session.c

1615

do_rc_files(ssh, s, shell);

crypto/openssh/session.c

186

auth_input_request_forwarding(struct ssh *ssh, struct passwd *pw, int agent_new)

crypto/openssh/session.c

1861

session_window_change_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1865

if ((r = sshpkt_get_u32(ssh, &s->col)) != 0 ||

crypto/openssh/session.c

1866

(r = sshpkt_get_u32(ssh, &s->row)) != 0 ||

crypto/openssh/session.c

1867

(r = sshpkt_get_u32(ssh, &s->xpixel)) != 0 ||

crypto/openssh/session.c

1868

(r = sshpkt_get_u32(ssh, &s->ypixel)) != 0 ||

crypto/openssh/session.c

1869

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

1870

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1876

session_pty_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1885

ssh_packet_disconnect(ssh, "Protocol error: you already have a pty.");

crypto/openssh/session.c

1889

if ((r = sshpkt_get_cstring(ssh, &s->term, NULL)) != 0 ||

crypto/openssh/session.c

1890

(r = sshpkt_get_u32(ssh, &s->col)) != 0 ||

crypto/openssh/session.c

1891

(r = sshpkt_get_u32(ssh, &s->row)) != 0 ||

crypto/openssh/session.c

1892

(r = sshpkt_get_u32(ssh, &s->xpixel)) != 0 ||

crypto/openssh/session.c

1893

(r = sshpkt_get_u32(ssh, &s->ypixel)) != 0)

crypto/openssh/session.c

1894

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1913

ssh_tty_parse_modes(ssh, s->ttyfd);

crypto/openssh/session.c

1915

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

1916

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1926

session_subsystem_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1933

if ((r = sshpkt_get_cstring(ssh, &s->subsys, NULL)) != 0 ||

crypto/openssh/session.c

1934

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

1935

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1957

channel_set_xtype(ssh, s->chanid, type);

crypto/openssh/session.c

1959

success = do_exec(ssh, s, cmd) == 0;

crypto/openssh/session.c

1973

session_x11_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

1983

if ((r = sshpkt_get_u8(ssh, &single_connection)) != 0 ||

crypto/openssh/session.c

1984

(r = sshpkt_get_cstring(ssh, &s->auth_proto, NULL)) != 0 ||

crypto/openssh/session.c

1985

(r = sshpkt_get_cstring(ssh, &s->auth_data, NULL)) != 0 ||

crypto/openssh/session.c

1986

(r = sshpkt_get_u32(ssh, &s->screen)) != 0 ||

crypto/openssh/session.c

1987

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

1988

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

1994

success = session_setup_x11fwd(ssh, s);

crypto/openssh/session.c

2009

session_shell_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

201

ssh_packet_send_debug(ssh, "Agent forwarding disabled: "

crypto/openssh/session.c

2013

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2014

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2016

channel_set_xtype(ssh, s->chanid, "session:shell");

crypto/openssh/session.c

2018

return do_exec(ssh, s, NULL) == 0;

crypto/openssh/session.c

2022

session_exec_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2028

if ((r = sshpkt_get_cstring(ssh, &command, NULL)) != 0 ||

crypto/openssh/session.c

2029

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2030

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2032

channel_set_xtype(ssh, s->chanid, "session:command");

crypto/openssh/session.c

2034

success = do_exec(ssh, s, command) == 0;

crypto/openssh/session.c

2040

session_break_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2044

if ((r = sshpkt_get_u32(ssh, NULL)) != 0 || /* ignore */

crypto/openssh/session.c

2045

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2046

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2054

session_env_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2060

if ((r = sshpkt_get_cstring(ssh, &name, NULL)) != 0 ||

crypto/openssh/session.c

2061

(r = sshpkt_get_cstring(ssh, &val, NULL)) != 0 ||

crypto/openssh/session.c

2062

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2063

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

209

nc = channel_new(ssh, "auth-listener",

crypto/openssh/session.c

2115

session_signal_req(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2120

if ((r = sshpkt_get_cstring(ssh, &signame, NULL)) != 0 ||

crypto/openssh/session.c

2121

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/session.c

2157

session_auth_agent_req(struct ssh *ssh, Session *s, int agent_new)

crypto/openssh/session.c

2162

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/session.c

2163

sshpkt_fatal(ssh, r, "%s: parse packet", __func__);

crypto/openssh/session.c

2174

return auth_input_request_forwarding(ssh, s->pw, agent_new);

crypto/openssh/session.c

2178

session_input_channel_req(struct ssh *ssh, Channel *c, const char *rtype)

crypto/openssh/session.c

2195

success = session_shell_req(ssh, s);

crypto/openssh/session.c

2197

success = session_exec_req(ssh, s);

crypto/openssh/session.c

2199

success = session_pty_req(ssh, s);

crypto/openssh/session.c

2201

success = session_x11_req(ssh, s);

crypto/openssh/session.c

2203

success = session_auth_agent_req(ssh, s, 0);

crypto/openssh/session.c

2205

success = session_auth_agent_req(ssh, s, 1);

crypto/openssh/session.c

2207

success = session_subsystem_req(ssh, s);

crypto/openssh/session.c

2209

success = session_env_req(ssh, s);

crypto/openssh/session.c

2213

success = session_window_change_req(ssh, s);

crypto/openssh/session.c

2215

success = session_break_req(ssh, s);

crypto/openssh/session.c

2217

success = session_signal_req(ssh, s);

crypto/openssh/session.c

2224

session_set_fds(struct ssh *ssh, Session *s,

crypto/openssh/session.c

2233

channel_set_fds(ssh, s->chanid,

crypto/openssh/session.c

2304

session_close_x11(struct ssh *ssh, int id)

crypto/openssh/session.c

2308

if ((c = channel_by_id(ssh, id)) == NULL) {

crypto/openssh/session.c

2313

channel_cancel_cleanup(ssh, id);

crypto/openssh/session.c

2315

chan_mark_dead(ssh, c);

crypto/openssh/session.c

2320

session_close_single_x11(struct ssh *ssh, int id, int force, void *arg)

crypto/openssh/session.c

2326

channel_cancel_cleanup(ssh, id);

crypto/openssh/session.c

2337

session_close_x11(ssh, s->x11_chanids[i]);

crypto/openssh/session.c

2352

session_exit_message(struct ssh *ssh, Session *s, int status)

crypto/openssh/session.c

2358

if ((c = channel_lookup(ssh, s->chanid)) == NULL)

crypto/openssh/session.c

2362

channel_request_start(ssh, s->chanid, "exit-status", 0);

crypto/openssh/session.c

2363

if ((r = sshpkt_put_u32(ssh, WEXITSTATUS(status))) != 0 ||

crypto/openssh/session.c

2364

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/session.c

2365

sshpkt_fatal(ssh, r, "%s: exit reply", __func__);

crypto/openssh/session.c

2368

channel_request_start(ssh, s->chanid, "exit-signal", 0);

crypto/openssh/session.c

2372

if ((r = sshpkt_put_cstring(ssh, sig2name(WTERMSIG(status)))) != 0 ||

crypto/openssh/session.c

2373

(r = sshpkt_put_u8(ssh, WCOREDUMP(status)? 1 : 0)) != 0 ||

crypto/openssh/session.c

2374

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/session.c

2375

(r = sshpkt_put_cstring(ssh, "")) != 0 ||

crypto/openssh/session.c

2376

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/session.c

2377

sshpkt_fatal(ssh, r, "%s: exit reply", __func__);

crypto/openssh/session.c

2382

ssh_packet_disconnect(ssh, "wait returned status %04x.",

crypto/openssh/session.c

2398

channel_register_cleanup(ssh, c->self, session_close_by_channel, 1);

crypto/openssh/session.c

2407

chan_write_failed(ssh, c);

crypto/openssh/session.c

2411

session_close(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2417

ssh_remote_ipaddr(ssh),

crypto/openssh/session.c

2418

ssh_remote_port(ssh),

crypto/openssh/session.c

2442

session_close_by_pid(struct ssh *ssh, pid_t pid, int status)

crypto/openssh/session.c

2450

session_exit_message(ssh, s, status);

crypto/openssh/session.c

2461

session_close_by_channel(struct ssh *ssh, int id, int force, void *arg)

crypto/openssh/session.c

2484

channel_cancel_cleanup(ssh, s->chanid);

crypto/openssh/session.c

2489

session_close_x11(ssh, s->x11_chanids[i]);

crypto/openssh/session.c

2495

session_close(ssh, s);

crypto/openssh/session.c

2499

session_destroy_all(struct ssh *ssh, void (*closefunc)(Session *))

crypto/openssh/session.c

2508

session_close(ssh, s);

crypto/openssh/session.c

2551

session_setup_x11fwd(struct ssh *ssh, Session *s)

crypto/openssh/session.c

2559

ssh_packet_send_debug(ssh, "X11 forwarding disabled by key options.");

crypto/openssh/session.c

2568

ssh_packet_send_debug(ssh, "No xauth program; cannot forward X11.");

crypto/openssh/session.c

2575

if (x11_create_display_inet(ssh, options.x11_display_offset,

crypto/openssh/session.c

2582

channel_register_cleanup(ssh, s->x11_chanids[i],

crypto/openssh/session.c

2609

ssh_packet_send_debug(ssh, "Can't get IP address for X11 DISPLAY.");

crypto/openssh/session.c

2627

do_authenticated2(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

2629

server_loop2(ssh, authctxt);

crypto/openssh/session.c

2633

do_cleanup(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

2689

session_destroy_all(ssh, session_pty_cleanup2);

crypto/openssh/session.c

2695

session_get_remote_name_or_ip(struct ssh *ssh, u_int utmp_size, int use_dns)

crypto/openssh/session.c

2700

remote = auth_get_canonical_hostname(ssh, use_dns);

crypto/openssh/session.c

2702

remote = ssh_remote_ipaddr(ssh);

crypto/openssh/session.c

273

set_fwdpermit_from_authopts(struct ssh *ssh, const struct sshauthopt *opts)

crypto/openssh/session.c

280

channel_clear_permission(ssh, FORWARD_USER, FORWARD_LOCAL);

crypto/openssh/session.c

289

channel_add_permission(ssh,

crypto/openssh/session.c

295

channel_clear_permission(ssh, FORWARD_USER, FORWARD_REMOTE);

crypto/openssh/session.c

304

channel_add_permission(ssh,

crypto/openssh/session.c

312

do_authenticated(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/session.c

320

set_fwdpermit_from_authopts(ssh, auth_opts);

crypto/openssh/session.c

324

channel_disable_admin(ssh, FORWARD_LOCAL);

crypto/openssh/session.c

325

channel_disable_admin(ssh, FORWARD_REMOTE);

crypto/openssh/session.c

328

channel_disable_admin(ssh, FORWARD_LOCAL);

crypto/openssh/session.c

330

channel_permit_all(ssh, FORWARD_LOCAL);

crypto/openssh/session.c

332

channel_disable_admin(ssh, FORWARD_REMOTE);

crypto/openssh/session.c

334

channel_permit_all(ssh, FORWARD_REMOTE);

crypto/openssh/session.c

336

auth_debug_send(ssh);

crypto/openssh/session.c

340

do_authenticated2(ssh, authctxt);

crypto/openssh/session.c

342

do_cleanup(ssh, authctxt);

crypto/openssh/session.c

367

do_exec_no_pty(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

484

do_child(ssh, s, command);

crypto/openssh/session.c

509

session_set_fds(ssh, s, pin[1], pout[0], perr[0],

crypto/openssh/session.c

520

session_set_fds(ssh, s, inout[1], inout[1], err[1],

crypto/openssh/session.c

533

do_exec_pty(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

599

do_login(ssh, s, command);

crypto/openssh/session.c

605

do_child(ssh, s, command);

crypto/openssh/session.c

622

session_set_fds(ssh, s, ptyfd, fdout, -1, 1, 1);

crypto/openssh/session.c

631

do_exec(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

677

ssh_remote_ipaddr(ssh),

crypto/openssh/session.c

678

ssh_remote_port(ssh),

crypto/openssh/session.c

693

ret = do_exec_pty(ssh, s, command);

crypto/openssh/session.c

695

ret = do_exec_no_pty(ssh, s, command);

crypto/openssh/session.c

711

do_login(struct ssh *ssh, Session *s, const char *command)

crypto/openssh/session.c

722

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/session.c

723

if (getpeername(ssh_packet_get_connection_in(ssh),

crypto/openssh/session.c

934

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

112

struct ssh *c_ssh; /* SSH-connection */

crypto/openssh/ssh-keyscan.c

206

key_print_wrapper(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/ssh-keyscan.c

210

if ((c = ssh_get_app_data(ssh)) != NULL)

crypto/openssh/ssh.c

1329

channel_set_af(ssh, options.address_family);

crypto/openssh/ssh.c

1330

ssh_packet_set_qos(ssh, options.ip_qos_interactive,

crypto/openssh/ssh.c

1654

if (ssh_packet_set_connection(ssh, sock, sock) == NULL)

crypto/openssh/ssh.c

1656

ssh_packet_set_mux(ssh);

crypto/openssh/ssh.c

1678

channel_clear_timeouts(ssh);

crypto/openssh/ssh.c

1687

channel_add_timeout(ssh, cp, i);

crypto/openssh/ssh.c

1692

if (ssh_connect(ssh, host, options.host_arg, addrs, &hostaddr,

crypto/openssh/ssh.c

1698

ssh_packet_set_timeout(ssh, options.server_alive_interval,

crypto/openssh/ssh.c

1806

ssh_login(ssh, &sensitive_data, host, &hostaddr, options.port,

crypto/openssh/ssh.c

183

static int ssh_session2(struct ssh *, const struct ssh_conn_info *);

crypto/openssh/ssh.c

1841

exit_status = ssh_session2(ssh, cinfo);

crypto/openssh/ssh.c

1843

channel_free_channels(ssh);

crypto/openssh/ssh.c

1844

ssh_packet_free(ssh);

crypto/openssh/ssh.c

1928

ssh_confirm_remote_forward(struct ssh *ssh, int type, uint32_t seq, void *ctxt)

crypto/openssh/ssh.c

1944

if ((r = sshpkt_get_u32(ssh, &port)) != 0)

crypto/openssh/ssh.c

1952

channel_update_permission(ssh,

crypto/openssh/ssh.c

1961

channel_update_permission(ssh,

crypto/openssh/ssh.c

1965

channel_update_permission(ssh, rfwd->handle, -1);

crypto/openssh/ssh.c

1990

client_cleanup_stdio_fwd(struct ssh *ssh, int id, int force, void *arg)

crypto/openssh/ssh.c

1997

ssh_stdio_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

2004

ssh_tun_confirm(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

2017

ssh_init_stdio_forwarding(struct ssh *ssh)

crypto/openssh/ssh.c

2031

if ((c = channel_connect_stdio_fwd(ssh, options.stdio_forward_host,

crypto/openssh/ssh.c

2035

channel_register_cleanup(ssh, c->self, client_cleanup_stdio_fwd, 0);

crypto/openssh/ssh.c

2036

channel_register_open_confirm(ssh, c->self, ssh_stdio_confirm, NULL);

crypto/openssh/ssh.c

2040

ssh_init_forward_permissions(struct ssh *ssh, const char *what, char **opens,

crypto/openssh/ssh.c

2048

channel_clear_permission(ssh, FORWARD_ADM, where);

crypto/openssh/ssh.c

2056

channel_disable_admin(ssh, where);

crypto/openssh/ssh.c

2069

channel_add_permission(ssh, FORWARD_ADM,

crypto/openssh/ssh.c

2076

ssh_init_forwarding(struct ssh *ssh, char **ifname)

crypto/openssh/ssh.c

2081

ssh_init_forward_permissions(ssh, "permitremoteopen",

crypto/openssh/ssh.c

2101

success += channel_setup_local_fwd_listener(ssh,

crypto/openssh/ssh.c

2123

channel_request_remote_forwarding(ssh,

crypto/openssh/ssh.c

2137

if ((*ifname = client_request_tun_fwd(ssh,

crypto/openssh/ssh.c

2168

ssh_session2_setup(struct ssh *ssh, int id, int success, void *arg)

crypto/openssh/ssh.c

2180

if (options.forward_x11 && client_x11_get_proto(ssh, display,

crypto/openssh/ssh.c

2186

x11_request_forwarding_with_spoofing(ssh, id, display, proto,

crypto/openssh/ssh.c

2188

client_expect_confirm(ssh, id, "X11 forwarding", CONFIRM_WARN);

crypto/openssh/ssh.c

2194

client_channel_reqest_agent_forwarding(ssh, id);

crypto/openssh/ssh.c

2199

client_session2_setup(ssh, id, tty_flag,

crypto/openssh/ssh.c

2206

ssh_session2_open(struct ssh *ssh)

crypto/openssh/ssh.c

2228

c = channel_new(ssh,

crypto/openssh/ssh.c

2233

channel_set_tty(ssh, c);

crypto/openssh/ssh.c

2236

channel_send_open(ssh, c->self);

crypto/openssh/ssh.c

2238

channel_register_open_confirm(ssh, c->self,

crypto/openssh/ssh.c

2245

ssh_session2(struct ssh *ssh, const struct ssh_conn_info *cinfo)

crypto/openssh/ssh.c

2252

ssh_init_stdio_forwarding(ssh);

crypto/openssh/ssh.c

2254

ssh_init_forwarding(ssh, &tun_fwd_ifname);

crypto/openssh/ssh.c

2268

if (!ssh_packet_get_mux(ssh))

crypto/openssh/ssh.c

2269

muxserver_listen(ssh);

crypto/openssh/ssh.c

2299

ssh_init_stdio_forwarding(ssh);

crypto/openssh/ssh.c

2302

id = ssh_session2_open(ssh);

crypto/openssh/ssh.c

2306

(ssh->compat & SSH_NEW_OPENSSH)) {

crypto/openssh/ssh.c

2308

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/ssh.c

2309

(r = sshpkt_put_cstring(ssh,

crypto/openssh/ssh.c

2311

(r = sshpkt_put_u8(ssh, 0)) != 0 ||

crypto/openssh/ssh.c

2312

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/ssh.c

2343

return client_loop(ssh, tty_flag, tty_flag ?

crypto/openssh/ssh.c

622

struct ssh *ssh = NULL;

crypto/openssh/ssh.c

691

if ((ssh = ssh_alloc_session_state()) == NULL)

crypto/openssh/ssh.c

693

channel_init_channels(ssh);

crypto/openssh/ssh_api.c

101

if ((ssh = ssh_packet_set_connection(NULL, -1, -1)) == NULL)

crypto/openssh/ssh_api.c

104

ssh_packet_set_server(ssh);

crypto/openssh/ssh_api.c

108

kex_proposal_populate_entries(ssh, populated,

crypto/openssh/ssh_api.c

114

r = kex_ready(ssh, populated);

crypto/openssh/ssh_api.c

117

ssh_free(ssh);

crypto/openssh/ssh_api.c

121

ssh->kex->server = is_server;

crypto/openssh/ssh_api.c

124

ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_server;

crypto/openssh/ssh_api.c

125

ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_server;

crypto/openssh/ssh_api.c

126

ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_server;

crypto/openssh/ssh_api.c

127

ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_server;

crypto/openssh/ssh_api.c

128

ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_server;

crypto/openssh/ssh_api.c

129

ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_server;

crypto/openssh/ssh_api.c

130

ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_server;

crypto/openssh/ssh_api.c

132

ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_server;

crypto/openssh/ssh_api.c

135

ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_server;

crypto/openssh/ssh_api.c

136

ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_server;

crypto/openssh/ssh_api.c

137

ssh->kex->kex[KEX_KEM_MLKEM768X25519_SHA256] = kex_gen_server;

crypto/openssh/ssh_api.c

138

ssh->kex->load_host_public_key=&_ssh_host_public_key;

crypto/openssh/ssh_api.c

139

ssh->kex->load_host_private_key=&_ssh_host_private_key;

crypto/openssh/ssh_api.c

140

ssh->kex->sign=&_ssh_host_key_sign;

crypto/openssh/ssh_api.c

143

ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_client;

crypto/openssh/ssh_api.c

144

ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_client;

crypto/openssh/ssh_api.c

145

ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

146

ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

147

ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

148

ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;

crypto/openssh/ssh_api.c

149

ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;

crypto/openssh/ssh_api.c

151

ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_client;

crypto/openssh/ssh_api.c

154

ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

155

ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_client;

crypto/openssh/ssh_api.c

156

ssh->kex->kex[KEX_KEM_MLKEM768X25519_SHA256] = kex_gen_client;

crypto/openssh/ssh_api.c

157

ssh->kex->verify_host_key =&_ssh_verify_host_key;

crypto/openssh/ssh_api.c

159

*sshp = ssh;

crypto/openssh/ssh_api.c

164

ssh_free(struct ssh *ssh)

crypto/openssh/ssh_api.c

168

if (ssh == NULL)

crypto/openssh/ssh_api.c

175

while ((k = TAILQ_FIRST(&ssh->public_keys)) != NULL) {

crypto/openssh/ssh_api.c

176

TAILQ_REMOVE(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

177

if (ssh->kex && ssh->kex->server)

crypto/openssh/ssh_api.c

181

while ((k = TAILQ_FIRST(&ssh->private_keys)) != NULL) {

crypto/openssh/ssh_api.c

182

TAILQ_REMOVE(&ssh->private_keys, k, next);

crypto/openssh/ssh_api.c

185

ssh_packet_close(ssh);

crypto/openssh/ssh_api.c

186

free(ssh);

crypto/openssh/ssh_api.c

190

ssh_set_app_data(struct ssh *ssh, void *app_data)

crypto/openssh/ssh_api.c

192

ssh->app_data = app_data;

crypto/openssh/ssh_api.c

196

ssh_get_app_data(struct ssh *ssh)

crypto/openssh/ssh_api.c

198

return ssh->app_data;

crypto/openssh/ssh_api.c

203

ssh_add_hostkey(struct ssh *ssh, struct sshkey *key)

crypto/openssh/ssh_api.c

209

if (ssh->kex->server) {

crypto/openssh/ssh_api.c

219

TAILQ_INSERT_TAIL(&ssh->private_keys, k_prv, next);

crypto/openssh/ssh_api.c

223

TAILQ_INSERT_TAIL(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

229

TAILQ_INSERT_TAIL(&ssh->public_keys, k, next);

crypto/openssh/ssh_api.c

237

ssh_set_verify_host_key_callback(struct ssh *ssh,

crypto/openssh/ssh_api.c

238

int (*cb)(struct sshkey *, struct ssh *))

crypto/openssh/ssh_api.c

240

if (cb == NULL || ssh->kex == NULL)

crypto/openssh/ssh_api.c

243

ssh->kex->verify_host_key = cb;

crypto/openssh/ssh_api.c

249

ssh_input_append(struct ssh *ssh, const u_char *data, size_t len)

crypto/openssh/ssh_api.c

251

return sshbuf_put(ssh_packet_get_input(ssh), data, len);

crypto/openssh/ssh_api.c

255

ssh_packet_next(struct ssh *ssh, u_char *typep)

crypto/openssh/ssh_api.c

266

if (sshbuf_len(ssh->kex->client_version) == 0 ||

crypto/openssh/ssh_api.c

267

sshbuf_len(ssh->kex->server_version) == 0)

crypto/openssh/ssh_api.c

268

return _ssh_exchange_banner(ssh);

crypto/openssh/ssh_api.c

281

if ((r = ssh_packet_read_poll2(ssh, &type, &seqnr)) != 0)

crypto/openssh/ssh_api.c

285

ssh->dispatch[type] != NULL) {

crypto/openssh/ssh_api.c

286

if ((r = (*ssh->dispatch[type])(type, seqnr, ssh)) != 0)

crypto/openssh/ssh_api.c

296

ssh_packet_payload(struct ssh *ssh, size_t *lenp)

crypto/openssh/ssh_api.c

298

return sshpkt_ptr(ssh, lenp);

crypto/openssh/ssh_api.c

302

ssh_packet_put(struct ssh *ssh, int type, const u_char *data, size_t len)

crypto/openssh/ssh_api.c

306

if ((r = sshpkt_start(ssh, type)) != 0 ||

crypto/openssh/ssh_api.c

307

(r = sshpkt_put(ssh, data, len)) != 0 ||

crypto/openssh/ssh_api.c

308

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/ssh_api.c

314

ssh_output_ptr(struct ssh *ssh, size_t *len)

crypto/openssh/ssh_api.c

316

struct sshbuf *output = ssh_packet_get_output(ssh);

crypto/openssh/ssh_api.c

323

ssh_output_consume(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

325

return sshbuf_consume(ssh_packet_get_output(ssh), len);

crypto/openssh/ssh_api.c

329

ssh_output_space(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

331

return (0 == sshbuf_check_reserve(ssh_packet_get_output(ssh), len));

crypto/openssh/ssh_api.c

335

ssh_input_space(struct ssh *ssh, size_t len)

crypto/openssh/ssh_api.c

337

return (0 == sshbuf_check_reserve(ssh_packet_get_input(ssh), len));

crypto/openssh/ssh_api.c

342

_ssh_read_banner(struct ssh *ssh, struct sshbuf *banner)

crypto/openssh/ssh_api.c

344

struct sshbuf *input = ssh_packet_get_input(ssh);

crypto/openssh/ssh_api.c

378

if (ssh->kex->server || ++n > SSH_MAX_PRE_BANNER_LINES) {

crypto/openssh/ssh_api.c

380

if ((r = sshbuf_put(ssh_packet_get_output(ssh),

crypto/openssh/ssh_api.c

408

compat_banner(ssh, remote_version);

crypto/openssh/ssh_api.c

42

int _ssh_exchange_banner(struct ssh *);

crypto/openssh/ssh_api.c

425

_ssh_send_banner(struct ssh *ssh, struct sshbuf *banner)

crypto/openssh/ssh_api.c

43

int _ssh_send_banner(struct ssh *, struct sshbuf *);

crypto/openssh/ssh_api.c

432

if ((r = sshbuf_putb(ssh_packet_get_output(ssh), banner)) != 0)

crypto/openssh/ssh_api.c

44

int _ssh_read_banner(struct ssh *, struct sshbuf *);

crypto/openssh/ssh_api.c

445

_ssh_exchange_banner(struct ssh *ssh)

crypto/openssh/ssh_api.c

447

struct kex *kex = ssh->kex;

crypto/openssh/ssh_api.c

45

int _ssh_order_hostkeyalgs(struct ssh *);

crypto/openssh/ssh_api.c

457

if (sshbuf_len(ssh->kex->server_version) == 0)

crypto/openssh/ssh_api.c

458

r = _ssh_send_banner(ssh, ssh->kex->server_version);

crypto/openssh/ssh_api.c

46

int _ssh_verify_host_key(struct sshkey *, struct ssh *);

crypto/openssh/ssh_api.c

460

sshbuf_len(ssh->kex->server_version) != 0 &&

crypto/openssh/ssh_api.c

461

sshbuf_len(ssh->kex->client_version) == 0)

crypto/openssh/ssh_api.c

462

r = _ssh_read_banner(ssh, ssh->kex->client_version);

crypto/openssh/ssh_api.c

464

if (sshbuf_len(ssh->kex->server_version) == 0)

crypto/openssh/ssh_api.c

465

r = _ssh_read_banner(ssh, ssh->kex->server_version);

crypto/openssh/ssh_api.c

467

sshbuf_len(ssh->kex->server_version) != 0 &&

crypto/openssh/ssh_api.c

468

sshbuf_len(ssh->kex->client_version) == 0)

crypto/openssh/ssh_api.c

469

r = _ssh_send_banner(ssh, ssh->kex->client_version);

crypto/openssh/ssh_api.c

47

struct sshkey *_ssh_host_public_key(int, int, struct ssh *);

crypto/openssh/ssh_api.c

474

if (sshbuf_len(ssh->kex->server_version) != 0 &&

crypto/openssh/ssh_api.c

475

sshbuf_len(ssh->kex->client_version) != 0) {

crypto/openssh/ssh_api.c

476

if ((r = _ssh_order_hostkeyalgs(ssh)) != 0 ||

crypto/openssh/ssh_api.c

477

(r = kex_send_kexinit(ssh)) != 0)

crypto/openssh/ssh_api.c

48

struct sshkey *_ssh_host_private_key(int, int, struct ssh *);

crypto/openssh/ssh_api.c

484

_ssh_host_public_key(int type, int nid, struct ssh *ssh)

crypto/openssh/ssh_api.c

489

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

49

int _ssh_host_key_sign(struct ssh *, struct sshkey *, struct sshkey *,

crypto/openssh/ssh_api.c

499

_ssh_host_private_key(int type, int nid, struct ssh *ssh)

crypto/openssh/ssh_api.c

504

TAILQ_FOREACH(k, &ssh->private_keys, next) {

crypto/openssh/ssh_api.c

514

_ssh_verify_host_key(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/ssh_api.c

519

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

529

_ssh_order_hostkeyalgs(struct ssh *ssh)

crypto/openssh/ssh_api.c

538

if ((r = kex_buf2prop(ssh->kex->my, NULL, &proposal)) != 0)

crypto/openssh/ssh_api.c

555

TAILQ_FOREACH(k, &ssh->public_keys, next) {

crypto/openssh/ssh_api.c

571

debug2_f("orig/%d %s", ssh->kex->server, orig);

crypto/openssh/ssh_api.c

572

debug2_f("replace/%d %s", ssh->kex->server, replace);

crypto/openssh/ssh_api.c

576

r = kex_prop2buf(ssh->kex->my, proposal);

crypto/openssh/ssh_api.c

586

_ssh_host_key_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/ssh_api.c

591

alg, NULL, NULL, ssh->compat);

crypto/openssh/ssh_api.c

87

ssh_init(struct ssh **sshp, int is_server, struct kex_params *kex_params)

crypto/openssh/ssh_api.c

91

struct ssh *ssh;

crypto/openssh/ssh_api.h

102

int ssh_packet_put(struct ssh *ssh, int type, const u_char *data,

crypto/openssh/ssh_api.h

109

int ssh_input_space(struct ssh *ssh, size_t len);

crypto/openssh/ssh_api.h

114

int ssh_input_append(struct ssh *ssh, const u_char *data, size_t len);

crypto/openssh/ssh_api.h

120

int ssh_output_space(struct ssh *ssh, size_t len);

crypto/openssh/ssh_api.h

128

const u_char *ssh_output_ptr(struct ssh *ssh, size_t *len);

crypto/openssh/ssh_api.h

134

int ssh_output_consume(struct ssh *ssh, size_t len);

crypto/openssh/ssh_api.h

42

int ssh_init(struct ssh **, int is_server, struct kex_params *kex_params);

crypto/openssh/ssh_api.h

47

void ssh_free(struct ssh *);

crypto/openssh/ssh_api.h

52

void ssh_set_app_data(struct ssh *, void *);

crypto/openssh/ssh_api.h

53

void *ssh_get_app_data(struct ssh *);

crypto/openssh/ssh_api.h

63

int ssh_add_hostkey(struct ssh *ssh, struct sshkey *key);

crypto/openssh/ssh_api.h

71

int ssh_set_verify_host_key_callback(struct ssh *ssh,

crypto/openssh/ssh_api.h

72

int (*cb)(struct sshkey *, struct ssh *));

crypto/openssh/ssh_api.h

88

int ssh_packet_next(struct ssh *ssh, u_char *typep);

crypto/openssh/ssh_api.h

95

const u_char *ssh_packet_payload(struct ssh *ssh, size_t *lenp);

crypto/openssh/sshconnect.c

143

ssh_proxy_fdpass_connect(struct ssh *ssh, const char *host,

crypto/openssh/sshconnect.c

1639

ssh_login(struct ssh *ssh, Sensitive *sensitive, const char *orighost,

crypto/openssh/sshconnect.c

1655

if ((r = kex_exchange_identification(ssh, timeout_ms,

crypto/openssh/sshconnect.c

1657

sshpkt_fatal(ssh, r, "banner exchange");

crypto/openssh/sshconnect.c

1659

if ((ssh->compat & SSH_BUG_NOREKEY)) {

crypto/openssh/sshconnect.c

1665

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshconnect.c

1670

ssh_kex2(ssh, host, hostaddr, port, cinfo);

crypto/openssh/sshconnect.c

1671

if (!options.kex_algorithms_set && ssh->kex != NULL &&

crypto/openssh/sshconnect.c

1672

ssh->kex->name != NULL && options.warn_weak_crypto &&

crypto/openssh/sshconnect.c

1673

!kex_is_pq_from_name(ssh->kex->name))

crypto/openssh/sshconnect.c

1675

ssh_userauth2(ssh, local_user, server_user, host, sensitive);

crypto/openssh/sshconnect.c

215

if (ssh_packet_set_connection(ssh, sock, sock) == NULL)

crypto/openssh/sshconnect.c

225

ssh_proxy_connect(struct ssh *ssh, const char *host, const char *host_arg,

crypto/openssh/sshconnect.c

298

if (ssh_packet_set_connection(ssh, pout[0], pin[1]) == NULL)

crypto/openssh/sshconnect.c

477

ssh_connect_direct(struct ssh *ssh, const char *host, struct addrinfo *aitop,

crypto/openssh/sshconnect.c

577

if (ssh_packet_set_connection(ssh, sock, sock) == NULL)

crypto/openssh/sshconnect.c

584

ssh_connect(struct ssh *ssh, const char *host, const char *host_arg,

crypto/openssh/sshconnect.c

591

return ssh_connect_direct(ssh, host, addrs, hostaddr, port,

crypto/openssh/sshconnect.c

601

if ((ssh_packet_set_connection(ssh, in, out)) == NULL)

crypto/openssh/sshconnect.c

605

return ssh_proxy_fdpass_connect(ssh, host, host_arg, port,

crypto/openssh/sshconnect.c

608

return ssh_proxy_connect(ssh, host, host_arg, port,

crypto/openssh/sshconnect.h

51

struct ssh;

crypto/openssh/sshconnect.h

73

int ssh_connect(struct ssh *, const char *, const char *,

crypto/openssh/sshconnect.h

78

void ssh_login(struct ssh *, Sensitive *, const char *,

crypto/openssh/sshconnect.h

88

void ssh_kex2(struct ssh *ssh, char *, struct sockaddr_storage *, u_short,

crypto/openssh/sshconnect.h

91

void ssh_userauth2(struct ssh *ssh, const char *, const char *,

crypto/openssh/sshconnect2.c

1001

input_gssapi_error(int type, uint32_t plen, struct ssh *ssh)

crypto/openssh/sshconnect2.c

1007

if ((r = sshpkt_get_u32(ssh, NULL)) != 0 || /* maj */

crypto/openssh/sshconnect2.c

1008

(r = sshpkt_get_u32(ssh, NULL)) != 0 || /* min */

crypto/openssh/sshconnect2.c

1009

(r = sshpkt_get_cstring(ssh, &msg, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1010

(r = sshpkt_get_cstring(ssh, &lang, NULL)) != 0)

crypto/openssh/sshconnect2.c

1012

r = sshpkt_get_end(ssh);

crypto/openssh/sshconnect2.c

1022

userauth_none(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1024

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1028

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1029

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1030

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1031

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1032

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1038

userauth_passwd(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1040

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1054

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1055

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1056

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1057

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1058

(r = sshpkt_put_u8(ssh, 0)) != 0 ||

crypto/openssh/sshconnect2.c

1059

(r = sshpkt_put_cstring(ssh, password)) != 0 ||

crypto/openssh/sshconnect2.c

1060

(r = sshpkt_add_padding(ssh, 64)) != 0 ||

crypto/openssh/sshconnect2.c

1061

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1068

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

crypto/openssh/sshconnect2.c

1078

input_userauth_passwd_changereq(int type, uint32_t seqnr, struct ssh *ssh)

crypto/openssh/sshconnect2.c

1080

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

1094

if ((r = sshpkt_get_cstring(ssh, &info, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1095

(r = sshpkt_get_cstring(ssh, &lang, NULL)) != 0)

crypto/openssh/sshconnect2.c

1101

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1102

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1103

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1104

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1105

(r = sshpkt_put_u8(ssh, 1)) != 0) /* additional info */

crypto/openssh/sshconnect2.c

1112

if ((r = sshpkt_put_cstring(ssh, password)) != 0)

crypto/openssh/sshconnect2.c

1138

if ((r = sshpkt_put_cstring(ssh, password)) != 0 ||

crypto/openssh/sshconnect2.c

1139

(r = sshpkt_add_padding(ssh, 64)) != 0 ||

crypto/openssh/sshconnect2.c

1140

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1143

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PASSWD_CHANGEREQ,

crypto/openssh/sshconnect2.c

1162

key_sig_algorithm(struct ssh *ssh, const struct sshkey *key)

crypto/openssh/sshconnect2.c

1172

if (ssh == NULL || ssh->kex->server_sig_algs == NULL ||

crypto/openssh/sshconnect2.c

1174

(key->type == KEY_RSA_CERT && (ssh->compat & SSH_BUG_SIGTYPE))) {

crypto/openssh/sshconnect2.c

1184

server_sig_algs = ssh->kex->server_sig_algs;

crypto/openssh/sshconnect2.c

1185

if (key->type == KEY_RSA && (ssh->compat & SSH_BUG_SIGTYPE74))

crypto/openssh/sshconnect2.c

1318

sign_and_send_pubkey(struct ssh *ssh, Identity *id)

crypto/openssh/sshconnect2.c

1320

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1331

if ((ssh->kex->flags & KEX_HAS_PUBKEY_HOSTBOUND) != 0 &&

crypto/openssh/sshconnect2.c

1399

if ((alg = key_sig_algorithm(fallback_sigtype ? NULL : ssh,

crypto/openssh/sshconnect2.c

1409

if (ssh->compat & SSH_OLD_SESSIONID) {

crypto/openssh/sshconnect2.c

1410

if ((r = sshbuf_putb(b, ssh->kex->session_id)) != 0)

crypto/openssh/sshconnect2.c

1414

ssh->kex->session_id)) != 0)

crypto/openssh/sshconnect2.c

1428

if (ssh->kex->initial_hostkey == NULL) {

crypto/openssh/sshconnect2.c

1432

if ((r = sshkey_puts(ssh->kex->initial_hostkey, b)) != 0)

crypto/openssh/sshconnect2.c

1437

sshbuf_ptr(b), sshbuf_len(b), ssh->compat, alg);

crypto/openssh/sshconnect2.c

1473

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1474

(r = sshpkt_putb(ssh, b)) != 0 ||

crypto/openssh/sshconnect2.c

1475

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1490

send_pubkey_test(struct ssh *ssh, Identity *id)

crypto/openssh/sshconnect2.c

1492

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1499

if ((alg = key_sig_algorithm(ssh, id->key)) == NULL) {

crypto/openssh/sshconnect2.c

1510

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_PK_OK, &input_userauth_pk_ok);

crypto/openssh/sshconnect2.c

1512

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1513

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1514

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1515

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1516

(r = sshpkt_put_u8(ssh, have_sig)) != 0 ||

crypto/openssh/sshconnect2.c

1517

(r = sshpkt_put_cstring(ssh, alg)) != 0 ||

crypto/openssh/sshconnect2.c

1518

(r = sshpkt_put_string(ssh, blob, bloblen)) != 0 ||

crypto/openssh/sshconnect2.c

1519

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1642

get_agent_identities(struct ssh *ssh, int *agent_fdp,

crypto/openssh/sshconnect2.c

1653

if ((r = ssh_agent_bind_hostkey(agent_fd, ssh->kex->initial_hostkey,

crypto/openssh/sshconnect2.c

1654

ssh->kex->session_id, ssh->kex->initial_sig, 0)) == 0)

crypto/openssh/sshconnect2.c

1680

pubkey_prepare(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/sshconnect2.c

1742

if ((r = get_agent_identities(ssh, &agent_fd, &idlist)) == 0) {

crypto/openssh/sshconnect2.c

1815

} else if (ssh->kex->server_sig_algs != NULL &&

crypto/openssh/sshconnect2.c

1816

(cp = key_sig_algorithm(ssh, id->key)) == NULL) {

crypto/openssh/sshconnect2.c

1841

pubkey_cleanup(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1843

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1869

userauth_pubkey(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1871

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1878

pubkey_prepare(ssh, authctxt);

crypto/openssh/sshconnect2.c

1897

sent = send_pubkey_test(ssh, id);

crypto/openssh/sshconnect2.c

1903

sent = sign_and_send_pubkey(ssh, id);

crypto/openssh/sshconnect2.c

1919

userauth_kbdint(struct ssh *ssh)

crypto/openssh/sshconnect2.c

1921

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

1929

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_REQUEST, NULL);

crypto/openssh/sshconnect2.c

1934

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

1935

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

1936

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

1937

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

1938

(r = sshpkt_put_cstring(ssh, "")) != 0 || /* lang */

crypto/openssh/sshconnect2.c

1939

(r = sshpkt_put_cstring(ssh, options.kbd_interactive_devices ?

crypto/openssh/sshconnect2.c

1941

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

1944

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_INFO_REQUEST, &input_userauth_info_req);

crypto/openssh/sshconnect2.c

1952

input_userauth_info_req(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

1954

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

1969

if ((r = sshpkt_get_cstring(ssh, &name, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1970

(r = sshpkt_get_cstring(ssh, &inst, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1971

(r = sshpkt_get_cstring(ssh, &lang, NULL)) != 0)

crypto/openssh/sshconnect2.c

1982

if ((r = sshpkt_get_u32(ssh, &num_prompts)) != 0)

crypto/openssh/sshconnect2.c

1990

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_INFO_RESPONSE)) != 0 ||

crypto/openssh/sshconnect2.c

1991

(r = sshpkt_put_u32(ssh, num_prompts)) != 0)

crypto/openssh/sshconnect2.c

1996

if ((r = sshpkt_get_cstring(ssh, &prompt, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

1997

(r = sshpkt_get_u8(ssh, &echo)) != 0)

crypto/openssh/sshconnect2.c

2004

if ((r = sshpkt_put_cstring(ssh, response)) != 0)

crypto/openssh/sshconnect2.c

2012

if ((r = sshpkt_get_end(ssh)) != 0 ||

crypto/openssh/sshconnect2.c

2013

(r = sshpkt_add_padding(ssh, 64)) != 0)

crypto/openssh/sshconnect2.c

2015

r = sshpkt_send(ssh);

crypto/openssh/sshconnect2.c

2028

ssh_keysign(struct ssh *ssh, struct sshkey *key, u_char **sigp, size_t *lenp,

crypto/openssh/sshconnect2.c

2035

int sock = ssh_packet_get_connection_in(ssh);

crypto/openssh/sshconnect2.c

2144

userauth_hostbased(struct ssh *ssh)

crypto/openssh/sshconnect2.c

2146

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

219

ssh_kex2(struct ssh *ssh, char *host, struct sockaddr_storage *hostaddr,

crypto/openssh/sshconnect2.c

2209

lname = get_local_name(ssh_packet_get_connection_in(ssh));

crypto/openssh/sshconnect2.c

2228

if ((r = sshbuf_put_stringb(b, ssh->kex->session_id)) != 0 ||

crypto/openssh/sshconnect2.c

2244

if ((r = ssh_keysign(ssh, private, &sig, &siglen,

crypto/openssh/sshconnect2.c

2250

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

2251

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

2252

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

2253

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

2254

(r = sshpkt_put_cstring(ssh, authctxt->active_ktype)) != 0 ||

crypto/openssh/sshconnect2.c

2255

(r = sshpkt_put_string(ssh, keyblob, keylen)) != 0 ||

crypto/openssh/sshconnect2.c

2256

(r = sshpkt_put_cstring(ssh, chost)) != 0 ||

crypto/openssh/sshconnect2.c

2257

(r = sshpkt_put_cstring(ssh, authctxt->local_user)) != 0 ||

crypto/openssh/sshconnect2.c

2258

(r = sshpkt_put_string(ssh, sig, siglen)) != 0 ||

crypto/openssh/sshconnect2.c

2259

(r = sshpkt_send(ssh)) != 0) {

crypto/openssh/sshconnect2.c

231

ssh_packet_set_rekey_limits(ssh, options.rekey_limit,

crypto/openssh/sshconnect2.c

256

kex_proposal_populate_entries(ssh, myproposal,

crypto/openssh/sshconnect2.c

264

if ((r = kex_setup(ssh, myproposal)) != 0)

crypto/openssh/sshconnect2.c

267

ssh->kex->kex[KEX_DH_GRP1_SHA1] = kex_gen_client;

crypto/openssh/sshconnect2.c

268

ssh->kex->kex[KEX_DH_GRP14_SHA1] = kex_gen_client;

crypto/openssh/sshconnect2.c

269

ssh->kex->kex[KEX_DH_GRP14_SHA256] = kex_gen_client;

crypto/openssh/sshconnect2.c

270

ssh->kex->kex[KEX_DH_GRP16_SHA512] = kex_gen_client;

crypto/openssh/sshconnect2.c

271

ssh->kex->kex[KEX_DH_GRP18_SHA512] = kex_gen_client;

crypto/openssh/sshconnect2.c

272

ssh->kex->kex[KEX_DH_GEX_SHA1] = kexgex_client;

crypto/openssh/sshconnect2.c

273

ssh->kex->kex[KEX_DH_GEX_SHA256] = kexgex_client;

crypto/openssh/sshconnect2.c

275

ssh->kex->kex[KEX_ECDH_SHA2] = kex_gen_client;

crypto/openssh/sshconnect2.c

278

ssh->kex->kex[KEX_C25519_SHA256] = kex_gen_client;

crypto/openssh/sshconnect2.c

279

ssh->kex->kex[KEX_KEM_SNTRUP761X25519_SHA512] = kex_gen_client;

crypto/openssh/sshconnect2.c

280

ssh->kex->kex[KEX_KEM_MLKEM768X25519_SHA256] = kex_gen_client;

crypto/openssh/sshconnect2.c

281

ssh->kex->verify_host_key=&verify_host_key_callback;

crypto/openssh/sshconnect2.c

283

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &ssh->kex->done);

crypto/openssh/sshconnect2.c

288

if ((r = sshpkt_start(ssh, SSH2_MSG_IGNORE)) != 0 ||

crypto/openssh/sshconnect2.c

289

(r = sshpkt_put_cstring(ssh, "markus")) != 0 ||

crypto/openssh/sshconnect2.c

290

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/sshconnect2.c

291

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/sshconnect2.c

347

int (*userauth)(struct ssh *ssh);

crypto/openssh/sshconnect2.c

348

void (*cleanup)(struct ssh *ssh);

crypto/openssh/sshconnect2.c

353

static int input_userauth_service_accept(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

354

static int input_userauth_success(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

355

static int input_userauth_failure(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

356

static int input_userauth_banner(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

357

static int input_userauth_error(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

358

static int input_userauth_info_req(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

359

static int input_userauth_pk_ok(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

360

static int input_userauth_passwd_changereq(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

362

static int userauth_none(struct ssh *);

crypto/openssh/sshconnect2.c

363

static int userauth_pubkey(struct ssh *);

crypto/openssh/sshconnect2.c

364

static int userauth_passwd(struct ssh *);

crypto/openssh/sshconnect2.c

365

static int userauth_kbdint(struct ssh *);

crypto/openssh/sshconnect2.c

366

static int userauth_hostbased(struct ssh *);

crypto/openssh/sshconnect2.c

369

static int userauth_gssapi(struct ssh *);

crypto/openssh/sshconnect2.c

370

static void userauth_gssapi_cleanup(struct ssh *);

crypto/openssh/sshconnect2.c

371

static int input_gssapi_response(int type, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

372

static int input_gssapi_token(int type, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

373

static int input_gssapi_error(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

374

static int input_gssapi_errtok(int, uint32_t, struct ssh *);

crypto/openssh/sshconnect2.c

377

void userauth(struct ssh *, char *);

crypto/openssh/sshconnect2.c

379

static void pubkey_cleanup(struct ssh *);

crypto/openssh/sshconnect2.c

380

static int sign_and_send_pubkey(struct ssh *ssh, Identity *);

crypto/openssh/sshconnect2.c

381

static void pubkey_prepare(struct ssh *, Authctxt *);

crypto/openssh/sshconnect2.c

426

ssh_userauth2(struct ssh *ssh, const char *local_user,

crypto/openssh/sshconnect2.c

458

if ((r = sshpkt_start(ssh, SSH2_MSG_SERVICE_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

459

(r = sshpkt_put_cstring(ssh, "ssh-userauth")) != 0 ||

crypto/openssh/sshconnect2.c

460

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

463

ssh->authctxt = &authctxt;

crypto/openssh/sshconnect2.c

464

ssh_dispatch_init(ssh, &input_userauth_error);

crypto/openssh/sshconnect2.c

465

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, kex_input_ext_info);

crypto/openssh/sshconnect2.c

466

ssh_dispatch_set(ssh, SSH2_MSG_SERVICE_ACCEPT, &input_userauth_service_accept);

crypto/openssh/sshconnect2.c

467

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &authctxt.success); /* loop until success */

crypto/openssh/sshconnect2.c

468

pubkey_cleanup(ssh);

crypto/openssh/sshconnect2.c

477

ssh->authctxt = NULL;

crypto/openssh/sshconnect2.c

479

ssh_dispatch_range(ssh, SSH2_MSG_USERAUTH_MIN, SSH2_MSG_USERAUTH_MAX, NULL);

crypto/openssh/sshconnect2.c

483

if (ssh_packet_connection_is_on_socket(ssh)) {

crypto/openssh/sshconnect2.c

485

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh),

crypto/openssh/sshconnect2.c

494

input_userauth_service_accept(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

498

if (ssh_packet_remaining(ssh) > 0) {

crypto/openssh/sshconnect2.c

501

if ((r = sshpkt_get_cstring(ssh, &reply, NULL)) != 0)

crypto/openssh/sshconnect2.c

508

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

513

userauth_none(ssh);

crypto/openssh/sshconnect2.c

516

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, ssh->kex->ext_info_s ?

crypto/openssh/sshconnect2.c

518

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_SUCCESS, &input_userauth_success);

crypto/openssh/sshconnect2.c

519

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_FAILURE, &input_userauth_failure);

crypto/openssh/sshconnect2.c

520

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_BANNER, &input_userauth_banner);

crypto/openssh/sshconnect2.c

527

userauth(struct ssh *ssh, char *authlist)

crypto/openssh/sshconnect2.c

529

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

532

authctxt->method->cleanup(ssh);

crypto/openssh/sshconnect2.c

550

ssh_dispatch_range(ssh, SSH2_MSG_USERAUTH_PER_METHOD_MIN,

crypto/openssh/sshconnect2.c

554

if (method->userauth(ssh) != 0) {

crypto/openssh/sshconnect2.c

565

input_userauth_error(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

572

input_userauth_banner(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

579

if ((r = sshpkt_get_cstring(ssh, &msg, &len)) != 0 ||

crypto/openssh/sshconnect2.c

580

(r = sshpkt_get_cstring(ssh, NULL, NULL)) != 0)

crypto/openssh/sshconnect2.c

591

input_userauth_success(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

593

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

600

authctxt->method->cleanup(ssh);

crypto/openssh/sshconnect2.c

604

ssh_dispatch_set(ssh, SSH2_MSG_EXT_INFO, dispatch_protocol_error);

crypto/openssh/sshconnect2.c

610

input_userauth_success_unexpected(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

612

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

624

input_userauth_failure(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

626

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

633

if (sshpkt_get_cstring(ssh, &authlist, NULL) != 0 ||

crypto/openssh/sshconnect2.c

634

sshpkt_get_u8(ssh, &partial) != 0 ||

crypto/openssh/sshconnect2.c

635

sshpkt_get_end(ssh) != 0)

crypto/openssh/sshconnect2.c

646

userauth(ssh, authlist);

crypto/openssh/sshconnect2.c

684

input_userauth_pk_ok(int type, uint32_t seq, struct ssh *ssh)

crypto/openssh/sshconnect2.c

686

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

698

if ((r = sshpkt_get_cstring(ssh, &pkalg, NULL)) != 0 ||

crypto/openssh/sshconnect2.c

699

(r = sshpkt_get_string(ssh, &pkblob, &blen)) != 0 ||

crypto/openssh/sshconnect2.c

700

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

741

sent = sign_and_send_pubkey(ssh, id);

crypto/openssh/sshconnect2.c

752

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

758

userauth_gssapi(struct ssh *ssh)

crypto/openssh/sshconnect2.c

760

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

791

if ((r = sshpkt_start(ssh, SSH2_MSG_USERAUTH_REQUEST)) != 0 ||

crypto/openssh/sshconnect2.c

792

(r = sshpkt_put_cstring(ssh, authctxt->server_user)) != 0 ||

crypto/openssh/sshconnect2.c

793

(r = sshpkt_put_cstring(ssh, authctxt->service)) != 0 ||

crypto/openssh/sshconnect2.c

794

(r = sshpkt_put_cstring(ssh, authctxt->method->name)) != 0 ||

crypto/openssh/sshconnect2.c

795

(r = sshpkt_put_u32(ssh, 1)) != 0 ||

crypto/openssh/sshconnect2.c

796

(r = sshpkt_put_u32(ssh, (mech->length) + 2)) != 0 ||

crypto/openssh/sshconnect2.c

797

(r = sshpkt_put_u8(ssh, SSH_GSS_OIDTYPE)) != 0 ||

crypto/openssh/sshconnect2.c

798

(r = sshpkt_put_u8(ssh, mech->length)) != 0 ||

crypto/openssh/sshconnect2.c

799

(r = sshpkt_put(ssh, mech->elements, mech->length)) != 0 ||

crypto/openssh/sshconnect2.c

800

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

803

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_RESPONSE, &input_gssapi_response);

crypto/openssh/sshconnect2.c

804

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_TOKEN, &input_gssapi_token);

crypto/openssh/sshconnect2.c

805

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERROR, &input_gssapi_error);

crypto/openssh/sshconnect2.c

806

ssh_dispatch_set(ssh, SSH2_MSG_USERAUTH_GSSAPI_ERRTOK, &input_gssapi_errtok);

crypto/openssh/sshconnect2.c

814

userauth_gssapi_cleanup(struct ssh *ssh)

crypto/openssh/sshconnect2.c

816

Authctxt *authctxt = (Authctxt *)ssh->authctxt;

crypto/openssh/sshconnect2.c

824

process_gssapi_token(struct ssh *ssh, gss_buffer_t recv_tok)

crypto/openssh/sshconnect2.c

826

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

842

if ((r = sshpkt_start(ssh, type)) != 0 ||

crypto/openssh/sshconnect2.c

843

(r = sshpkt_put_string(ssh, send_tok.value,

crypto/openssh/sshconnect2.c

845

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

854

if ((r = sshpkt_start(ssh,

crypto/openssh/sshconnect2.c

856

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

865

ssh->kex->session_id);

crypto/openssh/sshconnect2.c

874

if ((r = sshpkt_start(ssh,

crypto/openssh/sshconnect2.c

876

(r = sshpkt_put_string(ssh, mic.value,

crypto/openssh/sshconnect2.c

878

(r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshconnect2.c

891

input_gssapi_response(int type, uint32_t plen, struct ssh *ssh)

crypto/openssh/sshconnect2.c

893

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

904

if ((r = sshpkt_get_string(ssh, &oidv, &oidlen)) != 0)

crypto/openssh/sshconnect2.c

91

verify_host_key_callback(struct sshkey *hostkey, struct ssh *ssh)

crypto/openssh/sshconnect2.c

911

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

918

if ((r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

921

if (GSS_ERROR(process_gssapi_token(ssh, GSS_C_NO_BUFFER))) {

crypto/openssh/sshconnect2.c

924

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

935

input_gssapi_token(int type, uint32_t plen, struct ssh *ssh)

crypto/openssh/sshconnect2.c

937

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

947

if ((r = sshpkt_get_string(ssh, &p, &len)) != 0 ||

crypto/openssh/sshconnect2.c

948

(r = sshpkt_get_end(ssh)) != 0)

crypto/openssh/sshconnect2.c

953

status = process_gssapi_token(ssh, &recv_tok);

crypto/openssh/sshconnect2.c

957

userauth(ssh, NULL);

crypto/openssh/sshconnect2.c

967

input_gssapi_errtok(int type, uint32_t plen, struct ssh *ssh)

crypto/openssh/sshconnect2.c

969

Authctxt *authctxt = ssh->authctxt;

crypto/openssh/sshconnect2.c

982

if ((r = sshpkt_get_string(ssh, &p, &len)) != 0 ||

crypto/openssh/sshconnect2.c

983

(r = sshpkt_get_end(ssh)) != 0) {

crypto/openssh/sshd-auth.c

148

struct ssh *the_active_state;

crypto/openssh/sshd-auth.c

163

static void do_ssh2_kex(struct ssh *);

crypto/openssh/sshd-auth.c

288

get_hostkey_public_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-auth.c

326

get_hostkey_private_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-auth.c

339

get_hostkey_public_by_index(int ind, struct ssh *ssh)

crypto/openssh/sshd-auth.c

347

get_hostkey_index(struct sshkey *key, int compare, struct ssh *ssh)

crypto/openssh/sshd-auth.c

419

recv_privsep_state(struct ssh *ssh, ServerOptions *o, uint64_t *timing_secretp)

crypto/openssh/sshd-auth.c

425

mm_get_state(ssh, o, NULL, timing_secretp,

crypto/openssh/sshd-auth.c

440

struct ssh *ssh = NULL;

crypto/openssh/sshd-auth.c

608

if ((ssh = ssh_packet_set_connection(NULL, sock_in, sock_out)) == NULL)

crypto/openssh/sshd-auth.c

610

the_active_state = ssh;

crypto/openssh/sshd-auth.c

611

ssh_packet_set_server(ssh);

crypto/openssh/sshd-auth.c

612

pmonitor->m_pkex = &ssh->kex;

crypto/openssh/sshd-auth.c

618

recv_privsep_state(ssh, &options, &timing_secret);

crypto/openssh/sshd-auth.c

620

ssh_packet_set_qos(ssh, options.ip_qos_interactive,

crypto/openssh/sshd-auth.c

704

channel_init_channels(ssh);

crypto/openssh/sshd-auth.c

705

channel_set_af(ssh, options.address_family);

crypto/openssh/sshd-auth.c

706

server_process_channel_timeouts(ssh);

crypto/openssh/sshd-auth.c

707

server_process_permitopen(ssh);

crypto/openssh/sshd-auth.c

709

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshd-auth.c

713

ssh->authctxt = authctxt;

crypto/openssh/sshd-auth.c

736

do_ssh2_kex(ssh);

crypto/openssh/sshd-auth.c

737

do_authentication2(ssh);

crypto/openssh/sshd-auth.c

742

mm_send_keystate(ssh, pmonitor);

crypto/openssh/sshd-auth.c

744

ssh_packet_clear_keys(ssh);

crypto/openssh/sshd-auth.c

749

sshd_hostkey_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/sshd-auth.c

754

if (mm_sshkey_sign(ssh, privkey, signature, slenp,

crypto/openssh/sshd-auth.c

756

ssh->compat) < 0)

crypto/openssh/sshd-auth.c

759

if (mm_sshkey_sign(ssh, pubkey, signature, slenp,

crypto/openssh/sshd-auth.c

761

ssh->compat) < 0)

crypto/openssh/sshd-auth.c

769

do_ssh2_kex(struct ssh *ssh)

crypto/openssh/sshd-auth.c

777

ssh_packet_set_rekey_limits(ssh, options.rekey_limit,

crypto/openssh/sshd-auth.c

784

kex_proposal_populate_entries(ssh, myproposal, options.kex_algorithms,

crypto/openssh/sshd-auth.c

789

if ((r = kex_exchange_identification(ssh, -1,

crypto/openssh/sshd-auth.c

791

BLOCKLIST_NOTIFY(ssh, BLOCKLIST_AUTH_FAIL, "Banner exchange");

crypto/openssh/sshd-auth.c

792

sshpkt_fatal(ssh, r, "banner exchange");

crypto/openssh/sshd-auth.c

794

mm_sshkey_setcompat(ssh); /* tell monitor */

crypto/openssh/sshd-auth.c

796

if ((ssh->compat & SSH_BUG_NOREKEY))

crypto/openssh/sshd-auth.c

800

if ((r = kex_setup(ssh, myproposal)) != 0)

crypto/openssh/sshd-auth.c

802

kex_set_server_sig_algs(ssh, options.pubkey_accepted_algos);

crypto/openssh/sshd-auth.c

803

kex = ssh->kex;

crypto/openssh/sshd-auth.c

825

ssh_dispatch_run_fatal(ssh, DISPATCH_BLOCK, &kex->done);

crypto/openssh/sshd-auth.c

830

if ((r = sshpkt_start(ssh, SSH2_MSG_IGNORE)) != 0 ||

crypto/openssh/sshd-auth.c

831

(r = sshpkt_put_cstring(ssh, "markus")) != 0 ||

crypto/openssh/sshd-auth.c

832

(r = sshpkt_send(ssh)) != 0 ||

crypto/openssh/sshd-auth.c

833

(r = ssh_packet_write_wait(ssh)) != 0)

crypto/openssh/sshd-session.c

1159

if ((ssh = ssh_packet_set_connection(NULL, sock_in, sock_out)) == NULL)

crypto/openssh/sshd-session.c

1161

the_active_state = ssh;

crypto/openssh/sshd-session.c

1162

ssh_packet_set_server(ssh);

crypto/openssh/sshd-session.c

1163

ssh_packet_set_qos(ssh, options.ip_qos_interactive,

crypto/openssh/sshd-session.c

1166

check_ip_options(ssh);

crypto/openssh/sshd-session.c

1169

channel_init_channels(ssh);

crypto/openssh/sshd-session.c

1170

channel_set_af(ssh, options.address_family);

crypto/openssh/sshd-session.c

1171

server_process_channel_timeouts(ssh);

crypto/openssh/sshd-session.c

1172

server_process_permitopen(ssh);

crypto/openssh/sshd-session.c

1175

if (options.tcp_keep_alive && ssh_packet_connection_is_on_socket(ssh) &&

crypto/openssh/sshd-session.c

1179

if ((remote_port = ssh_remote_port(ssh)) < 0) {

crypto/openssh/sshd-session.c

1186

auth_get_canonical_hostname(ssh, options.use_dns);

crypto/openssh/sshd-session.c

1194

remote_ip = ssh_remote_ipaddr(ssh);

crypto/openssh/sshd-session.c

1200

rdomain = ssh_packet_rdomain_in(ssh);

crypto/openssh/sshd-session.c

1205

remote_ip, remote_port, laddr, ssh_local_port(ssh),

crypto/openssh/sshd-session.c

1232

ssh_packet_set_nonblocking(ssh);

crypto/openssh/sshd-session.c

1236

ssh->authctxt = authctxt;

crypto/openssh/sshd-session.c

1250

if (privsep_preauth(ssh) != 1)

crypto/openssh/sshd-session.c

1273

set_process_rdomain(ssh, options.routing_domain);

crypto/openssh/sshd-session.c

1276

audit_event(ssh, SSH_AUTH_SUCCESS);

crypto/openssh/sshd-session.c

1289

do_pam_session(ssh);

crypto/openssh/sshd-session.c

1297

privsep_postauth(ssh, authctxt);

crypto/openssh/sshd-session.c

1300

ssh_packet_set_timeout(ssh, options.client_alive_interval,

crypto/openssh/sshd-session.c

1304

notify_hostkeys(ssh);

crypto/openssh/sshd-session.c

1307

do_authenticated(ssh, authctxt);

crypto/openssh/sshd-session.c

1310

ssh_packet_get_bytes(ssh, &ibytes, &obytes);

crypto/openssh/sshd-session.c

1322

mm_audit_event(ssh, SSH_CONNECTION_CLOSE);

crypto/openssh/sshd-session.c

1325

ssh_packet_close(ssh);

crypto/openssh/sshd-session.c

1333

sshd_hostkey_sign(struct ssh *ssh, struct sshkey *privkey,

crypto/openssh/sshd-session.c

1338

if (mm_sshkey_sign(ssh, privkey, signature, slenp,

crypto/openssh/sshd-session.c

1340

ssh->compat) < 0)

crypto/openssh/sshd-session.c

1343

if (mm_sshkey_sign(ssh, pubkey, signature, slenp,

crypto/openssh/sshd-session.c

1345

ssh->compat) < 0)

crypto/openssh/sshd-session.c

170

struct ssh *the_active_state;

crypto/openssh/sshd-session.c

304

privsep_preauth(struct ssh *ssh)

crypto/openssh/sshd-session.c

312

pmonitor->m_pkex = &ssh->kex;

crypto/openssh/sshd-session.c

327

monitor_child_preauth(ssh, pmonitor);

crypto/openssh/sshd-session.c

347

if (ssh_packet_get_connection_in(ssh) != STDIN_FILENO &&

crypto/openssh/sshd-session.c

348

dup2(ssh_packet_get_connection_in(ssh), STDIN_FILENO) == -1)

crypto/openssh/sshd-session.c

350

if (ssh_packet_get_connection_out(ssh) != STDOUT_FILENO &&

crypto/openssh/sshd-session.c

351

dup2(ssh_packet_get_connection_out(ssh),

crypto/openssh/sshd-session.c

373

privsep_postauth(struct ssh *ssh, Authctxt *authctxt)

crypto/openssh/sshd-session.c

399

monitor_clear_keystate(ssh, pmonitor);

crypto/openssh/sshd-session.c

400

monitor_child_postauth(ssh, pmonitor);

crypto/openssh/sshd-session.c

421

monitor_apply_keystate(ssh, pmonitor);

crypto/openssh/sshd-session.c

427

ssh_packet_set_authenticated(ssh);

crypto/openssh/sshd-session.c

431

get_hostkey_by_type(int type, int nid, int need_private, struct ssh *ssh)

crypto/openssh/sshd-session.c

471

get_hostkey_public_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-session.c

473

return get_hostkey_by_type(type, nid, 0, ssh);

crypto/openssh/sshd-session.c

477

get_hostkey_private_by_type(int type, int nid, struct ssh *ssh)

crypto/openssh/sshd-session.c

479

return get_hostkey_by_type(type, nid, 1, ssh);

crypto/openssh/sshd-session.c

491

get_hostkey_public_by_index(int ind, struct ssh *ssh)

crypto/openssh/sshd-session.c

499

get_hostkey_index(struct sshkey *key, int compare, struct ssh *ssh)

crypto/openssh/sshd-session.c

526

notify_hostkeys(struct ssh *ssh)

crypto/openssh/sshd-session.c

535

if (ssh->compat & SSH_BUG_HOSTKEYS)

crypto/openssh/sshd-session.c

541

key = get_hostkey_public_by_index(i, ssh);

crypto/openssh/sshd-session.c

554

if ((r = sshpkt_start(ssh, SSH2_MSG_GLOBAL_REQUEST)) != 0 ||

crypto/openssh/sshd-session.c

555

(r = sshpkt_put_cstring(ssh, "hostkeys-00@openssh.com")) != 0 ||

crypto/openssh/sshd-session.c

556

(r = sshpkt_put_u8(ssh, 0)) != 0) /* want reply */

crypto/openssh/sshd-session.c

557

sshpkt_fatal(ssh, r, "%s: start request", __func__);

crypto/openssh/sshd-session.c

563

if ((r = sshpkt_put_stringb(ssh, buf)) != 0)

crypto/openssh/sshd-session.c

564

sshpkt_fatal(ssh, r, "%s: append key", __func__);

crypto/openssh/sshd-session.c

570

if ((r = sshpkt_send(ssh)) != 0)

crypto/openssh/sshd-session.c

571

sshpkt_fatal(ssh, r, "%s: send", __func__);

crypto/openssh/sshd-session.c

712

check_ip_options(struct ssh *ssh)

crypto/openssh/sshd-session.c

715

int sock_in = ssh_packet_get_connection_in(ssh);

crypto/openssh/sshd-session.c

736

ssh_remote_ipaddr(ssh), ssh_remote_port(ssh), text);

crypto/openssh/sshd-session.c

743

set_process_rdomain(struct ssh *ssh, const char *name)

crypto/openssh/sshd-session.c

751

if ((name = ssh_packet_rdomain_in(ssh)) == NULL)

crypto/openssh/sshd-session.c

765

if ((name = ssh_packet_rdomain_in(ssh)) == NULL)

crypto/openssh/sshd-session.c

787

struct ssh *ssh = NULL;

crypto/openssh/sshd-session.c

912

connection_info = server_get_connection_info(ssh, 0, 0);

crypto/openssh/ttymodes.c

278

ssh_tty_make_modes(struct ssh *ssh, int fd, struct termios *tiop)

crypto/openssh/ttymodes.c

318

if (OP == SSH_TTYMODE_IUTF8 && (ssh->compat & SSH_BUG_UTF8TTYMODE)) { \

crypto/openssh/ttymodes.c

332

(r = sshpkt_put_stringb(ssh, buf)) != 0)

crypto/openssh/ttymodes.c

342

ssh_tty_parse_modes(struct ssh *ssh, int fd)

crypto/openssh/ttymodes.c

352

if ((r = sshpkt_get_string_direct(ssh, &data, &len)) != 0)

sys/fs/pseudofs/pseudofs_vnops.c

632

struct sbuf_seek_helper *ssh;

sys/fs/pseudofs/pseudofs_vnops.c

636

ssh = arg;

sys/fs/pseudofs/pseudofs_vnops.c

637

uio = ssh->uio;

sys/fs/pseudofs/pseudofs_vnops.c

641

if (ssh->skip_bytes > 0) {

sys/fs/pseudofs/pseudofs_vnops.c

642

if (ssh->skip_bytes >= len) {

sys/fs/pseudofs/pseudofs_vnops.c

643

ssh->skip_bytes -= len;

sys/fs/pseudofs/pseudofs_vnops.c

647

data += ssh->skip_bytes;

sys/fs/pseudofs/pseudofs_vnops.c

648

len -= ssh->skip_bytes;

sys/fs/pseudofs/pseudofs_vnops.c

649

skipped = ssh->skip_bytes;

sys/fs/pseudofs/pseudofs_vnops.c

650

ssh->skip_bytes = 0;

sys/fs/pseudofs/pseudofs_vnops.c

683

struct sbuf_seek_helper ssh;

sys/fs/pseudofs/pseudofs_vnops.c

753

ssh.skip_bytes = uio->uio_offset;

sys/fs/pseudofs/pseudofs_vnops.c

754

ssh.uio = uio;

sys/fs/pseudofs/pseudofs_vnops.c

755

sbuf_set_drain(sb, pfs_sbuf_uio_drain, &ssh);