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