1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2018 Nexenta Systems, Inc. All rights reserved. 24 * Copyright 2022 RackTop Systems, Inc. 25 */ 26 27 /* 28 * Volume Copy Shadow Services (VSS) provides a way for users to 29 * restore/recover deleted files/directories. 30 * For the server to support VSS for Microsoft clients, there is 31 * two basic functions that need to be implemented. 32 * The first is to intercept the NT_TRANSACT_IOCTL command with 33 * the function code of FSCTL_SRV_ENUMERATE_SNAPSHOTS (0x00144064). 34 * This is to report the count or the count and list of snapshots 35 * for that share. 36 * The second function need to trap commands with the 37 * SMB_FLAGS2_REPARSE_PATH bit set in the smb header. This bit 38 * means that there is a @GMT token in path that needs to be 39 * processed. The @GMT token means to process this command, but 40 * in the snapshot. 41 */ 42 43 #include <smbsrv/smb_kproto.h> 44 #include <smbsrv/string.h> 45 #include <smb/winioctl.h> 46 #include <smbsrv/smb_door.h> 47 48 /* Size of the token on the wire due to encoding */ 49 #define SMB_VSS_GMT_NET_SIZE(sr) (smb_ascii_or_unicode_null_len(sr) * \ 50 SMB_VSS_GMT_SIZE) 51 52 #define SMB_VSS_COUNT_SIZE 16 53 54 static boolean_t smb_vss_is_gmttoken(const char *); 55 static const char *smb_vss_find_gmttoken(const char *); 56 static uint32_t smb_vss_encode_gmttokens(smb_request_t *, smb_fsctl_t *, 57 int32_t, smb_gmttoken_response_t *); 58 static void smb_vss_remove_first_token_from_path(char *); 59 60 static uint32_t smb_vss_get_count(smb_tree_t *, char *); 61 static void smb_vss_map_gmttoken(smb_tree_t *, char *, char *, time_t, char *); 62 static void smb_vss_get_snapshots(smb_tree_t *, char *, 63 uint32_t, smb_gmttoken_response_t *); 64 static void smb_vss_get_snapshots_free(smb_gmttoken_response_t *); 65 static int smb_vss_lookup_node(smb_request_t *sr, smb_node_t *, vnode_t *, 66 char *, smb_node_t *, smb_node_t **); 67 68 /* 69 * This is to respond to the nt_transact_ioctl to either respond with the 70 * number of snapshots, or to respond with the list. It needs to be sorted 71 * before the reply. If the the max data bytes to return is 72 * SMB_VSS_COUNT_SIZE, then all that is requested is the count, otherwise 73 * return the count and the list of @GMT tokens (one token for each 74 * snapshot). 75 */ 76 uint32_t 77 smb_vss_enum_snapshots(smb_request_t *sr, smb_fsctl_t *fsctl) 78 { 79 uint32_t count = 0; 80 char *root_path; 81 uint32_t status = NT_STATUS_SUCCESS; 82 smb_gmttoken_response_t snaps; 83 84 ASSERT(sr->fid_ofile); 85 ASSERT(sr->fid_ofile->f_node); 86 87 if (fsctl->MaxOutputResp < SMB_VSS_COUNT_SIZE) 88 return (NT_STATUS_INVALID_PARAMETER); 89 90 /* 91 * smbd will find the root of the lowest filesystem from mntpath of a 92 * file by comparing it agaisnt mnttab, repeatedly removing components 93 * until one matches. 94 */ 95 root_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP); 96 if (smb_node_getmntpath(sr->fid_ofile->f_node, root_path, 97 MAXPATHLEN) != 0) 98 return (NT_STATUS_INVALID_PARAMETER); 99 100 if (fsctl->MaxOutputResp == SMB_VSS_COUNT_SIZE) { 101 count = smb_vss_get_count(sr->tid_tree, root_path); 102 if (smb_mbc_encodef(fsctl->out_mbc, "lllw", count, 0, 103 (count * SMB_VSS_GMT_NET_SIZE(sr) + 104 smb_ascii_or_unicode_null_len(sr)), 0) != 0) { 105 status = NT_STATUS_INVALID_PARAMETER; 106 } 107 } else { 108 count = fsctl->MaxOutputResp / SMB_VSS_GMT_NET_SIZE(sr); 109 110 smb_vss_get_snapshots(sr->tid_tree, root_path, 111 count, &snaps); 112 113 status = smb_vss_encode_gmttokens(sr, fsctl, count, &snaps); 114 115 smb_vss_get_snapshots_free(&snaps); 116 } 117 118 kmem_free(root_path, MAXPATHLEN); 119 return (status); 120 } 121 122 /* 123 * sr - the request info, used to find root of dataset, 124 * unicode or ascii, where the share is rooted in the 125 * dataset 126 * cur_node - where in the share for the command 127 * vss_cur_node - returned value for the snapshot version 128 * of the cur_node 129 * gmttoken - if SMB1, the gmttoken to be used to find the snapshot. 130 * Otherwise, NULL. 131 * 132 * This routine is the processing for handling the 133 * SMB_FLAGS2_REPARSE_PATH bit being set in the smb header. 134 * 135 * By using the cur_node passed in, a new node is found or 136 * created that is the same place in the directory tree, but 137 * in the snapshot. 138 */ 139 int 140 smb_vss_lookup_nodes(smb_request_t *sr, smb_node_t *cur_node, 141 smb_node_t **vss_cur_node, char *gmttoken) 142 { 143 smb_arg_open_t *op = &sr->arg.open; 144 char *snapname, *path; 145 vnode_t *fsrootvp = NULL; 146 time_t toktime; 147 int err = 0; 148 149 if (sr->tid_tree == NULL) 150 return (ESTALE); 151 152 if (gmttoken != NULL) { 153 toktime = 0; 154 } else { 155 /* SMB2 and later */ 156 toktime = op->timewarp.tv_sec; 157 } 158 159 path = smb_srm_alloc(sr, MAXPATHLEN); 160 snapname = smb_srm_alloc(sr, MAXPATHLEN); 161 162 err = smb_node_getmntpath(cur_node, path, MAXPATHLEN); 163 if (err != 0) 164 return (err); 165 166 /* 167 * Find the corresponding snapshot name. If snapname is 168 * empty after the map call, no such snapshot was found. 169 */ 170 *snapname = '\0'; 171 smb_vss_map_gmttoken(sr->tid_tree, path, gmttoken, toktime, 172 snapname); 173 if (*snapname == '\0') 174 return (ENOENT); 175 176 /* find snapshot nodes */ 177 err = VFS_ROOT(cur_node->vp->v_vfsp, &fsrootvp); 178 if (err != 0) 179 return (err); 180 181 /* find snapshot node corresponding to cur_node */ 182 err = smb_vss_lookup_node(sr, cur_node, fsrootvp, 183 snapname, cur_node, vss_cur_node); 184 185 VN_RELE(fsrootvp); 186 187 return (err); 188 } 189 190 /* 191 * Find snapshot node corresponding to 'node', and return it in 192 * 'vss_node', as follows: 193 * - find the path from fsrootvp to node, appending it to the 194 * the snapshot path 195 * - lookup the vnode and smb_node (vss_node). 196 */ 197 static int 198 smb_vss_lookup_node(smb_request_t *sr, smb_node_t *node, vnode_t *fsrootvp, 199 char *snapname, smb_node_t *dnode, smb_node_t **vss_node) 200 { 201 char *p, *path; 202 int err, len; 203 vnode_t *vp = NULL; 204 205 *vss_node = NULL; 206 207 path = kmem_alloc(MAXPATHLEN, KM_SLEEP); 208 (void) snprintf(path, MAXPATHLEN, ".zfs/snapshot/%s/", snapname); 209 len = strlen(path); 210 p = path + len; 211 212 err = smb_node_getpath(node, fsrootvp, p, MAXPATHLEN - len); 213 if (err == 0) { 214 vp = smb_lookuppathvptovp(sr, path, fsrootvp, fsrootvp); 215 if (vp) { 216 *vss_node = smb_node_lookup(sr, NULL, zone_kcred(), 217 vp, snapname, dnode, NULL); 218 VN_RELE(vp); 219 } 220 } 221 222 kmem_free(path, MAXPATHLEN); 223 224 if (*vss_node != NULL) 225 return (0); 226 227 return (err ? err : ENOENT); 228 } 229 230 231 static boolean_t 232 smb_vss_is_gmttoken(const char *s) 233 { 234 char *t = "@GMT-NNNN.NN.NN-NN.NN.NN"; 235 const char *str; 236 char *template; 237 238 template = t; 239 str = s; 240 241 while (*template) { 242 if (*template == 'N') { 243 if (!smb_isdigit(*str)) 244 return (B_FALSE); 245 } else if (*template != *str) { 246 return (B_FALSE); 247 } 248 249 template++; 250 str++; 251 } 252 253 /* Make sure it is JUST the @GMT token */ 254 if ((*str == '\0') || (*str == '/')) 255 return (B_TRUE); 256 257 return (B_FALSE); 258 } 259 260 static const char * 261 smb_vss_find_gmttoken(const char *path) 262 { 263 const char *p; 264 265 p = path; 266 267 while (*p) { 268 if (*p == '@' && smb_vss_is_gmttoken(p)) 269 return (p); 270 p++; 271 } 272 return (NULL); 273 } 274 275 static uint32_t 276 smb_vss_encode_gmttokens(smb_request_t *sr, smb_fsctl_t *fsctl, 277 int32_t count, smb_gmttoken_response_t *snap_data) 278 { 279 uint32_t i; 280 uint32_t returned_count; 281 uint32_t num_gmttokens; 282 char **gmttokens; 283 uint32_t status = NT_STATUS_SUCCESS; 284 uint32_t data_size; 285 286 returned_count = snap_data->gtr_count; 287 num_gmttokens = snap_data->gtr_gmttokens.gtr_gmttokens_len; 288 gmttokens = snap_data->gtr_gmttokens.gtr_gmttokens_val; 289 290 if (returned_count > count) 291 status = NT_STATUS_BUFFER_TOO_SMALL; 292 293 data_size = returned_count * SMB_VSS_GMT_NET_SIZE(sr) + 294 smb_ascii_or_unicode_null_len(sr); 295 296 if (smb_mbc_encodef(fsctl->out_mbc, "lll", returned_count, 297 num_gmttokens, data_size) != 0) 298 return (NT_STATUS_INVALID_PARAMETER); 299 300 if (status == NT_STATUS_SUCCESS) { 301 for (i = 0; i < num_gmttokens; i++) { 302 if (smb_mbc_encodef(fsctl->out_mbc, "%u", sr, 303 *gmttokens) != 0) 304 status = NT_STATUS_INVALID_PARAMETER; 305 gmttokens++; 306 } 307 // WPTS says there should be a final unicode null. 308 (void) smb_mbc_encodef(fsctl->out_mbc, ".."); 309 } 310 311 return (status); 312 } 313 314 /* This removes the first @GMT from the path */ 315 static void 316 smb_vss_remove_first_token_from_path(char *path) 317 { 318 boolean_t found; 319 char *src, *dest; 320 321 src = path; 322 dest = path; 323 324 found = B_FALSE; 325 326 while (*src != '\0') { 327 if (!found && smb_vss_is_gmttoken(src)) { 328 src += SMB_VSS_GMT_SIZE - 1; 329 if (*src == '/') 330 src += 1; 331 found = B_TRUE; 332 continue; 333 } 334 *dest = *src; 335 src++; 336 dest++; 337 } 338 *dest = *src; 339 } 340 341 /* 342 * This returns the number of snapshots for the dataset 343 * of the path provided. 344 */ 345 static uint32_t 346 smb_vss_get_count(smb_tree_t *tree, char *resource_path) 347 { 348 uint32_t count = 0; 349 int rc; 350 smb_string_t path; 351 352 path.buf = resource_path; 353 354 rc = smb_kdoor_upcall(tree->t_server, SMB_DR_VSS_GET_COUNT, 355 &path, smb_string_xdr, &count, xdr_uint32_t); 356 357 if (rc != 0) 358 count = 0; 359 360 return (count); 361 } 362 363 /* 364 * This takes a path for the root of the dataset and gets the counts of 365 * snapshots for that dataset and the list of @GMT tokens (one for each 366 * snapshot) up to the count provided. 367 * 368 * Call smb_vss_get_snapshots_free after to free up the data. 369 */ 370 static void 371 smb_vss_get_snapshots(smb_tree_t *tree, char *resource_path, 372 uint32_t count, smb_gmttoken_response_t *gmttokens) 373 { 374 smb_gmttoken_query_t request; 375 376 request.gtq_count = count; 377 request.gtq_path = resource_path; 378 bzero(gmttokens, sizeof (smb_gmttoken_response_t)); 379 380 (void) smb_kdoor_upcall(tree->t_server, SMB_DR_VSS_GET_SNAPSHOTS, 381 &request, smb_gmttoken_query_xdr, 382 gmttokens, smb_gmttoken_response_xdr); 383 } 384 385 static void 386 smb_vss_get_snapshots_free(smb_gmttoken_response_t *reply) 387 { 388 xdr_free(smb_gmttoken_response_xdr, (char *)reply); 389 } 390 391 /* 392 * Returns the snapshot name for the @GMT token provided for the dataset 393 * of the path. If the snapshot cannot be found, a string with a NULL 394 * is returned. 395 */ 396 static void 397 smb_vss_map_gmttoken(smb_tree_t *tree, char *path, char *gmttoken, 398 time_t toktime, char *snapname) 399 { 400 smb_gmttoken_snapname_t request; 401 smb_string_t result; 402 403 bzero(&result, sizeof (smb_string_t)); 404 result.buf = snapname; 405 406 request.gts_path = path; 407 request.gts_gmttoken = gmttoken; 408 request.gts_toktime = toktime; 409 410 (void) smb_kdoor_upcall(tree->t_server, SMB_DR_VSS_MAP_GMTTOKEN, 411 &request, smb_gmttoken_snapname_xdr, 412 &result, smb_string_xdr); 413 } 414 415 int 416 smb_vss_extract_gmttoken(char *buf, char *gmttoken) 417 { 418 const char *p; 419 420 /* get gmttoken from buf */ 421 if ((p = smb_vss_find_gmttoken(buf)) == NULL) 422 return (ENOENT); 423 424 bcopy(p, gmttoken, SMB_VSS_GMT_SIZE); 425 gmttoken[SMB_VSS_GMT_SIZE - 1] = '\0'; 426 427 smb_vss_remove_first_token_from_path(buf); 428 429 return (0); 430 } 431