Context Navigation

source: branches/samba-3.3.x/source/libsmb/clifsinfo.c@ 635

Visit:

Last change on this file since 635 was 221, checked in by Herwig Bauernfeind, 16 years ago
Update Samba 3.3 to 3.3.1
File size: 20.0 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3	FS info functions
4	Copyright (C) Stefan (metze) Metzmacher 2003
5	Copyright (C) Jeremy Allison 2007
6
7	This program is free software; you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 3 of the License, or
10	(at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program. If not, see <http://www.gnu.org/licenses/>.
19	*/
20
21	#include "includes.h"
22
23	/****************************************************************************
24	Get UNIX extensions version info.
25	****************************************************************************/
26
27	bool cli_unix_extensions_version(struct cli_state cli, uint16 pmajor, uint16 *pminor,
28	uint32 pcaplow, uint32 pcaphigh)
29	{
30	bool ret = False;
31	uint16 setup;
32	char param[2];
33	char rparam=NULL, rdata=NULL;
34	unsigned int rparam_count=0, rdata_count=0;
35
36	setup = TRANSACT2_QFSINFO;
37
38	SSVAL(param,0,SMB_QUERY_CIFS_UNIX_INFO);
39
40	if (!cli_send_trans(cli, SMBtrans2,
41	NULL,
42	0, 0,
43	&setup, 1, 0,
44	param, 2, 0,
45	NULL, 0, 560)) {
46	goto cleanup;
47	}
48
49	if (!cli_receive_trans(cli, SMBtrans2,
50	&rparam, &rparam_count,
51	&rdata, &rdata_count)) {
52	goto cleanup;
53	}
54
55	if (cli_is_error(cli)) {
56	ret = False;
57	goto cleanup;
58	} else {
59	ret = True;
60	}
61
62	if (rdata_count < 12) {
63	goto cleanup;
64	}
65
66	*pmajor = SVAL(rdata,0);
67	*pminor = SVAL(rdata,2);
68	cli->posix_capabilities = *pcaplow = IVAL(rdata,4);
69	*pcaphigh = IVAL(rdata,8);
70
71	/* todo: but not yet needed
72	* return the other stuff
73	*/
74
75	cleanup:
76	SAFE_FREE(rparam);
77	SAFE_FREE(rdata);
78
79	return ret;
80	}
81
82	/****************************************************************************
83	Set UNIX extensions capabilities.
84	****************************************************************************/
85
86	bool cli_set_unix_extensions_capabilities(struct cli_state *cli, uint16 major, uint16 minor,
87	uint32 caplow, uint32 caphigh)
88	{
89	bool ret = False;
90	uint16 setup;
91	char param[4];
92	char data[12];
93	char rparam=NULL, rdata=NULL;
94	unsigned int rparam_count=0, rdata_count=0;
95
96	setup = TRANSACT2_SETFSINFO;
97
98	SSVAL(param,0,0);
99	SSVAL(param,2,SMB_SET_CIFS_UNIX_INFO);
100
101	SSVAL(data,0,major);
102	SSVAL(data,2,minor);
103	SIVAL(data,4,caplow);
104	SIVAL(data,8,caphigh);
105
106	if (!cli_send_trans(cli, SMBtrans2,
107	NULL,
108	0, 0,
109	&setup, 1, 0,
110	param, 4, 0,
111	data, 12, 560)) {
112	goto cleanup;
113	}
114
115	if (!cli_receive_trans(cli, SMBtrans2,
116	&rparam, &rparam_count,
117	&rdata, &rdata_count)) {
118	goto cleanup;
119	}
120
121	if (cli_is_error(cli)) {
122	ret = False;
123	goto cleanup;
124	} else {
125	ret = True;
126	}
127
128	cleanup:
129	SAFE_FREE(rparam);
130	SAFE_FREE(rdata);
131
132	return ret;
133	}
134
135	bool cli_get_fs_attr_info(struct cli_state cli, uint32 fs_attr)
136	{
137	bool ret = False;
138	uint16 setup;
139	char param[2];
140	char rparam=NULL, rdata=NULL;
141	unsigned int rparam_count=0, rdata_count=0;
142
143	if (!cli\|\|!fs_attr)
144	smb_panic("cli_get_fs_attr_info() called with NULL Pionter!");
145
146	setup = TRANSACT2_QFSINFO;
147
148	SSVAL(param,0,SMB_QUERY_FS_ATTRIBUTE_INFO);
149
150	if (!cli_send_trans(cli, SMBtrans2,
151	NULL,
152	0, 0,
153	&setup, 1, 0,
154	param, 2, 0,
155	NULL, 0, 560)) {
156	goto cleanup;
157	}
158
159	if (!cli_receive_trans(cli, SMBtrans2,
160	&rparam, &rparam_count,
161	&rdata, &rdata_count)) {
162	goto cleanup;
163	}
164
165	if (cli_is_error(cli)) {
166	ret = False;
167	goto cleanup;
168	} else {
169	ret = True;
170	}
171
172	if (rdata_count < 12) {
173	goto cleanup;
174	}
175
176	*fs_attr = IVAL(rdata,0);
177
178	/* todo: but not yet needed
179	* return the other stuff
180	*/
181
182	cleanup:
183	SAFE_FREE(rparam);
184	SAFE_FREE(rdata);
185
186	return ret;
187	}
188
189	bool cli_get_fs_volume_info_old(struct cli_state cli, fstring volume_name, uint32 pserial_number)
190	{
191	bool ret = False;
192	uint16 setup;
193	char param[2];
194	char rparam=NULL, rdata=NULL;
195	unsigned int rparam_count=0, rdata_count=0;
196	unsigned char nlen;
197
198	setup = TRANSACT2_QFSINFO;
199
200	SSVAL(param,0,SMB_INFO_VOLUME);
201
202	if (!cli_send_trans(cli, SMBtrans2,
203	NULL,
204	0, 0,
205	&setup, 1, 0,
206	param, 2, 0,
207	NULL, 0, 560)) {
208	goto cleanup;
209	}
210
211	if (!cli_receive_trans(cli, SMBtrans2,
212	&rparam, &rparam_count,
213	&rdata, &rdata_count)) {
214	goto cleanup;
215	}
216
217	if (cli_is_error(cli)) {
218	ret = False;
219	goto cleanup;
220	} else {
221	ret = True;
222	}
223
224	if (rdata_count < 5) {
225	goto cleanup;
226	}
227
228	if (pserial_number) {
229	*pserial_number = IVAL(rdata,0);
230	}
231	nlen = CVAL(rdata,l2_vol_cch);
232	clistr_pull(cli, volume_name, rdata + l2_vol_szVolLabel, sizeof(fstring), nlen, STR_NOALIGN);
233
234	/* todo: but not yet needed
235	* return the other stuff
236	*/
237
238	cleanup:
239	SAFE_FREE(rparam);
240	SAFE_FREE(rdata);
241
242	return ret;
243	}
244
245	bool cli_get_fs_volume_info(struct cli_state cli, fstring volume_name, uint32 pserial_number, time_t *pdate)
246	{
247	bool ret = False;
248	uint16 setup;
249	char param[2];
250	char rparam=NULL, rdata=NULL;
251	unsigned int rparam_count=0, rdata_count=0;
252	unsigned int nlen;
253
254	setup = TRANSACT2_QFSINFO;
255
256	SSVAL(param,0,SMB_QUERY_FS_VOLUME_INFO);
257
258	if (!cli_send_trans(cli, SMBtrans2,
259	NULL,
260	0, 0,
261	&setup, 1, 0,
262	param, 2, 0,
263	NULL, 0, 560)) {
264	goto cleanup;
265	}
266
267	if (!cli_receive_trans(cli, SMBtrans2,
268	&rparam, &rparam_count,
269	&rdata, &rdata_count)) {
270	goto cleanup;
271	}
272
273	if (cli_is_error(cli)) {
274	ret = False;
275	goto cleanup;
276	} else {
277	ret = True;
278	}
279
280	if (rdata_count < 19) {
281	goto cleanup;
282	}
283
284	if (pdate) {
285	struct timespec ts;
286	ts = interpret_long_date(rdata);
287	*pdate = ts.tv_sec;
288	}
289	if (pserial_number) {
290	*pserial_number = IVAL(rdata,8);
291	}
292	nlen = IVAL(rdata,12);
293	clistr_pull(cli, volume_name, rdata + 18, sizeof(fstring), nlen, STR_UNICODE);
294
295	/* todo: but not yet needed
296	* return the other stuff
297	*/
298
299	cleanup:
300	SAFE_FREE(rparam);
301	SAFE_FREE(rdata);
302
303	return ret;
304	}
305
306	bool cli_get_fs_full_size_info(struct cli_state *cli,
307	SMB_BIG_UINT *total_allocation_units,
308	SMB_BIG_UINT *caller_allocation_units,
309	SMB_BIG_UINT *actual_allocation_units,
310	SMB_BIG_UINT *sectors_per_allocation_unit,
311	SMB_BIG_UINT *bytes_per_sector)
312	{
313	bool ret = False;
314	uint16 setup;
315	char param[2];
316	char rparam=NULL, rdata=NULL;
317	unsigned int rparam_count=0, rdata_count=0;
318
319	setup = TRANSACT2_QFSINFO;
320
321	SSVAL(param,0,SMB_FS_FULL_SIZE_INFORMATION);
322
323	if (!cli_send_trans(cli, SMBtrans2,
324	NULL,
325	0, 0,
326	&setup, 1, 0,
327	param, 2, 0,
328	NULL, 0, 560)) {
329	goto cleanup;
330	}
331
332	if (!cli_receive_trans(cli, SMBtrans2,
333	&rparam, &rparam_count,
334	&rdata, &rdata_count)) {
335	goto cleanup;
336	}
337
338	if (cli_is_error(cli)) {
339	ret = False;
340	goto cleanup;
341	} else {
342	ret = True;
343	}
344
345	if (rdata_count != 32) {
346	goto cleanup;
347	}
348
349	if (total_allocation_units) {
350	*total_allocation_units = BIG_UINT(rdata, 0);
351	}
352	if (caller_allocation_units) {
353	*caller_allocation_units = BIG_UINT(rdata,8);
354	}
355	if (actual_allocation_units) {
356	*actual_allocation_units = BIG_UINT(rdata,16);
357	}
358	if (sectors_per_allocation_unit) {
359	*sectors_per_allocation_unit = IVAL(rdata,24);
360	}
361	if (bytes_per_sector) {
362	*bytes_per_sector = IVAL(rdata,28);
363	}
364
365	cleanup:
366	SAFE_FREE(rparam);
367	SAFE_FREE(rdata);
368
369	return ret;
370	}
371
372	bool cli_get_posix_fs_info(struct cli_state *cli,
373	uint32 *optimal_transfer_size,
374	uint32 *block_size,
375	SMB_BIG_UINT *total_blocks,
376	SMB_BIG_UINT *blocks_available,
377	SMB_BIG_UINT *user_blocks_available,
378	SMB_BIG_UINT *total_file_nodes,
379	SMB_BIG_UINT *free_file_nodes,
380	SMB_BIG_UINT *fs_identifier)
381	{
382	bool ret = False;
383	uint16 setup;
384	char param[2];
385	char rparam=NULL, rdata=NULL;
386	unsigned int rparam_count=0, rdata_count=0;
387
388	setup = TRANSACT2_QFSINFO;
389
390	SSVAL(param,0,SMB_QUERY_POSIX_FS_INFO);
391
392	if (!cli_send_trans(cli, SMBtrans2,
393	NULL,
394	0, 0,
395	&setup, 1, 0,
396	param, 2, 0,
397	NULL, 0, 560)) {
398	goto cleanup;
399	}
400
401	if (!cli_receive_trans(cli, SMBtrans2,
402	&rparam, &rparam_count,
403	&rdata, &rdata_count)) {
404	goto cleanup;
405	}
406
407	if (cli_is_error(cli)) {
408	ret = False;
409	goto cleanup;
410	} else {
411	ret = True;
412	}
413
414	if (rdata_count != 56) {
415	goto cleanup;
416	}
417
418	if (optimal_transfer_size) {
419	*optimal_transfer_size = IVAL(rdata, 0);
420	}
421	if (block_size) {
422	*block_size = IVAL(rdata,4);
423	}
424	if (total_blocks) {
425	*total_blocks = BIG_UINT(rdata,8);
426	}
427	if (blocks_available) {
428	*blocks_available = BIG_UINT(rdata,16);
429	}
430	if (user_blocks_available) {
431	*user_blocks_available = BIG_UINT(rdata,24);
432	}
433	if (total_file_nodes) {
434	*total_file_nodes = BIG_UINT(rdata,32);
435	}
436	if (free_file_nodes) {
437	*free_file_nodes = BIG_UINT(rdata,40);
438	}
439	if (fs_identifier) {
440	*fs_identifier = BIG_UINT(rdata,48);
441	}
442
443	cleanup:
444	SAFE_FREE(rparam);
445	SAFE_FREE(rdata);
446
447	return ret;
448	}
449
450
451	/******************************************************************************
452	Send/receive the request encryption blob.
453	******************************************************************************/
454
455	static NTSTATUS enc_blob_send_receive(struct cli_state cli, DATA_BLOB in, DATA_BLOB out, DATA_BLOB param_out)
456	{
457	uint16 setup;
458	char param[4];
459	char rparam=NULL, rdata=NULL;
460	unsigned int rparam_count=0, rdata_count=0;
461	NTSTATUS status = NT_STATUS_OK;
462
463	setup = TRANSACT2_SETFSINFO;
464
465	SSVAL(param,0,0);
466	SSVAL(param,2,SMB_REQUEST_TRANSPORT_ENCRYPTION);
467
468	if (!cli_send_trans(cli, SMBtrans2,
469	NULL,
470	0, 0,
471	&setup, 1, 0,
472	param, 4, 0,
473	(char *)in->data, in->length, CLI_BUFFER_SIZE)) {
474	status = cli_nt_error(cli);
475	goto out;
476	}
477
478	if (!cli_receive_trans(cli, SMBtrans2,
479	&rparam, &rparam_count,
480	&rdata, &rdata_count)) {
481	status = cli_nt_error(cli);
482	goto out;
483	}
484
485	if (cli_is_error(cli)) {
486	status = cli_nt_error(cli);
487	if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
488	goto out;
489	}
490	}
491
492	*out = data_blob(rdata, rdata_count);
493	*param_out = data_blob(rparam, rparam_count);
494
495	out:
496
497	SAFE_FREE(rparam);
498	SAFE_FREE(rdata);
499	return status;
500	}
501
502	/******************************************************************************
503	Make a client state struct.
504	******************************************************************************/
505
506	static struct smb_trans_enc_state *make_cli_enc_state(enum smb_trans_enc_type smb_enc_type)
507	{
508	struct smb_trans_enc_state *es = NULL;
509	es = SMB_MALLOC_P(struct smb_trans_enc_state);
510	if (!es) {
511	return NULL;
512	}
513	ZERO_STRUCTP(es);
514	es->smb_enc_type = smb_enc_type;
515
516	#if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
517	if (smb_enc_type == SMB_TRANS_ENC_GSS) {
518	es->s.gss_state = SMB_MALLOC_P(struct smb_tran_enc_state_gss);
519	if (!es->s.gss_state) {
520	SAFE_FREE(es);
521	return NULL;
522	}
523	ZERO_STRUCTP(es->s.gss_state);
524	}
525	#endif
526	return es;
527	}
528
529	/******************************************************************************
530	Start a raw ntlmssp encryption.
531	******************************************************************************/
532
533	NTSTATUS cli_raw_ntlm_smb_encryption_start(struct cli_state *cli,
534	const char *user,
535	const char *pass,
536	const char *domain)
537	{
538	DATA_BLOB blob_in = data_blob_null;
539	DATA_BLOB blob_out = data_blob_null;
540	DATA_BLOB param_out = data_blob_null;
541	NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
542	struct smb_trans_enc_state *es = make_cli_enc_state(SMB_TRANS_ENC_NTLM);
543
544	if (!es) {
545	return NT_STATUS_NO_MEMORY;
546	}
547	status = ntlmssp_client_start(&es->s.ntlmssp_state);
548	if (!NT_STATUS_IS_OK(status)) {
549	goto fail;
550	}
551
552	ntlmssp_want_feature(es->s.ntlmssp_state, NTLMSSP_FEATURE_SESSION_KEY);
553	es->s.ntlmssp_state->neg_flags \|= (NTLMSSP_NEGOTIATE_SIGN\|NTLMSSP_NEGOTIATE_SEAL);
554
555	if (!NT_STATUS_IS_OK(status = ntlmssp_set_username(es->s.ntlmssp_state, user))) {
556	goto fail;
557	}
558	if (!NT_STATUS_IS_OK(status = ntlmssp_set_domain(es->s.ntlmssp_state, domain))) {
559	goto fail;
560	}
561	if (!NT_STATUS_IS_OK(status = ntlmssp_set_password(es->s.ntlmssp_state, pass))) {
562	goto fail;
563	}
564
565	do {
566	status = ntlmssp_update(es->s.ntlmssp_state, blob_in, &blob_out);
567	data_blob_free(&blob_in);
568	data_blob_free(&param_out);
569	if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) \|\| NT_STATUS_IS_OK(status)) {
570	NTSTATUS trans_status = enc_blob_send_receive(cli,
571	&blob_out,
572	&blob_in,
573	&param_out);
574	if (!NT_STATUS_EQUAL(trans_status,
575	NT_STATUS_MORE_PROCESSING_REQUIRED) &&
576	!NT_STATUS_IS_OK(trans_status)) {
577	status = trans_status;
578	} else {
579	if (param_out.length == 2) {
580	es->enc_ctx_num = SVAL(param_out.data, 0);
581	}
582	}
583	}
584	data_blob_free(&blob_out);
585	} while (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED));
586
587	data_blob_free(&blob_in);
588
589	if (NT_STATUS_IS_OK(status)) {
590	/* Replace the old state, if any. */
591	if (cli->trans_enc_state) {
592	common_free_encryption_state(&cli->trans_enc_state);
593	}
594	cli->trans_enc_state = es;
595	cli->trans_enc_state->enc_on = True;
596	es = NULL;
597	}
598
599	fail:
600
601	common_free_encryption_state(&es);
602	return status;
603	}
604
605	#if defined(HAVE_GSSAPI) && defined(HAVE_KRB5)
606
607	#ifndef SMB_GSS_REQUIRED_FLAGS
608	#define SMB_GSS_REQUIRED_FLAGS (GSS_C_CONF_FLAG\|GSS_C_INTEG_FLAG\|GSS_C_MUTUAL_FLAG\|GSS_C_REPLAY_FLAG\|GSS_C_SEQUENCE_FLAG)
609	#endif
610
611	/******************************************************************************
612	Get client gss blob to send to a server.
613	******************************************************************************/
614
615	static NTSTATUS make_cli_gss_blob(struct smb_trans_enc_state *es,
616	const char *service,
617	const char *host,
618	NTSTATUS status_in,
619	DATA_BLOB spnego_blob_in,
620	DATA_BLOB *p_blob_out)
621	{
622	const char *krb_mechs[] = {OID_KERBEROS5, NULL};
623	OM_uint32 ret;
624	OM_uint32 min;
625	gss_name_t srv_name;
626	gss_buffer_desc input_name;
627	gss_buffer_desc *p_tok_in;
628	gss_buffer_desc tok_out, tok_in;
629	DATA_BLOB blob_out = data_blob_null;
630	DATA_BLOB blob_in = data_blob_null;
631	char *host_princ_s = NULL;
632	OM_uint32 ret_flags = 0;
633	NTSTATUS status = NT_STATUS_OK;
634
635	gss_OID_desc nt_hostbased_service =
636	{10, CONST_DISCARD(char *,"\x2a\x86\x48\x86\xf7\x12\x01\x02\x01\x04")};
637
638	memset(&tok_out, '\0', sizeof(tok_out));
639
640	/* Get a ticket for the service@host */
641	if (asprintf(&host_princ_s, "%s@%s", service, host) == -1) {
642	return NT_STATUS_NO_MEMORY;
643	}
644
645	input_name.value = host_princ_s;
646	input_name.length = strlen(host_princ_s) + 1;
647
648	ret = gss_import_name(&min,
649	&input_name,
650	&nt_hostbased_service,
651	&srv_name);
652
653	if (ret != GSS_S_COMPLETE) {
654	SAFE_FREE(host_princ_s);
655	return map_nt_error_from_gss(ret, min);
656	}
657
658	if (spnego_blob_in.length == 0) {
659	p_tok_in = GSS_C_NO_BUFFER;
660	} else {
661	/* Remove the SPNEGO wrapper */
662	if (!spnego_parse_auth_response(spnego_blob_in, status_in, OID_KERBEROS5, &blob_in)) {
663	status = NT_STATUS_UNSUCCESSFUL;
664	goto fail;
665	}
666	tok_in.value = blob_in.data;
667	tok_in.length = blob_in.length;
668	p_tok_in = &tok_in;
669	}
670
671	ret = gss_init_sec_context(&min,
672	GSS_C_NO_CREDENTIAL, /* Use our default cred. */
673	&es->s.gss_state->gss_ctx,
674	srv_name,
675	GSS_C_NO_OID, /* default OID. */
676	GSS_C_MUTUAL_FLAG \| GSS_C_REPLAY_FLAG \| GSS_C_SEQUENCE_FLAG \| GSS_C_DELEG_FLAG,
677	GSS_C_INDEFINITE, /* requested ticket lifetime. */
678	NULL, /* no channel bindings */
679	p_tok_in,
680	NULL, /* ignore mech type */
681	&tok_out,
682	&ret_flags,
683	NULL); /* ignore time_rec */
684
685	status = map_nt_error_from_gss(ret, min);
686	if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status,NT_STATUS_MORE_PROCESSING_REQUIRED)) {
687	ADS_STATUS adss = ADS_ERROR_GSS(ret, min);
688	DEBUG(10,("make_cli_gss_blob: gss_init_sec_context failed with %s\n",
689	ads_errstr(adss)));
690	goto fail;
691	}
692
693	if ((ret_flags & SMB_GSS_REQUIRED_FLAGS) != SMB_GSS_REQUIRED_FLAGS) {
694	status = NT_STATUS_ACCESS_DENIED;
695	}
696
697	blob_out = data_blob(tok_out.value, tok_out.length);
698
699	/* Wrap in an SPNEGO wrapper */
700	*p_blob_out = gen_negTokenTarg(krb_mechs, blob_out);
701
702	fail:
703
704	data_blob_free(&blob_out);
705	data_blob_free(&blob_in);
706	SAFE_FREE(host_princ_s);
707	gss_release_name(&min, &srv_name);
708	if (tok_out.value) {
709	gss_release_buffer(&min, &tok_out);
710	}
711	return status;
712	}
713
714	/******************************************************************************
715	Start a SPNEGO gssapi encryption context.
716	******************************************************************************/
717
718	NTSTATUS cli_gss_smb_encryption_start(struct cli_state *cli)
719	{
720	DATA_BLOB blob_recv = data_blob_null;
721	DATA_BLOB blob_send = data_blob_null;
722	DATA_BLOB param_out = data_blob_null;
723	NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
724	fstring fqdn;
725	const char *servicename;
726	struct smb_trans_enc_state *es = make_cli_enc_state(SMB_TRANS_ENC_GSS);
727
728	if (!es) {
729	return NT_STATUS_NO_MEMORY;
730	}
731
732	name_to_fqdn(fqdn, cli->desthost);
733	strlower_m(fqdn);
734
735	servicename = "cifs";
736	status = make_cli_gss_blob(es, servicename, fqdn, NT_STATUS_OK, blob_recv, &blob_send);
737	if (!NT_STATUS_EQUAL(status,NT_STATUS_MORE_PROCESSING_REQUIRED)) {
738	servicename = "host";
739	status = make_cli_gss_blob(es, servicename, fqdn, NT_STATUS_OK, blob_recv, &blob_send);
740	if (!NT_STATUS_EQUAL(status,NT_STATUS_MORE_PROCESSING_REQUIRED)) {
741	goto fail;
742	}
743	}
744
745	do {
746	data_blob_free(&blob_recv);
747	status = enc_blob_send_receive(cli, &blob_send, &blob_recv, &param_out);
748	if (param_out.length == 2) {
749	es->enc_ctx_num = SVAL(param_out.data, 0);
750	}
751	data_blob_free(&blob_send);
752	status = make_cli_gss_blob(es, servicename, fqdn, status, blob_recv, &blob_send);
753	} while (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED));
754	data_blob_free(&blob_recv);
755
756	if (NT_STATUS_IS_OK(status)) {
757	/* Replace the old state, if any. */
758	if (cli->trans_enc_state) {
759	common_free_encryption_state(&cli->trans_enc_state);
760	}
761	cli->trans_enc_state = es;
762	cli->trans_enc_state->enc_on = True;
763	es = NULL;
764	}
765
766	fail:
767
768	common_free_encryption_state(&es);
769	return status;
770	}
771	#else
772	NTSTATUS cli_gss_smb_encryption_start(struct cli_state *cli)
773	{
774	return NT_STATUS_NOT_SUPPORTED;
775	}
776	#endif
777
778	/********************************************************************
779	Ensure a connection is encrypted.
780	********************************************************************/
781
782	NTSTATUS cli_force_encryption(struct cli_state *c,
783	const char *username,
784	const char *password,
785	const char *domain)
786	{
787	uint16 major, minor;
788	uint32 caplow, caphigh;
789
790	if (!SERVER_HAS_UNIX_CIFS(c)) {
791	return NT_STATUS_NOT_SUPPORTED;
792	}
793
794	if (!cli_unix_extensions_version(c, &major, &minor, &caplow, &caphigh)) {
795	return NT_STATUS_UNKNOWN_REVISION;
796	}
797
798	if (!(caplow & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)) {
799	return NT_STATUS_UNSUPPORTED_COMPRESSION;
800	}
801
802	if (c->use_kerberos) {
803	return cli_gss_smb_encryption_start(c);
804	}
805	return cli_raw_ntlm_smb_encryption_start(c,
806	username,
807	password,
808	domain);
809	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: