sys/netproto/smb/smb_smb.c

   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  * $DragonFly: src/sys/netproto/smb/smb_smb.c,v 1.4 2003/08/07 21:17:39 dillon Exp $
  34  */
  35 /*
  36  * various SMB requests. Most of the routines merely packs data into mbufs.
  37  */
  38 #include <sys/param.h>
  39 #include <sys/systm.h>
  40 #include <sys/kernel.h>
  41 #include <sys/malloc.h>
  42 #include <sys/proc.h>
  43 #include <sys/lock.h>
  44 #include <sys/sysctl.h>
  45 #include <sys/socket.h>
  46 #include <sys/uio.h>
  47
  48 #include <sys/iconv.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 (sizeof(smb_dialects) / sizeof(struct smb_dialect) - 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, __FUNCTION__) != 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, ulen;
 239
 240         vcp->vc_smbuid = SMB_UID_UNKNOWN;
 241
 242         if (smb_smb_nomux(vcp, scred, __FUNCTION__) != 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 = malloc(SMB_MAXPASSWORDLEN + 1, M_SMBTEMP, M_WAITOK);
 249         encpass = malloc(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 = malloc(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 = malloc(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         ulen = strlen(up) + 1;
 292         mb_put_uint8(mbp, 0xff);
 293         mb_put_uint8(mbp, 0);
 294         mb_put_uint16le(mbp, 0);
 295         mb_put_uint16le(mbp, vcp->vc_sopt.sv_maxtx);
 296         mb_put_uint16le(mbp, vcp->vc_sopt.sv_maxmux);
 297         mb_put_uint16le(mbp, vcp->vc_number);
 298         mb_put_uint32le(mbp, vcp->vc_sopt.sv_skey);
 299         mb_put_uint16le(mbp, plen);
 300         if (SMB_DIALECT(vcp) < SMB_DIALECT_NTLM0_12) {
 301                 mb_put_uint32le(mbp, 0);
 302                 smb_rq_wend(rqp);
 303                 smb_rq_bstart(rqp);
 304                 mb_put_mem(mbp, pp, plen, MB_MSYSTEM);
 305                 smb_put_dstring(mbp, vcp, up, SMB_CS_NONE);
 306         } else {
 307                 mb_put_uint16le(mbp, uniplen);
 308                 mb_put_uint32le(mbp, 0);                /* reserved */
 309                 mb_put_uint32le(mbp, vcp->obj.co_flags & SMBV_UNICODE ?
 310                                      SMB_CAP_UNICODE : 0);
 311                 smb_rq_wend(rqp);
 312                 smb_rq_bstart(rqp);
 313                 mb_put_mem(mbp, pp, plen, MB_MSYSTEM);
 314                 mb_put_mem(mbp, (caddr_t)unipp, uniplen, MB_MSYSTEM);
 315                 smb_put_dstring(mbp, vcp, up, SMB_CS_NONE);             /* AccountName */
 316                 smb_put_dstring(mbp, vcp, vcp->vc_domain, SMB_CS_NONE); /* PrimaryDomain */
 317                 smb_put_dstring(mbp, vcp, "FreeBSD", SMB_CS_NONE);      /* Client's OS */
 318                 smb_put_dstring(mbp, vcp, "NETSMB", SMB_CS_NONE);               /* Client name */
 319         }
 320         smb_rq_bend(rqp);
 321         if (ntencpass)
 322                 free(ntencpass, M_SMBTEMP);
 323         error = smb_rq_simple(rqp);
 324         SMBSDEBUG("%d\n", error);
 325         if (error) {
 326                 if (rqp->sr_errclass == ERRDOS && rqp->sr_serror == ERRnoaccess)
 327                         error = EAUTH;
 328                 goto bad;
 329         }
 330         vcp->vc_smbuid = rqp->sr_rpuid;
 331 bad:
 332         free(encpass, M_SMBTEMP);
 333         free(pbuf, M_SMBTEMP);
 334         smb_rq_done(rqp);
 335         return error;
 336 }
 337
 338 int
 339 smb_smb_ssnclose(struct smb_vc *vcp, struct smb_cred *scred)
 340 {
 341         struct smb_rq *rqp;
 342         struct mbchain *mbp;
 343         int error;
 344
 345         if (vcp->vc_smbuid == SMB_UID_UNKNOWN)
 346                 return 0;
 347
 348         if (smb_smb_nomux(vcp, scred, __FUNCTION__) != 0)
 349                 return EINVAL;
 350
 351         error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_LOGOFF_ANDX, scred, &rqp);
 352         if (error)
 353                 return error;
 354         mbp = &rqp->sr_rq;
 355         smb_rq_wstart(rqp);
 356         mb_put_uint8(mbp, 0xff);
 357         mb_put_uint8(mbp, 0);
 358         mb_put_uint16le(mbp, 0);
 359         smb_rq_wend(rqp);
 360         smb_rq_bstart(rqp);
 361         smb_rq_bend(rqp);
 362         error = smb_rq_simple(rqp);
 363         SMBSDEBUG("%d\n", error);
 364         smb_rq_done(rqp);
 365         return error;
 366 }
 367
 368 static char smb_any_share[] = "?????";
 369
 370 static char *
 371 smb_share_typename(int stype)
 372 {
 373         char *pp;
 374
 375         switch (stype) {
 376             case SMB_ST_DISK:
 377                 pp = "A:";
 378                 break;
 379             case SMB_ST_PRINTER:
 380                 pp = smb_any_share;             /* can't use LPT: here... */
 381                 break;
 382             case SMB_ST_PIPE:
 383                 pp = "IPC";
 384                 break;
 385             case SMB_ST_COMM:
 386                 pp = "COMM";
 387                 break;
 388             case SMB_ST_ANY:
 389             default:
 390                 pp = smb_any_share;
 391                 break;
 392         }
 393         return pp;
 394 }
 395
 396 int
 397 smb_smb_treeconnect(struct smb_share *ssp, struct smb_cred *scred)
 398 {
 399         struct smb_vc *vcp;
 400         struct smb_rq rq, *rqp = &rq;
 401         struct mbchain *mbp;
 402         char *pp, *pbuf, *encpass;
 403         int error, plen, caseopt;
 404
 405         ssp->ss_tid = SMB_TID_UNKNOWN;
 406         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_TREE_CONNECT_ANDX, scred, &rqp);
 407         if (error)
 408                 return error;
 409         vcp = rqp->sr_vc;
 410         caseopt = SMB_CS_NONE;
 411         if (vcp->vc_sopt.sv_sm & SMB_SM_USER) {
 412                 plen = 1;
 413                 pp = "";
 414                 pbuf = NULL;
 415                 encpass = NULL;
 416         } else {
 417                 pbuf = malloc(SMB_MAXPASSWORDLEN + 1, M_SMBTEMP, M_WAITOK);
 418                 encpass = malloc(24, M_SMBTEMP, M_WAITOK);
 419                 iconv_convstr(vcp->vc_toupper, pbuf, smb_share_getpass(ssp));
 420                 iconv_convstr(vcp->vc_toserver, pbuf, pbuf);
 421                 if (vcp->vc_sopt.sv_sm & SMB_SM_ENCRYPT) {
 422                         plen = 24;
 423                         smb_encrypt(pbuf, vcp->vc_ch, encpass);
 424                         pp = encpass;
 425                 } else {
 426                         plen = strlen(pbuf) + 1;
 427                         pp = pbuf;
 428                 }
 429         }
 430         mbp = &rqp->sr_rq;
 431         smb_rq_wstart(rqp);
 432         mb_put_uint8(mbp, 0xff);
 433         mb_put_uint8(mbp, 0);
 434         mb_put_uint16le(mbp, 0);
 435         mb_put_uint16le(mbp, 0);                /* Flags */
 436         mb_put_uint16le(mbp, plen);
 437         smb_rq_wend(rqp);
 438         smb_rq_bstart(rqp);
 439         mb_put_mem(mbp, pp, plen, MB_MSYSTEM);
 440         smb_put_dmem(mbp, vcp, "\\\\", 2, caseopt);
 441         pp = vcp->vc_srvname;
 442         smb_put_dmem(mbp, vcp, pp, strlen(pp), caseopt);
 443         smb_put_dmem(mbp, vcp, "\\", 1, caseopt);
 444         pp = ssp->ss_name;
 445         smb_put_dstring(mbp, vcp, pp, caseopt);
 446         pp = smb_share_typename(ssp->ss_type);
 447         smb_put_dstring(mbp, vcp, pp, caseopt);
 448         smb_rq_bend(rqp);
 449         error = smb_rq_simple(rqp);
 450         SMBSDEBUG("%d\n", error);
 451         if (error)
 452                 goto bad;
 453         ssp->ss_tid = rqp->sr_rptid;
 454         ssp->ss_vcgenid = vcp->vc_genid;
 455         ssp->ss_flags |= SMBS_CONNECTED;
 456 bad:
 457         if (encpass)
 458                 free(encpass, M_SMBTEMP);
 459         if (pbuf)
 460                 free(pbuf, M_SMBTEMP);
 461         smb_rq_done(rqp);
 462         return error;
 463 }
 464
 465 int
 466 smb_smb_treedisconnect(struct smb_share *ssp, struct smb_cred *scred)
 467 {
 468         struct smb_rq *rqp;
 469         struct mbchain *mbp;
 470         int error;
 471
 472         if (ssp->ss_tid == SMB_TID_UNKNOWN)
 473                 return 0;
 474         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_TREE_DISCONNECT, scred, &rqp);
 475         if (error)
 476                 return error;
 477         mbp = &rqp->sr_rq;
 478         smb_rq_wstart(rqp);
 479         smb_rq_wend(rqp);
 480         smb_rq_bstart(rqp);
 481         smb_rq_bend(rqp);
 482         error = smb_rq_simple(rqp);
 483         SMBSDEBUG("%d\n", error);
 484         smb_rq_done(rqp);
 485         ssp->ss_tid = SMB_TID_UNKNOWN;
 486         return error;
 487 }
 488
 489 static __inline int
 490 smb_smb_read(struct smb_share *ssp, u_int16_t fid,
 491         int *len, int *rresid, struct uio *uio, struct smb_cred *scred)
 492 {
 493         struct smb_rq *rqp;
 494         struct mbchain *mbp;
 495         struct mdchain *mdp;
 496         u_int16_t resid, bc;
 497         u_int8_t wc;
 498         int error, rlen, blksz;
 499
 500         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_READ, scred, &rqp);
 501         if (error)
 502                 return error;
 503
 504         blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16;
 505         rlen = *len = min(blksz, *len);
 506
 507         smb_rq_getrequest(rqp, &mbp);
 508         smb_rq_wstart(rqp);
 509         mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
 510         mb_put_uint16le(mbp, rlen);
 511         mb_put_uint32le(mbp, uio->uio_offset);
 512         mb_put_uint16le(mbp, min(uio->uio_resid, 0xffff));
 513         smb_rq_wend(rqp);
 514         smb_rq_bstart(rqp);
 515         smb_rq_bend(rqp);
 516         do {
 517                 error = smb_rq_simple(rqp);
 518                 if (error)
 519                         break;
 520                 smb_rq_getreply(rqp, &mdp);
 521                 md_get_uint8(mdp, &wc);
 522                 if (wc != 5) {
 523                         error = EBADRPC;
 524                         break;
 525                 }
 526                 md_get_uint16le(mdp, &resid);
 527                 md_get_mem(mdp, NULL, 4 * 2, MB_MSYSTEM);
 528                 md_get_uint16le(mdp, &bc);
 529                 md_get_uint8(mdp, NULL);                /* ignore buffer type */
 530                 md_get_uint16le(mdp, &resid);
 531                 if (resid == 0) {
 532                         *rresid = resid;
 533                         break;
 534                 }
 535                 error = md_get_uio(mdp, uio, resid);
 536                 if (error)
 537                         break;
 538                 *rresid = resid;
 539         } while(0);
 540         smb_rq_done(rqp);
 541         return error;
 542 }
 543
 544 int
 545 smb_read(struct smb_share *ssp, u_int16_t fid, struct uio *uio,
 546         struct smb_cred *scred)
 547 {
 548         int tsize, len, resid;
 549         int error = 0;
 550
 551         tsize = uio->uio_resid;
 552         while (tsize > 0) {
 553                 len = tsize;
 554                 error = smb_smb_read(ssp, fid, &len, &resid, uio, scred);
 555                 if (error)
 556                         break;
 557                 tsize -= resid;
 558                 if (resid < len)
 559                         break;
 560         }
 561         return error;
 562 }
 563
 564 static __inline int
 565 smb_smb_write(struct smb_share *ssp, u_int16_t fid, int *len, int *rresid,
 566         struct uio *uio, struct smb_cred *scred)
 567 {
 568         struct smb_rq *rqp;
 569         struct mbchain *mbp;
 570         struct mdchain *mdp;
 571         u_int16_t resid;
 572         u_int8_t wc;
 573         int error, blksz;
 574
 575         blksz = SSTOVC(ssp)->vc_txmax - SMB_HDRLEN - 16;
 576         if (blksz > 0xffff)
 577                 blksz = 0xffff;
 578
 579         resid = *len = min(blksz, *len);
 580
 581         error = smb_rq_alloc(SSTOCP(ssp), SMB_COM_WRITE, scred, &rqp);
 582         if (error)
 583                 return error;
 584         smb_rq_getrequest(rqp, &mbp);
 585         smb_rq_wstart(rqp);
 586         mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
 587         mb_put_uint16le(mbp, resid);
 588         mb_put_uint32le(mbp, uio->uio_offset);
 589         mb_put_uint16le(mbp, min(uio->uio_resid, 0xffff));
 590         smb_rq_wend(rqp);
 591         smb_rq_bstart(rqp);
 592         mb_put_uint8(mbp, SMB_DT_DATA);
 593         mb_put_uint16le(mbp, resid);
 594         do {
 595                 error = mb_put_uio(mbp, uio, resid);
 596                 if (error)
 597                         break;
 598                 smb_rq_bend(rqp);
 599                 error = smb_rq_simple(rqp);
 600                 if (error)
 601                         break;
 602                 smb_rq_getreply(rqp, &mdp);
 603                 md_get_uint8(mdp, &wc);
 604                 if (wc != 1) {
 605                         error = EBADRPC;
 606                         break;
 607                 }
 608                 md_get_uint16le(mdp, &resid);
 609                 *rresid = resid;
 610         } while(0);
 611         smb_rq_done(rqp);
 612         return error;
 613 }
 614
 615 int
 616 smb_write(struct smb_share *ssp, u_int16_t fid, struct uio *uio,
 617         struct smb_cred *scred)
 618 {
 619         int error = 0, len, tsize, resid;
 620         struct uio olduio;
 621
 622         tsize = uio->uio_resid;
 623         olduio = *uio;
 624         while (tsize > 0) {
 625                 len = tsize;
 626                 error = smb_smb_write(ssp, fid, &len, &resid, uio, scred);
 627                 if (error)
 628                         break;
 629                 if (resid < len) {
 630                         error = EIO;
 631                         break;
 632                 }
 633                 tsize -= resid;
 634         }
 635         if (error) {
 636                 /*
 637                  * Errors can happen on the copyin, the rpc, etc.  So they
 638                  * imply resid is unreliable.  The only safe thing is
 639                  * to pretend zero bytes made it.  We needn't restore the
 640                  * iovs because callers don't depend on them in error
 641                  * paths - uio_resid and uio_offset are what matter.
 642                  */
 643                 *uio = olduio;
 644         }
 645         return error;
 646 }
 647
 648 int
 649 smb_smb_echo(struct smb_vc *vcp, struct smb_cred *scred)
 650 {
 651         struct smb_rq *rqp;
 652         struct mbchain *mbp;
 653         int error;
 654
 655         error = smb_rq_alloc(VCTOCP(vcp), SMB_COM_ECHO, scred, &rqp);
 656         if (error)
 657                 return error;
 658         mbp = &rqp->sr_rq;
 659         smb_rq_wstart(rqp);
 660         mb_put_uint16le(mbp, 1);
 661         smb_rq_wend(rqp);
 662         smb_rq_bstart(rqp);
 663         mb_put_uint32le(mbp, 0);
 664         smb_rq_bend(rqp);
 665         error = smb_rq_simple(rqp);
 666         SMBSDEBUG("%d\n", error);
 667         smb_rq_done(rqp);
 668         return error;
 669 }