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/fs/smbfs/smbfs_smb.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 

    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$
   33  */
   34 #include <sys/param.h>
   35 #include <sys/systm.h>
   36 #include <sys/kernel.h>
   37 #include <sys/malloc.h>
   38 #include <sys/proc.h>
   39 #include <sys/lock.h>
   40 #include <sys/vnode.h>
   41 #include <sys/mbuf.h>
   42 #include <sys/mount.h>
   43 
   44 #ifdef USE_MD5_HASH
   45 #include <sys/md5.h>
   46 #endif
   47 
   48 #include <netsmb/smb.h>
   49 #include <netsmb/smb_subr.h>
   50 #include <netsmb/smb_rq.h>
   51 #include <netsmb/smb_conn.h>
   52 
   53 #include <fs/smbfs/smbfs.h>
   54 #include <fs/smbfs/smbfs_node.h>
   55 #include <fs/smbfs/smbfs_subr.h>
   56 
   57 /*
   58  * Lack of inode numbers leads us to the problem of generating them.
   59  * Partially this problem can be solved by having a dir/file cache
   60  * with inode numbers generated from the incremented by one counter.
   61  * However this way will require too much kernel memory, gives all
   62  * sorts of locking and consistency problems, not to mentinon counter overflows.
   63  * So, I'm decided to use a hash function to generate pseudo random (and unique)
   64  * inode numbers.
   65  */
   66 static long
   67 smbfs_getino(struct smbnode *dnp, const char *name, int nmlen)
   68 {
   69 #ifdef USE_MD5_HASH
   70         MD5_CTX md5;
   71         u_int32_t state[4];
   72         long ino;
   73         int i;
   74 
   75         MD5Init(&md5);
   76         MD5Update(&md5, name, nmlen);
   77         MD5Final((u_char *)state, &md5);
   78         for (i = 0, ino = 0; i < 4; i++)
   79                 ino += state[i];
   80         return dnp->n_ino + ino;
   81 #endif
   82         u_int32_t ino;
   83 
   84         ino = dnp->n_ino + smbfs_hash(name, nmlen);
   85         if (ino <= 2)
   86                 ino += 3;
   87         return ino;
   88 }
   89 
   90 static int
   91 smbfs_smb_lockandx(struct smbnode *np, int op, u_int32_t pid, off_t start, off_t end,
   92         struct smb_cred *scred)
   93 {
   94         struct smb_share *ssp = np->n_mount->sm_share;
   95         struct smb_rq rq, *rqp = &rq;
   96         struct mbchain *mbp;
   97         u_char ltype = 0;
   98         int error;
   99 
  100         if (op == SMB_LOCK_SHARED)
  101                 ltype |= SMB_LOCKING_ANDX_SHARED_LOCK;
  102         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_LOCKING_ANDX, scred);
  103         if (error)
  104                 return error;
  105         smb_rq_getrequest(rqp, &mbp);
  106         smb_rq_wstart(rqp);
  107         mb_put_uint8(mbp, 0xff);        /* secondary command */
  108         mb_put_uint8(mbp, 0);           /* MBZ */
  109         mb_put_uint16le(mbp, 0);
  110         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
  111         mb_put_uint8(mbp, ltype);       /* locktype */
  112         mb_put_uint8(mbp, 0);           /* oplocklevel - 0 seems is NO_OPLOCK */
  113         mb_put_uint32le(mbp, 0);        /* timeout - break immediately */
  114         mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 1 : 0);
  115         mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 0 : 1);
  116         smb_rq_wend(rqp);
  117         smb_rq_bstart(rqp);
  118         mb_put_uint16le(mbp, pid);
  119         mb_put_uint32le(mbp, start);
  120         mb_put_uint32le(mbp, end - start);
  121         smb_rq_bend(rqp);
  122         error = smb_rq_simple(rqp);
  123         smb_rq_done(rqp);
  124         return error;
  125 }
  126 
  127 int
  128 smbfs_smb_lock(struct smbnode *np, int op, caddr_t id,
  129         off_t start, off_t end, struct smb_cred *scred)
  130 {
  131         struct smb_share *ssp = np->n_mount->sm_share;
  132 
  133         if (SMB_DIALECT(SSTOVC(ssp)) < SMB_DIALECT_LANMAN1_0)
  134                 /*
  135                  * TODO: use LOCK_BYTE_RANGE here.
  136                  */
  137                 return EINVAL;
  138         else
  139                 return smbfs_smb_lockandx(np, op, (uintptr_t)id, start, end, scred);
  140 }
  141 
  142 static int
  143 smbfs_smb_qpathinfo(struct smbnode *np, struct smbfattr *fap,
  144                     struct smb_cred *scred, short infolevel)
  145 {
  146         struct smb_share *ssp = np->n_mount->sm_share;
  147         struct smb_vc *vcp = SSTOVC(ssp);
  148         struct smb_t2rq *t2p;
  149         int error, svtz, timesok = 1;
  150         struct mbchain *mbp;
  151         struct mdchain *mdp;
  152         u_int16_t date, time, wattr;
  153         int64_t lint;
  154         u_int32_t size, dattr;
  155 
  156         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_PATH_INFORMATION,
  157                              scred, &t2p);
  158         if (error)
  159                 return error;
  160         mbp = &t2p->t2_tparam;
  161         mb_init(mbp);
  162         if (!infolevel) {
  163                 if (SMB_DIALECT(vcp) < SMB_DIALECT_NTLM0_12)
  164                         infolevel = SMB_QUERY_FILE_STANDARD;
  165                 else
  166                         infolevel = SMB_QUERY_FILE_BASIC_INFO;
  167         }
  168         mb_put_uint16le(mbp, infolevel);
  169         mb_put_uint32le(mbp, 0);
  170         /* mb_put_uint8(mbp, SMB_DT_ASCII); specs are wrong */
  171         error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
  172         if (error) {
  173                 smb_t2_done(t2p);
  174                 return error;
  175         }
  176         t2p->t2_maxpcount = 2;
  177         t2p->t2_maxdcount = vcp->vc_txmax;
  178         error = smb_t2_request(t2p);
  179         if (error) {
  180                 smb_t2_done(t2p);
  181                 if (infolevel == SMB_QUERY_FILE_STANDARD || error != EINVAL)
  182                         return error;
  183                 return smbfs_smb_qpathinfo(np, fap, scred,
  184                                            SMB_QUERY_FILE_STANDARD);
  185         }
  186         mdp = &t2p->t2_rdata;
  187         svtz = vcp->vc_sopt.sv_tz;
  188         switch (infolevel) {
  189             case SMB_QUERY_FILE_STANDARD:
  190                 timesok = 0;
  191                 md_get_uint16le(mdp, NULL);
  192                 md_get_uint16le(mdp, NULL);     /* creation time */
  193                 md_get_uint16le(mdp, &date);
  194                 md_get_uint16le(mdp, &time);    /* access time */
  195                 if (date || time) {
  196                         timesok++;
  197                         smb_dos2unixtime(date, time, 0, svtz, &fap->fa_atime);
  198                 }
  199                 md_get_uint16le(mdp, &date);
  200                 md_get_uint16le(mdp, &time);    /* modify time */
  201                 if (date || time) {
  202                         timesok++;
  203                         smb_dos2unixtime(date, time, 0, svtz, &fap->fa_mtime);
  204                 }
  205                 md_get_uint32le(mdp, &size);
  206                 fap->fa_size = size;
  207                 md_get_uint32(mdp, NULL);       /* allocation size */
  208                 md_get_uint16le(mdp, &wattr);
  209                 fap->fa_attr = wattr;
  210                 break;
  211             case SMB_QUERY_FILE_BASIC_INFO:
  212                 timesok = 0;
  213                 md_get_int64(mdp, NULL);        /* creation time */
  214                 md_get_int64le(mdp, &lint);
  215                 if (lint) {
  216                         timesok++;
  217                         smb_time_NT2local(lint, svtz, &fap->fa_atime);
  218                 }
  219                 md_get_int64le(mdp, &lint);
  220                 if (lint) {
  221                         timesok++;
  222                         smb_time_NT2local(lint, svtz, &fap->fa_mtime);
  223                 }
  224                 md_get_int64le(mdp, &lint);
  225                 if (lint) {
  226                         timesok++;
  227                         smb_time_NT2local(lint, svtz, &fap->fa_ctime);
  228                 }
  229                 md_get_uint32le(mdp, &dattr);
  230                 fap->fa_attr = dattr;
  231                 md_get_uint32(mdp, NULL);
  232                 /* XXX could use ALL_INFO to get size */
  233                 break;
  234             default:
  235                 SMBERROR("unexpected info level %d\n", infolevel);
  236                 error = EINVAL;
  237         }
  238         smb_t2_done(t2p);
  239         /*
  240          * if all times are zero (observed with FAT on NT4SP6)
  241          * then fall back to older info level
  242          */
  243         if (!timesok) {
  244                 if (infolevel != SMB_QUERY_FILE_STANDARD)
  245                         return smbfs_smb_qpathinfo(np, fap, scred,
  246                                                    SMB_QUERY_FILE_STANDARD);
  247                 error = EINVAL;
  248         }
  249         return error;
  250 }
  251 
  252 int
  253 smbfs_smb_statfs2(struct smb_share *ssp, struct statfs *sbp,
  254         struct smb_cred *scred)
  255 {
  256         struct smb_t2rq *t2p;
  257         struct mbchain *mbp;
  258         struct mdchain *mdp;
  259         u_int16_t bsize;
  260         u_int32_t units, bpu, funits;
  261         int error;
  262 
  263         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_FS_INFORMATION,
  264             scred, &t2p);
  265         if (error)
  266                 return error;
  267         mbp = &t2p->t2_tparam;
  268         mb_init(mbp);
  269         mb_put_uint16le(mbp, SMB_INFO_ALLOCATION);
  270         t2p->t2_maxpcount = 4;
  271         t2p->t2_maxdcount = 4 * 4 + 2;
  272         error = smb_t2_request(t2p);
  273         if (error) {
  274                 smb_t2_done(t2p);
  275                 return error;
  276         }
  277         mdp = &t2p->t2_rdata;
  278         md_get_uint32(mdp, NULL);       /* fs id */
  279         md_get_uint32le(mdp, &bpu);
  280         md_get_uint32le(mdp, &units);
  281         md_get_uint32le(mdp, &funits);
  282         md_get_uint16le(mdp, &bsize);
  283         sbp->f_bsize = bpu * bsize;     /* fundamental filesystem block size */
  284         sbp->f_blocks= units;           /* total data blocks in filesystem */
  285         sbp->f_bfree = funits;          /* free blocks in fs */
  286         sbp->f_bavail= funits;          /* free blocks avail to non-superuser */
  287         sbp->f_files = 0xffff;          /* total file nodes in filesystem */
  288         sbp->f_ffree = 0xffff;          /* free file nodes in fs */
  289         smb_t2_done(t2p);
  290         return 0;
  291 }
  292 
  293 int
  294 smbfs_smb_statfs(struct smb_share *ssp, struct statfs *sbp,
  295         struct smb_cred *scred)
  296 {
  297         struct smb_rq rq, *rqp = &rq;
  298         struct mdchain *mdp;
  299         u_int16_t units, bpu, bsize, funits;
  300         int error;
  301 
  302         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_QUERY_INFORMATION_DISK, scred);
  303         if (error)
  304                 return error;
  305         smb_rq_wstart(rqp);
  306         smb_rq_wend(rqp);
  307         smb_rq_bstart(rqp);
  308         smb_rq_bend(rqp);
  309         error = smb_rq_simple(rqp);
  310         if (error) {
  311                 smb_rq_done(rqp);
  312                 return error;
  313         }
  314         smb_rq_getreply(rqp, &mdp);
  315         md_get_uint16le(mdp, &units);
  316         md_get_uint16le(mdp, &bpu);
  317         md_get_uint16le(mdp, &bsize);
  318         md_get_uint16le(mdp, &funits);
  319         sbp->f_bsize = bpu * bsize;     /* fundamental filesystem block size */
  320         sbp->f_blocks= units;           /* total data blocks in filesystem */
  321         sbp->f_bfree = funits;          /* free blocks in fs */
  322         sbp->f_bavail= funits;          /* free blocks avail to non-superuser */
  323         sbp->f_files = 0xffff;          /* total file nodes in filesystem */
  324         sbp->f_ffree = 0xffff;          /* free file nodes in fs */
  325         smb_rq_done(rqp);
  326         return 0;
  327 }
  328 
  329 static int
  330 smbfs_smb_seteof(struct smbnode *np, int64_t newsize, struct smb_cred *scred)
  331 {
  332         struct smb_t2rq *t2p;
  333         struct smb_share *ssp = np->n_mount->sm_share;
  334         struct mbchain *mbp;
  335         int error;
  336 
  337         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
  338             scred, &t2p);
  339         if (error)
  340                 return error;
  341         mbp = &t2p->t2_tparam;
  342         mb_init(mbp);
  343         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
  344         mb_put_uint16le(mbp, SMB_SET_FILE_END_OF_FILE_INFO);
  345         mb_put_uint32le(mbp, 0);
  346         mbp = &t2p->t2_tdata;
  347         mb_init(mbp);
  348         mb_put_int64le(mbp, newsize);
  349         mb_put_uint32le(mbp, 0);                        /* padding */
  350         mb_put_uint16le(mbp, 0);
  351         t2p->t2_maxpcount = 2;
  352         t2p->t2_maxdcount = 0;
  353         error = smb_t2_request(t2p);
  354         smb_t2_done(t2p);
  355         return error;
  356 }
  357 
  358 static int
  359 smb_smb_flush(struct smbnode *np, struct smb_cred *scred)
  360 {
  361         struct smb_share *ssp = np->n_mount->sm_share;
  362         struct smb_rq rq, *rqp = &rq;
  363         struct mbchain *mbp;
  364         int error;
  365 
  366         if ((np->n_flag & NOPEN) == 0 || !SMBTOV(np) ||
  367             SMBTOV(np)->v_type != VREG)
  368                 return 0; /* not a regular open file */
  369         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_FLUSH, scred);
  370         if (error)
  371                 return (error);
  372         smb_rq_getrequest(rqp, &mbp);
  373         smb_rq_wstart(rqp);
  374         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
  375         smb_rq_wend(rqp);
  376         smb_rq_bstart(rqp);
  377         smb_rq_bend(rqp);
  378         error = smb_rq_simple(rqp);
  379         smb_rq_done(rqp);
  380         if (!error)
  381                 np->n_flag &= ~NFLUSHWIRE;
  382         return (error);
  383 }
  384 
  385 int
  386 smbfs_smb_flush(struct smbnode *np, struct smb_cred *scred)
  387 {
  388         if (np->n_flag & NFLUSHWIRE)
  389                 return (smb_smb_flush(np, scred));
  390         return (0);
  391 }
  392 
  393 int
  394 smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred)
  395 {
  396         struct smb_share *ssp = np->n_mount->sm_share;
  397         struct smb_rq rq, *rqp = &rq;
  398         struct mbchain *mbp;
  399         int error;
  400 
  401         if (!smbfs_smb_seteof(np, (int64_t) newsize, scred)) {
  402                 np->n_flag |= NFLUSHWIRE;
  403                 return (0);
  404         }
  405 
  406         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_WRITE, scred);
  407         if (error)
  408                 return error;
  409         smb_rq_getrequest(rqp, &mbp);
  410         smb_rq_wstart(rqp);
  411         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
  412         mb_put_uint16le(mbp, 0);
  413         mb_put_uint32le(mbp, newsize);
  414         mb_put_uint16le(mbp, 0);
  415         smb_rq_wend(rqp);
  416         smb_rq_bstart(rqp);
  417         mb_put_uint8(mbp, SMB_DT_DATA);
  418         mb_put_uint16le(mbp, 0);
  419         smb_rq_bend(rqp);
  420         error = smb_rq_simple(rqp);
  421         smb_rq_done(rqp);
  422         return error;
  423 }
  424 
  425 int
  426 smbfs_smb_query_info(struct smbnode *np, const char *name, int len,
  427                      struct smbfattr *fap, struct smb_cred *scred)
  428 {
  429         struct smb_rq rq, *rqp = &rq;
  430         struct smb_share *ssp = np->n_mount->sm_share;
  431         struct mbchain *mbp;
  432         struct mdchain *mdp;
  433         u_int8_t wc;
  434         int error;
  435         u_int16_t wattr;
  436         u_int32_t lint;
  437 
  438         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_QUERY_INFORMATION, scred);
  439         if (error)
  440                 return error;
  441         smb_rq_getrequest(rqp, &mbp);
  442         smb_rq_wstart(rqp);
  443         smb_rq_wend(rqp);
  444         smb_rq_bstart(rqp);
  445         mb_put_uint8(mbp, SMB_DT_ASCII);
  446         do {
  447                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, name, len);
  448                 if (error)
  449                         break;
  450                 smb_rq_bend(rqp);
  451                 error = smb_rq_simple(rqp);
  452                 if (error)
  453                         break;
  454                 smb_rq_getreply(rqp, &mdp);
  455                 if (md_get_uint8(mdp, &wc) != 0 || wc != 10) {
  456                         error = EBADRPC;
  457                         break;
  458                 }
  459                 md_get_uint16le(mdp, &wattr);
  460                 fap->fa_attr = wattr;
  461                 /*
  462                  * Be careful using the time returned here, as
  463                  * with FAT on NT4SP6, at least, the time returned is low
  464                  * 32 bits of 100s of nanoseconds (since 1601) so it rolls
  465                  * over about every seven minutes!
  466                  */
  467                 md_get_uint32le(mdp, &lint); /* specs: secs since 1970 */
  468                 if (lint)       /* avoid bogus zero returns */
  469                         smb_time_server2local(lint, SSTOVC(ssp)->vc_sopt.sv_tz,
  470                                               &fap->fa_mtime);
  471                 md_get_uint32le(mdp, &lint);
  472                 fap->fa_size = lint;
  473         } while(0);
  474         smb_rq_done(rqp);
  475         return error;
  476 }
  477 
  478 /*
  479  * Set DOS file attributes. mtime should be NULL for dialects above lm10
  480  */
  481 int
  482 smbfs_smb_setpattr(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
  483         struct smb_cred *scred)
  484 {
  485         struct smb_rq rq, *rqp = &rq;
  486         struct smb_share *ssp = np->n_mount->sm_share;
  487         struct mbchain *mbp;
  488         u_long time;
  489         int error, svtz;
  490 
  491         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION, scred);
  492         if (error)
  493                 return error;
  494         svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
  495         smb_rq_getrequest(rqp, &mbp);
  496         smb_rq_wstart(rqp);
  497         mb_put_uint16le(mbp, attr);
  498         if (mtime) {
  499                 smb_time_local2server(mtime, svtz, &time);
  500         } else
  501                 time = 0;
  502         mb_put_uint32le(mbp, time);             /* mtime */
  503         mb_put_mem(mbp, NULL, 5 * 2, MB_MZERO);
  504         smb_rq_wend(rqp);
  505         smb_rq_bstart(rqp);
  506         mb_put_uint8(mbp, SMB_DT_ASCII);
  507         do {
  508                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
  509                 if (error)
  510                         break;
  511                 mb_put_uint8(mbp, SMB_DT_ASCII);
  512                 mb_put_uint8(mbp, 0);
  513                 smb_rq_bend(rqp);
  514                 error = smb_rq_simple(rqp);
  515                 SMBERROR("%d\n", error);
  516                 if (error)
  517                         break;
  518         } while(0);
  519         smb_rq_done(rqp);
  520         return error;
  521 }
  522 
  523 /*
  524  * Note, win95 doesn't support this call.
  525  */
  526 int
  527 smbfs_smb_setptime2(struct smbnode *np, struct timespec *mtime,
  528         struct timespec *atime, int attr, struct smb_cred *scred)
  529 {
  530         struct smb_t2rq *t2p;
  531         struct smb_share *ssp = np->n_mount->sm_share;
  532         struct smb_vc *vcp = SSTOVC(ssp);
  533         struct mbchain *mbp;
  534         u_int16_t date, time;
  535         int error, tzoff;
  536 
  537         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
  538             scred, &t2p);
  539         if (error)
  540                 return error;
  541         mbp = &t2p->t2_tparam;
  542         mb_init(mbp);
  543         mb_put_uint16le(mbp, SMB_INFO_STANDARD);
  544         mb_put_uint32le(mbp, 0);                /* MBZ */
  545         /* mb_put_uint8(mbp, SMB_DT_ASCII); specs incorrect */
  546         error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
  547         if (error) {
  548                 smb_t2_done(t2p);
  549                 return error;
  550         }
  551         tzoff = vcp->vc_sopt.sv_tz;
  552         mbp = &t2p->t2_tdata;
  553         mb_init(mbp);
  554         mb_put_uint32le(mbp, 0);                /* creation time */
  555         if (atime)
  556                 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
  557         else
  558                 time = date = 0;
  559         mb_put_uint16le(mbp, date);
  560         mb_put_uint16le(mbp, time);
  561         if (mtime)
  562                 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
  563         else
  564                 time = date = 0;
  565         mb_put_uint16le(mbp, date);
  566         mb_put_uint16le(mbp, time);
  567         mb_put_uint32le(mbp, 0);                /* file size */
  568         mb_put_uint32le(mbp, 0);                /* allocation unit size */
  569         mb_put_uint16le(mbp, attr);     /* DOS attr */
  570         mb_put_uint32le(mbp, 0);                /* EA size */
  571         t2p->t2_maxpcount = 5 * 2;
  572         t2p->t2_maxdcount = vcp->vc_txmax;
  573         error = smb_t2_request(t2p);
  574         smb_t2_done(t2p);
  575         return error;
  576 }
  577 
  578 /*
  579  * NT level. Specially for win9x
  580  */
  581 int
  582 smbfs_smb_setpattrNT(struct smbnode *np, u_short attr, struct timespec *mtime,
  583         struct timespec *atime, struct smb_cred *scred)
  584 {
  585         struct smb_t2rq *t2p;
  586         struct smb_share *ssp = np->n_mount->sm_share;
  587         struct smb_vc *vcp = SSTOVC(ssp);
  588         struct mbchain *mbp;
  589         int64_t tm;
  590         int error, tzoff;
  591 
  592         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
  593             scred, &t2p);
  594         if (error)
  595                 return error;
  596         mbp = &t2p->t2_tparam;
  597         mb_init(mbp);
  598         mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
  599         mb_put_uint32le(mbp, 0);                /* MBZ */
  600         /* mb_put_uint8(mbp, SMB_DT_ASCII); specs incorrect */
  601         error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
  602         if (error) {
  603                 smb_t2_done(t2p);
  604                 return error;
  605         }
  606         tzoff = vcp->vc_sopt.sv_tz;
  607         mbp = &t2p->t2_tdata;
  608         mb_init(mbp);
  609         mb_put_int64le(mbp, 0);         /* creation time */
  610         if (atime) {
  611                 smb_time_local2NT(atime, tzoff, &tm);
  612         } else
  613                 tm = 0;
  614         mb_put_int64le(mbp, tm);
  615         if (mtime) {
  616                 smb_time_local2NT(mtime, tzoff, &tm);
  617         } else
  618                 tm = 0;
  619         mb_put_int64le(mbp, tm);
  620         mb_put_int64le(mbp, tm);                /* change time */
  621         mb_put_uint32le(mbp, attr);             /* attr */
  622         t2p->t2_maxpcount = 24;
  623         t2p->t2_maxdcount = 56;
  624         error = smb_t2_request(t2p);
  625         smb_t2_done(t2p);
  626         return error;
  627 }
  628 
  629 /*
  630  * Set file atime and mtime. Doesn't supported by core dialect.
  631  */
  632 int
  633 smbfs_smb_setftime(struct smbnode *np, struct timespec *mtime,
  634         struct timespec *atime, struct smb_cred *scred)
  635 {
  636         struct smb_rq rq, *rqp = &rq;
  637         struct smb_share *ssp = np->n_mount->sm_share;
  638         struct mbchain *mbp;
  639         u_int16_t date, time;
  640         int error, tzoff;
  641 
  642         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION2, scred);
  643         if (error)
  644                 return error;
  645         tzoff = SSTOVC(ssp)->vc_sopt.sv_tz;
  646         smb_rq_getrequest(rqp, &mbp);
  647         smb_rq_wstart(rqp);
  648         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
  649         mb_put_uint32le(mbp, 0);                /* creation time */
  650 
  651         if (atime)
  652                 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
  653         else
  654                 time = date = 0;
  655         mb_put_uint16le(mbp, date);
  656         mb_put_uint16le(mbp, time);
  657         if (mtime)
  658                 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
  659         else
  660                 time = date = 0;
  661         mb_put_uint16le(mbp, date);
  662         mb_put_uint16le(mbp, time);
  663         smb_rq_wend(rqp);
  664         smb_rq_bstart(rqp);
  665         smb_rq_bend(rqp);
  666         error = smb_rq_simple(rqp);
  667         SMBSDEBUG("%d\n", error);
  668         smb_rq_done(rqp);
  669         return error;
  670 }
  671 
  672 /*
  673  * Set DOS file attributes.
  674  * Looks like this call can be used only if CAP_NT_SMBS bit is on.
  675  */
  676 int
  677 smbfs_smb_setfattrNT(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
  678         struct timespec *atime, struct smb_cred *scred)
  679 {
  680         struct smb_t2rq *t2p;
  681         struct smb_share *ssp = np->n_mount->sm_share;
  682         struct mbchain *mbp;
  683         int64_t tm;
  684         int error, svtz;
  685 
  686         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
  687             scred, &t2p);
  688         if (error)
  689                 return error;
  690         svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
  691         mbp = &t2p->t2_tparam;
  692         mb_init(mbp);
  693         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
  694         mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
  695         mb_put_uint32le(mbp, 0);
  696         mbp = &t2p->t2_tdata;
  697         mb_init(mbp);
  698         mb_put_int64le(mbp, 0);         /* creation time */
  699         if (atime) {
  700                 smb_time_local2NT(atime, svtz, &tm);
  701         } else
  702                 tm = 0;
  703         mb_put_int64le(mbp, tm);
  704         if (mtime) {
  705                 smb_time_local2NT(mtime, svtz, &tm);
  706         } else
  707                 tm = 0;
  708         mb_put_int64le(mbp, tm);
  709         mb_put_int64le(mbp, tm);                /* change time */
  710         mb_put_uint16le(mbp, attr);
  711         mb_put_uint32le(mbp, 0);                        /* padding */
  712         mb_put_uint16le(mbp, 0);
  713         t2p->t2_maxpcount = 2;
  714         t2p->t2_maxdcount = 0;
  715         error = smb_t2_request(t2p);
  716         smb_t2_done(t2p);
  717         return error;
  718 }
  719 
  720 
  721 int
  722 smbfs_smb_open(struct smbnode *np, int accmode, struct smb_cred *scred)
  723 {
  724         struct smb_rq rq, *rqp = &rq;
  725         struct smb_share *ssp = np->n_mount->sm_share;
  726         struct mbchain *mbp;
  727         struct mdchain *mdp;
  728         u_int8_t wc;
  729         u_int16_t fid, wattr, grantedmode;
  730         int error;
  731 
  732         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_OPEN, scred);
  733         if (error)
  734                 return error;
  735         smb_rq_getrequest(rqp, &mbp);
  736         smb_rq_wstart(rqp);
  737         mb_put_uint16le(mbp, accmode);
  738         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
  739         smb_rq_wend(rqp);
  740         smb_rq_bstart(rqp);
  741         mb_put_uint8(mbp, SMB_DT_ASCII);
  742         do {
  743                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
  744                 if (error)
  745                         break;
  746                 smb_rq_bend(rqp);
  747                 error = smb_rq_simple(rqp);
  748                 if (error)
  749                         break;
  750                 smb_rq_getreply(rqp, &mdp);
  751                 if (md_get_uint8(mdp, &wc) != 0 || wc != 7) {
  752                         error = EBADRPC;
  753                         break;
  754                 }
  755                 md_get_uint16(mdp, &fid);
  756                 md_get_uint16le(mdp, &wattr);
  757                 md_get_uint32(mdp, NULL);       /* mtime */
  758                 md_get_uint32(mdp, NULL);       /* fsize */
  759                 md_get_uint16le(mdp, &grantedmode);
  760                 /*
  761                  * TODO: refresh attributes from this reply
  762                  */
  763         } while(0);
  764         smb_rq_done(rqp);
  765         if (error)
  766                 return error;
  767         np->n_fid = fid;
  768         np->n_rwstate = grantedmode;
  769         return 0;
  770 }
  771 
  772 
  773 int
  774 smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime,
  775         struct smb_cred *scred)
  776 {
  777         struct smb_rq rq, *rqp = &rq;
  778         struct mbchain *mbp;
  779         u_long time;
  780         int error;
  781 
  782         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CLOSE, scred);
  783         if (error)
  784                 return error;
  785         smb_rq_getrequest(rqp, &mbp);
  786         smb_rq_wstart(rqp);
  787         mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
  788         if (mtime) {
  789                 smb_time_local2server(mtime, SSTOVC(ssp)->vc_sopt.sv_tz, &time);
  790         } else
  791                 time = 0;
  792         mb_put_uint32le(mbp, time);
  793         smb_rq_wend(rqp);
  794         smb_rq_bstart(rqp);
  795         smb_rq_bend(rqp);
  796         error = smb_rq_simple(rqp);
  797         smb_rq_done(rqp);
  798         return error;
  799 }
  800 
  801 int
  802 smbfs_smb_create(struct smbnode *dnp, const char *name, int nmlen,
  803         struct smb_cred *scred)
  804 {
  805         struct smb_rq rq, *rqp = &rq;
  806         struct smb_share *ssp = dnp->n_mount->sm_share;
  807         struct mbchain *mbp;
  808         struct mdchain *mdp;
  809         struct timespec ctime;
  810         u_int8_t wc;
  811         u_int16_t fid;
  812         u_long tm;
  813         int error;
  814 
  815         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE, scred);
  816         if (error)
  817                 return error;
  818         smb_rq_getrequest(rqp, &mbp);
  819         smb_rq_wstart(rqp);
  820         mb_put_uint16le(mbp, SMB_FA_ARCHIVE);           /* attributes  */
  821         nanotime(&ctime);
  822         smb_time_local2server(&ctime, SSTOVC(ssp)->vc_sopt.sv_tz, &tm);
  823         mb_put_uint32le(mbp, tm);
  824         smb_rq_wend(rqp);
  825         smb_rq_bstart(rqp);
  826         mb_put_uint8(mbp, SMB_DT_ASCII);
  827         error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, nmlen);
  828         if (!error) {
  829                 smb_rq_bend(rqp);
  830                 error = smb_rq_simple(rqp);
  831                 if (!error) {
  832                         smb_rq_getreply(rqp, &mdp);
  833                         md_get_uint8(mdp, &wc);
  834                         if (wc == 1)
  835                                 md_get_uint16(mdp, &fid);
  836                         else
  837                                 error = EBADRPC;
  838                 }
  839         }
  840         smb_rq_done(rqp);
  841         if (error)
  842                 return error;
  843         smbfs_smb_close(ssp, fid, &ctime, scred);
  844         return error;
  845 }
  846 
  847 int
  848 smbfs_smb_delete(struct smbnode *np, struct smb_cred *scred)
  849 {
  850         struct smb_rq rq, *rqp = &rq;
  851         struct smb_share *ssp = np->n_mount->sm_share;
  852         struct mbchain *mbp;
  853         int error;
  854 
  855         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE, scred);
  856         if (error)
  857                 return error;
  858         smb_rq_getrequest(rqp, &mbp);
  859         smb_rq_wstart(rqp);
  860         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
  861         smb_rq_wend(rqp);
  862         smb_rq_bstart(rqp);
  863         mb_put_uint8(mbp, SMB_DT_ASCII);
  864         error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
  865         if (!error) {
  866                 smb_rq_bend(rqp);
  867                 error = smb_rq_simple(rqp);
  868         }
  869         smb_rq_done(rqp);
  870         return error;
  871 }
  872 
  873 int
  874 smbfs_smb_rename(struct smbnode *src, struct smbnode *tdnp,
  875         const char *tname, int tnmlen, struct smb_cred *scred)
  876 {
  877         struct smb_rq rq, *rqp = &rq;
  878         struct smb_share *ssp = src->n_mount->sm_share;
  879         struct mbchain *mbp;
  880         int error;
  881 
  882         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_RENAME, scred);
  883         if (error)
  884                 return error;
  885         smb_rq_getrequest(rqp, &mbp);
  886         smb_rq_wstart(rqp);
  887         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
  888         smb_rq_wend(rqp);
  889         smb_rq_bstart(rqp);
  890         mb_put_uint8(mbp, SMB_DT_ASCII);
  891         do {
  892                 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
  893                 if (error)
  894                         break;
  895                 mb_put_uint8(mbp, SMB_DT_ASCII);
  896                 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
  897                 if (error)
  898                         break;
  899                 smb_rq_bend(rqp);
  900                 error = smb_rq_simple(rqp);
  901         } while(0);
  902         smb_rq_done(rqp);
  903         return error;
  904 }
  905 
  906 int
  907 smbfs_smb_move(struct smbnode *src, struct smbnode *tdnp,
  908         const char *tname, int tnmlen, u_int16_t flags, struct smb_cred *scred)
  909 {
  910         struct smb_rq rq, *rqp = &rq;
  911         struct smb_share *ssp = src->n_mount->sm_share;
  912         struct mbchain *mbp;
  913         int error;
  914 
  915         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_MOVE, scred);
  916         if (error)
  917                 return error;
  918         smb_rq_getrequest(rqp, &mbp);
  919         smb_rq_wstart(rqp);
  920         mb_put_uint16le(mbp, SMB_TID_UNKNOWN);
  921         mb_put_uint16le(mbp, 0x20);     /* delete target file */
  922         mb_put_uint16le(mbp, flags);
  923         smb_rq_wend(rqp);
  924         smb_rq_bstart(rqp);
  925         mb_put_uint8(mbp, SMB_DT_ASCII);
  926         do {
  927                 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
  928                 if (error)
  929                         break;
  930                 mb_put_uint8(mbp, SMB_DT_ASCII);
  931                 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
  932                 if (error)
  933                         break;
  934                 smb_rq_bend(rqp);
  935                 error = smb_rq_simple(rqp);
  936         } while(0);
  937         smb_rq_done(rqp);
  938         return error;
  939 }
  940 
  941 int
  942 smbfs_smb_mkdir(struct smbnode *dnp, const char *name, int len,
  943         struct smb_cred *scred)
  944 {
  945         struct smb_rq rq, *rqp = &rq;
  946         struct smb_share *ssp = dnp->n_mount->sm_share;
  947         struct mbchain *mbp;
  948         int error;
  949 
  950         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE_DIRECTORY, scred);
  951         if (error)
  952                 return error;
  953         smb_rq_getrequest(rqp, &mbp);
  954         smb_rq_wstart(rqp);
  955         smb_rq_wend(rqp);
  956         smb_rq_bstart(rqp);
  957         mb_put_uint8(mbp, SMB_DT_ASCII);
  958         error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, len);
  959         if (!error) {
  960                 smb_rq_bend(rqp);
  961                 error = smb_rq_simple(rqp);
  962         }
  963         smb_rq_done(rqp);
  964         return error;
  965 }
  966 
  967 int
  968 smbfs_smb_rmdir(struct smbnode *np, struct smb_cred *scred)
  969 {
  970         struct smb_rq rq, *rqp = &rq;
  971         struct smb_share *ssp = np->n_mount->sm_share;
  972         struct mbchain *mbp;
  973         int error;
  974 
  975         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE_DIRECTORY, scred);
  976         if (error)
  977                 return error;
  978         smb_rq_getrequest(rqp, &mbp);
  979         smb_rq_wstart(rqp);
  980         smb_rq_wend(rqp);
  981         smb_rq_bstart(rqp);
  982         mb_put_uint8(mbp, SMB_DT_ASCII);
  983         error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
  984         if (!error) {
  985                 smb_rq_bend(rqp);
  986                 error = smb_rq_simple(rqp);
  987         }
  988         smb_rq_done(rqp);
  989         return error;
  990 }
  991 
  992 static int
  993 smbfs_smb_search(struct smbfs_fctx *ctx)
  994 {
  995         struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
  996         struct smb_rq *rqp;
  997         struct mbchain *mbp;
  998         struct mdchain *mdp;
  999         u_int8_t wc, bt;
 1000         u_int16_t ec, dlen, bc;
 1001         int maxent, error, iseof = 0;
 1002 
 1003         maxent = min(ctx->f_left, (vcp->vc_txmax - SMB_HDRLEN - 3) / SMB_DENTRYLEN);
 1004         if (ctx->f_rq) {
 1005                 smb_rq_done(ctx->f_rq);
 1006                 ctx->f_rq = NULL;
 1007         }
 1008         error = smb_rq_alloc(SSTOCP(ctx->f_ssp), SMB_COM_SEARCH, ctx->f_scred, &rqp);
 1009         if (error)
 1010                 return error;
 1011         ctx->f_rq = rqp;
 1012         smb_rq_getrequest(rqp, &mbp);
 1013         smb_rq_wstart(rqp);
 1014         mb_put_uint16le(mbp, maxent);   /* max entries to return */
 1015         mb_put_uint16le(mbp, ctx->f_attrmask);
 1016         smb_rq_wend(rqp);
 1017         smb_rq_bstart(rqp);
 1018         mb_put_uint8(mbp, SMB_DT_ASCII);        /* buffer format */
 1019         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
 1020                 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
 1021                 if (error)
 1022                         return error;
 1023                 mb_put_uint8(mbp, SMB_DT_VARIABLE);
 1024                 mb_put_uint16le(mbp, 0);        /* context length */
 1025                 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
 1026         } else {
 1027                 mb_put_uint8(mbp, 0);   /* file name length */
 1028                 mb_put_uint8(mbp, SMB_DT_VARIABLE);
 1029                 mb_put_uint16le(mbp, SMB_SKEYLEN);
 1030                 mb_put_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
 1031         }
 1032         smb_rq_bend(rqp);
 1033         error = smb_rq_simple(rqp);
 1034         if (error) {
 1035                 if (rqp->sr_errclass == ERRDOS && rqp->sr_serror == ERRnofiles) {
 1036                         error = 0;
 1037                         iseof = 1;
 1038                         ctx->f_flags |= SMBFS_RDD_EOF;
 1039                 } else
 1040                         return error;
 1041         }
 1042         smb_rq_getreply(rqp, &mdp);
 1043         md_get_uint8(mdp, &wc);
 1044         if (wc != 1) 
 1045                 return iseof ? ENOENT : EBADRPC;
 1046         md_get_uint16le(mdp, &ec);
 1047         if (ec == 0)
 1048                 return ENOENT;
 1049         ctx->f_ecnt = ec;
 1050         md_get_uint16le(mdp, &bc);
 1051         if (bc < 3)
 1052                 return EBADRPC;
 1053         bc -= 3;
 1054         md_get_uint8(mdp, &bt);
 1055         if (bt != SMB_DT_VARIABLE)
 1056                 return EBADRPC;
 1057         md_get_uint16le(mdp, &dlen);
 1058         if (dlen != bc || dlen % SMB_DENTRYLEN != 0)
 1059                 return EBADRPC;
 1060         return 0;
 1061 }
 1062 
 1063 static int
 1064 smbfs_findopenLM1(struct smbfs_fctx *ctx, struct smbnode *dnp,
 1065         const char *wildcard, int wclen, int attr, struct smb_cred *scred)
 1066 {
 1067         ctx->f_attrmask = attr;
 1068         if (wildcard) {
 1069                 if (wclen == 1 && wildcard[0] == '*') {
 1070                         ctx->f_wildcard = "*.*";
 1071                         ctx->f_wclen = 3;
 1072                 } else {
 1073                         ctx->f_wildcard = wildcard;
 1074                         ctx->f_wclen = wclen;
 1075                 }
 1076         } else {
 1077                 ctx->f_wildcard = NULL;
 1078                 ctx->f_wclen = 0;
 1079         }
 1080         ctx->f_name = ctx->f_fname;
 1081         return 0;
 1082 }
 1083 
 1084 static int
 1085 smbfs_findnextLM1(struct smbfs_fctx *ctx, int limit)
 1086 {
 1087         struct mdchain *mbp;
 1088         struct smb_rq *rqp;
 1089         char *cp;
 1090         u_int8_t battr;
 1091         u_int16_t date, time;
 1092         u_int32_t size;
 1093         int error;
 1094 
 1095         if (ctx->f_ecnt == 0) {
 1096                 if (ctx->f_flags & SMBFS_RDD_EOF)
 1097                         return ENOENT;
 1098                 ctx->f_left = ctx->f_limit = limit;
 1099                 error = smbfs_smb_search(ctx);
 1100                 if (error)
 1101                         return error;
 1102         }
 1103         rqp = ctx->f_rq;
 1104         smb_rq_getreply(rqp, &mbp);
 1105         md_get_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
 1106         md_get_uint8(mbp, &battr);
 1107         md_get_uint16le(mbp, &time);
 1108         md_get_uint16le(mbp, &date);
 1109         md_get_uint32le(mbp, &size);
 1110         cp = ctx->f_name;
 1111         md_get_mem(mbp, cp, sizeof(ctx->f_fname), MB_MSYSTEM);
 1112         cp[sizeof(ctx->f_fname) - 1] = 0;
 1113         cp += strlen(cp) - 1;
 1114         while (*cp == ' ' && cp >= ctx->f_name)
 1115                 *cp-- = 0;
 1116         ctx->f_attr.fa_attr = battr;
 1117         smb_dos2unixtime(date, time, 0, rqp->sr_vc->vc_sopt.sv_tz,
 1118             &ctx->f_attr.fa_mtime);
 1119         ctx->f_attr.fa_size = size;
 1120         ctx->f_nmlen = strlen(ctx->f_name);
 1121         ctx->f_ecnt--;
 1122         ctx->f_left--;
 1123         return 0;
 1124 }
 1125 
 1126 static int
 1127 smbfs_findcloseLM1(struct smbfs_fctx *ctx)
 1128 {
 1129         if (ctx->f_rq)
 1130                 smb_rq_done(ctx->f_rq);
 1131         return 0;
 1132 }
 1133 
 1134 /*
 1135  * TRANS2_FIND_FIRST2/NEXT2, used for NT LM12 dialect
 1136  */
 1137 static int
 1138 smbfs_smb_trans2find2(struct smbfs_fctx *ctx)
 1139 {
 1140         struct smb_t2rq *t2p;
 1141         struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
 1142         struct mbchain *mbp;
 1143         struct mdchain *mdp;
 1144         u_int16_t tw, flags;
 1145         int error;
 1146 
 1147         if (ctx->f_t2) {
 1148                 smb_t2_done(ctx->f_t2);
 1149                 ctx->f_t2 = NULL;
 1150         }
 1151         ctx->f_flags &= ~SMBFS_RDD_GOTRNAME;
 1152         flags = 8 | 2;                  /* <resume> | <close if EOS> */
 1153         if (ctx->f_flags & SMBFS_RDD_FINDSINGLE) {
 1154                 flags |= 1;             /* close search after this request */
 1155                 ctx->f_flags |= SMBFS_RDD_NOCLOSE;
 1156         }
 1157         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
 1158                 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_FIRST2,
 1159                     ctx->f_scred, &t2p);
 1160                 if (error)
 1161                         return error;
 1162                 ctx->f_t2 = t2p;
 1163                 mbp = &t2p->t2_tparam;
 1164                 mb_init(mbp);
 1165                 mb_put_uint16le(mbp, ctx->f_attrmask);
 1166                 mb_put_uint16le(mbp, ctx->f_limit);
 1167                 mb_put_uint16le(mbp, flags);
 1168                 mb_put_uint16le(mbp, ctx->f_infolevel);
 1169                 mb_put_uint32le(mbp, 0);
 1170                 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
 1171                 if (error)
 1172                         return error;
 1173         } else  {
 1174                 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_NEXT2,
 1175                     ctx->f_scred, &t2p);
 1176                 if (error)
 1177                         return error;
 1178                 ctx->f_t2 = t2p;
 1179                 mbp = &t2p->t2_tparam;
 1180                 mb_init(mbp);
 1181                 mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
 1182                 mb_put_uint16le(mbp, ctx->f_limit);
 1183                 mb_put_uint16le(mbp, ctx->f_infolevel);
 1184                 mb_put_uint32le(mbp, 0);                /* resume key */
 1185                 mb_put_uint16le(mbp, flags);
 1186                 if (ctx->f_rname)
 1187                         mb_put_mem(mbp, ctx->f_rname, strlen(ctx->f_rname) + 1, MB_MSYSTEM);
 1188                 else
 1189                         mb_put_uint8(mbp, 0);   /* resume file name */
 1190 #if 0
 1191         struct timeval tv;
 1192         tv.tv_sec = 0;
 1193         tv.tv_usec = 200 * 1000;        /* 200ms */
 1194                 if (vcp->vc_flags & SMBC_WIN95) {
 1195                         /*
 1196                          * some implementations suggests to sleep here
 1197                          * for 200ms, due to the bug in the Win95.
 1198                          * I've didn't notice any problem, but put code
 1199                          * for it.
 1200                          */
 1201                          tsleep(&flags, PVFS, "fix95", tvtohz(&tv));
 1202                 }
 1203 #endif
 1204         }
 1205         t2p->t2_maxpcount = 5 * 2;
 1206         t2p->t2_maxdcount = vcp->vc_txmax;
 1207         error = smb_t2_request(t2p);
 1208         if (error)
 1209                 return error;
 1210         mdp = &t2p->t2_rparam;
 1211         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
 1212                 if ((error = md_get_uint16(mdp, &ctx->f_Sid)) != 0)
 1213                         return error;
 1214                 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
 1215         }
 1216         if ((error = md_get_uint16le(mdp, &tw)) != 0)
 1217                 return error;
 1218         ctx->f_ecnt = tw;
 1219         if ((error = md_get_uint16le(mdp, &tw)) != 0)
 1220                 return error;
 1221         if (tw)
 1222                 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE;
 1223         if ((error = md_get_uint16le(mdp, &tw)) != 0)
 1224                 return error;
 1225         if ((error = md_get_uint16le(mdp, &tw)) != 0)
 1226                 return error;
 1227         if (ctx->f_ecnt == 0)
 1228                 return ENOENT;
 1229         ctx->f_rnameofs = tw;
 1230         mdp = &t2p->t2_rdata;
 1231         if (mdp->md_top == NULL) {
 1232                 printf("bug: ecnt = %d, but data is NULL (please report)\n", ctx->f_ecnt);
 1233                 return ENOENT;
 1234         }
 1235         if (mdp->md_top->m_len == 0) {
 1236                 printf("bug: ecnt = %d, but m_len = 0 and m_next = %p (please report)\n", ctx->f_ecnt,mbp->mb_top->m_next);
 1237                 return ENOENT;
 1238         }
 1239         ctx->f_eofs = 0;
 1240         return 0;
 1241 }
 1242 
 1243 static int
 1244 smbfs_smb_findclose2(struct smbfs_fctx *ctx)
 1245 {
 1246         struct smb_rq rq, *rqp = &rq;
 1247         struct mbchain *mbp;
 1248         int error;
 1249 
 1250         error = smb_rq_init(rqp, SSTOCP(ctx->f_ssp), SMB_COM_FIND_CLOSE2, ctx->f_scred);
 1251         if (error)
 1252                 return error;
 1253         smb_rq_getrequest(rqp, &mbp);
 1254         smb_rq_wstart(rqp);
 1255         mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
 1256         smb_rq_wend(rqp);
 1257         smb_rq_bstart(rqp);
 1258         smb_rq_bend(rqp);
 1259         error = smb_rq_simple(rqp);
 1260         smb_rq_done(rqp);
 1261         return error;
 1262 }
 1263 
 1264 static int
 1265 smbfs_findopenLM2(struct smbfs_fctx *ctx, struct smbnode *dnp,
 1266         const char *wildcard, int wclen, int attr, struct smb_cred *scred)
 1267 {
 1268         ctx->f_name = malloc(SMB_MAXFNAMELEN, M_SMBFSDATA, M_WAITOK);
 1269         if (ctx->f_name == NULL)
 1270                 return ENOMEM;
 1271         ctx->f_infolevel = SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_NTLM0_12 ?
 1272             SMB_INFO_STANDARD : SMB_FIND_FILE_DIRECTORY_INFO;
 1273         ctx->f_attrmask = attr;
 1274         ctx->f_wildcard = wildcard;
 1275         ctx->f_wclen = wclen;
 1276         return 0;
 1277 }
 1278 
 1279 static int
 1280 smbfs_findnextLM2(struct smbfs_fctx *ctx, int limit)
 1281 {
 1282         struct mdchain *mbp;
 1283         struct smb_t2rq *t2p;
 1284         char *cp;
 1285         u_int8_t tb;
 1286         u_int16_t date, time, wattr;
 1287         u_int32_t size, next, dattr;
 1288         int64_t lint;
 1289         int error, svtz, cnt, fxsz, nmlen, recsz;
 1290 
 1291         if (ctx->f_ecnt == 0) {
 1292                 if (ctx->f_flags & SMBFS_RDD_EOF)
 1293                         return ENOENT;
 1294                 ctx->f_left = ctx->f_limit = limit;
 1295                 error = smbfs_smb_trans2find2(ctx);
 1296                 if (error)
 1297                         return error;
 1298         }
 1299         t2p = ctx->f_t2;
 1300         mbp = &t2p->t2_rdata;
 1301         svtz = SSTOVC(ctx->f_ssp)->vc_sopt.sv_tz;
 1302         switch (ctx->f_infolevel) {
 1303             case SMB_INFO_STANDARD:
 1304                 next = 0;
 1305                 fxsz = 0;
 1306                 md_get_uint16le(mbp, &date);
 1307                 md_get_uint16le(mbp, &time);    /* creation time */
 1308                 md_get_uint16le(mbp, &date);
 1309                 md_get_uint16le(mbp, &time);    /* access time */
 1310                 smb_dos2unixtime(date, time, 0, svtz, &ctx->f_attr.fa_atime);
 1311                 md_get_uint16le(mbp, &date);
 1312                 md_get_uint16le(mbp, &time);    /* access time */
 1313                 smb_dos2unixtime(date, time, 0, svtz, &ctx->f_attr.fa_mtime);
 1314                 md_get_uint32le(mbp, &size);
 1315                 ctx->f_attr.fa_size = size;
 1316                 md_get_uint32(mbp, NULL);       /* allocation size */
 1317                 md_get_uint16le(mbp, &wattr);
 1318                 ctx->f_attr.fa_attr = wattr;
 1319                 md_get_uint8(mbp, &tb);
 1320                 size = nmlen = tb;
 1321                 fxsz = 23;
 1322                 recsz = next = 24 + nmlen;      /* docs misses zero byte at end */
 1323                 break;
 1324             case SMB_FIND_FILE_DIRECTORY_INFO:
 1325                 md_get_uint32le(mbp, &next);
 1326                 md_get_uint32(mbp, NULL);       /* file index */
 1327                 md_get_int64(mbp, NULL);        /* creation time */
 1328                 md_get_int64le(mbp, &lint);
 1329                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_atime);
 1330                 md_get_int64le(mbp, &lint);
 1331                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_mtime);
 1332                 md_get_int64le(mbp, &lint);
 1333                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_ctime);
 1334                 md_get_int64le(mbp, &lint);     /* file size */
 1335                 ctx->f_attr.fa_size = lint;
 1336                 md_get_int64(mbp, NULL);        /* real size (should use) */
 1337                 md_get_uint32le(mbp, &dattr);   /* EA */
 1338                 ctx->f_attr.fa_attr = dattr;
 1339                 md_get_uint32le(mbp, &size);    /* name len */
 1340                 fxsz = 64;
 1341                 recsz = next ? next : fxsz + size;
 1342                 break;
 1343             default:
 1344                 SMBERROR("unexpected info level %d\n", ctx->f_infolevel);
 1345                 return EINVAL;
 1346         }
 1347         nmlen = min(size, SMB_MAXFNAMELEN);
 1348         cp = ctx->f_name;
 1349         error = md_get_mem(mbp, cp, nmlen, MB_MSYSTEM);
 1350         if (error)
 1351                 return error;
 1352         if (next) {
 1353                 cnt = next - nmlen - fxsz;
 1354                 if (cnt > 0)
 1355                         md_get_mem(mbp, NULL, cnt, MB_MSYSTEM);
 1356                 else if (cnt < 0) {
 1357                         SMBERROR("out of sync\n");
 1358                         return EBADRPC;
 1359                 }
 1360         }
 1361         if (nmlen && cp[nmlen - 1] == 0)
 1362                 nmlen--;
 1363         if (nmlen == 0)
 1364                 return EBADRPC;
 1365 
 1366         next = ctx->f_eofs + recsz;
 1367         if (ctx->f_rnameofs && (ctx->f_flags & SMBFS_RDD_GOTRNAME) == 0 &&
 1368             (ctx->f_rnameofs >= ctx->f_eofs && ctx->f_rnameofs < next)) {
 1369                 /*
 1370                  * Server needs a resume filename.
 1371                  */
 1372                 if (ctx->f_rnamelen <= nmlen) {
 1373                         if (ctx->f_rname)
 1374                                 free(ctx->f_rname, M_SMBFSDATA);
 1375                         ctx->f_rname = malloc(nmlen + 1, M_SMBFSDATA, M_WAITOK);
 1376                         ctx->f_rnamelen = nmlen;
 1377                 }
 1378                 bcopy(ctx->f_name, ctx->f_rname, nmlen);
 1379                 ctx->f_rname[nmlen] = 0;
 1380                 ctx->f_flags |= SMBFS_RDD_GOTRNAME;
 1381         }
 1382         ctx->f_nmlen = nmlen;
 1383         ctx->f_eofs = next;
 1384         ctx->f_ecnt--;
 1385         ctx->f_left--;
 1386         return 0;
 1387 }
 1388 
 1389 static int
 1390 smbfs_findcloseLM2(struct smbfs_fctx *ctx)
 1391 {
 1392         if (ctx->f_name)
 1393                 free(ctx->f_name, M_SMBFSDATA);
 1394         if (ctx->f_t2)
 1395                 smb_t2_done(ctx->f_t2);
 1396         if ((ctx->f_flags & SMBFS_RDD_NOCLOSE) == 0)
 1397                 smbfs_smb_findclose2(ctx);
 1398         return 0;
 1399 }
 1400 
 1401 int
 1402 smbfs_findopen(struct smbnode *dnp, const char *wildcard, int wclen, int attr,
 1403         struct smb_cred *scred, struct smbfs_fctx **ctxpp)
 1404 {
 1405         struct smbfs_fctx *ctx;
 1406         int error;
 1407 
 1408         ctx = malloc(sizeof(*ctx), M_SMBFSDATA, M_WAITOK);
 1409         if (ctx == NULL)
 1410                 return ENOMEM;
 1411         bzero(ctx, sizeof(*ctx));
 1412         ctx->f_ssp = dnp->n_mount->sm_share;
 1413         ctx->f_dnp = dnp;
 1414         ctx->f_flags = SMBFS_RDD_FINDFIRST;
 1415         ctx->f_scred = scred;
 1416         if (SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_LANMAN2_0 ||
 1417             (dnp->n_mount->sm_args.flags & SMBFS_MOUNT_NO_LONG)) {
 1418                 ctx->f_flags |= SMBFS_RDD_USESEARCH;
 1419                 error = smbfs_findopenLM1(ctx, dnp, wildcard, wclen, attr, scred);
 1420         } else
 1421                 error = smbfs_findopenLM2(ctx, dnp, wildcard, wclen, attr, scred);
 1422         if (error)
 1423                 smbfs_findclose(ctx, scred);
 1424         else
 1425                 *ctxpp = ctx;
 1426         return error;
 1427 }
 1428 
 1429 int
 1430 smbfs_findnext(struct smbfs_fctx *ctx, int limit, struct smb_cred *scred)
 1431 {
 1432         int error;
 1433 
 1434         if (limit == 0)
 1435                 limit = 1000000;
 1436         else if (limit > 1)
 1437                 limit *= 4;     /* imperical */
 1438         ctx->f_scred = scred;
 1439         for (;;) {
 1440                 if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
 1441                         error = smbfs_findnextLM1(ctx, limit);
 1442                 } else
 1443                         error = smbfs_findnextLM2(ctx, limit);
 1444                 if (error)
 1445                         return error;
 1446                 if ((ctx->f_nmlen == 1 && ctx->f_name[0] == '.') ||
 1447                     (ctx->f_nmlen == 2 && ctx->f_name[0] == '.' &&
 1448                      ctx->f_name[1] == '.'))
 1449                         continue;
 1450                 break;
 1451         }
 1452         smbfs_fname_tolocal(SSTOVC(ctx->f_ssp), ctx->f_name, ctx->f_nmlen,
 1453             ctx->f_dnp->n_mount->sm_caseopt);
 1454         ctx->f_attr.fa_ino = smbfs_getino(ctx->f_dnp, ctx->f_name, ctx->f_nmlen);
 1455         return 0;
 1456 }
 1457 
 1458 int
 1459 smbfs_findclose(struct smbfs_fctx *ctx, struct smb_cred *scred)
 1460 {
 1461         ctx->f_scred = scred;
 1462         if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
 1463                 smbfs_findcloseLM1(ctx);
 1464         } else
 1465                 smbfs_findcloseLM2(ctx);
 1466         if (ctx->f_rname)
 1467                 free(ctx->f_rname, M_SMBFSDATA);
 1468         free(ctx, M_SMBFSDATA);
 1469         return 0;
 1470 }
 1471 
 1472 int
 1473 smbfs_smb_lookup(struct smbnode *dnp, const char *name, int nmlen,
 1474         struct smbfattr *fap, struct smb_cred *scred)
 1475 {
 1476         struct smbfs_fctx *ctx;
 1477         int error;
 1478 
 1479         if (dnp == NULL || (dnp->n_ino == 2 && name == NULL)) {
 1480                 bzero(fap, sizeof(*fap));
 1481                 fap->fa_attr = SMB_FA_DIR;
 1482                 fap->fa_ino = 2;
 1483                 return 0;
 1484         }
 1485         if (nmlen == 1 && name[0] == '.') {
 1486                 error = smbfs_smb_lookup(dnp, NULL, 0, fap, scred);
 1487                 return error;
 1488         } else if (nmlen == 2 && name[0] == '.' && name[1] == '.') {
 1489                 error = smbfs_smb_lookup(VTOSMB(dnp->n_parent), NULL, 0, fap,
 1490                     scred);
 1491                 printf("%s: knows NOTHING about '..'\n", __func__);
 1492                 return error;
 1493         }
 1494         error = smbfs_findopen(dnp, name, nmlen,
 1495             SMB_FA_SYSTEM | SMB_FA_HIDDEN | SMB_FA_DIR, scred, &ctx);
 1496         if (error)
 1497                 return error;
 1498         ctx->f_flags |= SMBFS_RDD_FINDSINGLE;
 1499         error = smbfs_findnext(ctx, 1, scred);
 1500         if (error == 0) {
 1501                 *fap = ctx->f_attr;
 1502                 if (name == NULL)
 1503                         fap->fa_ino = dnp->n_ino;
 1504         }
 1505         smbfs_findclose(ctx, scred);
 1506         return error;
 1507 }

Cache object: 802ffbf4e6beb50b325471967a95ec44


[ 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.