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