Lines Matching defs:ctx
98 smbfs_ctx_rpc_cleanup(struct smb_ctx *ctx)
101 (*close_hook)(ctx);
107 smb_ctx_t *ctx;
110 ctx = malloc(sizeof (*ctx));
111 if (ctx == NULL)
113 err = smbfs_ctx_init(ctx);
115 free(ctx);
118 *ctx_pp = ctx;
149 smbfs_ctx_getconfigs(struct smb_ctx *ctx)
158 ctx->ct_authflags =
162 ctx->ct_authflags = SMB_AT_NTLM1 | SMB_AT_KRB5;
167 ctx->ct_authflags = SMB_AT_NTLM2 | SMB_AT_KRB5;
176 (void) smbfs_ctx_setsigning(ctx, signing_req);
182 (void) smbfs_ctx_setdomain(ctx, domain, FALSE);
184 (void) smbfs_nb_ctx_getconfigs(ctx->ct_nb);
193 smbfs_ctx_init(struct smb_ctx *ctx)
197 bzero(ctx, sizeof (*ctx));
199 error = smbfs_nb_ctx_create(&ctx->ct_nb);
203 ctx->ct_dev_fd = -1;
204 ctx->ct_door_fd = -1;
205 ctx->ct_tran_fd = -1;
206 ctx->ct_parsedlevel = SMBL_NONE;
207 ctx->ct_minlevel = SMBL_NONE;
208 ctx->ct_maxlevel = SMBL_PATH;
211 ctx->ct_vopt = SMBVOPT_EXT_SEC;
212 ctx->ct_owner = SMBM_ANY_OWNER;
213 ctx->ct_authflags = SMB_AT_DEFAULT;
214 ctx->ct_ntstatus = NT_STATUS_SUCCESS;
216 (void) smbfs_ctx_setsigning(ctx, FALSE);
218 smbfs_ctx_getconfigs(ctx);
224 (void) strlcpy(ctx->ct_domain, default_domain,
225 sizeof (ctx->ct_domain));
226 (void) strlcpy(ctx->ct_user, default_user,
227 sizeof (ctx->ct_user));
233 smbfs_ctx_free(smb_ctx_t *ctx)
235 if (ctx == NULL)
238 smbfs_ctx_done(ctx);
239 free(ctx);
243 smbfs_ctx_done(struct smb_ctx *ctx)
245 smbfs_ctx_rpc_cleanup(ctx);
247 if (ctx->ct_dev_fd != -1) {
248 (void) close(ctx->ct_dev_fd);
249 ctx->ct_dev_fd = -1;
251 if (ctx->ct_door_fd != -1) {
252 (void) close(ctx->ct_door_fd);
253 ctx->ct_door_fd = -1;
255 if (ctx->ct_tran_fd != -1) {
256 (void) close(ctx->ct_tran_fd);
257 ctx->ct_tran_fd = -1;
259 if (ctx->ct_srvaddr_s) {
260 free(ctx->ct_srvaddr_s);
261 ctx->ct_srvaddr_s = NULL;
263 if (ctx->ct_nb) {
264 smbfs_nb_ctx_done(ctx->ct_nb);
265 ctx->ct_nb = NULL;
267 if (ctx->ct_locname) {
268 free(ctx->ct_locname);
269 ctx->ct_locname = NULL;
271 if (ctx->ct_origshare) {
272 free(ctx->ct_origshare);
273 ctx->ct_origshare = NULL;
275 if (ctx->ct_fullserver) {
276 free(ctx->ct_fullserver);
277 ctx->ct_fullserver = NULL;
279 if (ctx->ct_addrinfo) {
280 freeaddrinfo(ctx->ct_addrinfo);
281 ctx->ct_addrinfo = NULL;
283 if (ctx->ct_rpath)
284 free(ctx->ct_rpath);
285 if (ctx->ct_srv_OS) {
286 free(ctx->ct_srv_OS);
287 ctx->ct_srv_OS = NULL;
289 if (ctx->ct_srv_LM) {
290 free(ctx->ct_srv_LM);
291 ctx->ct_srv_LM = NULL;
293 if (ctx->ct_mackey) {
294 free(ctx->ct_mackey);
295 ctx->ct_mackey = NULL;
304 smbfs_ctx_parseunc(struct smb_ctx *ctx, const char *unc,
317 ctx->ct_minlevel = minlevel;
318 ctx->ct_maxlevel = maxlevel;
319 ctx->ct_shtype_req = sharetype;
320 ctx->ct_parsedlevel = SMBL_NONE;
351 error = smbfs_ctx_setfullserver(ctx, host);
354 ctx->ct_parsedlevel = SMBL_VC;
373 if (ctx->ct_maxlevel < SMBL_SHARE) {
389 error = smbfs_ctx_setshare(ctx, p, sharetype);
392 ctx->ct_parsedlevel = SMBL_SHARE;
399 free(ctx->ct_rpath);
400 ctx->ct_rpath = strdup(path);
402 } else if (ctx->ct_minlevel >= SMBL_SHARE) {
413 smbfs_dump_ctx("after smbfs_ctx_parseunc", ctx);
466 smbfs_ctx_setauthflags(struct smb_ctx *ctx, int flags)
468 ctx->ct_authflags = flags;
473 smbfs_ctx_setfullserver(struct smb_ctx *ctx, const char *name)
479 if (ctx->ct_fullserver)
480 free(ctx->ct_fullserver);
481 ctx->ct_fullserver = p;
486 smbfs_ctx_setserver(struct smb_ctx *ctx, const char *name)
488 (void) strlcpy(ctx->ct_srvname, name,
489 sizeof (ctx->ct_srvname));
494 smbfs_ctx_setuser(struct smb_ctx *ctx, const char *name, int from_cmd)
496 if (strlen(name) >= sizeof (ctx->ct_user)) {
506 if (!from_cmd && (ctx->ct_flags & SMBCF_CMD_USR))
509 (void) strlcpy(ctx->ct_user, name,
510 sizeof (ctx->ct_user));
514 ctx->ct_flags |= SMBCF_CMD_USR;
526 smbfs_ctx_setrealm(struct smb_ctx *ctx, const char *name)
541 bzero(ctx->ct_realm, sizeof (ctx->ct_realm));
542 (void) strlcpy(ctx->ct_realm, dc_realm, sizeof (ctx->ct_realm));
549 (void) strlcpy(ctx->ct_realm, realm, sizeof (ctx->ct_realm));
562 smbfs_ctx_setdomain(struct smb_ctx *ctx, const char *name, int from_cmd)
564 if (strlen(name) >= sizeof (ctx->ct_domain)) {
574 if (!from_cmd && (ctx->ct_flags & SMBCF_CMD_DOM))
577 (void) strlcpy(ctx->ct_domain, name,
578 sizeof (ctx->ct_domain));
582 ctx->ct_flags |= SMBCF_CMD_DOM;
588 smbfs_ctx_setpassword(struct smb_ctx *ctx, const char *passwd, int from_cmd)
594 if (strlen(passwd) >= sizeof (ctx->ct_password)) {
604 if (!from_cmd && (ctx->ct_flags & SMBCF_CMD_PW))
607 (void) memset(ctx->ct_password, 0, sizeof (ctx->ct_password));
609 (void) smbfs_simpledecrypt(ctx->ct_password, passwd);
611 (void) strlcpy(ctx->ct_password, passwd,
612 sizeof (ctx->ct_password));
617 if (ctx->ct_password[0]) {
618 err = smbfs_ntlm_compute_nt_hash(ctx->ct_nthash,
619 ctx->ct_password);
622 err = smbfs_ntlm_compute_lm_hash(ctx->ct_lmhash,
623 ctx->ct_password);
630 ctx->ct_flags |= SMBCF_CMD_PW;
640 smbfs_ctx_setpwhash(smb_ctx_t *ctx,
645 if (ctx->ct_password[0] == '\0')
646 (void) strlcpy(ctx->ct_password, "$HASH",
647 sizeof (ctx->ct_password));
649 (void) memcpy(ctx->ct_nthash, nthash, NTLM_HASH_SZ);
653 (void) memcpy(ctx->ct_lmhash, lmhash, NTLM_HASH_SZ);
659 smbfs_ctx_setshare(struct smb_ctx *ctx, const char *share, int stype)
666 if (ctx->ct_origshare)
667 free(ctx->ct_origshare);
668 if ((ctx->ct_origshare = strdup(share)) == NULL)
671 ctx->ct_shtype_req = stype;
680 smbfs_ctx_setsigning(struct smb_ctx *ctx, boolean_t required)
683 ctx->ct_vopt |= SMBVOPT_SIGNING_REQUIRED;
685 ctx->ct_vopt &= ~SMBVOPT_SIGNING_REQUIRED;
694 smbfs_ctx_getaddr(struct smb_ctx *ctx)
696 struct nb_ctx *nbc = ctx->ct_nb;
701 if (ctx->ct_fullserver == NULL || ctx->ct_fullserver[0] == '\0')
704 if (ctx->ct_addrinfo != NULL) {
705 freeaddrinfo(ctx->ct_addrinfo);
706 ctx->ct_addrinfo = NULL;
713 if (ctx->ct_srvaddr_s) {
714 srvaddr_str = ctx->ct_srvaddr_s;
717 srvaddr_str = ctx->ct_fullserver;
723 (void) strlcpy(ctx->ct_srvname, ctx->ct_fullserver,
724 sizeof (ctx->ct_srvname));
737 ctx->ct_addrinfo = res;
747 gaierr2 = smbfs_nbns_getaddrinfo(ctx->ct_fullserver, nbc, &res);
750 (void) strlcpy(ctx->ct_srvname,
752 sizeof (ctx->ct_srvname));
753 ctx->ct_addrinfo = res;
764 ctx->ct_fullserver,
776 smbfs_ctx_resolve(struct smb_ctx *ctx)
778 struct smbioc_ossn *ssn = &ctx->ct_ssn;
782 smbfs_dump_ctx("before smb_ctx_resolve", ctx);
784 ctx->ct_flags &= ~SMBCF_RESOLVED;
786 if (ctx->ct_fullserver == NULL) {
792 if (ctx->ct_minlevel >= SMBL_SHARE &&
793 ctx->ct_origshare == NULL) {
796 0, ssn->ssn_user, ctx->ct_fullserver);
799 error = smbfs_nb_ctx_resolve(ctx->ct_nb);
810 error = smbfs_ctx_getaddr(ctx);
815 0, ctx->ct_fullserver, ais);
818 assert(ctx->ct_addrinfo != NULL);
825 if (ctx->ct_user[0] == '\0') {
829 ctx->ct_authflags = SMB_AT_ANON;
836 if (ctx->ct_password[0] == '\0')
837 (void) smbfs_get_keychain(ctx);
839 if (ctx->ct_authflags == 0) {
845 ctx->ct_flags |= SMBCF_RESOLVED;
847 smbfs_dump_ctx("after smb_ctx_resolve", ctx);
869 smbfs_ctx_gethandle(struct smb_ctx *ctx)
874 if (ctx->ct_dev_fd != -1) {
875 smbfs_ctx_rpc_cleanup(ctx);
876 (void) close(ctx->ct_dev_fd);
877 ctx->ct_dev_fd = -1;
878 ctx->ct_flags &= ~SMBCF_SSNACTIVE;
901 ctx->ct_dev_fd = fd;
910 smbfs_ctx_get_ssn(struct smb_ctx *ctx)
914 ctx->ct_ntstatus = NT_STATUS_UNSUCCESSFUL;
916 if ((ctx->ct_flags & SMBCF_RESOLVED) == 0)
919 if (ctx->ct_dev_fd < 0) {
920 if ((err = smbfs_ctx_gethandle(ctx)))
928 err = smbfs_ctx_findvc(ctx);
930 ctx->ct_ntstatus = NT_STATUS_SUCCESS;
937 err = smbfs_ctx_newvc(ctx);
945 err = smbfs_ctx_findvc(ctx);
955 smbfs_ctx_get_tree(struct smb_ctx *ctx)
960 if (ctx->ct_dev_fd < 0 ||
961 ctx->ct_origshare == NULL) {
974 (void) strlcpy(tcon->tc_sh.sh_name, ctx->ct_origshare,
978 tcon->tc_sh.sh_use = ctx->ct_shtype_req;
985 if (ioctl(ctx->ct_dev_fd, cmd, tcon) == -1) {
994 if (ctx->ct_shtype_req != USE_WILDCARD &&
995 ctx->ct_shtype_req != tcon->tc_sh.sh_type) {
998 0, ctx->ct_origshare);
1012 smbfs_ctx_flags2(struct smb_ctx *ctx)
1016 if (ioctl(ctx->ct_dev_fd, SMBIOC_FLAGS2, &flags2) == -1) {
1079 smbfs_ctx_setnbflags(struct smb_ctx *ctx, int ns_ena, int bc_ena)
1081 struct nb_ctx *nb = ctx->ct_nb;
1094 smbfs_ctx_setwins(struct smb_ctx *ctx, const char *wins1, const char *wins2)
1096 struct nb_ctx *nb = ctx->ct_nb;
1108 smbfs_ctx_setscope(struct smb_ctx *ctx, const char *scope)
1110 struct nb_ctx *nb = ctx->ct_nb;