1 /* 2 * Copyright (c) 2000-2001 Boris Popov 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by Boris Popov. 16 * 4. Neither the name of the author nor the names of any co-contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * $FreeBSD: src/sys/netsmb/smb_smb.c,v 1.1.2.3 2002/12/14 14:44:19 fjoe Exp $ 33 */ 34 /* 35 * various SMB requests. Most of the routines merely packs data into mbufs. 36 */ 37 #include <sys/param.h> 38 #include <sys/systm.h> 39 #include <sys/kernel.h> 40 #include <sys/malloc.h> 41 #include <sys/proc.h> 42 #include <sys/lock.h> 43 #include <sys/sysctl.h> 44 #include <sys/socket.h> 45 #include <sys/uio.h> 46 47 #include <sys/iconv.h> 48 #include <machine/limits.h> 49 50 #include "smb.h" 51 #include "smb_subr.h" 52 #include "smb_rq.h" 53 #include "smb_conn.h" 54 #include "smb_tran.h" 55 56 struct smb_dialect { 57 int d_id; 58 const char * d_name; 59 }; 60 61 static struct smb_dialect smb_dialects[] = { 62 {SMB_DIALECT_CORE, "PC NETWORK PROGRAM 1.0"}, 63 {SMB_DIALECT_COREPLUS, "MICROSOFT NETWORKS 1.03"}, 64 {SMB_DIALECT_LANMAN1_0, "MICROSOFT NETWORKS 3.0"}, 65 {SMB_DIALECT_LANMAN1_0, "LANMAN1.0"}, 66 {SMB_DIALECT_LANMAN2_0, "LM1.2X002"}, 67 {SMB_DIALECT_LANMAN2_0, "Samba"}, 68 {SMB_DIALECT_NTLM0_12, "NT LANMAN 1.0"}, 69 {SMB_DIALECT_NTLM0_12, "NT LM 0.12"}, 70 {-1, NULL} 71 }; 72 73 #define SMB_DIALECT_MAX (NELEM(smb_dialects) - 2) 74 75 static int 76 smb_smb_nomux(struct smb_vc *vcp, struct smb_cred *scred, const char *name) 77 { 78 if (scred->scr_td == vcp->vc_iod->iod_td) 79 return 0; 80 SMBERROR("wrong function called(%s)\n", name); 81 return EINVAL; 82 } 83 84 int 85 smb_smb_negotiate(struct smb_vc *vcp, struct smb_cred *scred) 86 { 87 struct smb_dialect *dp; 88 struct smb_sopt *sp = NULL; 89 struct smb_rq *rqp; 90 struct mbchain *mbp; 91 struct mdchain *mdp; 92 u_int8_t wc, stime[8], sblen; 93 u_int16_t dindex, tw, tw1, swlen, bc; 94 int error, maxqsz; 95 96 if (smb_smb_nomux(vcp, scred, __func__) != 0) 97 return EINVAL; 98 vcp->vc_hflags = 0; 99 vcp->vc_hflags2 = 0; 100 vcp->obj.co_flags &= ~(SMBV_ENCRYPT); 101 sp = &vcp->vc_sopt; 102 bzero(sp, sizeof(struct smb_sopt)); 103 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_NEGOTIATE, scred, &rqp); 104 if (error) 105 return error; 106 smb_rq_getrequest(rqp, &mbp); 107 smb_rq_wstart(rqp); 108 smb_rq_wend(rqp); 109 smb_rq_bstart(rqp); 110 for(dp = smb_dialects; dp->d_id != -1; dp++) { 111 mb_put_uint8(mbp, SMB_DT_DIALECT); 112 smb_put_dstring(mbp, vcp, dp->d_name, SMB_CS_NONE); 113 } 114 smb_rq_bend(rqp); 115 error = smb_rq_simple(rqp); 116 SMBSDEBUG("%d\n", error); 117 if (error) 118 goto bad; 119 smb_rq_getreply(rqp, &mdp); 120 do { 121 error = md_get_uint8(mdp, &wc); 122 if (error) 123 break; 124 error = md_get_uint16le(mdp, &dindex); 125 if (error) 126 break; 127 if (dindex > 7) { 128 SMBERROR("Don't know how to talk with server %s (%d)\n", "xxx", dindex); 129 error = EBADRPC; 130 break; 131 } 132 dp = smb_dialects + dindex; 133 sp->sv_proto = dp->d_id; 134 SMBSDEBUG("Dialect %s (%d, %d)\n", dp->d_name, dindex, wc); 135 error = EBADRPC; 136 if (dp->d_id >= SMB_DIALECT_NTLM0_12) { 137 if (wc != 17) 138 break; 139 md_get_uint8(mdp, &sp->sv_sm); 140 md_get_uint16le(mdp, &sp->sv_maxmux); 141 md_get_uint16le(mdp, &sp->sv_maxvcs); 142 md_get_uint32le(mdp, &sp->sv_maxtx); 143 md_get_uint32le(mdp, &sp->sv_maxraw); 144 md_get_uint32le(mdp, &sp->sv_skey); 145 md_get_uint32le(mdp, &sp->sv_caps); 146 md_get_mem(mdp, stime, 8, MB_MSYSTEM); 147 md_get_uint16le(mdp, (u_int16_t*)&sp->sv_tz); 148 md_get_uint8(mdp, &sblen); 149 if (sblen && (sp->sv_sm & SMB_SM_ENCRYPT)) { 150 if (sblen != SMB_MAXCHALLENGELEN) { 151 SMBERROR("Unexpected length of security blob (%d)\n", sblen); 152 break; 153 } 154 error = md_get_uint16(mdp, &bc); 155 if (error) 156 break; 157 if (sp->sv_caps & SMB_CAP_EXT_SECURITY) 158 md_get_mem(mdp, NULL, 16, MB_MSYSTEM); 159 error = md_get_mem(mdp, vcp->vc_ch, sblen, MB_MSYSTEM); 160 if (error) 161 break; 162 vcp->vc_chlen = sblen; 163 vcp->obj.co_flags |= SMBV_ENCRYPT; 164 } 165 vcp->vc_hflags2 |= SMB_FLAGS2_KNOWS_LONG_NAMES; 166 if (dp->d_id == SMB_DIALECT_NTLM0_12 && 167 sp->sv_maxtx < 4096 && 168 (sp->sv_caps & SMB_CAP_NT_SMBS) == 0) { 169 vcp->obj.co_flags |= SMBV_WIN95; 170 SMBSDEBUG("Win95 detected\n"); 171 } 172 } else if (dp->d_id > SMB_DIALECT_CORE) { 173 md_get_uint16le(mdp, &tw); 174 sp->sv_sm = tw; 175 md_get_uint16le(mdp, &tw); 176 sp->sv_maxtx = tw; 177 md_get_uint16le(mdp, &sp->sv_maxmux); 178 md_get_uint16le(mdp, &sp->sv_maxvcs); 179 md_get_uint16le(mdp, &tw); /* rawmode */ 180 md_get_uint32le(mdp, &sp->sv_skey); 181 if (wc == 13) { /* >= LANMAN1 */ 182 md_get_uint16(mdp, &tw); /* time */ 183 md_get_uint16(mdp, &tw1); /* date */ 184 md_get_uint16le(mdp, (u_int16_t*)&sp->sv_tz); 185 md_get_uint16le(mdp, &swlen); 186 if (swlen > SMB_MAXCHALLENGELEN) 187 break; 188 md_get_uint16(mdp, NULL); /* mbz */ 189 if (md_get_uint16(mdp, &bc) != 0) 190 break; 191 if (bc < swlen) 192 break; 193 if (swlen && (sp->sv_sm & SMB_SM_ENCRYPT)) { 194 error = md_get_mem(mdp, vcp->vc_ch, swlen, MB_MSYSTEM); 195 if (error) 196 break; 197 vcp->vc_chlen = swlen; 198 vcp->obj.co_flags |= SMBV_ENCRYPT; 199 } 200 } 201 vcp->vc_hflags2 |= SMB_FLAGS2_KNOWS_LONG_NAMES; 202 } else { /* an old CORE protocol */ 203 sp->sv_maxmux = 1; 204 } 205 error = 0; 206 } while (0); 207 if (error == 0) { 208 vcp->vc_maxvcs = sp->sv_maxvcs; 209 if (vcp->vc_maxvcs <= 1) { 210 if (vcp->vc_maxvcs == 0) 211 vcp->vc_maxvcs = 1; 212 } 213 if (sp->sv_maxtx <= 0 || sp->sv_maxtx > 0xffff) 214 sp->sv_maxtx = 1024; 215 SMB_TRAN_GETPARAM(vcp, SMBTP_SNDSZ, &maxqsz); 216 vcp->vc_txmax = min(sp->sv_maxtx, maxqsz); 217 SMBSDEBUG("TZ = %d\n", sp->sv_tz); 218 SMBSDEBUG("CAPS = %x\n", sp->sv_caps); 219 SMBSDEBUG("MAXMUX = %d\n", sp->sv_maxmux); 220 SMBSDEBUG("MAXVCS = %d\n", sp->sv_maxvcs); 221 SMBSDEBUG("MAXRAW = %d\n", sp->sv_maxraw); 222 SMBSDEBUG("MAXTX = %d\n", sp->sv_maxtx); 223 } 224 bad: 225 smb_rq_done(rqp); 226 return error; 227 } 228 229 int 230 smb_smb_ssnsetup(struct smb_vc *vcp, struct smb_cred *scred) 231 { 232 struct smb_rq *rqp; 233 struct mbchain *mbp; 234 /* u_int8_t wc; 235 u_int16_t tw, tw1;*/ 236 smb_uniptr unipp, ntencpass = NULL; 237 char *pp, *up, *pbuf, *encpass; 238 int error, plen, uniplen; 239 240 vcp->vc_smbuid = SMB_UID_UNKNOWN; 241 242 if (smb_smb_nomux(vcp, scred, __func__) != 0) 243 return EINVAL; 244 245 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_SESSION_SETUP_ANDX, scred, &rqp); 246 if (error) 247 return error; 248 pbuf = kmalloc(SMB_MAXPASSWORDLEN + 1, M_SMBTEMP, M_WAITOK); 249 encpass = kmalloc(24, M_SMBTEMP, M_WAITOK); 250 if (vcp->vc_sopt.sv_sm & SMB_SM_USER) { 251 iconv_convstr(vcp->vc_toupper, pbuf, smb_vc_getpass(vcp)); 252 iconv_convstr(vcp->vc_toserver, pbuf, pbuf); 253 if (vcp->vc_sopt.sv_sm & SMB_SM_ENCRYPT) { 254 uniplen = plen = 24; 255 smb_encrypt(pbuf, vcp->vc_ch, encpass); 256 ntencpass = kmalloc(uniplen, M_SMBTEMP, M_WAITOK); 257 iconv_convstr(vcp->vc_toserver, pbuf, smb_vc_getpass(vcp)); 258 smb_ntencrypt(pbuf, vcp->vc_ch, (u_char*)ntencpass); 259 pp = encpass; 260 unipp = ntencpass; 261 } else { 262 plen = strlen(pbuf) + 1; 263 pp = pbuf; 264 uniplen = plen * 2; 265 ntencpass = kmalloc(uniplen, M_SMBTEMP, M_WAITOK); 266 smb_strtouni(ntencpass, smb_vc_getpass(vcp)); 267 plen--; 268 269 /* 270 * The uniplen is zeroed because Samba cannot deal 271 * with this 2nd cleartext password. This Samba 272 * "bug" is actually a workaround for problems in 273 * Microsoft clients. 274 */ 275 uniplen = 0/*-= 2*/; 276 unipp = ntencpass; 277 } 278 } else { 279 /* 280 * In the share security mode password will be used 281 * only in the tree authentication 282 */ 283 pp = ""; 284 plen = 1; 285 unipp = &smb_unieol; 286 uniplen = 0 /* sizeof(smb_unieol) */; 287 } 288 smb_rq_wstart(rqp); 289 mbp = &rqp->sr_rq; 290 up = vcp->vc_username; 291 mb_put_uint8(mbp, 0xff); 292 mb_put_uint8(mbp, 0); 293 mb_put_uint16le(mbp, 0); 294 mb_put_uint16le(mbp, vcp->vc_sopt.sv_maxtx); 295 mb_put_uint16le(mbp, vcp->vc_sopt.sv_maxmux); 296 mb_put_uint16le(mbp, vcp->vc_number); 297 mb_put_uint32le(mbp, vcp->vc_sopt.sv_skey); 298 mb_put_uint16le(mbp, plen); 299 if (SMB_DIALECT(vcp) < SMB_DIALECT_NTLM0_12) { 300 mb_put_uint32le(mbp, 0); 301 smb_rq_wend(rqp); 302 smb_rq_bstart(rqp); 303 mb_put_mem(mbp, pp, plen, MB_MSYSTEM); 304 smb_put_dstring(mbp, vcp, up, SMB_CS_NONE); 305 } else { 306 mb_put_uint16le(mbp, uniplen); 307 mb_put_uint32le(mbp, 0); /* reserved */ 308 mb_put_uint32le(mbp, vcp->obj.co_flags & SMBV_UNICODE ? 309 SMB_CAP_UNICODE : 0); 310 smb_rq_wend(rqp); 311 smb_rq_bstart(rqp); 312 mb_put_mem(mbp, pp, plen, MB_MSYSTEM); 313 mb_put_mem(mbp, (caddr_t)unipp, uniplen, MB_MSYSTEM); 314 smb_put_dstring(mbp, vcp, up, SMB_CS_NONE); /* AccountName */ 315 smb_put_dstring(mbp, vcp, vcp->vc_domain, SMB_CS_NONE); /* PrimaryDomain */ 316 smb_put_dstring(mbp, vcp, "FreeBSD", SMB_CS_NONE); /* Client's OS */ 317 smb_put_dstring(mbp, vcp, "NETSMB", SMB_CS_NONE); /* Client name */ 318 } 319 smb_rq_bend(rqp); 320 if (ntencpass) 321 kfree(ntencpass, M_SMBTEMP); 322 error = smb_rq_simple(rqp); 323 SMBSDEBUG("%d\n", error); 324 if (error) { 325 if (rqp->sr_errclass == ERRDOS && rqp->sr_serror == ERRnoaccess) 326 error = EAUTH; 327 goto bad; 328 } 329 vcp->vc_smbuid = rqp->sr_rpuid; 330 bad: 331 kfree(encpass, M_SMBTEMP); 332 kfree(pbuf, M_SMBTEMP); 333 smb_rq_done(rqp); 334 return error; 335 } 336 337 int 338 smb_smb_ssnclose(struct smb_vc *vcp, struct smb_cred *scred) 339 { 340 struct smb_rq *rqp; 341 struct mbchain *mbp; 342 int error; 343 344 if (vcp->vc_smbuid == SMB_UID_UNKNOWN) 345 return 0; 346 347 if (smb_smb_nomux(vcp, scred, __func__) != 0) 348 return EINVAL; 349 350 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_LOGOFF_ANDX, scred, &rqp); 351 if (error) 352 return error; 353 mbp = &rqp->sr_rq; 354 smb_rq_wstart(rqp); 355 mb_put_uint8(mbp, 0xff); 356 mb_put_uint8(mbp, 0); 357 mb_put_uint16le(mbp, 0); 358 smb_rq_wend(rqp); 359 smb_rq_bstart(rqp); 360 smb_rq_bend(rqp); 361 error = smb_rq_simple(rqp); 362 SMBSDEBUG("%d\n", error); 363 smb_rq_done(rqp); 364 return error; 365 } 366 367 static char smb_any_share[] = "?????"; 368 369 static char * 370 smb_share_typename(int stype) 371 { 372 char *pp; 373 374 switch (stype) { 375 case SMB_ST_DISK: 376 pp = "A:"; 377 break; 378 case SMB_ST_PRINTER: 379 pp = smb_any_share; /* can't use LPT: here... */ 380 break; 381 case SMB_ST_PIPE: 382 pp = "IPC"; 383 break; 384 case SMB_ST_COMM: 385 pp = "COMM"; 386 break; 387 case SMB_ST_ANY: 388 default: 389 pp = smb_any_share; 390 break; 391 } 392 return pp; 393 } 394 395 int 396 smb_smb_treeconnect(struct smb_share *ssp, struct smb_cred *scred) 397 { 398 struct smb_vc *vcp; 399 struct smb_rq rq, *rqp = &rq; 400 struct mbchain *mbp; 401 char *pp, *pbuf, *encpass; 402 int error, plen, caseopt; 403 404 ssp->ss_tid = SMB_TID_UNKNOWN; 405 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_TREE_CONNECT_ANDX, scred, &rqp); 406 if (error) 407 return error; 408 vcp = rqp->sr_vc; 409 caseopt = SMB_CS_NONE; 410 if (vcp->vc_sopt.sv_sm & SMB_SM_USER) { 411 plen = 1; 412 pp = ""; 413 pbuf = NULL; 414 encpass = NULL; 415 } else { 416 pbuf = kmalloc(SMB_MAXPASSWORDLEN + 1, M_SMBTEMP, M_WAITOK); 417 encpass = kmalloc(24, M_SMBTEMP, M_WAITOK); 418 iconv_convstr(vcp->vc_toupper, pbuf, smb_share_getpass(ssp)); 419 iconv_convstr(vcp->vc_toserver, pbuf, pbuf); 420 if (vcp->vc_sopt.sv_sm & SMB_SM_ENCRYPT) { 421 plen = 24; 422 smb_encrypt(pbuf, vcp->vc_ch, encpass); 423 pp = encpass; 424 } else { 425 plen = strlen(pbuf) + 1; 426 pp = pbuf; 427 } 428 } 429 mbp = &rqp->sr_rq; 430 smb_rq_wstart(rqp); 431 mb_put_uint8(mbp, 0xff); 432 mb_put_uint8(mbp, 0); 433 mb_put_uint16le(mbp, 0); 434 mb_put_uint16le(mbp, 0); /* Flags */ 435 mb_put_uint16le(mbp, plen); 436 smb_rq_wend(rqp); 437 smb_rq_bstart(rqp); 438 mb_put_mem(mbp, pp, plen, MB_MSYSTEM); 439 smb_put_dmem(mbp, vcp, "\\\\", 2, caseopt); 440 pp = vcp->vc_srvname; 441 smb_put_dmem(mbp, vcp, pp, strlen(pp), caseopt); 442 smb_put_dmem(mbp, vcp, "\\", 1, caseopt); 443 pp = ssp->ss_name; 444 smb_put_dstring(mbp, vcp, pp, caseopt); 445 pp = smb_share_typename(ssp->ss_type); 446 smb_put_dstring(mbp, vcp, pp, caseopt); 447 smb_rq_bend(rqp); 448 error = smb_rq_simple(rqp); 449 SMBSDEBUG("%d\n", error); 450 if (error) 451 goto bad; 452 ssp->ss_tid = rqp->sr_rptid; 453 ssp->ss_vcgenid = vcp->vc_genid; 454 ssp->ss_flags |= SMBS_CONNECTED; 455 bad: 456 if (encpass) 457 kfree(encpass, M_SMBTEMP); 458 if (pbuf) 459 kfree(pbuf, M_SMBTEMP); 460 smb_rq_done(rqp); 461 return error; 462 } 463 464 int 465 smb_smb_treedisconnect(struct smb_share *ssp, struct smb_cred *scred) 466 { 467 struct smb_rq *rqp; 468 int error; 469 470 if (ssp->ss_tid == SMB_TID_UNKNOWN) 471 return 0; 472 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_TREE_DISCONNECT, scred, &rqp); 473 if (error) 474 return error; 475 smb_rq_wstart(rqp); 476 smb_rq_wend(rqp); 477 smb_rq_bstart(rqp); 478 smb_rq_bend(rqp); 479 error = smb_rq_simple(rqp); 480 SMBSDEBUG("%d\n", error); 481 smb_rq_done(rqp); 482 ssp->ss_tid = SMB_TID_UNKNOWN; 483 return error; 484 } 485 486 static __inline int 487 smb_smb_read(struct smb_share *ssp, u_int16_t fid, 488 int *len, int *rresid, struct uio *uio, struct smb_cred *scred) 489 { 490 struct smb_rq *rqp; 491 struct mbchain *mbp; 492 struct mdchain *mdp; 493 u_int16_t resid, bc; 494 u_int8_t wc; 495 int error, rlen, blksz; 496 497 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_READ, scred, &rqp); 498 if (error) 499 return error; 500 501 blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16; 502 rlen = *len = min(blksz, *len); 503 504 smb_rq_getrequest(rqp, &mbp); 505 smb_rq_wstart(rqp); 506 mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM); 507 mb_put_uint16le(mbp, rlen); 508 mb_put_uint32le(mbp, uio->uio_offset); 509 mb_put_uint16le(mbp, (unsigned short)szmin(uio->uio_resid, 0xffff)); 510 smb_rq_wend(rqp); 511 smb_rq_bstart(rqp); 512 smb_rq_bend(rqp); 513 do { 514 error = smb_rq_simple(rqp); 515 if (error) 516 break; 517 smb_rq_getreply(rqp, &mdp); 518 md_get_uint8(mdp, &wc); 519 if (wc != 5) { 520 error = EBADRPC; 521 break; 522 } 523 md_get_uint16le(mdp, &resid); 524 md_get_mem(mdp, NULL, 4 * 2, MB_MSYSTEM); 525 md_get_uint16le(mdp, &bc); 526 md_get_uint8(mdp, NULL); /* ignore buffer type */ 527 md_get_uint16le(mdp, &resid); 528 if (resid == 0) { 529 *rresid = resid; 530 break; 531 } 532 error = md_get_uio(mdp, uio, resid); 533 if (error) 534 break; 535 *rresid = resid; 536 } while(0); 537 smb_rq_done(rqp); 538 return error; 539 } 540 541 int 542 smb_read(struct smb_share *ssp, u_int16_t fid, struct uio *uio, 543 struct smb_cred *scred) 544 { 545 int len, resid; 546 int error = 0; 547 548 while (uio->uio_resid > 0) { 549 if (uio->uio_resid > INT_MAX) 550 len = INT_MAX; 551 else 552 len = (int)uio->uio_resid; 553 error = smb_smb_read(ssp, fid, &len, &resid, uio, scred); 554 if (error) 555 break; 556 if (resid < len) 557 break; 558 } 559 return error; 560 } 561 562 static __inline int 563 smb_smb_write(struct smb_share *ssp, u_int16_t fid, int *len, int *rresid, 564 struct uio *uio, struct smb_cred *scred) 565 { 566 struct smb_rq *rqp; 567 struct mbchain *mbp; 568 struct mdchain *mdp; 569 u_int16_t resid; 570 u_int8_t wc; 571 int error, blksz; 572 573 /* write data must be real */ 574 KKASSERT(uio->uio_segflg != UIO_NOCOPY); 575 576 blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16; 577 if (blksz > 0xffff) 578 blksz = 0xffff; 579 580 resid = *len = min(blksz, *len); 581 582 error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp); 583 if (error) 584 return error; 585 smb_rq_getrequest(rqp, &mbp); 586 smb_rq_wstart(rqp); 587 mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM); 588 mb_put_uint16le(mbp, resid); 589 mb_put_uint32le(mbp, uio->uio_offset); 590 mb_put_uint16le(mbp, (unsigned short)szmin(uio->uio_resid, 0xffff)); 591 smb_rq_wend(rqp); 592 smb_rq_bstart(rqp); 593 mb_put_uint8(mbp, SMB_DT_DATA); 594 mb_put_uint16le(mbp, resid); 595 do { 596 error = mb_put_uio(mbp, uio, resid); 597 if (error) 598 break; 599 smb_rq_bend(rqp); 600 error = smb_rq_simple(rqp); 601 if (error) 602 break; 603 smb_rq_getreply(rqp, &mdp); 604 md_get_uint8(mdp, &wc); 605 if (wc != 1) { 606 error = EBADRPC; 607 break; 608 } 609 md_get_uint16le(mdp, &resid); 610 *rresid = resid; 611 } while(0); 612 smb_rq_done(rqp); 613 return error; 614 } 615 616 int 617 smb_write(struct smb_share *ssp, u_int16_t fid, struct uio *uio, 618 struct smb_cred *scred) 619 { 620 int error = 0, len, resid; 621 struct uio olduio; 622 623 olduio = *uio; 624 while (uio->uio_resid > 0) { 625 if (uio->uio_resid > INT_MAX) 626 len = INT_MAX; 627 else 628 len = (int)uio->uio_resid; 629 error = smb_smb_write(ssp, fid, &len, &resid, uio, scred); 630 if (error) 631 break; 632 if (resid < len) { 633 error = EIO; 634 break; 635 } 636 } 637 if (error) { 638 /* 639 * Errors can happen on the copyin, the rpc, etc. So they 640 * imply resid is unreliable. The only safe thing is 641 * to pretend zero bytes made it. We needn't restore the 642 * iovs because callers don't depend on them in error 643 * paths - uio_resid and uio_offset are what matter. 644 */ 645 *uio = olduio; 646 } 647 return error; 648 } 649 650 int 651 smb_smb_echo(struct smb_vc *vcp, struct smb_cred *scred) 652 { 653 struct smb_rq *rqp; 654 struct mbchain *mbp; 655 int error; 656 657 error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_ECHO, scred, &rqp); 658 if (error) 659 return error; 660 mbp = &rqp->sr_rq; 661 smb_rq_wstart(rqp); 662 mb_put_uint16le(mbp, 1); 663 smb_rq_wend(rqp); 664 smb_rq_bstart(rqp); 665 mb_put_uint32le(mbp, 0); 666 smb_rq_bend(rqp); 667 error = smb_rq_simple(rqp); 668 SMBSDEBUG("%d\n", error); 669 smb_rq_done(rqp); 670 return error; 671 } 672