The Design and Implementation of the FreeBSD Operating System, Second Edition
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-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

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

Cache object: 0e56f6c4ba6e2862d9cb930612ef2cba


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.