| blob | faa04b380b6bba4c778c501e5d5347727cd51fef |
1 /*
2 Unix SMB/CIFS implementation.
3 Initial test for the smb2 client lib
4 Copyright (C) Volker Lendecke 2011
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
38 {
40 NTSTATUS status;
56 }
63 }
69 }
75 }
87 FILE_SHARE_READ|
88 FILE_SHARE_WRITE|
95 NULL,
96 NULL,
97 NULL,
98 NULL);
102 }
110 }
117 }
126 }
132 }
138 }
145 }
155 SEC_STD_SYNCHRONIZE|
156 SEC_DIR_LIST|
159 FILE_SHARE_READ|
160 FILE_SHARE_WRITE|
163 FILE_SYNCHRONOUS_IO_NONALERT|
168 NULL,
169 NULL,
170 NULL,
171 NULL);
175 }
185 }
192 }
199 saved_tid,
212 }
221 }
228 }
234 }
242 }
245 }
248 {
250 NTSTATUS status;
258 }
265 }
275 }
285 }
291 }
294 }
297 {
299 NTSTATUS status;
307 }
314 }
320 }
326 }
332 }
335 }
338 {
341 NTSTATUS status;
347 DATA_BLOB out_blob;
348 DATA_BLOB session_key;
359 }
366 }
372 }
378 }
390 FILE_SHARE_READ|
391 FILE_SHARE_WRITE|
398 NULL,
399 NULL,
400 NULL,
401 NULL);
405 }
413 }
420 }
429 }
435 }
441 }
443 /* prepare second session */
447 }
454 }
460 }
463 GENSEC_FEATURE_SESSION_KEY);
469 }
475 }
481 }
488 }
499 /* in_previous_session_id: */
505 }
511 }
519 }
526 }
535 /* in_previous_session_id: */
541 }
547 }
555 }
563 }
565 /* check file operation on the old client */
572 }
578 }
580 /*
581 * checking file operations without signing.
582 * on w2k8r2 at least, flush, read and write also work the same way,
583 * while create gives ACCESS_DENIED without signing
584 */
589 {
592 }
599 {
602 }
610 {
613 }
625 FILE_SHARE_READ|
626 FILE_SHARE_WRITE|
633 NULL,
634 NULL,
635 NULL,
636 NULL);
641 }
643 /* now grab the session key and try with signing */
646 session_key,
647 recv_iov);
651 }
653 /* the tid seems to be irrelevant at this stage */
659 {
662 }
669 {
672 }
680 {
683 }
695 FILE_SHARE_READ|
696 FILE_SHARE_WRITE|
703 NULL,
704 NULL,
705 NULL,
706 NULL);
709 {
712 }
714 /* now do a new tcon and test file calls again */
720 }
732 FILE_SHARE_READ|
733 FILE_SHARE_WRITE|
740 NULL,
741 NULL,
742 NULL,
743 NULL);
747 }
755 }
762 }
771 }
777 }
783 }
786 }
789 {
791 NTSTATUS status;
803 }
810 }
816 }
822 }
834 FILE_SHARE_READ|
835 FILE_SHARE_WRITE|
842 NULL,
843 NULL,
844 NULL,
845 NULL);
849 }
857 }
864 }
873 }
879 }
885 }
887 /* check behaviour with wrong tid... */
891 tcon2_id++;
894 tcon2_id,
907 }
912 }
915 {
919 NTSTATUS status;
925 DATA_BLOB out_blob;
926 DATA_BLOB channel_session_key;
940 }
944 }
948 }
957 }
964 }
971 }
977 }
983 }
993 }
999 }
1002 GENSEC_FEATURE_SESSION_KEY);
1008 }
1014 }
1020 }
1027 }
1041 }
1047 }
1055 }
1062 }
1076 }
1082 }
1090 }
1098 }
1101 channel_session_key,
1102 recv_iov);
1106 }
1116 }
1122 }
1125 GENSEC_FEATURE_SESSION_KEY);
1131 }
1137 }
1144 }
1158 }
1164 }
1172 }
1179 }
1193 }
1199 }
1207 }
1215 }
1218 channel_session_key,
1219 recv_iov);
1223 }
1235 FILE_SHARE_READ|
1236 FILE_SHARE_WRITE|
1243 NULL,
1244 NULL,
1245 NULL,
1246 NULL);
1250 }
1258 }
1265 }
1272 }
1279 }
1288 }
1294 }
1300 }
1306 }
1309 GENSEC_FEATURE_SESSION_KEY);
1315 }
1321 }
1328 }
1342 }
1348 }
1356 }
1363 }
1370 }
1377 }
1384 }
1396 FILE_SHARE_READ|
1397 FILE_SHARE_WRITE|
1404 NULL,
1405 NULL,
1406 NULL,
1407 NULL);
1411 }
1423 FILE_SHARE_READ|
1424 FILE_SHARE_WRITE|
1431 NULL,
1432 NULL,
1433 NULL,
1434 NULL);
1438 }
1450 FILE_SHARE_READ|
1451 FILE_SHARE_WRITE|
1458 NULL,
1459 NULL,
1460 NULL,
1461 NULL);
1465 }
1479 }
1485 }
1493 }
1500 }
1507 }
1514 }
1521 }
1524 }
1527 {
1529 NTSTATUS status;
1538 DATA_BLOB out_blob;
1539 DATA_BLOB in_input_buffer;
1540 DATA_BLOB out_output_buffer;
1551 }
1553 /*
1554 * PROTOCOL_SMB2_22 has a bug in win8pre0
1555 * it behaves like PROTOCOL_SMB2_02
1556 * and returns NT_STATUS_REQUEST_NOT_ACCEPTED,
1557 * while it allows it on PROTOCOL_SMB2_10.
1558 */
1564 }
1570 }
1576 }
1588 FILE_SHARE_READ|
1589 FILE_SHARE_WRITE|
1596 NULL,
1597 NULL,
1598 NULL,
1599 NULL);
1603 }
1613 SEC_STD_SYNCHRONIZE|
1614 SEC_DIR_LIST|
1617 FILE_SHARE_READ|
1618 FILE_SHARE_WRITE|
1621 FILE_SYNCHRONOUS_IO_NONALERT|
1626 NULL,
1627 NULL,
1628 NULL,
1629 NULL);
1633 }
1643 }
1649 }
1652 GENSEC_FEATURE_SESSION_KEY);
1658 }
1664 }
1670 }
1677 }
1691 }
1697 }
1705 }
1712 }
1719 }
1729 }
1731 /*
1732 * query_info seems to be a path based operation on Windows...
1733 */
1738 SMB2_0_INFO_SECURITY,
1744 fid_persistent,
1745 fid_volatile,
1751 }
1758 SMB2_0_INFO_FILE,
1759 in_file_info_class,
1764 fid_persistent,
1765 fid_volatile,
1771 }
1781 SMB2_0_INFO_FILE,
1782 in_file_info_class,
1785 fid_persistent,
1786 fid_volatile);
1790 }
1802 FILE_SHARE_READ|
1803 FILE_SHARE_WRITE|
1810 NULL,
1811 NULL,
1812 NULL,
1813 NULL);
1817 }
1827 SEC_STD_SYNCHRONIZE|
1828 SEC_DIR_LIST|
1831 FILE_SHARE_READ|
1832 FILE_SHARE_WRITE|
1835 FILE_SYNCHRONOUS_IO_NONALERT|
1840 NULL,
1841 NULL,
1842 NULL,
1843 NULL);
1847 }
1854 saved_tid,
1863 }
1879 }
1885 }
1893 }
1900 }
1906 SMB2_0_INFO_SECURITY,
1912 fid_persistent,
1913 fid_volatile,
1919 }
1926 SMB2_0_INFO_FILE,
1927 in_file_info_class,
1932 fid_persistent,
1933 fid_volatile,
1939 }
1949 SMB2_0_INFO_FILE,
1950 in_file_info_class,
1953 fid_persistent,
1954 fid_volatile);
1958 }
1965 SMB2_0_INFO_FILE,
1966 in_file_info_class,
1971 fid_persistent,
1972 fid_volatile,
1978 }
1985 }
1997 FILE_SHARE_READ|
1998 FILE_SHARE_WRITE|
2005 NULL,
2006 NULL,
2007 NULL,
2008 NULL);
2012 }
2022 }
2029 }
2036 }
2043 saved_tid,
2052 }
2057 }
2063 {
2067 fnum,
2068 NULL,
2070 NULL,
2071 NULL,
2072 NULL,
2073 NULL,
2074 NULL);
2078 fname,
2081 }
2087 fname);
2088 /* Use EOF to mean bad size. */
2090 }
2092 }
2094 /* Ensure cli_ftruncate() works for SMB2. */
2097 {
2105 NTSTATUS status;
2111 }
2118 }
2124 }
2130 }
2136 fname,
2138 GENERIC_ALL_ACCESS,
2139 FILE_ATTRIBUTE_NORMAL,
2140 FILE_SHARE_NONE,
2141 FILE_CREATE,
2145 NULL);
2150 }
2155 }
2157 /* Write 1MB. */
2159 fnum,
2161 buf,
2163 buflen,
2164 NULL);
2169 fname,
2172 }
2177 }
2179 /* Now ftruncate. */
2185 fname,
2188 }
2192 }
2193 }
2197 fail:
2201 }
2205 }
2211 }
2213 }
2215 /* Ensure SMB2 flush on directories behaves correctly. */
2218 {
2219 NTSTATUS status;
2224 /* Open directory - no write abilities. */
2230 path,
2233 SEC_STD_SYNCHRONIZE|
2234 SEC_DIR_LIST|
2237 FILE_SHARE_READ|
2238 FILE_SHARE_WRITE|
2241 FILE_SYNCHRONOUS_IO_NONALERT|
2246 NULL,
2247 NULL,
2248 NULL,
2249 NULL);
2252 path,
2255 }
2266 }
2268 /* Open directory no write access. Flush should fail. */
2276 }
2283 }
2285 /* Open directory write-attributes only. Flush should still fail. */
2292 path,
2295 SEC_STD_SYNCHRONIZE|
2296 SEC_DIR_LIST|
2297 SEC_DIR_WRITE_ATTRIBUTE|
2300 FILE_SHARE_READ|
2301 FILE_SHARE_WRITE|
2304 FILE_SYNCHRONOUS_IO_NONALERT|
2309 NULL,
2310 NULL,
2311 NULL,
2312 NULL);
2315 path,
2318 }
2328 }
2337 }
2344 }
2346 /* Open directory with SEC_DIR_ADD_FILE access. Flush should now succeed. */
2353 path,
2356 SEC_STD_SYNCHRONIZE|
2357 SEC_DIR_LIST|
2360 FILE_SHARE_READ|
2361 FILE_SHARE_WRITE|
2364 FILE_SYNCHRONOUS_IO_NONALERT|
2369 NULL,
2370 NULL,
2371 NULL,
2372 NULL);
2375 path,
2378 }
2388 }
2396 }
2403 }
2405 /* Open directory with SEC_DIR_ADD_FILE access. Flush should now succeed. */
2412 path,
2415 SEC_STD_SYNCHRONIZE|
2416 SEC_DIR_LIST|
2419 FILE_SHARE_READ|
2420 FILE_SHARE_WRITE|
2423 FILE_SYNCHRONOUS_IO_NONALERT|
2428 NULL,
2429 NULL,
2430 NULL,
2431 NULL);
2434 path,
2437 }
2447 }
2455 }
2462 }
2466 }
2469 {
2471 NTSTATUS status;
2479 }
2486 }
2492 }
2498 }
2504 dname,
2507 }
2509 /* Test on a subdirectory. */
2514 }
2517 /* Test on the root handle of a share. */
2521 }
2523 }
2526 {
2528 NTSTATUS status;
2542 }
2549 }
2555 }
2561 }
2568 /* Try to create a directory with the backslash name. */
2574 dname_backslash,
2579 FILE_SHARE_READ|
2580 FILE_SHARE_WRITE|
2587 NULL,
2588 NULL,
2589 NULL,
2590 NULL);
2592 /* directory ending in '\\' should be success. */
2597 dname_backslash,
2600 }
2606 fid_persistent,
2607 fid_volatile);
2611 }
2615 /* Try to create a directory with the slash name. */
2621 dname_slash,
2626 FILE_SHARE_READ|
2627 FILE_SHARE_WRITE|
2634 NULL,
2635 NULL,
2636 NULL,
2637 NULL);
2639 /* directory ending in '/' is an error. */
2643 dname_slash,
2651 fid_persistent,
2652 fid_volatile);
2653 }
2656 }
2660 /* Try to create a file with the backslash name. */
2666 fname_backslash,
2671 FILE_SHARE_READ|
2672 FILE_SHARE_WRITE|
2679 NULL,
2680 NULL,
2681 NULL,
2682 NULL);
2684 /* file ending in '\\' should be error. */
2689 fname_backslash,
2697 fid_persistent,
2698 fid_volatile);
2699 }
2702 }
2706 /* Try to create a file with the slash name. */
2712 fname_slash,
2717 FILE_SHARE_READ|
2718 FILE_SHARE_WRITE|
2725 NULL,
2726 NULL,
2727 NULL,
2728 NULL);
2730 /* file ending in '/' should be error. */
2735 fname_slash,
2743 fid_persistent,
2744 fid_volatile);
2745 }
2748 }
2752 }
2754 /*
2755 * NB. This can only work against a server where
2756 * the connecting user has been granted SeSecurityPrivilege.
2757 *
2758 * 1). Create a test file.
2759 * 2). Open with SEC_FLAG_SYSTEM_SECURITY *only*. ACCESS_DENIED -
2760 * NB. SMB2-only behavior.
2761 * 3). Open with SEC_FLAG_SYSTEM_SECURITY|FILE_WRITE_ATTRIBUTES.
2762 * 4). Write SACL. Should fail with ACCESS_DENIED (seems to need WRITE_DAC).
2763 * 5). Close (3).
2764 * 6). Open with SEC_FLAG_SYSTEM_SECURITY|SEC_STD_WRITE_DAC.
2765 * 7). Write SACL. Success.
2766 * 8). Close (4).
2767 * 9). Open with SEC_FLAG_SYSTEM_SECURITY|READ_ATTRIBUTES.
2768 * 10). Read SACL. Success.
2769 * 11). Read DACL. Should fail with ACCESS_DENIED (no READ_CONTROL).
2770 * 12). Close (9).
2771 */
2774 {
2776 NTSTATUS status;
2786 }
2790 PROTOCOL_SMB2_02,
2791 PROTOCOL_SMB3_11);
2795 }
2801 }
2807 }
2811 /* First create a file. */
2813 fname,
2815 GENERIC_ALL_ACCESS,
2816 FILE_ATTRIBUTE_NORMAL,
2817 FILE_SHARE_NONE,
2818 FILE_CREATE,
2822 NULL);
2826 fname,
2829 }
2834 /*
2835 * Now try to open with *only* SEC_FLAG_SYSTEM_SECURITY.
2836 * This should fail with NT_STATUS_ACCESS_DENIED - but
2837 * only against an SMB2 server. SMB1 allows this as tested
2838 * in SMB1-SYSTEM-SECURITY.
2839 */
2842 fname,
2844 SMB2_IMPERSONATION_IMPERSONATION,
2847 FILE_SHARE_READ|
2848 FILE_SHARE_WRITE|
2861 "This is the "
2865 }
2870 fname,
2873 }
2875 /*
2876 * Open with SEC_FLAG_SYSTEM_SECURITY|FILE_WRITE_ATTRIBUTES.
2877 */
2880 fname,
2882 SMB2_IMPERSONATION_IMPERSONATION,
2883 SEC_FLAG_SYSTEM_SECURITY|
2886 FILE_SHARE_READ|
2887 FILE_SHARE_WRITE|
2900 fname,
2903 }
2905 /* Create an SD with a SACL. */
2910 /* first ACE. */
2911 SID_WORLD,
2912 SEC_ACE_TYPE_SYSTEM_AUDIT,
2913 SEC_GENERIC_ALL,
2914 SEC_ACE_FLAG_FAILED_ACCESS,
2915 NULL);
2920 }
2922 /*
2923 * Write the SACL SD. This should fail
2924 * even though we have SEC_FLAG_SYSTEM_SECURITY,
2925 * as it seems to also need WRITE_DAC access.
2926 */
2928 fnum,
2930 sd_sacl);
2935 fname,
2938 }
2940 /* And close. */
2944 /*
2945 * Open with SEC_FLAG_SYSTEM_SECURITY|SEC_STD_WRITE_DAC.
2946 */
2949 fname,
2951 SMB2_IMPERSONATION_IMPERSONATION,
2952 SEC_FLAG_SYSTEM_SECURITY|
2955 FILE_SHARE_READ|
2956 FILE_SHARE_WRITE|
2969 fname,
2972 }
2974 /*
2975 * Write the SACL SD. This should now succeed
2976 * as we have both SEC_FLAG_SYSTEM_SECURITY
2977 * and WRITE_DAC access.
2978 */
2980 fnum,
2982 sd_sacl);
2987 fname,
2990 }
2992 /* And close. */
2996 /* We're done with the sacl we made. */
2999 /*
3000 * Now try to open with SEC_FLAG_SYSTEM_SECURITY|READ_ATTRIBUTES.
3001 * This gives us access to the SACL.
3002 */
3005 fname,
3007 SMB2_IMPERSONATION_IMPERSONATION,
3008 SEC_FLAG_SYSTEM_SECURITY|
3011 FILE_SHARE_READ|
3012 FILE_SHARE_WRITE|
3025 fname,
3028 }
3030 /* Try and read the SACL - should succeed. */
3036 fname,
3039 }
3043 /*
3044 * Try and read the DACL - should fail as we have
3045 * no READ_DAC access.
3046 */
3053 fname,
3056 }
3061 }
3069 fail:
3077 }
3081 }
3084 {
3086 NTSTATUS status;
3094 }
3098 PROTOCOL_SMB2_02,
3099 PROTOCOL_SMB3_11);
3103 }
3109 }
3115 }
3118 cli,
3121 SMB2_IMPERSONATION_IMPERSONATION,
3124 FILE_SHARE_READ|
3125 FILE_SHARE_WRITE|
3137 }
3145 }
3148 }
3151 {
3153 NTSTATUS status;
3164 }
3168 PROTOCOL_SMB2_02,
3169 PROTOCOL_SMB3_11);
3173 }
3179 }
3185 }
3187 /* Ensure file doesn't exist. */
3190 /* Create the file. */
3192 fname,
3194 GENERIC_ALL_ACCESS,
3195 FILE_ATTRIBUTE_NORMAL,
3196 FILE_SHARE_NONE,
3197 FILE_CREATE,
3201 NULL);
3205 fname,
3208 }
3210 /* Close the handle. */
3214 /* Create the stream. */
3216 sname,
3218 FILE_READ_DATA|
3219 SEC_STD_READ_CONTROL|
3220 SEC_STD_WRITE_DAC,
3221 FILE_ATTRIBUTE_NORMAL,
3222 FILE_SHARE_NONE,
3223 FILE_CREATE,
3227 NULL);
3231 sname,
3234 }
3236 /* Close the handle. */
3240 /*
3241 * Open the stream - for Samba this ensures
3242 * we prove we have a pathref fsp.
3243 */
3245 sname,
3247 FILE_READ_DATA|
3248 SEC_STD_READ_CONTROL|
3249 SEC_STD_WRITE_DAC,
3250 FILE_ATTRIBUTE_NORMAL,
3251 FILE_SHARE_NONE,
3252 FILE_OPEN,
3256 NULL);
3260 sname,
3263 }
3265 /* Read the security descriptor off the stream handle. */
3267 fnum,
3268 SECINFO_DACL,
3274 sname,
3277 }
3283 sname);
3285 }
3287 /*
3288 * Ensure it allows FILE_READ_DATA in the first ace.
3289 * It always should.
3290 */
3294 sname);
3296 }
3298 /* Remove FILE_READ_DATA from the first ace and set. */
3302 fnum,
3303 SECINFO_DACL,
3304 sd_dacl);
3308 sname,
3311 }
3315 /* Read again and check it changed. */
3317 fnum,
3318 SECINFO_DACL,
3324 sname,
3327 }
3333 sname);
3335 }
3337 /* FILE_READ_DATA should be gone from the first ace. */
3340 sname);
3342 }
3346 fail:
3351 }
3355 }
3360 {
3364 }
3366 }
3368 /*
3369 * Must be run against a share with "smbd async dosmode = yes".
3370 * Checks we can return DOS attriutes other than "N".
3371 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=14758
3372 */
3375 {
3377 NTSTATUS status;
3386 }
3390 PROTOCOL_SMB2_02,
3391 PROTOCOL_SMB3_11);
3395 }
3401 }
3407 }
3409 /* Ensure directory doesn't exist. */
3416 }
3419 dname,
3421 list_fn,
3426 }
3431 }
3435 fail:
3439 }
3441 /*
3442 * Test delete a directory fails if a file is created
3443 * in a directory after the delete on close is set.
3444 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=14892
3445 */
3448 {
3450 NTSTATUS status;
3461 }
3465 PROTOCOL_SMB2_02,
3466 PROTOCOL_SMB3_11);
3470 }
3476 }
3482 }
3484 /* Ensure directory doesn't exist. */
3486 fname,
3490 /* Create target directory. */
3492 dname,
3495 FILE_ATTRIBUTE_DIRECTORY,
3496 FILE_SHARE_READ|
3497 FILE_SHARE_WRITE|
3498 FILE_SHARE_DELETE,
3499 FILE_CREATE,
3500 FILE_DIRECTORY_FILE,
3503 NULL);
3506 dname,
3509 }
3511 /* Now set the delete on close bit. */
3516 dname,
3519 }
3521 /* Create file inside target directory. */
3522 /*
3523 * NB. On Windows this will return NT_STATUS_DELETE_PENDING. Only on
3524 * Samba will this succeed by default (the option "check parent
3525 * directory delete on close" configures behaviour), but we're using
3526 * this to test a race condition.
3527 */
3529 fname,
3531 FILE_READ_DATA,
3532 FILE_ATTRIBUTE_NORMAL,
3533 FILE_SHARE_READ|
3534 FILE_SHARE_WRITE|
3535 FILE_SHARE_DELETE,
3536 FILE_CREATE,
3540 NULL);
3543 fname,
3546 }
3550 /* Now the close should fail. */
3554 dname,
3557 }
3561 out:
3565 }
3569 }
3571 fname,
3575 }
3580 {
3586 }
3588 }
3590 /*
3591 * Test setting the delete on close bit on a directory
3592 * containing an unwritable file fails or succeeds
3593 * an a share set with "hide unwritable = yes"
3594 * depending on the setting of "delete veto files".
3595 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15023
3596 *
3597 * First version. With "delete veto files = yes"
3598 * setting the delete on close should succeed.
3599 */
3602 {
3604 NTSTATUS status;
3615 }
3619 PROTOCOL_SMB2_02,
3620 PROTOCOL_SMB3_11);
3624 }
3630 }
3636 }
3638 /* Ensure target directory is seen as empty. */
3640 list_dname,
3641 FILE_ATTRIBUTE_DIRECTORY |
3642 FILE_ATTRIBUTE_HIDDEN |
3643 FILE_ATTRIBUTE_SYSTEM,
3644 check_empty_fn,
3648 dname,
3651 }
3654 dname,
3655 list_count);
3657 }
3659 /* Open target directory. */
3661 dname,
3664 FILE_ATTRIBUTE_DIRECTORY,
3665 FILE_SHARE_READ|
3666 FILE_SHARE_WRITE|
3667 FILE_SHARE_DELETE,
3668 FILE_OPEN,
3669 FILE_DIRECTORY_FILE,
3672 NULL);
3675 dname,
3678 }
3680 /* Now set the delete on close bit. */
3685 dname,
3688 }
3692 out:
3697 }
3699 }
3701 /*
3702 * Test setting the delete on close bit on a directory
3703 * containing an unwritable file fails or succeeds
3704 * an a share set with "hide unwritable = yes"
3705 * depending on the setting of "delete veto files".
3706 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15023
3707 *
3708 * Second version. With "delete veto files = no"
3709 * setting the delete on close should fail.
3710 */
3713 {
3715 NTSTATUS status;
3726 }
3730 PROTOCOL_SMB2_02,
3731 PROTOCOL_SMB3_11);
3735 }
3741 }
3747 }
3749 /* Ensure target directory is seen as empty. */
3751 list_dname,
3752 FILE_ATTRIBUTE_DIRECTORY |
3753 FILE_ATTRIBUTE_HIDDEN |
3754 FILE_ATTRIBUTE_SYSTEM,
3755 check_empty_fn,
3759 dname,
3762 }
3765 dname,
3766 list_count);
3768 }
3770 /* Open target directory. */
3772 dname,
3775 FILE_ATTRIBUTE_DIRECTORY,
3776 FILE_SHARE_READ|
3777 FILE_SHARE_WRITE|
3778 FILE_SHARE_DELETE,
3779 FILE_OPEN,
3780 FILE_DIRECTORY_FILE,
3783 NULL);
3786 dname,
3789 }
3791 /* Now set the delete on close bit. */
3795 "%s returned NT_STATUS_OK "
3797 dname);
3799 }
3802 "%s returned %s "
3803 "(should have returned "
3805 dname,
3808 }
3812 out:
3817 }
3819 }
3821 /*
3822 * Open an SMB2 file readonly and return the inode number.
3823 */
3827 {
3828 NTSTATUS status;
3832 /*
3833 * Open the file.
3834 */
3839 pathname,
3842 SEC_STD_SYNCHRONIZE|
3843 SEC_FILE_READ_DATA|
3858 }
3860 /*
3861 * Get the inode.
3862 */
3867 SMB2_0_INFO_FILE,
3873 fid_persistent,
3874 fid_volatile,
3880 }
3887 fid_persistent,
3888 fid_volatile);
3890 }
3892 /*
3893 * Check an inode matches a given SMB2 path.
3894 */
3899 {
3901 NTSTATUS status;
3904 test_pathname,
3909 __func__,
3910 test_pathname,
3913 }
3918 __func__,
3919 match_pathname,
3920 ino_tomatch,
3921 test_pathname,
3922 test_ino);
3924 }
3926 }
3928 /*
3929 * Delete an SMB2 file on a DFS share.
3930 */
3933 {
3934 NTSTATUS status;
3938 DATA_BLOB inbuf;
3940 /*
3941 * Open the file.
3942 */
3947 pathname,
3950 SEC_STD_SYNCHRONIZE|
3965 }
3967 /*
3968 * Set delete on close.
3969 */
3982 fid_persistent,
3983 fid_volatile);
3986 }
3992 fid_persistent,
3993 fid_volatile);
3995 }
3997 /*
3998 * Rename or hardlink an SMB2 file on a DFS share.
3999 */
4005 {
4006 NTSTATUS status;
4007 DATA_BLOB inbuf;
4016 newname,
4020 }
4021 /*
4022 * W2K8 insists the dest name is not null terminated. Remove
4023 * the last 2 zero bytes and reduce the name length.
4024 */
4027 }
4031 /* Integer wrap check. */
4033 }
4035 /*
4036 * The Windows 10 SMB2 server has a minimum length
4037 * for a SMB2_FILE_RENAME_INFORMATION buffer of
4038 * 24 bytes. It returns NT_STATUS_INFO_LENGTH_MISMATCH
4039 * if the length is less.
4040 */
4045 }
4053 /* Hardlink. */
4055 }
4065 fid_persistent,
4066 fid_volatile);
4068 }
4074 {
4076 fid_persistent,
4077 fid_volatile,
4078 newname,
4080 }
4086 {
4088 fid_persistent,
4089 fid_volatile,
4090 newname,
4092 }
4094 /*
4095 * According to:
4097 * https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-fscc/dc9978d7-6299-4c5a-a22d-a039cdc716ea
4098 *
4099 * (Characters " \ / [ ] : | < > + = ; , * ?,
4100 * and control characters in range 0x00 through
4101 * 0x1F, inclusive, are illegal in a share name)
4102 *
4103 * But Windows server only checks in DFS sharenames ':'. All other
4104 * share names are allowed.
4105 */
4110 {
4117 /* Setup template pathname. */
4120 /* Test invalid control characters. */
4124 dfs_root_share_name,
4125 root_ino,
4126 test_path);
4129 }
4130 }
4132 /* Test explicit invalid characters. */
4136 /*
4137 * Only ':' is treated as an INVALID sharename
4138 * for a DFS SERVER\\SHARE path.
4139 */
4142 test_path,
4147 __FILE__,
4148 __LINE__,
4149 test_path,
4152 }
4155 dfs_root_share_name,
4156 root_ino,
4157 test_path);
4160 }
4161 }
4162 }
4164 }
4166 /*
4167 * "Raw" test of SMB2 paths to a DFS share.
4168 * We must use the lower level smb2cli_XXXX() interfaces,
4169 * not the cli_XXX() ones here as the ultimate goal is to fix our
4170 * cli_XXX() interfaces to work transparently over DFS.
4171 *
4172 * So here, we're testing the server code, not the client code.
4173 *
4174 * Passes cleanly against Windows.
4175 */
4178 {
4180 NTSTATUS status;
4195 }
4199 PROTOCOL_SMB2_02,
4200 PROTOCOL_SMB3_11);
4204 }
4210 }
4216 }
4218 /* Ensure this is a DFS share. */
4224 }
4230 }
4231 /*
4232 * Create the "official" DFS share root name.
4233 * No SMB2 paths can start with '\\'.
4234 */
4242 }
4244 /* Get the share root inode number. */
4246 dfs_root_share_name,
4250 __FILE__,
4251 __LINE__,
4252 dfs_root_share_name,
4255 }
4257 /*
4258 * Test the Windows algorithm for parsing DFS names.
4259 */
4260 /*
4261 * A single "SERVER" element should open and match the share root.
4262 */
4264 dfs_root_share_name,
4265 root_ino,
4269 __FILE__,
4270 __LINE__,
4273 }
4275 /*
4276 * An "" DFS empty server name should open and match the share root on
4277 * Windows 2008. Windows 2022 returns NT_STATUS_INVALID_PARAMETER
4278 * for a DFS empty server name.
4279 */
4284 /*
4285 * Windows 2008 - open succeeded. Proceed to
4286 * check ino number.
4287 */
4289 dfs_root_share_name,
4290 root_ino,
4294 __FILE__,
4295 __LINE__,
4298 }
4299 }
4301 /*
4302 * For Windows 2022 we expect to fail with
4303 * NT_STATUS_INVALID_PARAMETER. Anything else is
4304 * unexpected.
4305 */
4307 __FILE__,
4308 __LINE__,
4312 }
4313 /* A "BAD" server name should open and match the share root. */
4315 dfs_root_share_name,
4316 root_ino,
4320 __FILE__,
4321 __LINE__,
4324 }
4325 /*
4326 * A "BAD\\BAD" server and share name should open
4327 * and match the share root.
4328 */
4330 dfs_root_share_name,
4331 root_ino,
4335 __FILE__,
4336 __LINE__,
4339 }
4340 /*
4341 * Trying to open "BAD\\BAD\\BAD" should get
4342 * NT_STATUS_OBJECT_NAME_NOT_FOUND.
4343 */
4350 __FILE__,
4351 __LINE__,
4355 }
4356 /*
4357 * Trying to open "BAD\\BAD\\BAD\\BAD" should get
4358 * NT_STATUS_OBJECT_PATH_NOT_FOUND.
4359 */
4366 __FILE__,
4367 __LINE__,
4371 }
4372 /*
4373 * Test for invalid pathname characters in the servername.
4374 * They are ignored, and it still opens the share root.
4375 */
4377 dfs_root_share_name,
4378 root_ino,
4382 __FILE__,
4383 __LINE__,
4386 }
4388 /*
4389 * Test for invalid pathname characters in the sharename.
4390 * Invalid sharename characters should still be flagged as
4391 * NT_STATUS_OBJECT_NAME_INVALID. It turns out only ':'
4392 * is considered an invalid sharename character.
4393 */
4395 dfs_root_share_name,
4396 root_ino);
4399 }
4401 /* Now create a file called "file". */
4409 SEC_STD_SYNCHRONIZE|
4410 SEC_STD_DELETE |
4411 SEC_FILE_READ_DATA|
4426 __FILE__,
4427 __LINE__,
4431 }
4433 /*
4434 * Trying to open "BAD\\BAD\\file" should now get
4435 * a valid inode.
4436 */
4443 __FILE__,
4444 __LINE__,
4448 }
4450 /*
4451 * Now show that renames use relative,
4452 * not full DFS paths.
4453 */
4455 /* Full DFS path should fail. */
4457 fid_persistent,
4458 fid_volatile,
4463 __FILE__,
4464 __LINE__,
4469 }
4470 /* Relative DFS path should succeed. */
4472 fid_persistent,
4473 fid_volatile,
4478 __FILE__,
4479 __LINE__,
4484 }
4486 /*
4487 * Trying to open "BAD\\BAD\\renamed_file" should now get
4488 * a valid inode.
4489 */
4496 __FILE__,
4497 __LINE__,
4501 }
4503 /*
4504 * Now show that hard links use relative,
4505 * not full DFS paths.
4506 */
4508 /* Full DFS path should fail. */
4510 fid_persistent,
4511 fid_volatile,
4516 __FILE__,
4517 __LINE__,
4522 }
4523 /* Relative DFS path should succeed. */
4525 fid_persistent,
4526 fid_volatile,
4531 __FILE__,
4532 __LINE__,
4537 }
4539 /*
4540 * Trying to open "BAD\\BAD\\hlink" should now get
4541 * a valid inode.
4542 */
4549 __FILE__,
4550 __LINE__,
4554 }
4558 err:
4566 fid_persistent,
4567 fid_volatile);
4568 }
4569 /* Delete anything we made. */
4575 }
4577 /*
4578 * Add a test that sends DFS paths and sets the
4579 * SMB2 flag FLAGS2_DFS_PATHNAMES, but to a non-DFS
4580 * share. Windows passes this (it just treats the
4581 * pathnames as non-DFS and ignores the FLAGS2_DFS_PATHNAMES
4582 * bit).
4583 */
4586 {
4588 NTSTATUS status;
4599 }
4603 PROTOCOL_SMB2_02,
4604 PROTOCOL_SMB3_11);
4608 }
4614 }
4620 }
4627 }
4628 /* Ensure this is *NOT* a DFS share. */
4634 }
4635 /*
4636 * Force the share to be DFS, as far as the client
4637 * is concerned.
4638 */
4645 SMB2_SHARE_CAP_DFS,
4648 /* Come up with a "valid" SMB2 DFS name. */
4656 }
4658 /* Now try create dfs_filename. */
4663 dfs_filename,
4666 SEC_STD_SYNCHRONIZE|
4667 SEC_STD_DELETE |
4668 SEC_FILE_READ_DATA|
4681 /*
4682 * Should fail with NT_STATUS_OBJECT_PATH_NOT_FOUND, as
4683 * even though we set the FLAGS2_DFS_PATHNAMES the server
4684 * knows this isn't a DFS share and so treats BAD\\BAD as
4685 * part of the filename.
4686 */
4690 __FILE__,
4691 __LINE__,
4692 dfs_filename,
4695 }
4696 /*
4697 * Prove we can still use non-DFS pathnames, even though
4698 * we are setting the FLAGS2_DFS_PATHNAMES in the SMB2
4699 * request.
4700 */
4708 SEC_STD_SYNCHRONIZE|
4709 SEC_STD_DELETE |
4710 SEC_FILE_READ_DATA|
4725 __FILE__,
4726 __LINE__,
4730 }
4734 err:
4739 }
4741 /*
4742 * Add a test that sends a non-DFS path and does not set the
4743 * SMB2 flag FLAGS2_DFS_PATHNAMES to a DFS
4744 * share. Windows passes this (it just treats the
4745 * pathnames as non-DFS).
4746 */
4749 {
4751 NTSTATUS status;
4764 }
4768 PROTOCOL_SMB2_02,
4769 PROTOCOL_SMB3_11);
4773 }
4779 }
4785 }
4792 }
4793 /* Ensure this is a DFS share. */
4799 }
4800 /* Come up with a "valid" SMB2 DFS name. */
4808 }
4810 /* Get the root of the share ino. */
4816 __FILE__,
4817 __LINE__,
4821 }
4823 /* Create a dfs_filename. */
4828 dfs_filename,
4831 SEC_STD_SYNCHRONIZE|
4832 SEC_STD_DELETE |
4833 SEC_FILE_READ_DATA|
4848 __FILE__,
4849 __LINE__,
4850 dfs_filename,
4853 }
4855 /* Close the handle we just opened. */
4861 fid_persistent,
4862 fid_volatile);
4867 /*
4868 * Force the share to be non-DFS, as far as the client
4869 * is concerned.
4870 */
4880 /*
4881 * Prove we can still use non-DFS pathnames on a DFS
4882 * share so long as we don't set the FLAGS2_DFS_PATHNAMES
4883 * in the SMB2 request.
4884 */
4892 SEC_STD_SYNCHRONIZE|
4893 SEC_STD_DELETE |
4894 SEC_FILE_READ_DATA|
4909 __FILE__,
4910 __LINE__,
4914 }
4916 /*
4917 * Show that now we're using non-DFS pathnames
4918 * on a DFS share, "" opens the root of the share.
4919 */
4922 root_ino,
4926 __FILE__,
4927 __LINE__,
4930 }
4934 err:
4942 fid_persistent,
4943 fid_volatile);
4944 }
4948 }
4950 /*
4951 * "Raw" test of an SMB2 filename with one or more leading
4952 * backslash characters to a DFS share.
4953 *
4954 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15277
4955 *
4956 * Once the server passes SMB2-DFS-PATHS we can
4957 * fold this test into that one.
4958 *
4959 * Passes cleanly against Windows.
4960 */
4963 {
4965 NTSTATUS status;
4979 }
4983 PROTOCOL_SMB2_02,
4984 PROTOCOL_SMB3_11);
4988 }
4994 }
5000 }
5002 /* Ensure this is a DFS share. */
5008 }
5014 }
5016 /*
5017 * Create the filename with one leading backslash.
5018 */
5026 }
5028 /*
5029 * Create the filename with many leading backslashes.
5030 */
5038 }
5040 /*
5041 * Trying to open "\\server\\share\\file" should get
5042 * NT_STATUS_OBJECT_NAME_NOT_FOUND.
5043 */
5045 dfs_filename_slash,
5050 __FILE__,
5051 __LINE__,
5052 dfs_filename_slash,
5055 }
5057 /* Now create a file called "\\server\\share\\file". */
5062 dfs_filename_slash,
5065 SEC_STD_SYNCHRONIZE|
5066 SEC_STD_DELETE |
5067 SEC_FILE_READ_DATA|
5082 __FILE__,
5083 __LINE__,
5084 dfs_filename_slash,
5087 }
5089 /*
5090 * Trying to open "\\server\\share\\file" should now get
5091 * a valid inode.
5092 */
5094 dfs_filename_slash,
5099 __FILE__,
5100 __LINE__,
5101 dfs_filename_slash,
5104 }
5106 /*
5107 * Trying to open "\\\\\\server\\share\\file" should now get
5108 * a valid inode that matches. MacOSX-style of DFS name test.
5109 */
5111 dfs_filename_slash,
5112 file_ino,
5113 dfs_filename_slash_multi);
5116 __FILE__,
5117 __LINE__,
5118 dfs_filename_slash_multi);
5120 }
5124 err:
5132 fid_persistent,
5133 fid_volatile);
5134 }
5135 /* Delete anything we made. */
5138 }
5140 /*
5141 * Ensure a named pipe async read followed by a disconnect
5142 * doesn't crash the server (server crash checked for in
5143 * containing test script:
5144 * source3/script/tests/test_smbtorture_nocrash_s3.sh)
5145 * BUG: https://bugzilla.samba.org/show_bug.cgi?id=15423
5146 */
5149 {
5151 NTSTATUS status;
5162 }
5166 PROTOCOL_SMB2_02,
5167 PROTOCOL_SMB3_11);
5171 }
5177 }
5184 }
5186 /* Open the SAMR pipe. */
5194 SEC_STD_SYNCHRONIZE|
5195 SEC_FILE_READ_DATA|
5210 __FILE__,
5211 __LINE__,
5214 }
5219 }
5221 /* Start an async read. */
5223 ev,
5230 fid_persistent,
5231 fid_volatile,
5236 }
5238 /* Force disconnect. */
5243 err:
5251 fid_persistent,
5252 fid_volatile);
5253 }
5255 }
5258 {
5260 NTSTATUS status;
5270 }
5274 PROTOCOL_SMB2_02,
5275 PROTOCOL_SMB3_11);
5279 }
5285 }
5291 }
5293 /* Try and connect to an unknown pipename. */
5298 unknown_pipe,
5301 SEC_STD_SYNCHRONIZE|
5302 SEC_FILE_READ_DATA|
5303 SEC_FILE_WRITE_DATA|
5316 /* We should get NT_STATUS_OBJECT_NAME_NOT_FOUND */
5319 __FILE__,
5320 __LINE__,
5321 unknown_pipe,
5324 }
5326 /* Try and connect to an invalid pipename containing unix separators. */
5331 invalid_pipe,
5334 SEC_STD_SYNCHRONIZE|
5335 SEC_FILE_READ_DATA|
5336 SEC_FILE_WRITE_DATA|
5349 /*
5350 * We should still get NT_STATUS_OBJECT_NAME_NOT_FOUND
5351 * (tested against Windows 2022).
5352 */
5355 __FILE__,
5356 __LINE__,
5357 invalid_pipe,
5360 }
5362 }