Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : Main metadata server / Spotlight client functions
4 :
5 : Copyright (C) Ralph Boehme 2019
6 :
7 : This program is free software; you can redistribute it and/or modify
8 : it under the terms of the GNU General Public License as published by
9 : the Free Software Foundation; either version 3 of the License, or
10 : (at your option) any later version.
11 :
12 : This program is distributed in the hope that it will be useful,
13 : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : GNU General Public License for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with this program. If not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : #include "includes.h"
22 : #include "rpc_client.h"
23 : #include "librpc/gen_ndr/mdssvc.h"
24 : #include "cli_mdssvc.h"
25 : #include "cli_mdssvc_private.h"
26 : #include "cli_mdssvc_util.h"
27 : #include "lib/util/tevent_ntstatus.h"
28 : #include "rpc_server/mdssvc/dalloc.h"
29 : #include "rpc_server/mdssvc/marshalling.h"
30 :
31 10 : NTSTATUS mdscli_blob_fetch_props(TALLOC_CTX *mem_ctx,
32 : struct mdscli_ctx *ctx,
33 : struct mdssvc_blob *blob)
34 : {
35 10 : DALLOC_CTX *d = NULL;
36 10 : uint64_t *uint64p = NULL;
37 10 : sl_array_t *array = NULL;
38 10 : sl_array_t *cmd_array = NULL;
39 : NTSTATUS status;
40 : int ret;
41 :
42 10 : d = dalloc_new(mem_ctx);
43 10 : if (d == NULL) {
44 0 : return NT_STATUS_NO_MEMORY;
45 : }
46 :
47 10 : array = dalloc_zero(d, sl_array_t);
48 10 : if (array == NULL) {
49 0 : TALLOC_FREE(d);
50 0 : return NT_STATUS_NO_MEMORY;
51 : }
52 :
53 10 : ret = dalloc_add(d, array, sl_array_t);
54 10 : if (ret != 0) {
55 0 : TALLOC_FREE(d);
56 0 : return NT_STATUS_NO_MEMORY;
57 : }
58 :
59 10 : cmd_array = dalloc_zero(d, sl_array_t);
60 10 : if (cmd_array == NULL) {
61 0 : TALLOC_FREE(d);
62 0 : return NT_STATUS_NO_MEMORY;
63 : }
64 :
65 10 : ret = dalloc_add(array, cmd_array, sl_array_t);
66 10 : if (ret != 0) {
67 0 : TALLOC_FREE(d);
68 0 : return NT_STATUS_NO_MEMORY;
69 : }
70 :
71 10 : ret = dalloc_stradd(cmd_array, "fetchPropertiesForContext:");
72 10 : if (ret != 0) {
73 0 : TALLOC_FREE(d);
74 0 : return NT_STATUS_NO_MEMORY;
75 : }
76 :
77 10 : uint64p = talloc_zero_array(cmd_array, uint64_t, 2);
78 10 : if (uint64p == NULL) {
79 0 : TALLOC_FREE(d);
80 0 : return NT_STATUS_NO_MEMORY;
81 : }
82 :
83 10 : talloc_set_name(uint64p, "uint64_t *");
84 :
85 10 : ret = dalloc_add(cmd_array, uint64p, uint64_t *);
86 10 : if (ret != 0) {
87 0 : TALLOC_FREE(d);
88 0 : return NT_STATUS_NO_MEMORY;
89 : }
90 :
91 10 : status = sl_pack_alloc(mem_ctx, d, blob, ctx->max_fragment_size);
92 10 : TALLOC_FREE(d);
93 10 : if (!NT_STATUS_IS_OK(status)) {
94 0 : return status;
95 : }
96 10 : return NT_STATUS_OK;
97 : }
98 :
99 6 : NTSTATUS mdscli_blob_search(TALLOC_CTX *mem_ctx,
100 : struct mdscli_search_ctx *search,
101 : struct mdssvc_blob *blob)
102 : {
103 6 : struct mdscli_ctx *ctx = search->mdscli_ctx;
104 6 : DALLOC_CTX *d = NULL;
105 6 : uint64_t *uint64p = NULL;
106 6 : sl_array_t *array = NULL;
107 6 : sl_array_t *cmd_array = NULL;
108 6 : sl_dict_t *query_dict = NULL;
109 6 : sl_array_t *attr_array = NULL;
110 6 : sl_array_t *scope_array = NULL;
111 : double dval;
112 : uint64_t uint64val;
113 : NTSTATUS status;
114 : int ret;
115 :
116 6 : d = dalloc_new(mem_ctx);
117 6 : if (d == NULL) {
118 0 : return NT_STATUS_NO_MEMORY;
119 : }
120 :
121 6 : array = dalloc_zero(d, sl_array_t);
122 6 : if (array == NULL) {
123 0 : TALLOC_FREE(d);
124 0 : return NT_STATUS_NO_MEMORY;
125 : }
126 :
127 6 : ret = dalloc_add(d, array, sl_array_t);
128 6 : if (ret != 0) {
129 0 : TALLOC_FREE(d);
130 0 : return NT_STATUS_NO_MEMORY;
131 : }
132 :
133 6 : cmd_array = dalloc_zero(d, sl_array_t);
134 6 : if (cmd_array == NULL) {
135 0 : TALLOC_FREE(d);
136 0 : return NT_STATUS_NO_MEMORY;
137 : }
138 :
139 6 : ret = dalloc_add(array, cmd_array, sl_array_t);
140 6 : if (ret != 0) {
141 0 : TALLOC_FREE(d);
142 0 : return NT_STATUS_NO_MEMORY;
143 : }
144 :
145 6 : ret = dalloc_stradd(cmd_array, "openQueryWithParams:forContext:");
146 6 : if (ret != 0) {
147 0 : TALLOC_FREE(d);
148 0 : return NT_STATUS_NO_MEMORY;
149 : }
150 :
151 6 : uint64p = talloc_zero_array(cmd_array, uint64_t, 2);
152 6 : if (uint64p == NULL) {
153 0 : TALLOC_FREE(d);
154 0 : return NT_STATUS_NO_MEMORY;
155 : }
156 :
157 6 : talloc_set_name(uint64p, "uint64_t *");
158 :
159 6 : uint64p[0] = search->ctx_id.id;
160 6 : uint64p[1] = search->ctx_id.connection;
161 :
162 6 : ret = dalloc_add(cmd_array, uint64p, uint64_t *);
163 6 : if (ret != 0) {
164 0 : TALLOC_FREE(d);
165 0 : return NT_STATUS_NO_MEMORY;
166 : }
167 :
168 6 : query_dict = dalloc_zero(array, sl_dict_t);
169 6 : if (query_dict == NULL) {
170 0 : TALLOC_FREE(d);
171 0 : return NT_STATUS_NO_MEMORY;
172 : }
173 :
174 6 : ret = dalloc_add(array, query_dict, sl_dict_t);
175 6 : if (ret != 0) {
176 0 : TALLOC_FREE(d);
177 0 : return NT_STATUS_NO_MEMORY;
178 : }
179 :
180 6 : ret = dalloc_stradd(query_dict, "kMDQueryBatchFirstDelay");
181 6 : if (ret != 0) {
182 0 : TALLOC_FREE(d);
183 0 : return NT_STATUS_NO_MEMORY;
184 : }
185 6 : dval = 1;
186 6 : ret = dalloc_add_copy(query_dict, &dval, double);
187 6 : if (ret != 0) {
188 0 : TALLOC_FREE(d);
189 0 : return NT_STATUS_NO_MEMORY;
190 : }
191 :
192 6 : ret = dalloc_stradd(query_dict, "kMDQueryUniqueId");
193 6 : if (ret != 0) {
194 0 : TALLOC_FREE(d);
195 0 : return NT_STATUS_NO_MEMORY;
196 : }
197 6 : ret = dalloc_add_copy(query_dict, &search->unique_id, uint64_t);
198 6 : if (ret != 0) {
199 0 : TALLOC_FREE(d);
200 0 : return NT_STATUS_NO_MEMORY;
201 : }
202 :
203 6 : ret = dalloc_stradd(query_dict, "kMDAttributeArray");
204 6 : if (ret != 0) {
205 0 : TALLOC_FREE(d);
206 0 : return NT_STATUS_NO_MEMORY;
207 : }
208 6 : attr_array = dalloc_zero(query_dict, sl_array_t);
209 6 : if (attr_array == NULL) {
210 0 : TALLOC_FREE(d);
211 0 : return NT_STATUS_NO_MEMORY;
212 : }
213 6 : ret = dalloc_add(query_dict, attr_array, sl_array_t);
214 6 : if (ret != 0) {
215 0 : TALLOC_FREE(d);
216 0 : return NT_STATUS_NO_MEMORY;
217 : }
218 6 : ret = dalloc_stradd(attr_array, "kMDItemFSName");
219 6 : if (ret != 0) {
220 0 : TALLOC_FREE(d);
221 0 : return NT_STATUS_NO_MEMORY;
222 : }
223 :
224 6 : ret = dalloc_stradd(query_dict, "kMDQueryBatchFirstCount");
225 6 : if (ret != 0) {
226 0 : TALLOC_FREE(d);
227 0 : return NT_STATUS_NO_MEMORY;
228 : }
229 6 : uint64val = 10;
230 6 : ret = dalloc_add_copy(query_dict, &uint64val, uint64_t);
231 6 : if (ret != 0) {
232 0 : TALLOC_FREE(d);
233 0 : return NT_STATUS_NO_MEMORY;
234 : }
235 :
236 6 : ret = dalloc_stradd(query_dict, "kMDQueryBatchUpdateCount");
237 6 : if (ret != 0) {
238 0 : TALLOC_FREE(d);
239 0 : return NT_STATUS_NO_MEMORY;
240 : }
241 6 : uint64val = 100;
242 6 : ret = dalloc_add_copy(query_dict, &uint64val, uint64_t);
243 6 : if (ret != 0) {
244 0 : TALLOC_FREE(d);
245 0 : return NT_STATUS_NO_MEMORY;
246 : }
247 :
248 6 : ret = dalloc_stradd(query_dict, "kMDQueryString");
249 6 : if (ret != 0) {
250 0 : TALLOC_FREE(d);
251 0 : return NT_STATUS_NO_MEMORY;
252 : }
253 6 : ret = dalloc_stradd(query_dict, search->mds_query);
254 6 : if (ret != 0) {
255 0 : TALLOC_FREE(d);
256 0 : return NT_STATUS_NO_MEMORY;
257 : }
258 :
259 6 : ret = dalloc_stradd(query_dict, "kMDScopeArray");
260 6 : if (ret != 0) {
261 0 : TALLOC_FREE(d);
262 0 : return NT_STATUS_NO_MEMORY;
263 : }
264 6 : scope_array = dalloc_zero(query_dict, sl_array_t);
265 6 : if (scope_array == NULL) {
266 0 : TALLOC_FREE(d);
267 0 : return NT_STATUS_NO_MEMORY;
268 : }
269 6 : ret = dalloc_add(query_dict, scope_array, sl_array_t);
270 6 : if (ret != 0) {
271 0 : TALLOC_FREE(d);
272 0 : return NT_STATUS_NO_MEMORY;
273 : }
274 6 : ret = dalloc_stradd(scope_array, search->path_scope);
275 6 : if (ret != 0) {
276 0 : TALLOC_FREE(d);
277 0 : return NT_STATUS_NO_MEMORY;
278 : }
279 :
280 6 : status = sl_pack_alloc(mem_ctx, d, blob, ctx->max_fragment_size);
281 6 : TALLOC_FREE(d);
282 6 : if (!NT_STATUS_IS_OK(status)) {
283 0 : return status;
284 : }
285 6 : return NT_STATUS_OK;
286 : }
287 :
288 8 : NTSTATUS mdscli_blob_get_results(TALLOC_CTX *mem_ctx,
289 : struct mdscli_search_ctx *search,
290 : struct mdssvc_blob *blob)
291 : {
292 8 : struct mdscli_ctx *ctx = search->mdscli_ctx;
293 8 : DALLOC_CTX *d = NULL;
294 8 : uint64_t *uint64p = NULL;
295 8 : sl_array_t *array = NULL;
296 8 : sl_array_t *cmd_array = NULL;
297 : NTSTATUS status;
298 : int ret;
299 :
300 8 : d = dalloc_new(mem_ctx);
301 8 : if (d == NULL) {
302 0 : return NT_STATUS_NO_MEMORY;
303 : }
304 :
305 8 : array = dalloc_zero(d, sl_array_t);
306 8 : if (array == NULL) {
307 0 : TALLOC_FREE(d);
308 0 : return NT_STATUS_NO_MEMORY;
309 : }
310 :
311 8 : ret = dalloc_add(d, array, sl_array_t);
312 8 : if (ret != 0) {
313 0 : TALLOC_FREE(d);
314 0 : return NT_STATUS_NO_MEMORY;
315 : }
316 :
317 8 : cmd_array = dalloc_zero(d, sl_array_t);
318 8 : if (cmd_array == NULL) {
319 0 : TALLOC_FREE(d);
320 0 : return NT_STATUS_NO_MEMORY;
321 : }
322 :
323 8 : ret = dalloc_add(array, cmd_array, sl_array_t);
324 8 : if (ret != 0) {
325 0 : TALLOC_FREE(d);
326 0 : return NT_STATUS_NO_MEMORY;
327 : }
328 :
329 8 : ret = dalloc_stradd(cmd_array, "fetchQueryResultsForContext:");
330 8 : if (ret != 0) {
331 0 : TALLOC_FREE(d);
332 0 : return NT_STATUS_NO_MEMORY;
333 : }
334 :
335 8 : uint64p = talloc_zero_array(cmd_array, uint64_t, 2);
336 8 : if (uint64p == NULL) {
337 0 : TALLOC_FREE(d);
338 0 : return NT_STATUS_NO_MEMORY;
339 : }
340 :
341 8 : talloc_set_name(uint64p, "uint64_t *");
342 :
343 8 : uint64p[0] = search->ctx_id.id;
344 8 : uint64p[1] = search->ctx_id.connection;
345 :
346 8 : ret = dalloc_add(cmd_array, uint64p, uint64_t *);
347 8 : if (ret != 0) {
348 0 : TALLOC_FREE(d);
349 0 : return NT_STATUS_NO_MEMORY;
350 : }
351 :
352 8 : status = sl_pack_alloc(mem_ctx, d, blob, ctx->max_fragment_size);
353 8 : TALLOC_FREE(d);
354 8 : if (!NT_STATUS_IS_OK(status)) {
355 0 : return status;
356 : }
357 8 : return NT_STATUS_OK;
358 : }
359 :
360 26 : NTSTATUS mdscli_blob_get_path(TALLOC_CTX *mem_ctx,
361 : struct mdscli_ctx *ctx,
362 : uint64_t cnid,
363 : struct mdssvc_blob *blob)
364 : {
365 26 : struct mdsctx_id ctx_id = mdscli_new_ctx_id(ctx);
366 26 : DALLOC_CTX *d = NULL;
367 26 : uint64_t *uint64var = NULL;
368 26 : sl_array_t *array = NULL;
369 26 : sl_array_t *cmd_array = NULL;
370 26 : sl_array_t *attr_array = NULL;
371 26 : sl_cnids_t *cnids = NULL;
372 : NTSTATUS status;
373 : int ret;
374 :
375 26 : d = dalloc_new(mem_ctx);
376 26 : if (d == NULL) {
377 0 : return NT_STATUS_NO_MEMORY;
378 : }
379 :
380 26 : array = dalloc_zero(d, sl_array_t);
381 26 : if (array == NULL) {
382 0 : TALLOC_FREE(d);
383 0 : return NT_STATUS_NO_MEMORY;
384 : }
385 :
386 26 : ret = dalloc_add(d, array, sl_array_t);
387 26 : if (ret != 0) {
388 0 : TALLOC_FREE(d);
389 0 : return NT_STATUS_NO_MEMORY;
390 : }
391 :
392 26 : cmd_array = dalloc_zero(d, sl_array_t);
393 26 : if (cmd_array == NULL) {
394 0 : TALLOC_FREE(d);
395 0 : return NT_STATUS_NO_MEMORY;
396 : }
397 :
398 26 : ret = dalloc_add(array, cmd_array, sl_array_t);
399 26 : if (ret != 0) {
400 0 : TALLOC_FREE(d);
401 0 : return NT_STATUS_NO_MEMORY;
402 : }
403 :
404 26 : ret = dalloc_stradd(cmd_array, "fetchAttributes:forOIDArray:context:");
405 26 : if (ret != 0) {
406 0 : TALLOC_FREE(d);
407 0 : return NT_STATUS_NO_MEMORY;
408 : }
409 :
410 26 : uint64var = talloc_zero_array(cmd_array, uint64_t, 2);
411 26 : if (uint64var == NULL) {
412 0 : TALLOC_FREE(d);
413 0 : return NT_STATUS_NO_MEMORY;
414 : }
415 :
416 26 : talloc_set_name(uint64var, "uint64_t *");
417 :
418 26 : uint64var[0] = ctx_id.id;
419 26 : uint64var[1] = 0;
420 :
421 26 : ret = dalloc_add(cmd_array, &uint64var[0], uint64_t *);
422 26 : if (ret != 0) {
423 0 : TALLOC_FREE(d);
424 0 : return NT_STATUS_NO_MEMORY;
425 : }
426 :
427 26 : attr_array = dalloc_zero(d, sl_array_t);
428 26 : if (attr_array == NULL) {
429 0 : TALLOC_FREE(d);
430 0 : return NT_STATUS_NO_MEMORY;
431 : }
432 :
433 26 : ret = dalloc_add(array, attr_array, sl_array_t);
434 26 : if (ret != 0) {
435 0 : TALLOC_FREE(d);
436 0 : return NT_STATUS_NO_MEMORY;
437 : }
438 :
439 26 : ret = dalloc_stradd(attr_array, "kMDItemPath");
440 26 : if (ret != 0) {
441 0 : TALLOC_FREE(d);
442 0 : return NT_STATUS_NO_MEMORY;
443 : }
444 :
445 : /* CNIDs */
446 26 : cnids = talloc_zero(array, sl_cnids_t);
447 26 : if (cnids == NULL) {
448 0 : TALLOC_FREE(d);
449 0 : return NT_STATUS_NO_MEMORY;
450 : }
451 :
452 26 : cnids->ca_cnids = dalloc_new(cnids);
453 26 : if (cnids->ca_cnids == NULL) {
454 0 : TALLOC_FREE(d);
455 0 : return NT_STATUS_NO_MEMORY;
456 : }
457 :
458 26 : cnids->ca_unkn1 = 0xadd;
459 26 : cnids->ca_context = 0x6b000020;
460 :
461 26 : ret = dalloc_add_copy(cnids->ca_cnids, &cnid, uint64_t);
462 26 : if (ret != 0) {
463 0 : TALLOC_FREE(d);
464 0 : return NT_STATUS_NO_MEMORY;
465 : }
466 :
467 26 : ret = dalloc_add(array, cnids, sl_cnids_t);
468 26 : if (ret != 0) {
469 0 : TALLOC_FREE(d);
470 0 : return NT_STATUS_NO_MEMORY;
471 : }
472 :
473 26 : status = sl_pack_alloc(mem_ctx, d, blob, ctx->max_fragment_size);
474 26 : TALLOC_FREE(d);
475 26 : if (!NT_STATUS_IS_OK(status)) {
476 0 : return status;
477 : }
478 26 : return NT_STATUS_OK;
479 : }
480 :
481 6 : NTSTATUS mdscli_blob_close_search(TALLOC_CTX *mem_ctx,
482 : struct mdscli_search_ctx *search,
483 : struct mdssvc_blob *blob)
484 : {
485 6 : struct mdscli_ctx *ctx = search->mdscli_ctx;
486 6 : DALLOC_CTX *d = NULL;
487 6 : uint64_t *uint64p = NULL;
488 6 : sl_array_t *array = NULL;
489 6 : sl_array_t *cmd_array = NULL;
490 : NTSTATUS status;
491 : int ret;
492 :
493 6 : d = dalloc_new(mem_ctx);
494 6 : if (d == NULL) {
495 0 : return NT_STATUS_NO_MEMORY;
496 : }
497 :
498 6 : array = dalloc_zero(d, sl_array_t);
499 6 : if (array == NULL) {
500 0 : TALLOC_FREE(d);
501 0 : return NT_STATUS_NO_MEMORY;
502 : }
503 :
504 6 : ret = dalloc_add(d, array, sl_array_t);
505 6 : if (ret != 0) {
506 0 : TALLOC_FREE(d);
507 0 : return NT_STATUS_NO_MEMORY;
508 : }
509 :
510 6 : cmd_array = dalloc_zero(d, sl_array_t);
511 6 : if (cmd_array == NULL) {
512 0 : TALLOC_FREE(d);
513 0 : return NT_STATUS_NO_MEMORY;
514 : }
515 :
516 6 : ret = dalloc_add(array, cmd_array, sl_array_t);
517 6 : if (ret != 0) {
518 0 : TALLOC_FREE(d);
519 0 : return NT_STATUS_NO_MEMORY;
520 : }
521 :
522 6 : ret = dalloc_stradd(cmd_array, "closeQueryForContext:");
523 6 : if (ret != 0) {
524 0 : TALLOC_FREE(d);
525 0 : return NT_STATUS_NO_MEMORY;
526 : }
527 :
528 6 : uint64p = talloc_zero_array(cmd_array, uint64_t, 2);
529 6 : if (uint64p == NULL) {
530 0 : TALLOC_FREE(d);
531 0 : return NT_STATUS_NO_MEMORY;
532 : }
533 :
534 6 : talloc_set_name(uint64p, "uint64_t *");
535 :
536 6 : uint64p[0] = search->ctx_id.id;
537 6 : uint64p[1] = search->ctx_id.connection;
538 :
539 6 : ret = dalloc_add(cmd_array, uint64p, uint64_t *);
540 6 : if (ret != 0) {
541 0 : TALLOC_FREE(d);
542 0 : return NT_STATUS_NO_MEMORY;
543 : }
544 :
545 6 : status = sl_pack_alloc(mem_ctx, d, blob, ctx->max_fragment_size);
546 6 : TALLOC_FREE(d);
547 6 : if (!NT_STATUS_IS_OK(status)) {
548 0 : return status;
549 : }
550 6 : return NT_STATUS_OK;
551 : }
|
