Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/netsmb/smb_rq.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 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 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include <sys/param.h> 33 #include <sys/systm.h> 34 #include <sys/endian.h> 35 #include <sys/kernel.h> 36 #include <sys/malloc.h> 37 #include <sys/module.h> 38 #include <sys/proc.h> 39 #include <sys/lock.h> 40 #include <sys/sysctl.h> 41 #include <sys/socket.h> 42 #include <sys/socketvar.h> 43 #include <sys/mbuf.h> 44 45 #include <netsmb/smb.h> 46 #include <netsmb/smb_conn.h> 47 #include <netsmb/smb_rq.h> 48 #include <netsmb/smb_subr.h> 49 #include <netsmb/smb_tran.h> 50 51 static MALLOC_DEFINE(M_SMBRQ, "SMBRQ", "SMB request"); 52 53 MODULE_DEPEND(netsmb, libmchain, 1, 1, 1); 54 55 static int smb_rq_reply(struct smb_rq *rqp); 56 static int smb_rq_enqueue(struct smb_rq *rqp); 57 static int smb_rq_getenv(struct smb_connobj *layer, 58 struct smb_vc **vcpp, struct smb_share **sspp); 59 static int smb_rq_new(struct smb_rq *rqp, u_char cmd); 60 static int smb_t2_reply(struct smb_t2rq *t2p); 61 62 int 63 smb_rq_alloc(struct smb_connobj *layer, u_char cmd, struct smb_cred *scred, 64 struct smb_rq **rqpp) 65 { 66 struct smb_rq *rqp; 67 int error; 68 69 rqp = malloc(sizeof(*rqp), M_SMBRQ, M_WAITOK); 70 if (rqp == NULL) 71 return ENOMEM; 72 error = smb_rq_init(rqp, layer, cmd, scred); 73 rqp->sr_flags |= SMBR_ALLOCED; 74 if (error) { 75 smb_rq_done(rqp); 76 return error; 77 } 78 *rqpp = rqp; 79 return 0; 80 } 81 82 static char tzero[12]; 83 84 int 85 smb_rq_init(struct smb_rq *rqp, struct smb_connobj *layer, u_char cmd, 86 struct smb_cred *scred) 87 { 88 int error; 89 90 bzero(rqp, sizeof(*rqp)); 91 smb_sl_init(&rqp->sr_slock, "srslock"); 92 error = smb_rq_getenv(layer, &rqp->sr_vc, &rqp->sr_share); 93 if (error) 94 return error; 95 error = smb_vc_access(rqp->sr_vc, scred, SMBM_EXEC); 96 if (error) 97 return error; 98 if (rqp->sr_share) { 99 error = smb_share_access(rqp->sr_share, scred, SMBM_EXEC); 100 if (error) 101 return error; 102 } 103 rqp->sr_cred = scred; 104 rqp->sr_mid = smb_vc_nextmid(rqp->sr_vc); 105 return smb_rq_new(rqp, cmd); 106 } 107 108 static int 109 smb_rq_new(struct smb_rq *rqp, u_char cmd) 110 { 111 struct smb_vc *vcp = rqp->sr_vc; 112 struct mbchain *mbp = &rqp->sr_rq; 113 int error; 114 u_int16_t flags2; 115 116 rqp->sr_sendcnt = 0; 117 mb_done(mbp); 118 md_done(&rqp->sr_rp); 119 error = mb_init(mbp); 120 if (error) 121 return error; 122 mb_put_mem(mbp, SMB_SIGNATURE, SMB_SIGLEN, MB_MSYSTEM); 123 mb_put_uint8(mbp, cmd); 124 mb_put_uint32le(mbp, 0); /* DosError */ 125 mb_put_uint8(mbp, vcp->vc_hflags); 126 flags2 = vcp->vc_hflags2; 127 if (cmd == SMB_COM_TRANSACTION || cmd == SMB_COM_TRANSACTION_SECONDARY) 128 flags2 &= ~SMB_FLAGS2_UNICODE; 129 if (cmd == SMB_COM_NEGOTIATE) 130 flags2 &= ~SMB_FLAGS2_SECURITY_SIGNATURE; 131 mb_put_uint16le(mbp, flags2); 132 if ((flags2 & SMB_FLAGS2_SECURITY_SIGNATURE) == 0) { 133 mb_put_mem(mbp, tzero, 12, MB_MSYSTEM); 134 rqp->sr_rqsig = NULL; 135 } else { 136 mb_put_uint16le(mbp, 0 /*scred->sc_p->p_pid >> 16*/); 137 rqp->sr_rqsig = (u_int8_t *)mb_reserve(mbp, 8); 138 mb_put_uint16le(mbp, 0); 139 } 140 rqp->sr_rqtid = mb_reserve(mbp, sizeof(u_int16_t)); 141 mb_put_uint16le(mbp, 1 /*scred->sc_p->p_pid & 0xffff*/); 142 rqp->sr_rquid = mb_reserve(mbp, sizeof(u_int16_t)); 143 mb_put_uint16le(mbp, rqp->sr_mid); 144 return 0; 145 } 146 147 void 148 smb_rq_done(struct smb_rq *rqp) 149 { 150 mb_done(&rqp->sr_rq); 151 md_done(&rqp->sr_rp); 152 smb_sl_destroy(&rqp->sr_slock); 153 if (rqp->sr_flags & SMBR_ALLOCED) 154 free(rqp, M_SMBRQ); 155 } 156 157 /* 158 * Simple request-reply exchange 159 */ 160 int 161 smb_rq_simple(struct smb_rq *rqp) 162 { 163 struct smb_vc *vcp = rqp->sr_vc; 164 int error = EINVAL, i; 165 166 for (i = 0; i < SMB_MAXRCN; i++) { 167 rqp->sr_flags &= ~SMBR_RESTART; 168 rqp->sr_timo = vcp->vc_timo; 169 rqp->sr_state = SMBRQ_NOTSENT; 170 error = smb_rq_enqueue(rqp); 171 if (error) 172 return error; 173 error = smb_rq_reply(rqp); 174 if (error == 0) 175 break; 176 if ((rqp->sr_flags & (SMBR_RESTART | SMBR_NORESTART)) != SMBR_RESTART) 177 break; 178 } 179 return error; 180 } 181 182 static int 183 smb_rq_enqueue(struct smb_rq *rqp) 184 { 185 struct smb_share *ssp = rqp->sr_share; 186 int error; 187 188 if (ssp == NULL || rqp->sr_cred == &rqp->sr_vc->vc_iod->iod_scred) { 189 return smb_iod_addrq(rqp); 190 } 191 for (;;) { 192 SMBS_ST_LOCK(ssp); 193 if (ssp->ss_flags & SMBS_RECONNECTING) { 194 msleep(&ssp->ss_vcgenid, SMBS_ST_LOCKPTR(ssp), 195 PWAIT | PDROP, "90trcn", hz); 196 if (smb_td_intr(rqp->sr_cred->scr_td)) 197 return EINTR; 198 continue; 199 } 200 if (smb_share_valid(ssp) || (ssp->ss_flags & SMBS_CONNECTED) == 0) { 201 SMBS_ST_UNLOCK(ssp); 202 } else { 203 SMBS_ST_UNLOCK(ssp); 204 error = smb_iod_request(rqp->sr_vc->vc_iod, 205 SMBIOD_EV_TREECONNECT | SMBIOD_EV_SYNC, ssp); 206 if (error) 207 return error; 208 } 209 error = smb_iod_addrq(rqp); 210 if (error != EXDEV) 211 break; 212 } 213 return error; 214 } 215 216 void 217 smb_rq_wstart(struct smb_rq *rqp) 218 { 219 rqp->sr_wcount = mb_reserve(&rqp->sr_rq, sizeof(u_int8_t)); 220 rqp->sr_rq.mb_count = 0; 221 } 222 223 void 224 smb_rq_wend(struct smb_rq *rqp) 225 { 226 if (rqp->sr_wcount == NULL) { 227 SMBERROR("no wcount\n"); /* actually panic */ 228 return; 229 } 230 if (rqp->sr_rq.mb_count & 1) 231 SMBERROR("odd word count\n"); 232 *rqp->sr_wcount = rqp->sr_rq.mb_count / 2; 233 } 234 235 void 236 smb_rq_bstart(struct smb_rq *rqp) 237 { 238 rqp->sr_bcount = mb_reserve(&rqp->sr_rq, sizeof(u_short)); 239 rqp->sr_rq.mb_count = 0; 240 } 241 242 void 243 smb_rq_bend(struct smb_rq *rqp) 244 { 245 int bcnt; 246 247 if (rqp->sr_bcount == NULL) { 248 SMBERROR("no bcount\n"); /* actually panic */ 249 return; 250 } 251 bcnt = rqp->sr_rq.mb_count; 252 if (bcnt > 0xffff) 253 SMBERROR("byte count too large (%d)\n", bcnt); 254 le16enc(rqp->sr_bcount, bcnt); 255 } 256 257 int 258 smb_rq_intr(struct smb_rq *rqp) 259 { 260 if (rqp->sr_flags & SMBR_INTR) 261 return EINTR; 262 return smb_td_intr(rqp->sr_cred->scr_td); 263 } 264 265 int 266 smb_rq_getrequest(struct smb_rq *rqp, struct mbchain **mbpp) 267 { 268 *mbpp = &rqp->sr_rq; 269 return 0; 270 } 271 272 int 273 smb_rq_getreply(struct smb_rq *rqp, struct mdchain **mbpp) 274 { 275 *mbpp = &rqp->sr_rp; 276 return 0; 277 } 278 279 static int 280 smb_rq_getenv(struct smb_connobj *layer, 281 struct smb_vc **vcpp, struct smb_share **sspp) 282 { 283 struct smb_vc *vcp = NULL; 284 struct smb_share *ssp = NULL; 285 struct smb_connobj *cp; 286 int error = 0; 287 288 switch (layer->co_level) { 289 case SMBL_VC: 290 vcp = CPTOVC(layer); 291 if (layer->co_parent == NULL) { 292 SMBERROR("zombie VC %s\n", vcp->vc_srvname); 293 error = EINVAL; 294 break; 295 } 296 break; 297 case SMBL_SHARE: 298 ssp = CPTOSS(layer); 299 cp = layer->co_parent; 300 if (cp == NULL) { 301 SMBERROR("zombie share %s\n", ssp->ss_name); 302 error = EINVAL; 303 break; 304 } 305 error = smb_rq_getenv(cp, &vcp, NULL); 306 if (error) 307 break; 308 break; 309 default: 310 SMBERROR("invalid layer %d passed\n", layer->co_level); 311 error = EINVAL; 312 } 313 if (vcpp) 314 *vcpp = vcp; 315 if (sspp) 316 *sspp = ssp; 317 return error; 318 } 319 320 /* 321 * Wait for reply on the request 322 */ 323 static int 324 smb_rq_reply(struct smb_rq *rqp) 325 { 326 struct mdchain *mdp = &rqp->sr_rp; 327 u_int32_t tdw; 328 u_int8_t tb; 329 int error, rperror = 0; 330 331 error = smb_iod_waitrq(rqp); 332 if (error) 333 return error; 334 error = md_get_uint32(mdp, &tdw); 335 if (error) 336 return error; 337 error = md_get_uint8(mdp, &tb); 338 if (rqp->sr_vc->vc_hflags2 & SMB_FLAGS2_ERR_STATUS) { 339 error = md_get_uint32le(mdp, &rqp->sr_error); 340 } else { 341 error = md_get_uint8(mdp, &rqp->sr_errclass); 342 error = md_get_uint8(mdp, &tb); 343 error = md_get_uint16le(mdp, &rqp->sr_serror); 344 if (!error) 345 rperror = smb_maperror(rqp->sr_errclass, rqp->sr_serror); 346 } 347 error = md_get_uint8(mdp, &rqp->sr_rpflags); 348 error = md_get_uint16le(mdp, &rqp->sr_rpflags2); 349 350 error = md_get_uint32(mdp, &tdw); 351 error = md_get_uint32(mdp, &tdw); 352 error = md_get_uint32(mdp, &tdw); 353 354 error = md_get_uint16le(mdp, &rqp->sr_rptid); 355 error = md_get_uint16le(mdp, &rqp->sr_rppid); 356 error = md_get_uint16le(mdp, &rqp->sr_rpuid); 357 error = md_get_uint16le(mdp, &rqp->sr_rpmid); 358 359 if (error == 0 && 360 (rqp->sr_vc->vc_hflags2 & SMB_FLAGS2_SECURITY_SIGNATURE)) 361 error = smb_rq_verify(rqp); 362 363 SMBSDEBUG("M:%04x, P:%04x, U:%04x, T:%04x, E: %d:%d\n", 364 rqp->sr_rpmid, rqp->sr_rppid, rqp->sr_rpuid, rqp->sr_rptid, 365 rqp->sr_errclass, rqp->sr_serror); 366 return error ? error : rperror; 367 } 368 369 370 #define ALIGN4(a) (((a) + 3) & ~3) 371 372 /* 373 * TRANS2 request implementation 374 */ 375 int 376 smb_t2_alloc(struct smb_connobj *layer, u_short setup, struct smb_cred *scred, 377 struct smb_t2rq **t2pp) 378 { 379 struct smb_t2rq *t2p; 380 int error; 381 382 t2p = malloc(sizeof(*t2p), M_SMBRQ, M_WAITOK); 383 if (t2p == NULL) 384 return ENOMEM; 385 error = smb_t2_init(t2p, layer, setup, scred); 386 t2p->t2_flags |= SMBT2_ALLOCED; 387 if (error) { 388 smb_t2_done(t2p); 389 return error; 390 } 391 *t2pp = t2p; 392 return 0; 393 } 394 395 int 396 smb_t2_init(struct smb_t2rq *t2p, struct smb_connobj *source, u_short setup, 397 struct smb_cred *scred) 398 { 399 int error; 400 401 bzero(t2p, sizeof(*t2p)); 402 t2p->t2_source = source; 403 t2p->t2_setupcount = 1; 404 t2p->t2_setupdata = t2p->t2_setup; 405 t2p->t2_setup[0] = setup; 406 t2p->t2_fid = 0xffff; 407 t2p->t2_cred = scred; 408 error = smb_rq_getenv(source, &t2p->t2_vc, NULL); 409 if (error) 410 return error; 411 return 0; 412 } 413 414 void 415 smb_t2_done(struct smb_t2rq *t2p) 416 { 417 mb_done(&t2p->t2_tparam); 418 mb_done(&t2p->t2_tdata); 419 md_done(&t2p->t2_rparam); 420 md_done(&t2p->t2_rdata); 421 if (t2p->t2_flags & SMBT2_ALLOCED) 422 free(t2p, M_SMBRQ); 423 } 424 425 static int 426 smb_t2_placedata(struct mbuf *mtop, u_int16_t offset, u_int16_t count, 427 struct mdchain *mdp) 428 { 429 struct mbuf *m, *m0; 430 int len; 431 432 m0 = m_split(mtop, offset, M_WAITOK); 433 len = m_length(m0, &m); 434 m->m_len -= len - count; 435 if (mdp->md_top == NULL) { 436 md_initm(mdp, m0); 437 } else 438 m_cat(mdp->md_top, m0); 439 return 0; 440 } 441 442 static int 443 smb_t2_reply(struct smb_t2rq *t2p) 444 { 445 struct mdchain *mdp; 446 struct smb_rq *rqp = t2p->t2_rq; 447 int error, totpgot, totdgot; 448 u_int16_t totpcount, totdcount, pcount, poff, doff, pdisp, ddisp; 449 u_int16_t tmp, bc, dcount; 450 u_int8_t wc; 451 452 error = smb_rq_reply(rqp); 453 if (error) 454 return error; 455 if ((t2p->t2_flags & SMBT2_ALLSENT) == 0) { 456 /* 457 * this is an interim response, ignore it. 458 */ 459 SMBRQ_SLOCK(rqp); 460 md_next_record(&rqp->sr_rp); 461 SMBRQ_SUNLOCK(rqp); 462 return 0; 463 } 464 /* 465 * Now we have to get all subsequent responses. The CIFS specification 466 * says that they can be disordered which is weird. 467 * TODO: timo 468 */ 469 totpgot = totdgot = 0; 470 totpcount = totdcount = 0xffff; 471 mdp = &rqp->sr_rp; 472 for (;;) { 473 m_dumpm(mdp->md_top); 474 if ((error = md_get_uint8(mdp, &wc)) != 0) 475 break; 476 if (wc < 10) { 477 error = ENOENT; 478 break; 479 } 480 if ((error = md_get_uint16le(mdp, &tmp)) != 0) 481 break; 482 if (totpcount > tmp) 483 totpcount = tmp; 484 md_get_uint16le(mdp, &tmp); 485 if (totdcount > tmp) 486 totdcount = tmp; 487 if ((error = md_get_uint16le(mdp, &tmp)) != 0 || /* reserved */ 488 (error = md_get_uint16le(mdp, &pcount)) != 0 || 489 (error = md_get_uint16le(mdp, &poff)) != 0 || 490 (error = md_get_uint16le(mdp, &pdisp)) != 0) 491 break; 492 if (pcount != 0 && pdisp != totpgot) { 493 SMBERROR("Can't handle disordered parameters %d:%d\n", 494 pdisp, totpgot); 495 error = EINVAL; 496 break; 497 } 498 if ((error = md_get_uint16le(mdp, &dcount)) != 0 || 499 (error = md_get_uint16le(mdp, &doff)) != 0 || 500 (error = md_get_uint16le(mdp, &ddisp)) != 0) 501 break; 502 if (dcount != 0 && ddisp != totdgot) { 503 SMBERROR("Can't handle disordered data\n"); 504 error = EINVAL; 505 break; 506 } 507 md_get_uint8(mdp, &wc); 508 md_get_uint8(mdp, NULL); 509 tmp = wc; 510 while (tmp--) 511 md_get_uint16(mdp, NULL); 512 if ((error = md_get_uint16le(mdp, &bc)) != 0) 513 break; 514 /* tmp = SMB_HDRLEN + 1 + 10 * 2 + 2 * wc + 2;*/ 515 if (dcount) { 516 error = smb_t2_placedata(mdp->md_top, doff, dcount, 517 &t2p->t2_rdata); 518 if (error) 519 break; 520 } 521 if (pcount) { 522 error = smb_t2_placedata(mdp->md_top, poff, pcount, 523 &t2p->t2_rparam); 524 if (error) 525 break; 526 } 527 totpgot += pcount; 528 totdgot += dcount; 529 if (totpgot >= totpcount && totdgot >= totdcount) { 530 error = 0; 531 t2p->t2_flags |= SMBT2_ALLRECV; 532 break; 533 } 534 /* 535 * We're done with this reply, look for the next one. 536 */ 537 SMBRQ_SLOCK(rqp); 538 md_next_record(&rqp->sr_rp); 539 SMBRQ_SUNLOCK(rqp); 540 error = smb_rq_reply(rqp); 541 if (error) 542 break; 543 } 544 return error; 545 } 546 547 /* 548 * Perform a full round of TRANS2 request 549 */ 550 static int 551 smb_t2_request_int(struct smb_t2rq *t2p) 552 { 553 struct smb_vc *vcp = t2p->t2_vc; 554 struct smb_cred *scred = t2p->t2_cred; 555 struct mbchain *mbp; 556 struct mdchain *mdp, mbparam, mbdata; 557 struct mbuf *m; 558 struct smb_rq *rqp; 559 int totpcount, leftpcount, totdcount, leftdcount, len, txmax, i; 560 int error, doff, poff, txdcount, txpcount, nmlen; 561 562 m = t2p->t2_tparam.mb_top; 563 if (m) { 564 md_initm(&mbparam, m); /* do not free it! */ 565 totpcount = m_fixhdr(m); 566 if (totpcount > 0xffff) /* maxvalue for u_short */ 567 return EINVAL; 568 } else 569 totpcount = 0; 570 m = t2p->t2_tdata.mb_top; 571 if (m) { 572 md_initm(&mbdata, m); /* do not free it! */ 573 totdcount = m_fixhdr(m); 574 if (totdcount > 0xffff) 575 return EINVAL; 576 } else 577 totdcount = 0; 578 leftdcount = totdcount; 579 leftpcount = totpcount; 580 txmax = vcp->vc_txmax; 581 error = smb_rq_alloc(t2p->t2_source, t2p->t_name ? 582 SMB_COM_TRANSACTION : SMB_COM_TRANSACTION2, scred, &rqp); 583 if (error) 584 return error; 585 rqp->sr_flags |= SMBR_MULTIPACKET; 586 t2p->t2_rq = rqp; 587 rqp->sr_t2 = t2p; 588 mbp = &rqp->sr_rq; 589 smb_rq_wstart(rqp); 590 mb_put_uint16le(mbp, totpcount); 591 mb_put_uint16le(mbp, totdcount); 592 mb_put_uint16le(mbp, t2p->t2_maxpcount); 593 mb_put_uint16le(mbp, t2p->t2_maxdcount); 594 mb_put_uint8(mbp, t2p->t2_maxscount); 595 mb_put_uint8(mbp, 0); /* reserved */ 596 mb_put_uint16le(mbp, 0); /* flags */ 597 mb_put_uint32le(mbp, 0); /* Timeout */ 598 mb_put_uint16le(mbp, 0); /* reserved 2 */ 599 len = mb_fixhdr(mbp); 600 /* 601 * now we have known packet size as 602 * ALIGN4(len + 5 * 2 + setupcount * 2 + 2 + strlen(name) + 1), 603 * and need to decide which parts should go into the first request 604 */ 605 nmlen = t2p->t_name ? strlen(t2p->t_name) : 0; 606 len = ALIGN4(len + 5 * 2 + t2p->t2_setupcount * 2 + 2 + nmlen + 1); 607 if (len + leftpcount > txmax) { 608 txpcount = min(leftpcount, txmax - len); 609 poff = len; 610 txdcount = 0; 611 doff = 0; 612 } else { 613 txpcount = leftpcount; 614 poff = txpcount ? len : 0; 615 len = ALIGN4(len + txpcount); 616 txdcount = min(leftdcount, txmax - len); 617 doff = txdcount ? len : 0; 618 } 619 leftpcount -= txpcount; 620 leftdcount -= txdcount; 621 mb_put_uint16le(mbp, txpcount); 622 mb_put_uint16le(mbp, poff); 623 mb_put_uint16le(mbp, txdcount); 624 mb_put_uint16le(mbp, doff); 625 mb_put_uint8(mbp, t2p->t2_setupcount); 626 mb_put_uint8(mbp, 0); 627 for (i = 0; i < t2p->t2_setupcount; i++) 628 mb_put_uint16le(mbp, t2p->t2_setupdata[i]); 629 smb_rq_wend(rqp); 630 smb_rq_bstart(rqp); 631 /* TDUNICODE */ 632 if (t2p->t_name) 633 mb_put_mem(mbp, t2p->t_name, nmlen, MB_MSYSTEM); 634 mb_put_uint8(mbp, 0); /* terminating zero */ 635 len = mb_fixhdr(mbp); 636 if (txpcount) { 637 mb_put_mem(mbp, NULL, ALIGN4(len) - len, MB_MZERO); 638 error = md_get_mbuf(&mbparam, txpcount, &m); 639 SMBSDEBUG("%d:%d:%d\n", error, txpcount, txmax); 640 if (error) 641 goto freerq; 642 mb_put_mbuf(mbp, m); 643 } 644 len = mb_fixhdr(mbp); 645 if (txdcount) { 646 mb_put_mem(mbp, NULL, ALIGN4(len) - len, MB_MZERO); 647 error = md_get_mbuf(&mbdata, txdcount, &m); 648 if (error) 649 goto freerq; 650 mb_put_mbuf(mbp, m); 651 } 652 smb_rq_bend(rqp); /* incredible, but thats it... */ 653 error = smb_rq_enqueue(rqp); 654 if (error) 655 goto freerq; 656 if (leftpcount == 0 && leftdcount == 0) 657 t2p->t2_flags |= SMBT2_ALLSENT; 658 error = smb_t2_reply(t2p); 659 if (error) 660 goto bad; 661 while (leftpcount || leftdcount) { 662 t2p->t2_flags |= SMBT2_SECONDARY; 663 error = smb_rq_new(rqp, t2p->t_name ? 664 SMB_COM_TRANSACTION_SECONDARY : SMB_COM_TRANSACTION2_SECONDARY); 665 if (error) 666 goto bad; 667 mbp = &rqp->sr_rq; 668 smb_rq_wstart(rqp); 669 mb_put_uint16le(mbp, totpcount); 670 mb_put_uint16le(mbp, totdcount); 671 len = mb_fixhdr(mbp); 672 /* 673 * now we have known packet size as 674 * ALIGN4(len + 7 * 2 + 2) for T2 request, and -2 for T one, 675 * and need to decide which parts should go into request 676 */ 677 len = ALIGN4(len + 6 * 2 + 2); 678 if (t2p->t_name == NULL) 679 len += 2; 680 if (len + leftpcount > txmax) { 681 txpcount = min(leftpcount, txmax - len); 682 poff = len; 683 txdcount = 0; 684 doff = 0; 685 } else { 686 txpcount = leftpcount; 687 poff = txpcount ? len : 0; 688 len = ALIGN4(len + txpcount); 689 txdcount = min(leftdcount, txmax - len); 690 doff = txdcount ? len : 0; 691 } 692 mb_put_uint16le(mbp, txpcount); 693 mb_put_uint16le(mbp, poff); 694 mb_put_uint16le(mbp, totpcount - leftpcount); 695 mb_put_uint16le(mbp, txdcount); 696 mb_put_uint16le(mbp, doff); 697 mb_put_uint16le(mbp, totdcount - leftdcount); 698 leftpcount -= txpcount; 699 leftdcount -= txdcount; 700 if (t2p->t_name == NULL) 701 mb_put_uint16le(mbp, t2p->t2_fid); 702 smb_rq_wend(rqp); 703 smb_rq_bstart(rqp); 704 mb_put_uint8(mbp, 0); /* name */ 705 len = mb_fixhdr(mbp); 706 if (txpcount) { 707 mb_put_mem(mbp, NULL, ALIGN4(len) - len, MB_MZERO); 708 error = md_get_mbuf(&mbparam, txpcount, &m); 709 if (error) 710 goto bad; 711 mb_put_mbuf(mbp, m); 712 } 713 len = mb_fixhdr(mbp); 714 if (txdcount) { 715 mb_put_mem(mbp, NULL, ALIGN4(len) - len, MB_MZERO); 716 error = md_get_mbuf(&mbdata, txdcount, &m); 717 if (error) 718 goto bad; 719 mb_put_mbuf(mbp, m); 720 } 721 smb_rq_bend(rqp); 722 rqp->sr_state = SMBRQ_NOTSENT; 723 error = smb_iod_request(vcp->vc_iod, SMBIOD_EV_NEWRQ, NULL); 724 if (error) 725 goto bad; 726 } /* while left params or data */ 727 t2p->t2_flags |= SMBT2_ALLSENT; 728 mdp = &t2p->t2_rdata; 729 if (mdp->md_top) { 730 m_fixhdr(mdp->md_top); 731 md_initm(mdp, mdp->md_top); 732 } 733 mdp = &t2p->t2_rparam; 734 if (mdp->md_top) { 735 m_fixhdr(mdp->md_top); 736 md_initm(mdp, mdp->md_top); 737 } 738 bad: 739 smb_iod_removerq(rqp); 740 freerq: 741 if (error) { 742 if (rqp->sr_flags & SMBR_RESTART) 743 t2p->t2_flags |= SMBT2_RESTART; 744 md_done(&t2p->t2_rparam); 745 md_done(&t2p->t2_rdata); 746 } 747 smb_rq_done(rqp); 748 return error; 749 } 750 751 int 752 smb_t2_request(struct smb_t2rq *t2p) 753 { 754 int error = EINVAL, i; 755 756 for (i = 0; i < SMB_MAXRCN; i++) { 757 t2p->t2_flags &= ~SMBR_RESTART; 758 error = smb_t2_request_int(t2p); 759 if (error == 0) 760 break; 761 if ((t2p->t2_flags & (SMBT2_RESTART | SMBT2_NORESTART)) != SMBT2_RESTART) 762 break; 763 } 764 return error; 765 }
Cache object: 1eab8256e4997c2c1b05934267a7239d
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]