2 * Copyright (c) 2000-2001 Boris Popov
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
40 #include <sys/vnode.h>
42 #include <sys/mount.h>
48 #include <netsmb/smb.h>
49 #include <netsmb/smb_subr.h>
50 #include <netsmb/smb_rq.h>
51 #include <netsmb/smb_conn.h>
53 #include <fs/smbfs/smbfs.h>
54 #include <fs/smbfs/smbfs_node.h>
55 #include <fs/smbfs/smbfs_subr.h>
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)
67 smbfs_getino(struct smbnode *dnp, const char *name, int nmlen)
76 MD5Update(&md5, name, nmlen);
77 MD5Final((u_char *)state, &md5);
78 for (i = 0, ino = 0; i < 4; i++)
80 return dnp->n_ino + ino;
84 ino = dnp->n_ino + smbfs_hash(name, nmlen);
91 smbfs_smb_lockandx(struct smbnode *np, int op, u_int32_t pid, off_t start, off_t end,
92 struct smb_cred *scred)
94 struct smb_share *ssp = np->n_mount->sm_share;
95 struct smb_rq rq, *rqp = &rq;
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);
105 smb_rq_getrequest(rqp, &mbp);
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);
118 mb_put_uint16le(mbp, pid);
119 mb_put_uint32le(mbp, start);
120 mb_put_uint32le(mbp, end - start);
122 error = smb_rq_simple(rqp);
128 smbfs_smb_lock(struct smbnode *np, int op, caddr_t id,
129 off_t start, off_t end, struct smb_cred *scred)
131 struct smb_share *ssp = np->n_mount->sm_share;
133 if (SMB_DIALECT(SSTOVC(ssp)) < SMB_DIALECT_LANMAN1_0)
135 * TODO: use LOCK_BYTE_RANGE here.
139 return smbfs_smb_lockandx(np, op, (uintptr_t)id, start, end, scred);
143 smbfs_smb_qpathinfo(struct smbnode *np, struct smbfattr *fap,
144 struct smb_cred *scred, short infolevel)
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;
152 u_int16_t date, time, wattr;
154 u_int32_t size, dattr;
156 error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_PATH_INFORMATION,
160 mbp = &t2p->t2_tparam;
163 if (SMB_DIALECT(vcp) < SMB_DIALECT_NTLM0_12)
164 infolevel = SMB_QUERY_FILE_STANDARD;
166 infolevel = SMB_QUERY_FILE_BASIC_INFO;
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);
176 t2p->t2_maxpcount = 2;
177 t2p->t2_maxdcount = vcp->vc_txmax;
178 error = smb_t2_request(t2p);
181 if (infolevel == SMB_QUERY_FILE_STANDARD || error != EINVAL)
183 return smbfs_smb_qpathinfo(np, fap, scred,
184 SMB_QUERY_FILE_STANDARD);
186 mdp = &t2p->t2_rdata;
187 svtz = vcp->vc_sopt.sv_tz;
189 case SMB_QUERY_FILE_STANDARD:
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 */
197 smb_dos2unixtime(date, time, 0, svtz, &fap->fa_atime);
199 md_get_uint16le(mdp, &date);
200 md_get_uint16le(mdp, &time); /* modify time */
203 smb_dos2unixtime(date, time, 0, svtz, &fap->fa_mtime);
205 md_get_uint32le(mdp, &size);
207 md_get_uint32(mdp, NULL); /* allocation size */
208 md_get_uint16le(mdp, &wattr);
209 fap->fa_attr = wattr;
211 case SMB_QUERY_FILE_BASIC_INFO:
213 md_get_int64(mdp, NULL); /* creation time */
214 md_get_int64le(mdp, &lint);
217 smb_time_NT2local(lint, svtz, &fap->fa_atime);
219 md_get_int64le(mdp, &lint);
222 smb_time_NT2local(lint, svtz, &fap->fa_mtime);
224 md_get_int64le(mdp, &lint);
227 smb_time_NT2local(lint, svtz, &fap->fa_ctime);
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 */
235 SMBERROR("unexpected info level %d\n", infolevel);
240 * if all times are zero (observed with FAT on NT4SP6)
241 * then fall back to older info level
244 if (infolevel != SMB_QUERY_FILE_STANDARD)
245 return smbfs_smb_qpathinfo(np, fap, scred,
246 SMB_QUERY_FILE_STANDARD);
253 smbfs_smb_statfs2(struct smb_share *ssp, struct statfs *sbp,
254 struct smb_cred *scred)
256 struct smb_t2rq *t2p;
260 u_int32_t units, bpu, funits;
263 error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_QUERY_FS_INFORMATION,
267 mbp = &t2p->t2_tparam;
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);
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 */
294 smbfs_smb_statfs(struct smb_share *ssp, struct statfs *sbp,
295 struct smb_cred *scred)
297 struct smb_rq rq, *rqp = &rq;
299 u_int16_t units, bpu, bsize, funits;
302 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_QUERY_INFORMATION_DISK, scred);
309 error = smb_rq_simple(rqp);
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 */
330 smbfs_smb_seteof(struct smbnode *np, int64_t newsize, struct smb_cred *scred)
332 struct smb_t2rq *t2p;
333 struct smb_share *ssp = np->n_mount->sm_share;
337 error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
341 mbp = &t2p->t2_tparam;
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;
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);
359 smb_smb_flush(struct smbnode *np, struct smb_cred *scred)
361 struct smb_share *ssp = np->n_mount->sm_share;
362 struct smb_rq rq, *rqp = &rq;
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);
372 smb_rq_getrequest(rqp, &mbp);
374 mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
378 error = smb_rq_simple(rqp);
381 np->n_flag &= ~NFLUSHWIRE;
386 smbfs_smb_flush(struct smbnode *np, struct smb_cred *scred)
388 if (np->n_flag & NFLUSHWIRE)
389 return (smb_smb_flush(np, scred));
394 smbfs_smb_setfsize(struct smbnode *np, int newsize, struct smb_cred *scred)
396 struct smb_share *ssp = np->n_mount->sm_share;
397 struct smb_rq rq, *rqp = &rq;
401 if (!smbfs_smb_seteof(np, (int64_t) newsize, scred)) {
402 np->n_flag |= NFLUSHWIRE;
406 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_WRITE, scred);
409 smb_rq_getrequest(rqp, &mbp);
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);
417 mb_put_uint8(mbp, SMB_DT_DATA);
418 mb_put_uint16le(mbp, 0);
420 error = smb_rq_simple(rqp);
426 smbfs_smb_query_info(struct smbnode *np, const char *name, int len,
427 struct smbfattr *fap, struct smb_cred *scred)
429 struct smb_rq rq, *rqp = &rq;
430 struct smb_share *ssp = np->n_mount->sm_share;
438 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_QUERY_INFORMATION, scred);
441 smb_rq_getrequest(rqp, &mbp);
445 mb_put_uint8(mbp, SMB_DT_ASCII);
447 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, name, len);
451 error = smb_rq_simple(rqp);
454 smb_rq_getreply(rqp, &mdp);
455 if (md_get_uint8(mdp, &wc) != 0 || wc != 10) {
459 md_get_uint16le(mdp, &wattr);
460 fap->fa_attr = wattr;
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!
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,
471 md_get_uint32le(mdp, &lint);
479 * Set DOS file attributes. mtime should be NULL for dialects above lm10
482 smbfs_smb_setpattr(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
483 struct smb_cred *scred)
485 struct smb_rq rq, *rqp = &rq;
486 struct smb_share *ssp = np->n_mount->sm_share;
491 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION, scred);
494 svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
495 smb_rq_getrequest(rqp, &mbp);
497 mb_put_uint16le(mbp, attr);
499 smb_time_local2server(mtime, svtz, &time);
502 mb_put_uint32le(mbp, time); /* mtime */
503 mb_put_mem(mbp, NULL, 5 * 2, MB_MZERO);
506 mb_put_uint8(mbp, SMB_DT_ASCII);
508 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
511 mb_put_uint8(mbp, SMB_DT_ASCII);
512 mb_put_uint8(mbp, 0);
514 error = smb_rq_simple(rqp);
516 SMBERROR("smb_rq_simple(rqp) => error %d\n", error);
525 * Note, win95 doesn't support this call.
528 smbfs_smb_setptime2(struct smbnode *np, struct timespec *mtime,
529 struct timespec *atime, int attr, struct smb_cred *scred)
531 struct smb_t2rq *t2p;
532 struct smb_share *ssp = np->n_mount->sm_share;
533 struct smb_vc *vcp = SSTOVC(ssp);
535 u_int16_t date, time;
538 error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
542 mbp = &t2p->t2_tparam;
544 mb_put_uint16le(mbp, SMB_INFO_STANDARD);
545 mb_put_uint32le(mbp, 0); /* MBZ */
546 /* mb_put_uint8(mbp, SMB_DT_ASCII); specs incorrect */
547 error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
552 tzoff = vcp->vc_sopt.sv_tz;
553 mbp = &t2p->t2_tdata;
555 mb_put_uint32le(mbp, 0); /* creation time */
557 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
560 mb_put_uint16le(mbp, date);
561 mb_put_uint16le(mbp, time);
563 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
566 mb_put_uint16le(mbp, date);
567 mb_put_uint16le(mbp, time);
568 mb_put_uint32le(mbp, 0); /* file size */
569 mb_put_uint32le(mbp, 0); /* allocation unit size */
570 mb_put_uint16le(mbp, attr); /* DOS attr */
571 mb_put_uint32le(mbp, 0); /* EA size */
572 t2p->t2_maxpcount = 5 * 2;
573 t2p->t2_maxdcount = vcp->vc_txmax;
574 error = smb_t2_request(t2p);
580 * NT level. Specially for win9x
583 smbfs_smb_setpattrNT(struct smbnode *np, u_short attr, struct timespec *mtime,
584 struct timespec *atime, struct smb_cred *scred)
586 struct smb_t2rq *t2p;
587 struct smb_share *ssp = np->n_mount->sm_share;
588 struct smb_vc *vcp = SSTOVC(ssp);
593 error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_PATH_INFORMATION,
597 mbp = &t2p->t2_tparam;
599 mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
600 mb_put_uint32le(mbp, 0); /* MBZ */
601 /* mb_put_uint8(mbp, SMB_DT_ASCII); specs incorrect */
602 error = smbfs_fullpath(mbp, vcp, np, NULL, 0);
607 tzoff = vcp->vc_sopt.sv_tz;
608 mbp = &t2p->t2_tdata;
610 mb_put_int64le(mbp, 0); /* creation time */
612 smb_time_local2NT(atime, tzoff, &tm);
615 mb_put_int64le(mbp, tm);
617 smb_time_local2NT(mtime, tzoff, &tm);
620 mb_put_int64le(mbp, tm);
621 mb_put_int64le(mbp, tm); /* change time */
622 mb_put_uint32le(mbp, attr); /* attr */
623 t2p->t2_maxpcount = 24;
624 t2p->t2_maxdcount = 56;
625 error = smb_t2_request(t2p);
631 * Set file atime and mtime. Doesn't supported by core dialect.
634 smbfs_smb_setftime(struct smbnode *np, struct timespec *mtime,
635 struct timespec *atime, struct smb_cred *scred)
637 struct smb_rq rq, *rqp = &rq;
638 struct smb_share *ssp = np->n_mount->sm_share;
640 u_int16_t date, time;
643 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_SET_INFORMATION2, scred);
646 tzoff = SSTOVC(ssp)->vc_sopt.sv_tz;
647 smb_rq_getrequest(rqp, &mbp);
649 mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
650 mb_put_uint32le(mbp, 0); /* creation time */
653 smb_time_unix2dos(atime, tzoff, &date, &time, NULL);
656 mb_put_uint16le(mbp, date);
657 mb_put_uint16le(mbp, time);
659 smb_time_unix2dos(mtime, tzoff, &date, &time, NULL);
662 mb_put_uint16le(mbp, date);
663 mb_put_uint16le(mbp, time);
667 error = smb_rq_simple(rqp);
668 SMBSDEBUG("%d\n", error);
674 * Set DOS file attributes.
675 * Looks like this call can be used only if CAP_NT_SMBS bit is on.
678 smbfs_smb_setfattrNT(struct smbnode *np, u_int16_t attr, struct timespec *mtime,
679 struct timespec *atime, struct smb_cred *scred)
681 struct smb_t2rq *t2p;
682 struct smb_share *ssp = np->n_mount->sm_share;
687 error = smb_t2_alloc(SSTOCP(ssp), SMB_TRANS2_SET_FILE_INFORMATION,
691 svtz = SSTOVC(ssp)->vc_sopt.sv_tz;
692 mbp = &t2p->t2_tparam;
694 mb_put_mem(mbp, (caddr_t)&np->n_fid, 2, MB_MSYSTEM);
695 mb_put_uint16le(mbp, SMB_SET_FILE_BASIC_INFO);
696 mb_put_uint32le(mbp, 0);
697 mbp = &t2p->t2_tdata;
699 mb_put_int64le(mbp, 0); /* creation time */
701 smb_time_local2NT(atime, svtz, &tm);
704 mb_put_int64le(mbp, tm);
706 smb_time_local2NT(mtime, svtz, &tm);
709 mb_put_int64le(mbp, tm);
710 mb_put_int64le(mbp, tm); /* change time */
711 mb_put_uint16le(mbp, attr);
712 mb_put_uint32le(mbp, 0); /* padding */
713 mb_put_uint16le(mbp, 0);
714 t2p->t2_maxpcount = 2;
715 t2p->t2_maxdcount = 0;
716 error = smb_t2_request(t2p);
723 smbfs_smb_open(struct smbnode *np, int accmode, struct smb_cred *scred)
725 struct smb_rq rq, *rqp = &rq;
726 struct smb_share *ssp = np->n_mount->sm_share;
730 u_int16_t fid, wattr, grantedmode;
733 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_OPEN, scred);
736 smb_rq_getrequest(rqp, &mbp);
738 mb_put_uint16le(mbp, accmode);
739 mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
742 mb_put_uint8(mbp, SMB_DT_ASCII);
744 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
748 error = smb_rq_simple(rqp);
751 smb_rq_getreply(rqp, &mdp);
752 if (md_get_uint8(mdp, &wc) != 0 || wc != 7) {
756 md_get_uint16(mdp, &fid);
757 md_get_uint16le(mdp, &wattr);
758 md_get_uint32(mdp, NULL); /* mtime */
759 md_get_uint32(mdp, NULL); /* fsize */
760 md_get_uint16le(mdp, &grantedmode);
762 * TODO: refresh attributes from this reply
769 np->n_rwstate = grantedmode;
775 smbfs_smb_close(struct smb_share *ssp, u_int16_t fid, struct timespec *mtime,
776 struct smb_cred *scred)
778 struct smb_rq rq, *rqp = &rq;
783 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CLOSE, scred);
786 smb_rq_getrequest(rqp, &mbp);
788 mb_put_mem(mbp, (caddr_t)&fid, sizeof(fid), MB_MSYSTEM);
790 smb_time_local2server(mtime, SSTOVC(ssp)->vc_sopt.sv_tz, &time);
793 mb_put_uint32le(mbp, time);
797 error = smb_rq_simple(rqp);
803 smbfs_smb_create(struct smbnode *dnp, const char *name, int nmlen,
804 struct smb_cred *scred)
806 struct smb_rq rq, *rqp = &rq;
807 struct smb_share *ssp = dnp->n_mount->sm_share;
810 struct timespec ctime;
816 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE, scred);
819 smb_rq_getrequest(rqp, &mbp);
821 mb_put_uint16le(mbp, SMB_FA_ARCHIVE); /* attributes */
823 smb_time_local2server(&ctime, SSTOVC(ssp)->vc_sopt.sv_tz, &tm);
824 mb_put_uint32le(mbp, tm);
827 mb_put_uint8(mbp, SMB_DT_ASCII);
828 error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, nmlen);
831 error = smb_rq_simple(rqp);
833 smb_rq_getreply(rqp, &mdp);
834 md_get_uint8(mdp, &wc);
836 md_get_uint16(mdp, &fid);
844 smbfs_smb_close(ssp, fid, &ctime, scred);
849 smbfs_smb_delete(struct smbnode *np, struct smb_cred *scred)
851 struct smb_rq rq, *rqp = &rq;
852 struct smb_share *ssp = np->n_mount->sm_share;
856 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE, scred);
859 smb_rq_getrequest(rqp, &mbp);
861 mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
864 mb_put_uint8(mbp, SMB_DT_ASCII);
865 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
868 error = smb_rq_simple(rqp);
875 smbfs_smb_rename(struct smbnode *src, struct smbnode *tdnp,
876 const char *tname, int tnmlen, struct smb_cred *scred)
878 struct smb_rq rq, *rqp = &rq;
879 struct smb_share *ssp = src->n_mount->sm_share;
883 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_RENAME, scred);
886 smb_rq_getrequest(rqp, &mbp);
888 mb_put_uint16le(mbp, SMB_FA_SYSTEM | SMB_FA_HIDDEN);
891 mb_put_uint8(mbp, SMB_DT_ASCII);
893 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
896 mb_put_uint8(mbp, SMB_DT_ASCII);
897 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
901 error = smb_rq_simple(rqp);
908 smbfs_smb_move(struct smbnode *src, struct smbnode *tdnp,
909 const char *tname, int tnmlen, u_int16_t flags, struct smb_cred *scred)
911 struct smb_rq rq, *rqp = &rq;
912 struct smb_share *ssp = src->n_mount->sm_share;
916 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_MOVE, scred);
919 smb_rq_getrequest(rqp, &mbp);
921 mb_put_uint16le(mbp, SMB_TID_UNKNOWN);
922 mb_put_uint16le(mbp, 0x20); /* delete target file */
923 mb_put_uint16le(mbp, flags);
926 mb_put_uint8(mbp, SMB_DT_ASCII);
928 error = smbfs_fullpath(mbp, SSTOVC(ssp), src, NULL, 0);
931 mb_put_uint8(mbp, SMB_DT_ASCII);
932 error = smbfs_fullpath(mbp, SSTOVC(ssp), tdnp, tname, tnmlen);
936 error = smb_rq_simple(rqp);
943 smbfs_smb_mkdir(struct smbnode *dnp, const char *name, int len,
944 struct smb_cred *scred)
946 struct smb_rq rq, *rqp = &rq;
947 struct smb_share *ssp = dnp->n_mount->sm_share;
951 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_CREATE_DIRECTORY, scred);
954 smb_rq_getrequest(rqp, &mbp);
958 mb_put_uint8(mbp, SMB_DT_ASCII);
959 error = smbfs_fullpath(mbp, SSTOVC(ssp), dnp, name, len);
962 error = smb_rq_simple(rqp);
969 smbfs_smb_rmdir(struct smbnode *np, struct smb_cred *scred)
971 struct smb_rq rq, *rqp = &rq;
972 struct smb_share *ssp = np->n_mount->sm_share;
976 error = smb_rq_init(rqp, SSTOCP(ssp), SMB_COM_DELETE_DIRECTORY, scred);
979 smb_rq_getrequest(rqp, &mbp);
983 mb_put_uint8(mbp, SMB_DT_ASCII);
984 error = smbfs_fullpath(mbp, SSTOVC(ssp), np, NULL, 0);
987 error = smb_rq_simple(rqp);
994 smbfs_smb_search(struct smbfs_fctx *ctx)
996 struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
1001 u_int16_t ec, dlen, bc;
1002 int maxent, error, iseof = 0;
1004 maxent = min(ctx->f_left, (vcp->vc_txmax - SMB_HDRLEN - 3) / SMB_DENTRYLEN);
1006 smb_rq_done(ctx->f_rq);
1009 error = smb_rq_alloc(SSTOCP(ctx->f_ssp), SMB_COM_SEARCH, ctx->f_scred, &rqp);
1013 smb_rq_getrequest(rqp, &mbp);
1015 mb_put_uint16le(mbp, maxent); /* max entries to return */
1016 mb_put_uint16le(mbp, ctx->f_attrmask);
1019 mb_put_uint8(mbp, SMB_DT_ASCII); /* buffer format */
1020 if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
1021 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
1024 mb_put_uint8(mbp, SMB_DT_VARIABLE);
1025 mb_put_uint16le(mbp, 0); /* context length */
1026 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
1028 mb_put_uint8(mbp, 0); /* file name length */
1029 mb_put_uint8(mbp, SMB_DT_VARIABLE);
1030 mb_put_uint16le(mbp, SMB_SKEYLEN);
1031 mb_put_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
1034 error = smb_rq_simple(rqp);
1036 if (rqp->sr_errclass == ERRDOS && rqp->sr_serror == ERRnofiles) {
1039 ctx->f_flags |= SMBFS_RDD_EOF;
1043 smb_rq_getreply(rqp, &mdp);
1044 md_get_uint8(mdp, &wc);
1046 return iseof ? ENOENT : EBADRPC;
1047 md_get_uint16le(mdp, &ec);
1051 md_get_uint16le(mdp, &bc);
1055 md_get_uint8(mdp, &bt);
1056 if (bt != SMB_DT_VARIABLE)
1058 md_get_uint16le(mdp, &dlen);
1059 if (dlen != bc || dlen % SMB_DENTRYLEN != 0)
1065 smbfs_findopenLM1(struct smbfs_fctx *ctx, struct smbnode *dnp,
1066 const char *wildcard, int wclen, int attr, struct smb_cred *scred)
1068 ctx->f_attrmask = attr;
1070 if (wclen == 1 && wildcard[0] == '*') {
1071 ctx->f_wildcard = "*.*";
1074 ctx->f_wildcard = wildcard;
1075 ctx->f_wclen = wclen;
1078 ctx->f_wildcard = NULL;
1081 ctx->f_name = ctx->f_fname;
1086 smbfs_findnextLM1(struct smbfs_fctx *ctx, int limit)
1088 struct mdchain *mbp;
1092 u_int16_t date, time;
1096 if (ctx->f_ecnt == 0) {
1097 if (ctx->f_flags & SMBFS_RDD_EOF)
1099 ctx->f_left = ctx->f_limit = limit;
1100 error = smbfs_smb_search(ctx);
1105 smb_rq_getreply(rqp, &mbp);
1106 md_get_mem(mbp, ctx->f_skey, SMB_SKEYLEN, MB_MSYSTEM);
1107 md_get_uint8(mbp, &battr);
1108 md_get_uint16le(mbp, &time);
1109 md_get_uint16le(mbp, &date);
1110 md_get_uint32le(mbp, &size);
1112 md_get_mem(mbp, cp, sizeof(ctx->f_fname), MB_MSYSTEM);
1113 cp[sizeof(ctx->f_fname) - 1] = 0;
1114 cp += strlen(cp) - 1;
1115 while (*cp == ' ' && cp >= ctx->f_name)
1117 ctx->f_attr.fa_attr = battr;
1118 smb_dos2unixtime(date, time, 0, rqp->sr_vc->vc_sopt.sv_tz,
1119 &ctx->f_attr.fa_mtime);
1120 ctx->f_attr.fa_size = size;
1121 ctx->f_nmlen = strlen(ctx->f_name);
1128 smbfs_findcloseLM1(struct smbfs_fctx *ctx)
1131 smb_rq_done(ctx->f_rq);
1136 * TRANS2_FIND_FIRST2/NEXT2, used for NT LM12 dialect
1139 smbfs_smb_trans2find2(struct smbfs_fctx *ctx)
1141 struct smb_t2rq *t2p;
1142 struct smb_vc *vcp = SSTOVC(ctx->f_ssp);
1143 struct mbchain *mbp;
1144 struct mdchain *mdp;
1145 u_int16_t tw, flags;
1149 smb_t2_done(ctx->f_t2);
1152 ctx->f_flags &= ~SMBFS_RDD_GOTRNAME;
1153 flags = 8 | 2; /* <resume> | <close if EOS> */
1154 if (ctx->f_flags & SMBFS_RDD_FINDSINGLE) {
1155 flags |= 1; /* close search after this request */
1156 ctx->f_flags |= SMBFS_RDD_NOCLOSE;
1158 if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
1159 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_FIRST2,
1160 ctx->f_scred, &t2p);
1164 mbp = &t2p->t2_tparam;
1166 mb_put_uint16le(mbp, ctx->f_attrmask);
1167 mb_put_uint16le(mbp, ctx->f_limit);
1168 mb_put_uint16le(mbp, flags);
1169 mb_put_uint16le(mbp, ctx->f_infolevel);
1170 mb_put_uint32le(mbp, 0);
1171 error = smbfs_fullpath(mbp, vcp, ctx->f_dnp, ctx->f_wildcard, ctx->f_wclen);
1175 error = smb_t2_alloc(SSTOCP(ctx->f_ssp), SMB_TRANS2_FIND_NEXT2,
1176 ctx->f_scred, &t2p);
1180 mbp = &t2p->t2_tparam;
1182 mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
1183 mb_put_uint16le(mbp, ctx->f_limit);
1184 mb_put_uint16le(mbp, ctx->f_infolevel);
1185 mb_put_uint32le(mbp, 0); /* resume key */
1186 mb_put_uint16le(mbp, flags);
1188 mb_put_mem(mbp, ctx->f_rname, strlen(ctx->f_rname) + 1, MB_MSYSTEM);
1190 mb_put_uint8(mbp, 0); /* resume file name */
1194 tv.tv_usec = 200 * 1000; /* 200ms */
1195 if (vcp->vc_flags & SMBC_WIN95) {
1197 * some implementations suggests to sleep here
1198 * for 200ms, due to the bug in the Win95.
1199 * I've didn't notice any problem, but put code
1202 pause("fix95", tvtohz(&tv));
1206 t2p->t2_maxpcount = 5 * 2;
1207 t2p->t2_maxdcount = vcp->vc_txmax;
1208 error = smb_t2_request(t2p);
1211 mdp = &t2p->t2_rparam;
1212 if (ctx->f_flags & SMBFS_RDD_FINDFIRST) {
1213 if ((error = md_get_uint16(mdp, &ctx->f_Sid)) != 0)
1215 ctx->f_flags &= ~SMBFS_RDD_FINDFIRST;
1217 if ((error = md_get_uint16le(mdp, &tw)) != 0)
1220 if ((error = md_get_uint16le(mdp, &tw)) != 0)
1223 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE;
1224 if ((error = md_get_uint16le(mdp, &tw)) != 0)
1226 if ((error = md_get_uint16le(mdp, &tw)) != 0)
1228 if (ctx->f_ecnt == 0) {
1229 ctx->f_flags |= SMBFS_RDD_EOF | SMBFS_RDD_NOCLOSE;
1232 ctx->f_rnameofs = tw;
1233 mdp = &t2p->t2_rdata;
1234 if (mdp->md_top == NULL) {
1235 printf("bug: ecnt = %d, but data is NULL (please report)\n", ctx->f_ecnt);
1238 if (mdp->md_top->m_len == 0) {
1239 printf("bug: ecnt = %d, but m_len = 0 and m_next = %p (please report)\n", ctx->f_ecnt,mbp->mb_top->m_next);
1247 smbfs_smb_findclose2(struct smbfs_fctx *ctx)
1249 struct smb_rq rq, *rqp = &rq;
1250 struct mbchain *mbp;
1253 error = smb_rq_init(rqp, SSTOCP(ctx->f_ssp), SMB_COM_FIND_CLOSE2, ctx->f_scred);
1256 smb_rq_getrequest(rqp, &mbp);
1258 mb_put_mem(mbp, (caddr_t)&ctx->f_Sid, 2, MB_MSYSTEM);
1262 error = smb_rq_simple(rqp);
1268 smbfs_findopenLM2(struct smbfs_fctx *ctx, struct smbnode *dnp,
1269 const char *wildcard, int wclen, int attr, struct smb_cred *scred)
1271 ctx->f_name = malloc(SMB_MAXFNAMELEN, M_SMBFSDATA, M_WAITOK);
1272 if (ctx->f_name == NULL)
1274 ctx->f_infolevel = SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_NTLM0_12 ?
1275 SMB_INFO_STANDARD : SMB_FIND_FILE_DIRECTORY_INFO;
1276 ctx->f_attrmask = attr;
1277 ctx->f_wildcard = wildcard;
1278 ctx->f_wclen = wclen;
1283 smbfs_findnextLM2(struct smbfs_fctx *ctx, int limit)
1285 struct mdchain *mbp;
1286 struct smb_t2rq *t2p;
1289 u_int16_t date, time, wattr;
1290 u_int32_t size, next, dattr;
1292 int error, svtz, cnt, fxsz, nmlen, recsz;
1294 if (ctx->f_ecnt == 0) {
1295 if (ctx->f_flags & SMBFS_RDD_EOF)
1297 ctx->f_left = ctx->f_limit = limit;
1298 error = smbfs_smb_trans2find2(ctx);
1303 mbp = &t2p->t2_rdata;
1304 svtz = SSTOVC(ctx->f_ssp)->vc_sopt.sv_tz;
1305 switch (ctx->f_infolevel) {
1306 case SMB_INFO_STANDARD:
1309 md_get_uint16le(mbp, &date);
1310 md_get_uint16le(mbp, &time); /* creation time */
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_atime);
1314 md_get_uint16le(mbp, &date);
1315 md_get_uint16le(mbp, &time); /* access time */
1316 smb_dos2unixtime(date, time, 0, svtz, &ctx->f_attr.fa_mtime);
1317 md_get_uint32le(mbp, &size);
1318 ctx->f_attr.fa_size = size;
1319 md_get_uint32(mbp, NULL); /* allocation size */
1320 md_get_uint16le(mbp, &wattr);
1321 ctx->f_attr.fa_attr = wattr;
1322 md_get_uint8(mbp, &tb);
1325 recsz = next = 24 + nmlen; /* docs misses zero byte at end */
1327 case SMB_FIND_FILE_DIRECTORY_INFO:
1328 md_get_uint32le(mbp, &next);
1329 md_get_uint32(mbp, NULL); /* file index */
1330 md_get_int64(mbp, NULL); /* creation time */
1331 md_get_int64le(mbp, &lint);
1332 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_atime);
1333 md_get_int64le(mbp, &lint);
1334 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_mtime);
1335 md_get_int64le(mbp, &lint);
1336 smb_time_NT2local(lint, svtz, &ctx->f_attr.fa_ctime);
1337 md_get_int64le(mbp, &lint); /* file size */
1338 ctx->f_attr.fa_size = lint;
1339 md_get_int64(mbp, NULL); /* real size (should use) */
1340 md_get_uint32le(mbp, &dattr); /* EA */
1341 ctx->f_attr.fa_attr = dattr;
1342 md_get_uint32le(mbp, &size); /* name len */
1344 recsz = next ? next : fxsz + size;
1347 SMBERROR("unexpected info level %d\n", ctx->f_infolevel);
1350 nmlen = min(size, SMB_MAXFNAMELEN);
1352 error = md_get_mem(mbp, cp, nmlen, MB_MSYSTEM);
1356 cnt = next - nmlen - fxsz;
1358 md_get_mem(mbp, NULL, cnt, MB_MSYSTEM);
1360 SMBERROR("out of sync\n");
1364 if (nmlen && cp[nmlen - 1] == 0)
1369 next = ctx->f_eofs + recsz;
1370 if (ctx->f_rnameofs && (ctx->f_flags & SMBFS_RDD_GOTRNAME) == 0 &&
1371 (ctx->f_rnameofs >= ctx->f_eofs && ctx->f_rnameofs < next)) {
1373 * Server needs a resume filename.
1375 if (ctx->f_rnamelen <= nmlen) {
1377 free(ctx->f_rname, M_SMBFSDATA);
1378 ctx->f_rname = malloc(nmlen + 1, M_SMBFSDATA, M_WAITOK);
1379 ctx->f_rnamelen = nmlen;
1381 bcopy(ctx->f_name, ctx->f_rname, nmlen);
1382 ctx->f_rname[nmlen] = 0;
1383 ctx->f_flags |= SMBFS_RDD_GOTRNAME;
1385 ctx->f_nmlen = nmlen;
1393 smbfs_findcloseLM2(struct smbfs_fctx *ctx)
1396 free(ctx->f_name, M_SMBFSDATA);
1398 smb_t2_done(ctx->f_t2);
1399 if ((ctx->f_flags & SMBFS_RDD_NOCLOSE) == 0)
1400 smbfs_smb_findclose2(ctx);
1405 smbfs_findopen(struct smbnode *dnp, const char *wildcard, int wclen, int attr,
1406 struct smb_cred *scred, struct smbfs_fctx **ctxpp)
1408 struct smbfs_fctx *ctx;
1411 ctx = malloc(sizeof(*ctx), M_SMBFSDATA, M_WAITOK);
1414 bzero(ctx, sizeof(*ctx));
1415 ctx->f_ssp = dnp->n_mount->sm_share;
1417 ctx->f_flags = SMBFS_RDD_FINDFIRST;
1418 ctx->f_scred = scred;
1419 if (SMB_DIALECT(SSTOVC(ctx->f_ssp)) < SMB_DIALECT_LANMAN2_0 ||
1420 (dnp->n_mount->sm_flags & SMBFS_MOUNT_NO_LONG)) {
1421 ctx->f_flags |= SMBFS_RDD_USESEARCH;
1422 error = smbfs_findopenLM1(ctx, dnp, wildcard, wclen, attr, scred);
1424 error = smbfs_findopenLM2(ctx, dnp, wildcard, wclen, attr, scred);
1426 smbfs_findclose(ctx, scred);
1433 smbfs_findnext(struct smbfs_fctx *ctx, int limit, struct smb_cred *scred)
1440 limit *= 4; /* imperical */
1441 ctx->f_scred = scred;
1443 if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
1444 error = smbfs_findnextLM1(ctx, limit);
1446 error = smbfs_findnextLM2(ctx, limit);
1449 if ((ctx->f_nmlen == 1 && ctx->f_name[0] == '.') ||
1450 (ctx->f_nmlen == 2 && ctx->f_name[0] == '.' &&
1451 ctx->f_name[1] == '.'))
1455 smbfs_fname_tolocal(SSTOVC(ctx->f_ssp), ctx->f_name, &ctx->f_nmlen,
1456 ctx->f_dnp->n_mount->sm_caseopt);
1457 ctx->f_attr.fa_ino = smbfs_getino(ctx->f_dnp, ctx->f_name, ctx->f_nmlen);
1462 smbfs_findclose(struct smbfs_fctx *ctx, struct smb_cred *scred)
1464 ctx->f_scred = scred;
1465 if (ctx->f_flags & SMBFS_RDD_USESEARCH) {
1466 smbfs_findcloseLM1(ctx);
1468 smbfs_findcloseLM2(ctx);
1470 free(ctx->f_rname, M_SMBFSDATA);
1471 free(ctx, M_SMBFSDATA);
1476 smbfs_smb_lookup(struct smbnode *dnp, const char *name, int nmlen,
1477 struct smbfattr *fap, struct smb_cred *scred)
1479 struct smbfs_fctx *ctx;
1482 if (dnp == NULL || (dnp->n_ino == 2 && name == NULL)) {
1483 bzero(fap, sizeof(*fap));
1484 fap->fa_attr = SMB_FA_DIR;
1488 if (nmlen == 1 && name[0] == '.') {
1489 error = smbfs_smb_lookup(dnp, NULL, 0, fap, scred);
1491 } else if (nmlen == 2 && name[0] == '.' && name[1] == '.') {
1492 error = smbfs_smb_lookup(VTOSMB(dnp->n_parent), NULL, 0, fap,
1494 printf("%s: knows NOTHING about '..'\n", __func__);
1497 error = smbfs_findopen(dnp, name, nmlen,
1498 SMB_FA_SYSTEM | SMB_FA_HIDDEN | SMB_FA_DIR, scred, &ctx);
1501 ctx->f_flags |= SMBFS_RDD_FINDSINGLE;
1502 error = smbfs_findnext(ctx, 1, scred);
1506 fap->fa_ino = dnp->n_ino;
1508 smbfs_findclose(ctx, scred);