cpdup(1): Move version and authors info to cpdup.h and bump version
[dragonfly.git] / sys / vfs / smbfs / smbfs_smb.c
1 /*
2  * Copyright (c) 2000-2001 Boris Popov
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *    This product includes software developed by Boris Popov.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $FreeBSD: src/sys/fs/smbfs/smbfs_smb.c,v 1.1.2.2 2003/01/17 08:20:26 tjr Exp $
33  * $DragonFly: src/sys/vfs/smbfs/smbfs_smb.c,v 1.11 2008/01/06 16:55:53 swildner Exp $
34  */
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/malloc.h>
39 #include <sys/proc.h>
40 #include <sys/lock.h>
41 #include <sys/vnode.h>
42 #include <sys/mbuf.h>
43 #include <sys/mount.h>
44
45 #ifdef USE_MD5_HASH
46 #include <sys/md5.h>
47 #endif
48
49 #include <netproto/smb/smb.h>
50 #include <netproto/smb/smb_subr.h>
51 #include <netproto/smb/smb_rq.h>
52 #include <netproto/smb/smb_conn.h>
53
54 #include "smbfs.h"
55 #include "smbfs_node.h"
56 #include "smbfs_subr.h"
57
58 /*
59  * Lack of inode numbers leads us to the problem of generating them.
60  * Partially this problem can be solved by having a dir/file cache
61  * with inode numbers generated from the incremented by one counter.
62  * However this way will require too much kernel memory, gives all
63  * sorts of locking and consistency problems, not to mentinon counter overflows.
64  * So, I'm decided to use a hash function to generate pseudo random (and unique)
65  * inode numbers.
66  */
67 static long
68 smbfs_getino(struct smbnode *dnp, const char *name, int nmlen)
69 {
70 #ifdef USE_MD5_HASH
71         MD5_CTX md5;
72         u_int32_t state[4];
73         long ino;
74         int i;
75
76         MD5Init(&md5);
77         MD5Update(&md5, name, nmlen);
78         MD5Final((u_char *)state, &md5);
79         for (i = 0, ino = 0; i < 4; i++)
80                 ino += state[i];
81         return dnp->n_ino + ino;
82 #endif
83         u_int32_t ino;
84
85         ino = dnp->n_ino + smbfs_hash(name, nmlen);
86         if (ino <= 2)
87                 ino += 3;
88         return ino;
89 }
90
91 static int
92 smbfs_smb_lockandx(struct smbnode *np, int op, u_int32_t pid, off_t start, off_t end,
93         struct smb_cred *scred)
94 {
95         struct smb_share *ssp = np->n_mount->sm_share;
96         struct smb_rq rq, *rqp = &rq;
97         struct mbchain *mbp;
98         u_char ltype = 0;
99         int error;
100
101         if (op == SMB_LOCK_SHARED)
102                 ltype |= SMB_LOCKING_ANDX_SHARED_LOCK;
103         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_LOCKING_ANDX, scred);
104         if (error)
105                 return error;
106         smb_rq_getrequest(rqp, &mbp);
107         smb_rq_wstart(rqp);
108         mb_put_uint8(mbp, 0xff);                /* secondary command */
109         mb_put_uint8(mbp, 0);           /* MBZ */
110         mb_put_uint16le(mbp, 0);
111         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
112         mb_put_uint8(mbp, ltype);       /* locktype */
113         mb_put_uint8(mbp, 0);           /* oplocklevel - 0 seems is NO_OPLOCK */
114         mb_put_uint32le(mbp, 0);                /* timeout - break immediately */
115         mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 1 : 0);
116         mb_put_uint16le(mbp, op == SMB_LOCK_RELEASE ? 0 : 1);
117         smb_rq_wend(rqp);
118         smb_rq_bstart(rqp);
119         mb_put_uint16le(mbp, pid);
120         mb_put_uint32le(mbp, start);
121         mb_put_uint32le(mbp, end - start);
122         smb_rq_bend(rqp);
123         error = smb_rq_simple(rqp);
124         smb_rq_done(rqp);
125         return error;
126 }
127
128 int
129 smbfs_smb_lock(struct smbnode *np, int op, caddr_t id,
130         off_t start, off_t end, struct smb_cred *scred)
131 {
132         struct smb_share *ssp = np->n_mount->sm_share;
133
134         if (SMB_DIALECT(SSTOVC(ssp)) < SMB_DIALECT_LANMAN1_0)
135                 /*
136                  * TODO: use LOCK_BYTE_RANGE here.
137                  */
138                 return EINVAL;
139         else
140                 return smbfs_smb_lockandx(np, op, (u_int32_t)(uintptr_t)id,
141                                           start, end, scred);
142 }
143
144 int
145 smbfs_smb_statfs2(struct smb_share *ssp, struct statfs *sbp,
146         struct smb_cred *scred)
147 {
148         struct smb_t2rq *t2p;
149         struct mbchain *mbp;
150         struct mdchain *mdp;
151         u_int16_t bsize;
152         u_int32_t units, bpu, funits;
153         int error;
154
155         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_FS_INFORMATION,
156             scred, &t2p);
157         if (error)
158                 return error;
159         mbp = &t2p->t2_tparam;
160         mb_init(mbp);
161         mb_put_uint16le(mbp, SMB_INFO_ALLOCATION);
162         t2p->t2_maxpcount = 4;
163         t2p->t2_maxdcount = 4 * 4 + 2;
164         error = smb_t2_request(t2p);
165         if (error) {
166                 smb_t2_done(t2p);
167                 return error;
168         }
169         mdp = &t2p->t2_rdata;
170         md_get_uint32(mdp, NULL);       /* fs id */
171         md_get_uint32le(mdp, &bpu);
172         md_get_uint32le(mdp, &units);
173         md_get_uint32le(mdp, &funits);
174         md_get_uint16le(mdp, &bsize);
175         sbp->f_bsize = bpu * bsize;     /* fundamental file system block size */
176         sbp->f_blocks= units;           /* total data blocks in file system */
177         sbp->f_bfree = funits;          /* free blocks in fs */
178         sbp->f_bavail= funits;          /* free blocks avail to non-superuser */
179         sbp->f_files = 0xffff;          /* total file nodes in file system */
180         sbp->f_ffree = 0xffff;          /* free file nodes in fs */
181         smb_t2_done(t2p);
182         return 0;
183 }
184
185 int
186 smbfs_smb_statfs(struct smb_share *ssp, struct statfs *sbp,
187         struct smb_cred *scred)
188 {
189         struct smb_rq rq, *rqp = &rq;
190         struct mdchain *mdp;
191         u_int16_t units, bpu, bsize, funits;
192         int error;
193
194         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_QUERY_INFORMATION_DISK, scred);
195         if (error)
196                 return error;
197         smb_rq_wstart(rqp);
198         smb_rq_wend(rqp);
199         smb_rq_bstart(rqp);
200         smb_rq_bend(rqp);
201         error = smb_rq_simple(rqp);
202         if (error) {
203                 smb_rq_done(rqp);
204                 return error;
205         }
206         smb_rq_getreply(rqp, &mdp);
207         md_get_uint16le(mdp, &units);
208         md_get_uint16le(mdp, &bpu);
209         md_get_uint16le(mdp, &bsize);
210         md_get_uint16le(mdp, &funits);
211         sbp->f_bsize = bpu * bsize;     /* fundamental file system block size */
212         sbp->f_blocks= units;           /* total data blocks in file system */
213         sbp->f_bfree = funits;          /* free blocks in fs */
214         sbp->f_bavail= funits;          /* free blocks avail to non-superuser */
215         sbp->f_files = 0xffff;          /* total file nodes in file system */
216         sbp->f_ffree = 0xffff;          /* free file nodes in fs */
217         smb_rq_done(rqp);
218         return 0;
219 }
220
221 int
222 smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred)
223 {
224         struct smb_share *ssp = np->n_mount->sm_share;
225         struct smb_rq rq, *rqp = &rq;
226         struct mbchain *mbp;
227         int error;
228
229         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_WRITE, scred);
230         if (error)
231                 return error;
232         smb_rq_getrequest(rqp, &mbp);
233         smb_rq_wstart(rqp);
234         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
235         mb_put_uint16le(mbp, 0);
236         mb_put_uint32le(mbp, newsize);
237         mb_put_uint16le(mbp, 0);
238         smb_rq_wend(rqp);
239         smb_rq_bstart(rqp);
240         mb_put_uint8(mbp, SMB_DT_DATA);
241         mb_put_uint16le(mbp, 0);
242         smb_rq_bend(rqp);
243         error = smb_rq_simple(rqp);
244         smb_rq_done(rqp);
245         return error;
246 }
247
248
249 /*
250  * Set DOS file attributes. mtime should be NULL for dialects above lm10
251  */
252 int
253 smbfs_smb_setpattr(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
254         struct smb_cred *scred)
255 {
256         struct smb_rq rq, *rqp = &rq;
257         struct smb_share *ssp = np->n_mount->sm_share;
258         struct mbchain *mbp;
259         u_long time;
260         int error, svtz;
261
262         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION, scred);
263         if (error)
264                 return error;
265         svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
266         smb_rq_getrequest(rqp, &mbp);
267         smb_rq_wstart(rqp);
268         mb_put_uint16le(mbp, attr);
269         if (mtime) {
270                 smb_time_local2server(mtime, svtz, &time);
271         } else
272                 time = 0;
273         mb_put_uint32le(mbp, time);             /* mtime */
274         mb_put_mem(mbp, NULL, 5 * 2, MB_MZERO);
275         smb_rq_wend(rqp);
276         smb_rq_bstart(rqp);
277         mb_put_uint8(mbp, SMB_DT_ASCII);
278         do {
279                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
280                 if (error)
281                         break;
282                 mb_put_uint8(mbp, SMB_DT_ASCII);
283                 mb_put_uint8(mbp, 0);
284                 smb_rq_bend(rqp);
285                 error = smb_rq_simple(rqp);
286                 SMBERROR("%d\n", error);
287                 if (error)
288                         break;
289         } while(0);
290         smb_rq_done(rqp);
291         return error;
292 }
293
294 /*
295  * Note, win95 doesn't support this call.
296  */
297 int
298 smbfs_smb_setptime2(struct smbnode *np, struct timespec *mtime,
299         struct timespec *atime, int attr, struct smb_cred *scred)
300 {
301         struct smb_t2rq *t2p;
302         struct smb_share *ssp = np->n_mount->sm_share;
303         struct smb_vc *vcp = SSTOVC(ssp);
304         struct mbchain *mbp;
305         u_int16_t date, time;
306         int error, tzoff;
307
308         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
309             scred, &t2p);
310         if (error)
311                 return error;
312         mbp = &t2p->t2_tparam;
313         mb_init(mbp);
314         mb_put_uint16le(mbp, SMB_INFO_STANDARD);
315         mb_put_uint32le(mbp, 0);                /* MBZ */
316         error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
317         if (error) {
318                 smb_t2_done(t2p);
319                 return error;
320         }
321         tzoff = vcp->vc_sopt.sv_tz;
322         mbp = &t2p->t2_tdata;
323         mb_init(mbp);
324         mb_put_uint32le(mbp, 0);                /* creation time */
325         if (atime)
326                 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
327         else
328                 time = date = 0;
329         mb_put_uint16le(mbp, date);
330         mb_put_uint16le(mbp, time);
331         if (mtime)
332                 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
333         else
334                 time = date = 0;
335         mb_put_uint16le(mbp, date);
336         mb_put_uint16le(mbp, time);
337         mb_put_uint32le(mbp, 0);                /* file size */
338         mb_put_uint32le(mbp, 0);                /* allocation unit size */
339         mb_put_uint16le(mbp, attr);     /* DOS attr */
340         mb_put_uint32le(mbp, 0);                /* EA size */
341         t2p->t2_maxpcount = 5 * 2;
342         t2p->t2_maxdcount = vcp->vc_txmax;
343         error = smb_t2_request(t2p);
344         smb_t2_done(t2p);
345         return error;
346 }
347
348 /*
349  * NT level. Specially for win9x
350  */
351 int
352 smbfs_smb_setpattrNT(struct smbnode *np, u_short attr, struct timespec *mtime,
353         struct timespec *atime, struct smb_cred *scred)
354 {
355         struct smb_t2rq *t2p;
356         struct smb_share *ssp = np->n_mount->sm_share;
357         struct smb_vc *vcp = SSTOVC(ssp);
358         struct mbchain *mbp;
359         int64_t tm;
360         int error, tzoff;
361
362         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
363             scred, &t2p);
364         if (error)
365                 return error;
366         mbp = &t2p->t2_tparam;
367         mb_init(mbp);
368         mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
369         mb_put_uint32le(mbp, 0);                /* MBZ */
370         error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
371         if (error) {
372                 smb_t2_done(t2p);
373                 return error;
374         }
375         tzoff = vcp->vc_sopt.sv_tz;
376         mbp = &t2p->t2_tdata;
377         mb_init(mbp);
378         mb_put_int64le(mbp, 0);         /* creation time */
379         if (atime) {
380                 smb_time_local2NT(atime, tzoff, &tm);
381         } else
382                 tm = 0;
383         mb_put_int64le(mbp, tm);
384         if (mtime) {
385                 smb_time_local2NT(mtime, tzoff, &tm);
386         } else
387                 tm = 0;
388         mb_put_int64le(mbp, tm);
389         mb_put_int64le(mbp, tm);                /* change time */
390         mb_put_uint32le(mbp, attr);             /* attr */
391         t2p->t2_maxpcount = 24;
392         t2p->t2_maxdcount = 56;
393         error = smb_t2_request(t2p);
394         smb_t2_done(t2p);
395         return error;
396 }
397
398 /*
399  * Set file atime and mtime. Doesn't supported by core dialect.
400  */
401 int
402 smbfs_smb_setftime(struct smbnode *np, struct timespec *mtime,
403         struct timespec *atime, struct smb_cred *scred)
404 {
405         struct smb_rq rq, *rqp = &rq;
406         struct smb_share *ssp = np->n_mount->sm_share;
407         struct mbchain *mbp;
408         u_int16_t date, time;
409         int error, tzoff;
410
411         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION2, scred);
412         if (error)
413                 return error;
414         tzoff = SSTOVC(ssp)->vc_sopt.sv_tz;
415         smb_rq_getrequest(rqp, &mbp);
416         smb_rq_wstart(rqp);
417         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
418         mb_put_uint32le(mbp, 0);                /* creation time */
419
420         if (atime)
421                 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
422         else
423                 time = date = 0;
424         mb_put_uint16le(mbp, date);
425         mb_put_uint16le(mbp, time);
426         if (mtime)
427                 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
428         else
429                 time = date = 0;
430         mb_put_uint16le(mbp, date);
431         mb_put_uint16le(mbp, time);
432         smb_rq_wend(rqp);
433         smb_rq_bstart(rqp);
434         smb_rq_bend(rqp);
435         error = smb_rq_simple(rqp);
436         SMBSDEBUG("%d\n", error);
437         smb_rq_done(rqp);
438         return error;
439 }
440
441 /*
442  * Set DOS file attributes.
443  * Looks like this call can be used only if CAP_NT_SMBS bit is on.
444  */
445 int
446 smbfs_smb_setfattrNT(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
447         struct timespec *atime, struct smb_cred *scred)
448 {
449         struct smb_t2rq *t2p;
450         struct smb_share *ssp = np->n_mount->sm_share;
451         struct mbchain *mbp;
452         int64_t tm;
453         int error, svtz;
454
455         error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
456             scred, &t2p);
457         if (error)
458                 return error;
459         svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
460         mbp = &t2p->t2_tparam;
461         mb_init(mbp);
462         mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
463         mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
464         mb_put_uint32le(mbp, 0);
465         mbp = &t2p->t2_tdata;
466         mb_init(mbp);
467         mb_put_int64le(mbp, 0);         /* creation time */
468         if (atime) {
469                 smb_time_local2NT(atime, svtz, &tm);
470         } else
471                 tm = 0;
472         mb_put_int64le(mbp, tm);
473         if (mtime) {
474                 smb_time_local2NT(mtime, svtz, &tm);
475         } else
476                 tm = 0;
477         mb_put_int64le(mbp, tm);
478         mb_put_int64le(mbp, tm);                /* change time */
479         mb_put_uint16le(mbp, attr);
480         mb_put_uint32le(mbp, 0);                        /* padding */
481         mb_put_uint16le(mbp, 0);
482         t2p->t2_maxpcount = 2;
483         t2p->t2_maxdcount = 0;
484         error = smb_t2_request(t2p);
485         smb_t2_done(t2p);
486         return error;
487 }
488
489
490 int
491 smbfs_smb_open(struct smbnode *np, int accmode, struct smb_cred *scred)
492 {
493         struct smb_rq rq, *rqp = &rq;
494         struct smb_share *ssp = np->n_mount->sm_share;
495         struct mbchain *mbp;
496         struct mdchain *mdp;
497         u_int8_t wc;
498         u_int16_t fid, wattr, grantedmode;
499         int error;
500
501         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_OPEN, scred);
502         if (error)
503                 return error;
504         smb_rq_getrequest(rqp, &mbp);
505         smb_rq_wstart(rqp);
506         mb_put_uint16le(mbp, accmode);
507         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
508         smb_rq_wend(rqp);
509         smb_rq_bstart(rqp);
510         mb_put_uint8(mbp, SMB_DT_ASCII);
511         do {
512                 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
513                 if (error)
514                         break;
515                 smb_rq_bend(rqp);
516                 error = smb_rq_simple(rqp);
517                 if (error)
518                         break;
519                 smb_rq_getreply(rqp, &mdp);
520                 if (md_get_uint8(mdp, &wc) != 0 || wc != 7) {
521                         error = EBADRPC;
522                         break;
523                 }
524                 md_get_uint16(mdp, &fid);
525                 md_get_uint16le(mdp, &wattr);
526                 md_get_uint32(mdp, NULL);       /* mtime */
527                 md_get_uint32(mdp, NULL);       /* fsize */
528                 md_get_uint16le(mdp, &grantedmode);
529                 /*
530                  * TODO: refresh attributes from this reply
531                  */
532         } while(0);
533         smb_rq_done(rqp);
534         if (error)
535                 return error;
536         np->n_fid = fid;
537         np->n_rwstate = grantedmode;
538         return 0;
539 }
540
541
542 int
543 smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime,
544         struct smb_cred *scred)
545 {
546         struct smb_rq rq, *rqp = &rq;
547         struct mbchain *mbp;
548         u_long time;
549         int error;
550
551         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CLOSE, scred);
552         if (error)
553                 return error;
554         smb_rq_getrequest(rqp, &mbp);
555         smb_rq_wstart(rqp);
556         mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
557         if (mtime) {
558                 smb_time_local2server(mtime, SSTOVC(ssp)->vc_sopt.sv_tz, &time);
559         } else
560                 time = 0;
561         mb_put_uint32le(mbp, time);
562         smb_rq_wend(rqp);
563         smb_rq_bstart(rqp);
564         smb_rq_bend(rqp);
565         error = smb_rq_simple(rqp);
566         smb_rq_done(rqp);
567         return error;
568 }
569
570 int
571 smbfs_smb_create(struct smbnode *dnp, const char *name, int nmlen,
572         struct smb_cred *scred)
573 {
574         struct smb_rq rq, *rqp = &rq;
575         struct smb_share *ssp = dnp->n_mount->sm_share;
576         struct mbchain *mbp;
577         struct mdchain *mdp;
578         struct timespec ctime;
579         u_int8_t wc;
580         u_int16_t fid;
581         u_long tm;
582         int error;
583
584         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE, scred);
585         if (error)
586                 return error;
587         smb_rq_getrequest(rqp, &mbp);
588         smb_rq_wstart(rqp);
589         mb_put_uint16le(mbp, SMB_FA_ARCHIVE);           /* attributes  */
590         nanotime(&ctime);
591         smb_time_local2server(&ctime, SSTOVC(ssp)->vc_sopt.sv_tz, &tm);
592         mb_put_uint32le(mbp, tm);
593         smb_rq_wend(rqp);
594         smb_rq_bstart(rqp);
595         mb_put_uint8(mbp, SMB_DT_ASCII);
596         error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, nmlen);
597         if (!error) {
598                 smb_rq_bend(rqp);
599                 error = smb_rq_simple(rqp);
600                 if (!error) {
601                         smb_rq_getreply(rqp, &mdp);
602                         md_get_uint8(mdp, &wc);
603                         if (wc == 1)
604                                 md_get_uint16(mdp, &fid);
605                         else
606                                 error = EBADRPC;
607                 }
608         }
609         smb_rq_done(rqp);
610         if (error)
611                 return error;
612         smbfs_smb_close(ssp, fid, &ctime, scred);
613         return error;
614 }
615
616 int
617 smbfs_smb_delete(struct smbnode *np, struct smb_cred *scred)
618 {
619         struct smb_rq rq, *rqp = &rq;
620         struct smb_share *ssp = np->n_mount->sm_share;
621         struct mbchain *mbp;
622         int error;
623
624         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE, scred);
625         if (error)
626                 return error;
627         smb_rq_getrequest(rqp, &mbp);
628         smb_rq_wstart(rqp);
629         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
630         smb_rq_wend(rqp);
631         smb_rq_bstart(rqp);
632         mb_put_uint8(mbp, SMB_DT_ASCII);
633         error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
634         if (!error) {
635                 smb_rq_bend(rqp);
636                 error = smb_rq_simple(rqp);
637         }
638         smb_rq_done(rqp);
639         return error;
640 }
641
642 int
643 smbfs_smb_rename(struct smbnode *src, struct smbnode *tdnp,
644         const char *tname, int tnmlen, struct smb_cred *scred)
645 {
646         struct smb_rq rq, *rqp = &rq;
647         struct smb_share *ssp = src->n_mount->sm_share;
648         struct mbchain *mbp;
649         int error;
650
651         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_RENAME, scred);
652         if (error)
653                 return error;
654         smb_rq_getrequest(rqp, &mbp);
655         smb_rq_wstart(rqp);
656         mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
657         smb_rq_wend(rqp);
658         smb_rq_bstart(rqp);
659         mb_put_uint8(mbp, SMB_DT_ASCII);
660         do {
661                 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
662                 if (error)
663                         break;
664                 mb_put_uint8(mbp, SMB_DT_ASCII);
665                 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
666                 if (error)
667                         break;
668                 smb_rq_bend(rqp);
669                 error = smb_rq_simple(rqp);
670         } while(0);
671         smb_rq_done(rqp);
672         return error;
673 }
674
675 int
676 smbfs_smb_move(struct smbnode *src, struct smbnode *tdnp,
677         const char *tname, int tnmlen, u_int16_t flags, struct smb_cred *scred)
678 {
679         struct smb_rq rq, *rqp = &rq;
680         struct smb_share *ssp = src->n_mount->sm_share;
681         struct mbchain *mbp;
682         int error;
683
684         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_MOVE, scred);
685         if (error)
686                 return error;
687         smb_rq_getrequest(rqp, &mbp);
688         smb_rq_wstart(rqp);
689         mb_put_uint16le(mbp, SMB_TID_UNKNOWN);
690         mb_put_uint16le(mbp, 0x20);     /* delete target file */
691         mb_put_uint16le(mbp, flags);
692         smb_rq_wend(rqp);
693         smb_rq_bstart(rqp);
694         mb_put_uint8(mbp, SMB_DT_ASCII);
695         do {
696                 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
697                 if (error)
698                         break;
699                 mb_put_uint8(mbp, SMB_DT_ASCII);
700                 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
701                 if (error)
702                         break;
703                 smb_rq_bend(rqp);
704                 error = smb_rq_simple(rqp);
705         } while(0);
706         smb_rq_done(rqp);
707         return error;
708 }
709
710 int
711 smbfs_smb_mkdir(struct smbnode *dnp, const char *name, int len,
712         struct smb_cred *scred)
713 {
714         struct smb_rq rq, *rqp = &rq;
715         struct smb_share *ssp = dnp->n_mount->sm_share;
716         struct mbchain *mbp;
717         int error;
718
719         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE_DIRECTORY, scred);
720         if (error)
721                 return error;
722         smb_rq_getrequest(rqp, &mbp);
723         smb_rq_wstart(rqp);
724         smb_rq_wend(rqp);
725         smb_rq_bstart(rqp);
726         mb_put_uint8(mbp, SMB_DT_ASCII);
727         error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, len);
728         if (!error) {
729                 smb_rq_bend(rqp);
730                 error = smb_rq_simple(rqp);
731         }
732         smb_rq_done(rqp);
733         return error;
734 }
735
736 int
737 smbfs_smb_rmdir(struct smbnode *np, struct smb_cred *scred)
738 {
739         struct smb_rq rq, *rqp = &rq;
740         struct smb_share *ssp = np->n_mount->sm_share;
741         struct mbchain *mbp;
742         int error;
743
744         error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE_DIRECTORY, scred);
745         if (error)
746                 return error;
747         smb_rq_getrequest(rqp, &mbp);
748         smb_rq_wstart(rqp);
749         smb_rq_wend(rqp);
750         smb_rq_bstart(rqp);
751         mb_put_uint8(mbp, SMB_DT_ASCII);
752         error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
753         if (!error) {
754                 smb_rq_bend(rqp);
755                 error = smb_rq_simple(rqp);
756         }
757         smb_rq_done(rqp);
758         return error;
759 }
760
761 static int
762 smbfs_smb_search(struct smbfs_fctx *ctx)
763 {
764         struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
765         struct smb_rq *rqp;
766         struct mbchain *mbp;
767         struct mdchain *mdp;
768         u_int8_t wc, bt;
769         u_int16_t ec, dlen, bc;
770         int maxent, error, iseof = 0;
771
772         maxent = min(ctx->f_left, (vcp->vc_txmax - SMB_HDRLEN - 3) / SMB_DENTRYLEN);
773         if (ctx->f_rq) {
774                 smb_rq_done(ctx->f_rq);
775                 ctx->f_rq = NULL;
776         }
777         error = smb_rq_alloc(SSTOCP(ctx->f_ssp), SMB_COM_SEARCH, ctx->f_scred, &rqp);
778         if (error)
779                 return error;
780         ctx->f_rq = rqp;
781         smb_rq_getrequest(rqp, &mbp);
782         smb_rq_wstart(rqp);
783         mb_put_uint16le(mbp, maxent);   /* max entries to return */
784         mb_put_uint16le(mbp, ctx->f_attrmask);
785         smb_rq_wend(rqp);
786         smb_rq_bstart(rqp);
787         mb_put_uint8(mbp, SMB_DT_ASCII);        /* buffer format */
788         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
789                 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
790                 if (error)
791                         return error;
792                 mb_put_uint8(mbp, SMB_DT_VARIABLE);
793                 mb_put_uint16le(mbp, 0);        /* context length */
794                 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
795         } else {
796                 mb_put_uint8(mbp, 0);   /* file name length */
797                 mb_put_uint8(mbp, SMB_DT_VARIABLE);
798                 mb_put_uint16le(mbp, SMB_SKEYLEN);
799                 mb_put_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
800         }
801         smb_rq_bend(rqp);
802         error = smb_rq_simple(rqp);
803         if (error) {
804                 if (rqp->sr_errclass == ERRDOS && rqp->sr_serror == ERRnofiles) {
805                         error = 0;
806                         iseof = 1;
807                         ctx->f_flags |= SMBFS_RDD_EOF;
808                 } else
809                         return error;
810         }
811         smb_rq_getreply(rqp, &mdp);
812         md_get_uint8(mdp, &wc);
813         if (wc != 1) 
814                 return iseof ? ENOENT : EBADRPC;
815         md_get_uint16le(mdp, &ec);
816         if (ec == 0)
817                 return ENOENT;
818         ctx->f_ecnt = ec;
819         md_get_uint16le(mdp, &bc);
820         if (bc < 3)
821                 return EBADRPC;
822         bc -= 3;
823         md_get_uint8(mdp, &bt);
824         if (bt != SMB_DT_VARIABLE)
825                 return EBADRPC;
826         md_get_uint16le(mdp, &dlen);
827         if (dlen != bc || dlen % SMB_DENTRYLEN != 0)
828                 return EBADRPC;
829         return 0;
830 }
831
832 static int
833 smbfs_findopenLM1(struct smbfs_fctx *ctx, struct smbnode *dnp,
834         const char *wildcard, int wclen, int attr, struct smb_cred *scred)
835 {
836         ctx->f_attrmask = attr;
837         if (wildcard) {
838                 if (wclen == 1 && wildcard[0] == '*') {
839                         ctx->f_wildcard = "*.*";
840                         ctx->f_wclen = 3;
841                 } else {
842                         ctx->f_wildcard = wildcard;
843                         ctx->f_wclen = wclen;
844                 }
845         } else {
846                 ctx->f_wildcard = NULL;
847                 ctx->f_wclen = 0;
848         }
849         ctx->f_name = ctx->f_fname;
850         return 0;
851 }
852
853 static int
854 smbfs_findnextLM1(struct smbfs_fctx *ctx, int limit)
855 {
856         struct mdchain *mbp;
857         struct smb_rq *rqp;
858         char *cp;
859         u_int8_t battr;
860         u_int16_t date, time;
861         u_int32_t size;
862         int error;
863
864         if (ctx->f_ecnt == 0) {
865                 if (ctx->f_flags & SMBFS_RDD_EOF)
866                         return ENOENT;
867                 ctx->f_left = ctx->f_limit = limit;
868                 error = smbfs_smb_search(ctx);
869                 if (error)
870                         return error;
871         }
872         rqp = ctx->f_rq;
873         smb_rq_getreply(rqp, &mbp);
874         md_get_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
875         md_get_uint8(mbp, &battr);
876         md_get_uint16le(mbp, &time);
877         md_get_uint16le(mbp, &date);
878         md_get_uint32le(mbp, &size);
879         cp = ctx->f_name;
880         md_get_mem(mbp, cp, sizeof(ctx->f_fname), MB_MSYSTEM);
881         cp[sizeof(ctx->f_fname) - 1] = 0;
882         cp += strlen(cp) - 1;
883         while (*cp == ' ' && cp >= ctx->f_name)
884                 *cp-- = 0;
885         ctx->f_attr.fa_attr = battr;
886         smb_dos2unixtime(date, time, 0, rqp->sr_vc->vc_sopt.sv_tz,
887             &ctx->f_attr.fa_mtime);
888         ctx->f_attr.fa_size = size;
889         ctx->f_nmlen = strlen(ctx->f_name);
890         ctx->f_ecnt--;
891         ctx->f_left--;
892         return 0;
893 }
894
895 static int
896 smbfs_findcloseLM1(struct smbfs_fctx *ctx)
897 {
898         if (ctx->f_rq)
899                 smb_rq_done(ctx->f_rq);
900         return 0;
901 }
902
903 /*
904  * TRANS2_FIND_FIRST2/NEXT2, used for NT LM12 dialect
905  */
906 static int
907 smbfs_smb_trans2find2(struct smbfs_fctx *ctx)
908 {
909         struct smb_t2rq *t2p;
910         struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
911         struct mbchain *mbp;
912         struct mdchain *mdp;
913         u_int16_t tw, flags;
914         int error;
915
916         if (ctx->f_t2) {
917                 smb_t2_done(ctx->f_t2);
918                 ctx->f_t2 = NULL;
919         }
920         ctx->f_flags &= ~SMBFS_RDD_GOTRNAME;
921         flags = 8 | 2;                  /* <resume> | <close if EOS> */
922         if (ctx->f_flags & SMBFS_RDD_FINDSINGLE) {
923                 flags |= 1;             /* close search after this request */
924                 ctx->f_flags |= SMBFS_RDD_NOCLOSE;
925         }
926         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
927                 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_FIRST2,
928                     ctx->f_scred, &t2p);
929                 if (error)
930                         return error;
931                 ctx->f_t2 = t2p;
932                 mbp = &t2p->t2_tparam;
933                 mb_init(mbp);
934                 mb_put_uint16le(mbp, ctx->f_attrmask);
935                 mb_put_uint16le(mbp, ctx->f_limit);
936                 mb_put_uint16le(mbp, flags);
937                 mb_put_uint16le(mbp, ctx->f_infolevel);
938                 mb_put_uint32le(mbp, 0);
939                 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
940                 if (error)
941                         return error;
942         } else  {
943                 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_NEXT2,
944                     ctx->f_scred, &t2p);
945                 if (error)
946                         return error;
947                 ctx->f_t2 = t2p;
948                 mbp = &t2p->t2_tparam;
949                 mb_init(mbp);
950                 mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
951                 mb_put_uint16le(mbp, ctx->f_limit);
952                 mb_put_uint16le(mbp, ctx->f_infolevel);
953                 mb_put_uint32le(mbp, 0);                /* resume key */
954                 mb_put_uint16le(mbp, flags);
955                 if (ctx->f_rname)
956                         mb_put_mem(mbp, ctx->f_rname, strlen(ctx->f_rname) + 1, MB_MSYSTEM);
957                 else
958                         mb_put_uint8(mbp, 0);   /* resume file name */
959 #if 0
960         struct timeval tv;
961         tv.tv_sec = 0;
962         tv.tv_usec = 200 * 1000;        /* 200ms */
963                 if (vcp->vc_flags & SMBC_WIN95) {
964                         /*
965                          * some implementations suggests to sleep here
966                          * for 200ms, due to the bug in the Win95.
967                          * I've didn't notice any problem, but put code
968                          * for it.
969                          */
970                          tsleep(&flags, 0, "fix95", tvtohz_high(&tv));
971                 }
972 #endif
973         }
974         t2p->t2_maxpcount = 5 * 2;
975         t2p->t2_maxdcount = vcp->vc_txmax;
976         error = smb_t2_request(t2p);
977         if (error)
978                 return error;
979         mdp = &t2p->t2_rparam;
980         if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
981                 if ((error = md_get_uint16(mdp, &ctx->f_Sid)) != 0)
982                         return error;
983                 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
984         }
985         if ((error = md_get_uint16le(mdp, &tw)) != 0)
986                 return error;
987         ctx->f_ecnt = tw;
988         if ((error = md_get_uint16le(mdp, &tw)) != 0)
989                 return error;
990         if (tw)
991                 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE;
992         if ((error = md_get_uint16le(mdp, &tw)) != 0)
993                 return error;
994         if ((error = md_get_uint16le(mdp, &tw)) != 0)
995                 return error;
996         if (ctx->f_ecnt == 0) {
997                 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE;
998                 return ENOENT;
999         }
1000         ctx->f_rnameofs = tw;
1001         mdp = &t2p->t2_rdata;
1002         if (mdp->md_top == NULL) {
1003                 kprintf("bug: ecnt = %d, but data is NULL (please report)\n", ctx->f_ecnt);
1004                 return ENOENT;
1005         }
1006         if (mdp->md_top->m_len == 0) {
1007                 kprintf("bug: ecnt = %d, but m_len = 0 and m_next = %p (please report)\n", ctx->f_ecnt,mbp->mb_top->m_next);
1008                 return ENOENT;
1009         }
1010         ctx->f_eofs = 0;
1011         return 0;
1012 }
1013
1014 static int
1015 smbfs_smb_findclose2(struct smbfs_fctx *ctx)
1016 {
1017         struct smb_rq rq, *rqp = &rq;
1018         struct mbchain *mbp;
1019         int error;
1020
1021         error = smb_rq_init(rqp, SSTOCP(ctx->f_ssp), SMB_COM_FIND_CLOSE2, ctx->f_scred);
1022         if (error)
1023                 return error;
1024         smb_rq_getrequest(rqp, &mbp);
1025         smb_rq_wstart(rqp);
1026         mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
1027         smb_rq_wend(rqp);
1028         smb_rq_bstart(rqp);
1029         smb_rq_bend(rqp);
1030         error = smb_rq_simple(rqp);
1031         smb_rq_done(rqp);
1032         return error;
1033 }
1034
1035 static int
1036 smbfs_findopenLM2(struct smbfs_fctx *ctx, struct smbnode *dnp,
1037         const char *wildcard, int wclen, int attr, struct smb_cred *scred)
1038 {
1039         ctx->f_name = kmalloc(SMB_MAXFNAMELEN, M_SMBFSDATA, M_WAITOK);
1040         ctx->f_infolevel = SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_NTLM0_12 ?
1041             SMB_INFO_STANDARD : SMB_FIND_FILE_DIRECTORY_INFO;
1042         ctx->f_attrmask = attr;
1043         ctx->f_wildcard = wildcard;
1044         ctx->f_wclen = wclen;
1045         return 0;
1046 }
1047
1048 static int
1049 smbfs_findnextLM2(struct smbfs_fctx *ctx, int limit)
1050 {
1051         struct mdchain *mbp;
1052         struct smb_t2rq *t2p;
1053         char *cp;
1054         u_int8_t tb;
1055         u_int16_t date, time, wattr;
1056         u_int32_t size, next, dattr;
1057         int64_t lint;
1058         int error, svtz, cnt, fxsz, nmlen, recsz;
1059
1060         if (ctx->f_ecnt == 0) {
1061                 if (ctx->f_flags & SMBFS_RDD_EOF)
1062                         return ENOENT;
1063                 ctx->f_left = ctx->f_limit = limit;
1064                 error = smbfs_smb_trans2find2(ctx);
1065                 if (error)
1066                         return error;
1067         }
1068         t2p = ctx->f_t2;
1069         mbp = &t2p->t2_rdata;
1070         svtz = SSTOVC(ctx->f_ssp)->vc_sopt.sv_tz;
1071         switch (ctx->f_infolevel) {
1072             case SMB_INFO_STANDARD:
1073                 next = 0;
1074                 fxsz = 0;
1075                 md_get_uint16le(mbp, &date);
1076                 md_get_uint16le(mbp, &time);    /* creation time */
1077                 md_get_uint16le(mbp, &date);
1078                 md_get_uint16le(mbp, &time);    /* access time */
1079                 smb_dos2unixtime(date, time, 0, svtz, &ctx->f_attr.fa_atime);
1080                 md_get_uint16le(mbp, &date);
1081                 md_get_uint16le(mbp, &time);    /* access time */
1082                 smb_dos2unixtime(date, time, 0, svtz, &ctx->f_attr.fa_mtime);
1083                 md_get_uint32le(mbp, &size);
1084                 ctx->f_attr.fa_size = size;
1085                 md_get_uint32(mbp, NULL);       /* allocation size */
1086                 md_get_uint16le(mbp, &wattr);
1087                 ctx->f_attr.fa_attr = wattr;
1088                 md_get_uint8(mbp, &tb);
1089                 size = nmlen = tb;
1090                 fxsz = 23;
1091                 recsz = next = 24 + nmlen;      /* docs misses zero byte at end */
1092                 break;
1093             case SMB_FIND_FILE_DIRECTORY_INFO:
1094                 md_get_uint32le(mbp, &next);
1095                 md_get_uint32(mbp, NULL);       /* file index */
1096                 md_get_int64(mbp, NULL);        /* creation time */
1097                 md_get_int64le(mbp, &lint);
1098                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_atime);
1099                 md_get_int64le(mbp, &lint);
1100                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_mtime);
1101                 md_get_int64le(mbp, &lint);
1102                 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_ctime);
1103                 md_get_int64le(mbp, &lint);     /* file size */
1104                 ctx->f_attr.fa_size = lint;
1105                 md_get_int64(mbp, NULL);        /* real size (should use) */
1106                 md_get_uint32(mbp, &dattr);     /* EA */
1107                 ctx->f_attr.fa_attr = dattr;
1108                 md_get_uint32le(mbp, &size);    /* name len */
1109                 fxsz = 64;
1110                 recsz = next ? next : fxsz + size;
1111                 break;
1112             default:
1113                 SMBERROR("unexpected info level %d\n", ctx->f_infolevel);
1114                 return EINVAL;
1115         }
1116         nmlen = min(size, SMB_MAXFNAMELEN);
1117         cp = ctx->f_name;
1118         error = md_get_mem(mbp, cp, nmlen, MB_MSYSTEM);
1119         if (error)
1120                 return error;
1121         if (next) {
1122                 cnt = next - nmlen - fxsz;
1123                 if (cnt > 0)
1124                         md_get_mem(mbp, NULL, cnt, MB_MSYSTEM);
1125                 else if (cnt < 0) {
1126                         SMBERROR("out of sync\n");
1127                         return EBADRPC;
1128                 }
1129         }
1130         if (nmlen && cp[nmlen - 1] == 0)
1131                 nmlen--;
1132         if (nmlen == 0)
1133                 return EBADRPC;
1134
1135         next = ctx->f_eofs + recsz;
1136         if (ctx->f_rnameofs && (ctx->f_flags & SMBFS_RDD_GOTRNAME) == 0 &&
1137             (ctx->f_rnameofs >= ctx->f_eofs && ctx->f_rnameofs < next)) {
1138                 /*
1139                  * Server needs a resume filename.
1140                  */
1141                 if (ctx->f_rnamelen <= nmlen) {
1142                         if (ctx->f_rname)
1143                                 kfree(ctx->f_rname, M_SMBFSDATA);
1144                         ctx->f_rname = kmalloc(nmlen + 1, M_SMBFSDATA, M_WAITOK);
1145                         ctx->f_rnamelen = nmlen;
1146                 }
1147                 bcopy(ctx->f_name, ctx->f_rname, nmlen);
1148                 ctx->f_rname[nmlen] = 0;
1149                 ctx->f_flags |= SMBFS_RDD_GOTRNAME;
1150         }
1151         ctx->f_nmlen = nmlen;
1152         ctx->f_eofs = next;
1153         ctx->f_ecnt--;
1154         ctx->f_left--;
1155         return 0;
1156 }
1157
1158 static int
1159 smbfs_findcloseLM2(struct smbfs_fctx *ctx)
1160 {
1161         if (ctx->f_name)
1162                 kfree(ctx->f_name, M_SMBFSDATA);
1163         if (ctx->f_t2)
1164                 smb_t2_done(ctx->f_t2);
1165         if ((ctx->f_flags & SMBFS_RDD_NOCLOSE) == 0)
1166                 smbfs_smb_findclose2(ctx);
1167         return 0;
1168 }
1169
1170 int
1171 smbfs_findopen(struct smbnode *dnp, const char *wildcard, int wclen, int attr,
1172         struct smb_cred *scred, struct smbfs_fctx **ctxpp)
1173 {
1174         struct smbfs_fctx *ctx;
1175         int error;
1176
1177         ctx = kmalloc(sizeof(*ctx), M_SMBFSDATA, M_WAITOK | M_ZERO);
1178         ctx->f_ssp = dnp->n_mount->sm_share;
1179         ctx->f_dnp = dnp;
1180         ctx->f_flags = SMBFS_RDD_FINDFIRST;
1181         ctx->f_scred = scred;
1182         if (SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_LANMAN2_0 ||
1183             (dnp->n_mount->sm_args.flags & SMBFS_MOUNT_NO_LONG)) {
1184                 ctx->f_flags |= SMBFS_RDD_USESEARCH;
1185                 error = smbfs_findopenLM1(ctx, dnp, wildcard, wclen, attr, scred);
1186         } else
1187                 error = smbfs_findopenLM2(ctx, dnp, wildcard, wclen, attr, scred);
1188         if (error)
1189                 smbfs_findclose(ctx, scred);
1190         else
1191                 *ctxpp = ctx;
1192         return error;
1193 }
1194
1195 int
1196 smbfs_findnext(struct smbfs_fctx *ctx, int limit, struct smb_cred *scred)
1197 {
1198         int error;
1199
1200         if (limit == 0)
1201                 limit = 1000000;
1202         else if (limit > 1)
1203                 limit *= 4;     /* imperical */
1204         ctx->f_scred = scred;
1205         for (;;) {
1206                 if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
1207                         error = smbfs_findnextLM1(ctx, limit);
1208                 } else
1209                         error = smbfs_findnextLM2(ctx, limit);
1210                 if (error)
1211                         return error;
1212                 if ((ctx->f_nmlen == 1 && ctx->f_name[0] == '.') ||
1213                     (ctx->f_nmlen == 2 && ctx->f_name[0] == '.' &&
1214                      ctx->f_name[1] == '.'))
1215                         continue;
1216                 break;
1217         }
1218         smbfs_fname_tolocal(SSTOVC(ctx->f_ssp), ctx->f_name, ctx->f_nmlen,
1219             ctx->f_dnp->n_mount->sm_caseopt);
1220         ctx->f_attr.fa_ino = smbfs_getino(ctx->f_dnp, ctx->f_name, ctx->f_nmlen);
1221         return 0;
1222 }
1223
1224 int
1225 smbfs_findclose(struct smbfs_fctx *ctx, struct smb_cred *scred)
1226 {
1227         ctx->f_scred = scred;
1228         if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
1229                 smbfs_findcloseLM1(ctx);
1230         } else
1231                 smbfs_findcloseLM2(ctx);
1232         if (ctx->f_rname)
1233                 kfree(ctx->f_rname, M_SMBFSDATA);
1234         kfree(ctx, M_SMBFSDATA);
1235         return 0;
1236 }
1237
1238 int
1239 smbfs_smb_lookup(struct smbnode *dnp, const char *name, int nmlen,
1240         struct smbfattr *fap, struct smb_cred *scred)
1241 {
1242         struct smbfs_fctx *ctx;
1243         int error;
1244
1245         if (dnp == NULL || (dnp->n_ino == 2 && name == NULL)) {
1246                 bzero(fap, sizeof(*fap));
1247                 fap->fa_attr = SMB_FA_DIR;
1248                 fap->fa_ino = 2;
1249                 return 0;
1250         }
1251         if (nmlen == 1 && name[0] == '.') {
1252                 error = smbfs_smb_lookup(dnp, NULL, 0, fap, scred);
1253                 return error;
1254         } else if (nmlen == 2 && name[0] == '.' && name[1] == '.') {
1255                 error = smbfs_smb_lookup(VTOSMB(dnp->n_parent), NULL, 0, fap,
1256                     scred);
1257                 kprintf("%s: knows NOTHING about '..'\n", __func__);
1258                 return error;
1259         }
1260         error = smbfs_findopen(dnp, name, nmlen,
1261             SMB_FA_SYSTEM | SMB_FA_HIDDEN | SMB_FA_DIR, scred, &ctx);
1262         if (error)
1263                 return error;
1264         ctx->f_flags |= SMBFS_RDD_FINDSINGLE;
1265         error = smbfs_findnext(ctx, 1, scred);
1266         if (error == 0) {
1267                 *fap = ctx->f_attr;
1268                 if (name == NULL)
1269                         fap->fa_ino = dnp->n_ino;
1270         }
1271         smbfs_findclose(ctx, scred);
1272         return error;
1273 }