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