?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mtw(4) remove misplaced DEBUG_FLAGS
[freebsd/src.git] / sys / netsmb / smb_smb.c
blob643adf774f082f948c394c67d50c0a448c021b7d
1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2000-2001 Boris Popov
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 /*
30 * various SMB requests. Most of the routines merely packs data into mbufs.
31 */
32
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
37 #include <sys/proc.h>
38 #include <sys/lock.h>
39 #include <sys/sysctl.h>
40 #include <sys/socket.h>
41 #include <sys/uio.h>
42
43 #include <sys/iconv.h>
44
45 #include <netsmb/smb.h>
46 #include <netsmb/smb_subr.h>
47 #include <netsmb/smb_rq.h>
48 #include <netsmb/smb_conn.h>
49 #include <netsmb/smb_tran.h>
50
51 #include "opt_netsmb.h"
52
53 struct smb_dialect {
54 int d_id;
55 const char * d_name;
56 };
57
58 static struct smb_dialect smb_dialects[] = {
59 {SMB_DIALECT_CORE, "PC NETWORK PROGRAM 1.0"},
60 {SMB_DIALECT_COREPLUS, "MICROSOFT NETWORKS 1.03"},
61 {SMB_DIALECT_LANMAN1_0, "MICROSOFT NETWORKS 3.0"},
62 {SMB_DIALECT_LANMAN1_0, "LANMAN1.0"},
63 {SMB_DIALECT_LANMAN2_0, "LM1.2X002"},
64 {SMB_DIALECT_LANMAN2_0, "Samba"},
65 {SMB_DIALECT_NTLM0_12, "NT LANMAN 1.0"},
66 {SMB_DIALECT_NTLM0_12, "NT LM 0.12"},
67 {-1, NULL}
68 };
69
70 static u_int32_t
71 smb_vc_maxread(struct smb_vc *vcp)
72 {
73 /*
74 * Specs say up to 64k data bytes, but Windows traffic
75 * uses 60k... no doubt for some good reason.
76 *
77 * Don't exceed the server's buffer size if signatures
78 * are enabled otherwise Windows 2003 chokes. Allow space
79 * for the SMB header & a little bit extra.
80 */
81 if ((vcp->vc_sopt.sv_caps & SMB_CAP_LARGE_READX) &&
82 (vcp->vc_hflags2 & SMB_FLAGS2_SECURITY_SIGNATURE) == 0)
83 return (60*1024);
84 else
85 return (vcp->vc_sopt.sv_maxtx - SMB_HDRLEN - 64);
86 }
87
88 static u_int32_t
89 smb_vc_maxwrite(struct smb_vc *vcp)
90 {
91 /*
92 * See comment above.
93 */
94 if ((vcp->vc_sopt.sv_caps & SMB_CAP_LARGE_WRITEX) &&
95 (vcp->vc_hflags2 & SMB_FLAGS2_SECURITY_SIGNATURE) == 0)
96 return (60*1024);
97 else
98 return (vcp->vc_sopt.sv_maxtx - SMB_HDRLEN - 64);
99 }
100
101 static int
102 smb_smb_nomux(struct smb_vc *vcp, struct smb_cred *scred, const char *name)
103 {
104 if (scred->scr_td->td_proc == vcp->vc_iod->iod_p)
105 return 0;
106 SMBERROR("wrong function called(%s)\n", name);
107 return EINVAL;
108 }
109
110 int
111 smb_smb_negotiate(struct smb_vc *vcp, struct smb_cred *scred)
112 {
113 struct smb_dialect *dp;
114 struct smb_sopt *sp = NULL;
115 struct smb_rq *rqp;
116 struct mbchain *mbp;
117 struct mdchain *mdp;
118 u_int8_t wc, stime[8], sblen;
119 u_int16_t dindex, tw, tw1, swlen, bc;
120 int error, maxqsz;
121 int unicode = SMB_UNICODE_STRINGS(vcp);
122 void * servercharset = vcp->vc_toserver;
123 void * localcharset = vcp->vc_tolocal;
124
125 if (smb_smb_nomux(vcp, scred, __func__) != 0)
126 return EINVAL;
127 /* Disable Unicode for SMB_COM_NEGOTIATE requests */
128 if (unicode) {
129 vcp->vc_toserver = vcp->vc_cp_toserver;
130 vcp->vc_tolocal = vcp->vc_cp_tolocal;
131 }
132 vcp->vc_hflags = 0;
133 vcp->vc_hflags2 = 0;
134 vcp->obj.co_flags &= ~(SMBV_ENCRYPT);
135 sp = &vcp->vc_sopt;
136 bzero(sp, sizeof(struct smb_sopt));
137 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_NEGOTIATE, scred, &rqp);
138 if (error)
139 return error;
140 smb_rq_getrequest(rqp, &mbp);
141 smb_rq_wstart(rqp);
142 smb_rq_wend(rqp);
143 smb_rq_bstart(rqp);
144 for(dp = smb_dialects; dp->d_id != -1; dp++) {
145 mb_put_uint8(mbp, SMB_DT_DIALECT);
146 smb_put_dstring(mbp, vcp, dp->d_name, SMB_CS_NONE);
147 }
148 smb_rq_bend(rqp);
149 error = smb_rq_simple(rqp);
150 SMBSDEBUG("%d\n", error);
151 if (error)
152 goto bad;
153 smb_rq_getreply(rqp, &mdp);
154 do {
155 error = md_get_uint8(mdp, &wc);
156 if (error)
157 break;
158 error = md_get_uint16le(mdp, &dindex);
159 if (error)
160 break;
161 if (dindex > 7) {
162 SMBERROR("Don't know how to talk with server %s (%d)\n", "xxx", dindex);
163 error = EBADRPC;
164 break;
165 }
166 dp = smb_dialects + dindex;
167 sp->sv_proto = dp->d_id;
168 SMBSDEBUG("Dialect %s (%d, %d)\n", dp->d_name, dindex, wc);
169 error = EBADRPC;
170 if (dp->d_id >= SMB_DIALECT_NTLM0_12) {
171 if (wc != 17)
172 break;
173 md_get_uint8(mdp, &sp->sv_sm);
174 md_get_uint16le(mdp, &sp->sv_maxmux);
175 md_get_uint16le(mdp, &sp->sv_maxvcs);
176 md_get_uint32le(mdp, &sp->sv_maxtx);
177 md_get_uint32le(mdp, &sp->sv_maxraw);
178 md_get_uint32le(mdp, &sp->sv_skey);
179 md_get_uint32le(mdp, &sp->sv_caps);
180 md_get_mem(mdp, stime, 8, MB_MSYSTEM);
181 md_get_uint16le(mdp, (u_int16_t*)&sp->sv_tz);
182 md_get_uint8(mdp, &sblen);
183 if (sblen && (sp->sv_sm & SMB_SM_ENCRYPT)) {
184 if (sblen != SMB_MAXCHALLENGELEN) {
185 SMBERROR("Unexpected length of security blob (%d)\n", sblen);
186 break;
187 }
188 error = md_get_uint16le(mdp, &bc);
189 if (error)
190 break;
191 if (sp->sv_caps & SMB_CAP_EXT_SECURITY)
192 md_get_mem(mdp, NULL, 16, MB_MSYSTEM);
193 error = md_get_mem(mdp, vcp->vc_ch, sblen, MB_MSYSTEM);
194 if (error)
195 break;
196 vcp->vc_chlen = sblen;
197 vcp->obj.co_flags |= SMBV_ENCRYPT;
198 }
199 if (sp->sv_sm & SMB_SM_SIGS_REQUIRE)
200 vcp->vc_hflags2 |= SMB_FLAGS2_SECURITY_SIGNATURE;
201 if (vcp->vc_ucs_toserver &&
202 sp->sv_caps & SMB_CAP_UNICODE) {
203 /*
204 * They do Unicode.
205 */
206 vcp->obj.co_flags |= SMBV_UNICODE;
207 }
208 vcp->vc_hflags2 |= SMB_FLAGS2_KNOWS_LONG_NAMES;
209 if (dp->d_id == SMB_DIALECT_NTLM0_12 &&
210 sp->sv_maxtx < 4096 &&
211 (sp->sv_caps & SMB_CAP_NT_SMBS) == 0) {
212 vcp->obj.co_flags |= SMBV_WIN95;
213 SMBSDEBUG("Win95 detected\n");
214 }
215 error = 0;
216 break;
217 }
218 vcp->vc_hflags2 &= ~(SMB_FLAGS2_EXT_SEC|SMB_FLAGS2_DFS|
219 SMB_FLAGS2_ERR_STATUS|SMB_FLAGS2_UNICODE);
220 unicode = 0;
221 if (dp->d_id > SMB_DIALECT_CORE) {
222 md_get_uint16le(mdp, &tw);
223 sp->sv_sm = tw;
224 md_get_uint16le(mdp, &tw);
225 sp->sv_maxtx = tw;
226 md_get_uint16le(mdp, &sp->sv_maxmux);
227 md_get_uint16le(mdp, &sp->sv_maxvcs);
228 md_get_uint16le(mdp, &tw); /* rawmode */
229 md_get_uint32le(mdp, &sp->sv_skey);
230 if (wc == 13) { /* >= LANMAN1 */
231 md_get_uint16(mdp, &tw); /* time */
232 md_get_uint16(mdp, &tw1); /* date */
233 md_get_uint16le(mdp, (u_int16_t*)&sp->sv_tz);
234 md_get_uint16le(mdp, &swlen);
235 if (swlen > SMB_MAXCHALLENGELEN)
236 break;
237 md_get_uint16(mdp, NULL); /* mbz */
238 if (md_get_uint16le(mdp, &bc) != 0)
239 break;
240 if (bc < swlen)
241 break;
242 if (swlen && (sp->sv_sm & SMB_SM_ENCRYPT)) {
243 error = md_get_mem(mdp, vcp->vc_ch, swlen, MB_MSYSTEM);
244 if (error)
245 break;
246 vcp->vc_chlen = swlen;
247 vcp->obj.co_flags |= SMBV_ENCRYPT;
248 }
249 }
250 vcp->vc_hflags2 |= SMB_FLAGS2_KNOWS_LONG_NAMES;
251 } else { /* an old CORE protocol */
252 sp->sv_maxmux = 1;
253 }
254 error = 0;
255 } while (0);
256 if (error == 0) {
257 vcp->vc_maxvcs = sp->sv_maxvcs;
258 if (vcp->vc_maxvcs <= 1) {
259 if (vcp->vc_maxvcs == 0)
260 vcp->vc_maxvcs = 1;
261 }
262 if (sp->sv_maxtx <= 0 || sp->sv_maxtx > 0xffff)
263 sp->sv_maxtx = 1024;
264 else
265 sp->sv_maxtx = min(sp->sv_maxtx,
266 63*1024 + SMB_HDRLEN + 16);
267 SMB_TRAN_GETPARAM(vcp, SMBTP_RCVSZ, &maxqsz);
268 vcp->vc_rxmax = min(smb_vc_maxread(vcp), maxqsz - 1024);
269 SMB_TRAN_GETPARAM(vcp, SMBTP_SNDSZ, &maxqsz);
270 vcp->vc_wxmax = min(smb_vc_maxwrite(vcp), maxqsz - 1024);
271 vcp->vc_txmax = min(sp->sv_maxtx, maxqsz);
272 SMBSDEBUG("TZ = %d\n", sp->sv_tz);
273 SMBSDEBUG("CAPS = %x\n", sp->sv_caps);
274 SMBSDEBUG("MAXMUX = %d\n", sp->sv_maxmux);
275 SMBSDEBUG("MAXVCS = %d\n", sp->sv_maxvcs);
276 SMBSDEBUG("MAXRAW = %d\n", sp->sv_maxraw);
277 SMBSDEBUG("MAXTX = %d\n", sp->sv_maxtx);
278 }
279 bad:
280 /* Restore Unicode conversion state */
281 if (unicode) {
282 vcp->vc_toserver = servercharset;
283 vcp->vc_tolocal = localcharset;
284 vcp->vc_hflags2 |= SMB_FLAGS2_UNICODE;
285 }
286 smb_rq_done(rqp);
287 return error;
288 }
289
290 int
291 smb_smb_ssnsetup(struct smb_vc *vcp, struct smb_cred *scred)
292 {
293 struct smb_rq *rqp;
294 struct mbchain *mbp;
295 /* u_int8_t wc;
296 u_int16_t tw, tw1;*/
297 smb_uniptr unipp, ntencpass = NULL;
298 char *pp, *up, *pbuf, *encpass;
299 int error, plen, uniplen, ulen, upper;
300 u_int32_t caps = 0;
301
302 upper = 0;
303
304 if (vcp->obj.co_flags & SMBV_UNICODE)
305 caps |= SMB_CAP_UNICODE;
306
307 again:
308
309 vcp->vc_smbuid = SMB_UID_UNKNOWN;
310
311 if (smb_smb_nomux(vcp, scred, __func__) != 0)
312 return EINVAL;
313
314 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_SESSION_SETUP_ANDX, scred, &rqp);
315 if (error)
316 return error;
317 pbuf = malloc(SMB_MAXPASSWORDLEN + 1, M_SMBTEMP, M_WAITOK);
318 encpass = malloc(24, M_SMBTEMP, M_WAITOK);
319 if (vcp->vc_sopt.sv_sm & SMB_SM_USER) {
320 /*
321 * We try w/o uppercasing first so Samba mixed case
322 * passwords work. If that fails we come back and try
323 * uppercasing to satisfy OS/2 and Windows for Workgroups.
324 */
325 if (upper++) {
326 iconv_convstr(vcp->vc_toupper, pbuf,
327 smb_vc_getpass(vcp)/*, SMB_MAXPASSWORDLEN*/);
328 } else {
329 strncpy(pbuf, smb_vc_getpass(vcp), SMB_MAXPASSWORDLEN);
330 pbuf[SMB_MAXPASSWORDLEN] = '\0';
331 }
332 if (!SMB_UNICODE_STRINGS(vcp))
333 iconv_convstr(vcp->vc_toserver, pbuf, pbuf/*,
334 SMB_MAXPASSWORDLEN*/);
335
336 if (vcp->vc_sopt.sv_sm & SMB_SM_ENCRYPT) {
337 uniplen = plen = 24;
338 smb_encrypt(pbuf, vcp->vc_ch, encpass);
339 ntencpass = malloc(uniplen, M_SMBTEMP, M_WAITOK);
340 if (SMB_UNICODE_STRINGS(vcp)) {
341 strncpy(pbuf, smb_vc_getpass(vcp),
342 SMB_MAXPASSWORDLEN);
343 pbuf[SMB_MAXPASSWORDLEN] = '\0';
344 } else
345 iconv_convstr(vcp->vc_toserver, pbuf,
346 smb_vc_getpass(vcp)/*,
347 SMB_MAXPASSWORDLEN*/);
348 smb_ntencrypt(pbuf, vcp->vc_ch, (u_char*)ntencpass);
349 pp = encpass;
350 unipp = ntencpass;
351 } else {
352 plen = strlen(pbuf) + 1;
353 pp = pbuf;
354 uniplen = plen * 2;
355 ntencpass = malloc(uniplen, M_SMBTEMP, M_WAITOK);
356 smb_strtouni(ntencpass, smb_vc_getpass(vcp));
357 plen--;
358
359 /*
360 * The uniplen is zeroed because Samba cannot deal
361 * with this 2nd cleartext password. This Samba
362 * "bug" is actually a workaround for problems in
363 * Microsoft clients.
364 */
365 uniplen = 0/*-= 2*/;
366 unipp = ntencpass;
367 }
368 } else {
369 /*
370 * In the share security mode password will be used
371 * only in the tree authentication
372 */
373 pp = "";
374 plen = 1;
375 unipp = &smb_unieol;
376 uniplen = 0 /* sizeof(smb_unieol) */;
377 }
378 smb_rq_wstart(rqp);
379 mbp = &rqp->sr_rq;
380 up = vcp->vc_username;
381 ulen = strlen(up) + 1;
382 /*
383 * If userid is null we are attempting anonymous browse login
384 * so passwords must be zero length.
385 */
386 if (ulen == 1)
387 plen = uniplen = 0;
388 mb_put_uint8(mbp, 0xff);
389 mb_put_uint8(mbp, 0);
390 mb_put_uint16le(mbp, 0);
391 mb_put_uint16le(mbp, vcp->vc_sopt.sv_maxtx);
392 mb_put_uint16le(mbp, vcp->vc_sopt.sv_maxmux);
393 mb_put_uint16le(mbp, vcp->vc_number);
394 mb_put_uint32le(mbp, vcp->vc_sopt.sv_skey);
395 mb_put_uint16le(mbp, plen);
396 if (SMB_DIALECT(vcp) < SMB_DIALECT_NTLM0_12) {
397 mb_put_uint32le(mbp, 0);
398 smb_rq_wend(rqp);
399 smb_rq_bstart(rqp);
400 mb_put_mem(mbp, pp, plen, MB_MSYSTEM);
401 smb_put_dstring(mbp, vcp, up, SMB_CS_NONE);
402 } else {
403 mb_put_uint16le(mbp, uniplen);
404 mb_put_uint32le(mbp, 0); /* reserved */
405 mb_put_uint32le(mbp, caps);
406 smb_rq_wend(rqp);
407 smb_rq_bstart(rqp);
408 mb_put_mem(mbp, pp, plen, MB_MSYSTEM);
409 mb_put_mem(mbp, (caddr_t)unipp, uniplen, MB_MSYSTEM);
410 smb_put_dstring(mbp, vcp, up, SMB_CS_NONE); /* AccountName */
411 smb_put_dstring(mbp, vcp, vcp->vc_domain, SMB_CS_NONE); /* PrimaryDomain */
412 smb_put_dstring(mbp, vcp, "FreeBSD", SMB_CS_NONE); /* Client's OS */
413 smb_put_dstring(mbp, vcp, "NETSMB", SMB_CS_NONE); /* Client name */
414 }
415 smb_rq_bend(rqp);
416 if (ntencpass)
417 free(ntencpass, M_SMBTEMP);
418 if (vcp->vc_hflags2 & SMB_FLAGS2_SECURITY_SIGNATURE)
419 smb_calcmackey(vcp);
420 error = smb_rq_simple(rqp);
421 SMBSDEBUG("%d\n", error);
422 if (error) {
423 if (rqp->sr_errclass == ERRDOS && rqp->sr_serror == ERRnoaccess)
424 error = EAUTH;
425 goto bad;
426 }
427 vcp->vc_smbuid = rqp->sr_rpuid;
428 bad:
429 free(encpass, M_SMBTEMP);
430 free(pbuf, M_SMBTEMP);
431 smb_rq_done(rqp);
432 if (error && upper == 1 && vcp->vc_sopt.sv_sm & SMB_SM_USER)
433 goto again;
434 return error;
435 }
436
437 int
438 smb_smb_ssnclose(struct smb_vc *vcp, struct smb_cred *scred)
439 {
440 struct smb_rq *rqp;
441 struct mbchain *mbp;
442 int error;
443
444 if (vcp->vc_smbuid == SMB_UID_UNKNOWN)
445 return 0;
446
447 if (smb_smb_nomux(vcp, scred, __func__) != 0)
448 return EINVAL;
449
450 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_LOGOFF_ANDX, scred, &rqp);
451 if (error)
452 return error;
453 mbp = &rqp->sr_rq;
454 smb_rq_wstart(rqp);
455 mb_put_uint8(mbp, 0xff);
456 mb_put_uint8(mbp, 0);
457 mb_put_uint16le(mbp, 0);
458 smb_rq_wend(rqp);
459 smb_rq_bstart(rqp);
460 smb_rq_bend(rqp);
461 error = smb_rq_simple(rqp);
462 SMBSDEBUG("%d\n", error);
463 smb_rq_done(rqp);
464 return error;
465 }
466
467 static char smb_any_share[] = "?????";
468
469 static char *
470 smb_share_typename(int stype)
471 {
472 char *pp;
473
474 switch (stype) {
475 case SMB_ST_DISK:
476 pp = "A:";
477 break;
478 case SMB_ST_PRINTER:
479 pp = smb_any_share; /* can't use LPT: here... */
480 break;
481 case SMB_ST_PIPE:
482 pp = "IPC";
483 break;
484 case SMB_ST_COMM:
485 pp = "COMM";
486 break;
487 case SMB_ST_ANY:
488 default:
489 pp = smb_any_share;
490 break;
491 }
492 return pp;
493 }
494
495 int
496 smb_smb_treeconnect(struct smb_share *ssp, struct smb_cred *scred)
497 {
498 struct smb_vc *vcp;
499 struct smb_rq rq, *rqp = &rq;
500 struct mbchain *mbp;
501 char *pp, *pbuf, *encpass;
502 int error, plen, caseopt, upper;
503
504 upper = 0;
505
506 again:
507 /* Disable Unicode for SMB_COM_TREE_CONNECT_ANDX requests */
508 if (SSTOVC(ssp)->vc_hflags2 & SMB_FLAGS2_UNICODE) {
509 vcp = SSTOVC(ssp);
510 vcp->vc_toserver = vcp->vc_cp_toserver;
511 vcp->vc_tolocal = vcp->vc_cp_tolocal;
512 vcp->vc_hflags2 &= ~SMB_FLAGS2_UNICODE;
513 }
514
515 ssp->ss_tid = SMB_TID_UNKNOWN;
516 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_TREE_CONNECT_ANDX, scred, &rqp);
517 if (error)
518 return error;
519 vcp = rqp->sr_vc;
520 caseopt = SMB_CS_NONE;
521 if (vcp->vc_sopt.sv_sm & SMB_SM_USER) {
522 plen = 1;
523 pp = "";
524 pbuf = NULL;
525 encpass = NULL;
526 } else {
527 pbuf = malloc(SMB_MAXPASSWORDLEN + 1, M_SMBTEMP, M_WAITOK);
528 encpass = malloc(24, M_SMBTEMP, M_WAITOK);
529 /*
530 * We try w/o uppercasing first so Samba mixed case
531 * passwords work. If that fails we come back and try
532 * uppercasing to satisfy OS/2 and Windows for Workgroups.
533 */
534 if (upper++) {
535 iconv_convstr(vcp->vc_toupper, pbuf,
536 smb_share_getpass(ssp)/*,
537 SMB_MAXPASSWORDLEN*/);
538 } else {
539 strncpy(pbuf, smb_share_getpass(ssp),
540 SMB_MAXPASSWORDLEN);
541 pbuf[SMB_MAXPASSWORDLEN] = '\0';
542 }
543 if (vcp->vc_sopt.sv_sm & SMB_SM_ENCRYPT) {
544 plen = 24;
545 smb_encrypt(pbuf, vcp->vc_ch, encpass);
546 pp = encpass;
547 } else {
548 plen = strlen(pbuf) + 1;
549 pp = pbuf;
550 }
551 }
552 mbp = &rqp->sr_rq;
553 smb_rq_wstart(rqp);
554 mb_put_uint8(mbp, 0xff);
555 mb_put_uint8(mbp, 0);
556 mb_put_uint16le(mbp, 0);
557 mb_put_uint16le(mbp, 0); /* Flags */
558 mb_put_uint16le(mbp, plen);
559 smb_rq_wend(rqp);
560 smb_rq_bstart(rqp);
561 mb_put_mem(mbp, pp, plen, MB_MSYSTEM);
562 smb_put_dmem(mbp, vcp, "\\\\", 2, caseopt);
563 pp = vcp->vc_srvname;
564 smb_put_dmem(mbp, vcp, pp, strlen(pp), caseopt);
565 smb_put_dmem(mbp, vcp, "\\", 1, caseopt);
566 pp = ssp->ss_name;
567 smb_put_dstring(mbp, vcp, pp, caseopt);
568 pp = smb_share_typename(ssp->ss_type);
569 smb_put_dstring(mbp, vcp, pp, caseopt);
570 smb_rq_bend(rqp);
571 error = smb_rq_simple(rqp);
572 SMBSDEBUG("%d\n", error);
573 if (error)
574 goto bad;
575 ssp->ss_tid = rqp->sr_rptid;
576 ssp->ss_vcgenid = vcp->vc_genid;
577 ssp->ss_flags |= SMBS_CONNECTED;
578 /*
579 * If the server can speak Unicode then switch
580 * our converters to do Unicode <--> Local
581 */
582 if (vcp->obj.co_flags & SMBV_UNICODE) {
583 vcp->vc_toserver = vcp->vc_ucs_toserver;
584 vcp->vc_tolocal = vcp->vc_ucs_tolocal;
585 vcp->vc_hflags2 |= SMB_FLAGS2_UNICODE;
586 }
587 bad:
588 if (encpass)
589 free(encpass, M_SMBTEMP);
590 if (pbuf)
591 free(pbuf, M_SMBTEMP);
592 smb_rq_done(rqp);
593 if (error && upper == 1)
594 goto again;
595 return error;
596 }
597
598 int
599 smb_smb_treedisconnect(struct smb_share *ssp, struct smb_cred *scred)
600 {
601 struct smb_rq *rqp;
602 int error;
603
604 if (ssp->ss_tid == SMB_TID_UNKNOWN)
605 return 0;
606 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_TREE_DISCONNECT, scred, &rqp);
607 if (error)
608 return error;
609 smb_rq_wstart(rqp);
610 smb_rq_wend(rqp);
611 smb_rq_bstart(rqp);
612 smb_rq_bend(rqp);
613 error = smb_rq_simple(rqp);
614 SMBSDEBUG("%d\n", error);
615 smb_rq_done(rqp);
616 ssp->ss_tid = SMB_TID_UNKNOWN;
617 return error;
618 }
619
620 static __inline int
621 smb_smb_readx(struct smb_share *ssp, u_int16_t fid, int *len, int *rresid,
622 struct uio *uio, struct smb_cred *scred)
623 {
624 struct smb_rq *rqp;
625 struct mbchain *mbp;
626 struct mdchain *mdp;
627 u_int8_t wc;
628 int error;
629 u_int16_t residhi, residlo, off, doff;
630 u_int32_t resid;
631
632 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_READ_ANDX, scred, &rqp);
633 if (error)
634 return error;
635 smb_rq_getrequest(rqp, &mbp);
636 smb_rq_wstart(rqp);
637 mb_put_uint8(mbp, 0xff); /* no secondary command */
638 mb_put_uint8(mbp, 0); /* MBZ */
639 mb_put_uint16le(mbp, 0); /* offset to secondary */
640 mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
641 mb_put_uint32le(mbp, uio->uio_offset);
642 *len = min(SSTOVC(ssp)->vc_rxmax, *len);
643 mb_put_uint16le(mbp, *len); /* MaxCount */
644 mb_put_uint16le(mbp, *len); /* MinCount (only indicates blocking) */
645 mb_put_uint32le(mbp, (unsigned)*len >> 16); /* MaxCountHigh */
646 mb_put_uint16le(mbp, *len); /* Remaining ("obsolete") */
647 mb_put_uint32le(mbp, uio->uio_offset >> 32); /* OffsetHigh */
648 smb_rq_wend(rqp);
649 smb_rq_bstart(rqp);
650 smb_rq_bend(rqp);
651 do {
652 error = smb_rq_simple(rqp);
653 if (error)
654 break;
655 smb_rq_getreply(rqp, &mdp);
656 off = SMB_HDRLEN;
657 md_get_uint8(mdp, &wc);
658 off++;
659 if (wc != 12) {
660 error = EBADRPC;
661 break;
662 }
663 md_get_uint8(mdp, NULL);
664 off++;
665 md_get_uint8(mdp, NULL);
666 off++;
667 md_get_uint16le(mdp, NULL);
668 off += 2;
669 md_get_uint16le(mdp, NULL);
670 off += 2;
671 md_get_uint16le(mdp, NULL); /* data compaction mode */
672 off += 2;
673 md_get_uint16le(mdp, NULL);
674 off += 2;
675 md_get_uint16le(mdp, &residlo);
676 off += 2;
677 md_get_uint16le(mdp, &doff); /* data offset */
678 off += 2;
679 md_get_uint16le(mdp, &residhi);
680 off += 2;
681 resid = (residhi << 16) | residlo;
682 md_get_mem(mdp, NULL, 4 * 2, MB_MSYSTEM);
683 off += 4*2;
684 md_get_uint16le(mdp, NULL); /* ByteCount */
685 off += 2;
686 if (doff > off) /* pad byte(s)? */
687 md_get_mem(mdp, NULL, doff - off, MB_MSYSTEM);
688 if (resid == 0) {
689 *rresid = resid;
690 break;
691 }
692 error = md_get_uio(mdp, uio, resid);
693 if (error)
694 break;
695 *rresid = resid;
696 } while(0);
697 smb_rq_done(rqp);
698 return (error);
699 }
700
701 static __inline int
702 smb_smb_writex(struct smb_share *ssp, u_int16_t fid, int *len, int *rresid,
703 struct uio *uio, struct smb_cred *scred)
704 {
705 struct smb_rq *rqp;
706 struct mbchain *mbp;
707 struct mdchain *mdp;
708 int error;
709 u_int8_t wc;
710 u_int16_t resid;
711
712 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE_ANDX, scred, &rqp);
713 if (error)
714 return (error);
715 smb_rq_getrequest(rqp, &mbp);
716 smb_rq_wstart(rqp);
717 mb_put_uint8(mbp, 0xff); /* no secondary command */
718 mb_put_uint8(mbp, 0); /* MBZ */
719 mb_put_uint16le(mbp, 0); /* offset to secondary */
720 mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
721 mb_put_uint32le(mbp, uio->uio_offset);
722 mb_put_uint32le(mbp, 0); /* MBZ (timeout) */
723 mb_put_uint16le(mbp, 0); /* !write-thru */
724 mb_put_uint16le(mbp, 0);
725 *len = min(SSTOVC(ssp)->vc_wxmax, *len);
726 mb_put_uint16le(mbp, (unsigned)*len >> 16);
727 mb_put_uint16le(mbp, *len);
728 mb_put_uint16le(mbp, 64); /* data offset from header start */
729 mb_put_uint32le(mbp, uio->uio_offset >> 32); /* OffsetHigh */
730 smb_rq_wend(rqp);
731 smb_rq_bstart(rqp);
732 do {
733 mb_put_uint8(mbp, 0xee); /* mimic xp pad byte! */
734 error = mb_put_uio(mbp, uio, *len);
735 if (error)
736 break;
737 smb_rq_bend(rqp);
738 error = smb_rq_simple(rqp);
739 if (error)
740 break;
741 smb_rq_getreply(rqp, &mdp);
742 md_get_uint8(mdp, &wc);
743 if (wc != 6) {
744 error = EBADRPC;
745 break;
746 }
747 md_get_uint8(mdp, NULL);
748 md_get_uint8(mdp, NULL);
749 md_get_uint16le(mdp, NULL);
750 md_get_uint16le(mdp, &resid);
751 *rresid = resid;
752 } while(0);
753
754 smb_rq_done(rqp);
755 return (error);
756 }
757
758 static __inline int
759 smb_smb_read(struct smb_share *ssp, u_int16_t fid,
760 int *len, int *rresid, struct uio *uio, struct smb_cred *scred)
761 {
762 struct smb_rq *rqp;
763 struct mbchain *mbp;
764 struct mdchain *mdp;
765 u_int16_t resid, bc;
766 u_int8_t wc;
767 int error, rlen, blksz;
768
769 if (SSTOVC(ssp)->vc_sopt.sv_caps & SMB_CAP_LARGE_READX)
770 return (smb_smb_readx(ssp, fid, len, rresid, uio, scred));
771
772 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_READ, scred, &rqp);
773 if (error)
774 return error;
775
776 blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16;
777 rlen = *len = min(blksz, *len);
778
779 smb_rq_getrequest(rqp, &mbp);
780 smb_rq_wstart(rqp);
781 mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
782 mb_put_uint16le(mbp, rlen);
783 mb_put_uint32le(mbp, uio->uio_offset);
784 mb_put_uint16le(mbp, min(uio->uio_resid, 0xffff));
785 smb_rq_wend(rqp);
786 smb_rq_bstart(rqp);
787 smb_rq_bend(rqp);
788 do {
789 error = smb_rq_simple(rqp);
790 if (error)
791 break;
792 smb_rq_getreply(rqp, &mdp);
793 md_get_uint8(mdp, &wc);
794 if (wc != 5) {
795 error = EBADRPC;
796 break;
797 }
798 md_get_uint16le(mdp, &resid);
799 md_get_mem(mdp, NULL, 4 * 2, MB_MSYSTEM);
800 md_get_uint16le(mdp, &bc);
801 md_get_uint8(mdp, NULL); /* ignore buffer type */
802 md_get_uint16le(mdp, &resid);
803 if (resid == 0) {
804 *rresid = resid;
805 break;
806 }
807 error = md_get_uio(mdp, uio, resid);
808 if (error)
809 break;
810 *rresid = resid;
811 } while(0);
812 smb_rq_done(rqp);
813 return error;
814 }
815
816 int
817 smb_read(struct smb_share *ssp, u_int16_t fid, struct uio *uio,
818 struct smb_cred *scred)
819 {
820 int tsize, len, resid;
821 int error = 0;
822
823 tsize = uio->uio_resid;
824 while (tsize > 0) {
825 resid = 0;
826 len = tsize;
827 error = smb_smb_read(ssp, fid, &len, &resid, uio, scred);
828 if (error)
829 break;
830 tsize -= resid;
831 if (resid < len)
832 break;
833 }
834 return error;
835 }
836
837 static __inline int
838 smb_smb_write(struct smb_share *ssp, u_int16_t fid, int *len, int *rresid,
839 struct uio *uio, struct smb_cred *scred)
840 {
841 struct smb_rq *rqp;
842 struct mbchain *mbp;
843 struct mdchain *mdp;
844 u_int16_t resid;
845 u_int8_t wc;
846 int error, blksz;
847
848 if (*len && SSTOVC(ssp)->vc_sopt.sv_caps & SMB_CAP_LARGE_WRITEX)
849 return (smb_smb_writex(ssp, fid, len, rresid, uio, scred));
850
851 blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16;
852 if (blksz > 0xffff)
853 blksz = 0xffff;
854
855 resid = *len = min(blksz, *len);
856
857 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp);
858 if (error)
859 return error;
860 smb_rq_getrequest(rqp, &mbp);
861 smb_rq_wstart(rqp);
862 mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
863 mb_put_uint16le(mbp, resid);
864 mb_put_uint32le(mbp, uio->uio_offset);
865 mb_put_uint16le(mbp, min(uio->uio_resid, 0xffff));
866 smb_rq_wend(rqp);
867 smb_rq_bstart(rqp);
868 mb_put_uint8(mbp, SMB_DT_DATA);
869 mb_put_uint16le(mbp, resid);
870 do {
871 error = mb_put_uio(mbp, uio, resid);
872 if (error)
873 break;
874 smb_rq_bend(rqp);
875 error = smb_rq_simple(rqp);
876 if (error)
877 break;
878 smb_rq_getreply(rqp, &mdp);
879 md_get_uint8(mdp, &wc);
880 if (wc != 1) {
881 error = EBADRPC;
882 break;
883 }
884 md_get_uint16le(mdp, &resid);
885 *rresid = resid;
886 } while(0);
887 smb_rq_done(rqp);
888 return error;
889 }
890
891 int
892 smb_write(struct smb_share *ssp, u_int16_t fid, struct uio *uio,
893 struct smb_cred *scred)
894 {
895 int error = 0, len, tsize, resid;
896 struct uio olduio;
897
898 tsize = uio->uio_resid;
899 olduio = *uio;
900 while (tsize > 0) {
901 resid = 0;
902 len = tsize;
903 error = smb_smb_write(ssp, fid, &len, &resid, uio, scred);
904 if (error)
905 break;
906 if (resid < len) {
907 error = EIO;
908 break;
909 }
910 tsize -= resid;
911 }
912 if (error) {
913 /*
914 * Errors can happen on the copyin, the rpc, etc. So they
915 * imply resid is unreliable. The only safe thing is
916 * to pretend zero bytes made it. We needn't restore the
917 * iovs because callers don't depend on them in error
918 * paths - uio_resid and uio_offset are what matter.
919 */
920 *uio = olduio;
921 }
922 return error;
923 }
924
925 int
926 smb_smb_echo(struct smb_vc *vcp, struct smb_cred *scred)
927 {
928 struct smb_rq *rqp;
929 struct mbchain *mbp;
930 int error;
931
932 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_ECHO, scred, &rqp);
933 if (error)
934 return error;
935 mbp = &rqp->sr_rq;
936 smb_rq_wstart(rqp);
937 mb_put_uint16le(mbp, 1);
938 smb_rq_wend(rqp);
939 smb_rq_bstart(rqp);
940 mb_put_uint32le(mbp, 0);
941 smb_rq_bend(rqp);
942 error = smb_rq_simple(rqp);
943 SMBSDEBUG("%d\n", error);
944 smb_rq_done(rqp);
945 return error;
946 }
The FreeBSD Project