LCOV - code coverage report
Current view: top level - source4/torture/ndr - ndr.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 354 384 92.2 %
Date: 2021-09-23 10:06:22 Functions: 22 23 95.7 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    test suite for winreg ndr operations
       4             : 
       5             :    Copyright (C) Jelmer Vernooij 2007
       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 "torture/ndr/ndr.h"
      23             : #include "torture/ndr/proto.h"
      24             : #include "../lib/util/dlinklist.h"
      25             : #include "param/param.h"
      26             : #include "librpc/gen_ndr/ndr_misc.h"
      27             : 
      28             : struct ndr_pull_test_data {
      29             :         DATA_BLOB data;
      30             :         DATA_BLOB data_context;
      31             :         size_t struct_size;
      32             :         ndr_pull_flags_fn_t pull_fn;
      33             :         ndr_push_flags_fn_t push_fn;
      34             :         ndr_print_fn_t print_fn;
      35             :         ndr_print_function_t print_function;
      36             :         int ndr_flags;
      37             :         int flags;
      38             :         enum ndr_err_code ndr_err;
      39             : };
      40             : 
      41          70 : static enum ndr_err_code torture_ndr_push_struct_blob_flags(DATA_BLOB *blob, TALLOC_CTX *mem_ctx, uint32_t flags, uint32_t ndr_flags, const void *p, ndr_push_flags_fn_t fn)
      42             : {
      43             :         struct ndr_push *ndr;
      44          70 :         ndr = ndr_push_init_ctx(mem_ctx);
      45          70 :         NDR_ERR_HAVE_NO_MEMORY(ndr);
      46             : 
      47          70 :         ndr->flags |= ndr_flags;
      48             : 
      49          70 :         NDR_CHECK(fn(ndr, flags, p));
      50             : 
      51          70 :         *blob = ndr_push_blob(ndr);
      52          70 :         talloc_steal(mem_ctx, blob->data);
      53          70 :         talloc_free(ndr);
      54             : 
      55          70 :         return NDR_ERR_SUCCESS;
      56             : }
      57             : 
      58         534 : static bool torture_ndrdump(struct torture_context *tctx,
      59             :                             struct ndr_pull *ndr,
      60             :                             const struct ndr_pull_test_data *data,
      61             :                             uint32_t flags,
      62             :                             void *ds,
      63             :                             const char *name)
      64             : {
      65             :         struct ndr_print *ndr_print;
      66             :         const char *name_raw;
      67         534 :         uint32_t ndr_flags = data->ndr_flags | flags;
      68             : 
      69         534 :         ndr_print = talloc_zero(tctx, struct ndr_print);
      70         534 :         torture_assert(tctx, ndr_print, "out of memory");
      71             : 
      72         534 :         if (DEBUGLEVEL >= 10) {
      73           0 :                 ndr_print->print = ndr_print_debug_helper;
      74             :         } else {
      75         534 :                 ndr_print->print = ndr_print_string_helper;
      76             :         }
      77             : 
      78         534 :         ndr_print->depth = 1;
      79             : 
      80         534 :         torture_assert(tctx, ndr_flags, "no flags have been set");
      81             : 
      82         534 :         if (ndr_flags & (NDR_BUFFERS|NDR_SCALARS)) {
      83         102 :                 data->print_fn(ndr_print, name, ds);
      84             :         } else {
      85         432 :                 data->print_function(ndr_print, name, ndr_flags, ds);
      86             :         }
      87             : 
      88         534 :         name_raw = talloc_asprintf(tctx, "%s (RAW DATA)", name);
      89         534 :         torture_assert(tctx, name_raw, "out of memory");
      90             : 
      91         534 :         ndr_print_DATA_BLOB(ndr_print, name_raw, data->data);
      92             : 
      93         534 :         talloc_free(ndr_print);
      94             : 
      95           0 :         return true;
      96             : }
      97             : 
      98         466 : static bool wrap_ndr_pullpush_test(struct torture_context *tctx,
      99             :                                    struct torture_tcase *tcase,
     100             :                                    struct torture_test *test)
     101             : {
     102         466 :         bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;
     103         466 :         const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;
     104         466 :         struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx);
     105         466 :         void *ds = talloc_zero_size(ndr, data->struct_size);
     106         466 :         bool ret = true;
     107             :         uint32_t highest_ofs;
     108             : 
     109           0 :         torture_assert(tctx, data, "out of memory");
     110         466 :         torture_assert(tctx, ndr, "out of memory");
     111         466 :         torture_assert(tctx, ds, "out of memory");
     112             : 
     113         466 :         ndr->flags |= data->flags;
     114             : 
     115         466 :         ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
     116             : 
     117         466 :         torture_assert_ndr_success(tctx, data->pull_fn(ndr, data->ndr_flags, ds),
     118             :                                    "pulling");
     119             : 
     120         466 :         if (ndr->offset > ndr->relative_highest_offset) {
     121           0 :                 highest_ofs = ndr->offset;
     122             :         } else {
     123          32 :                 highest_ofs = ndr->relative_highest_offset;
     124             :         }
     125             : 
     126         466 :         torture_assert(tctx, highest_ofs == ndr->data_size,
     127             :                                    talloc_asprintf(tctx,
     128             :                                            "%d unread bytes", ndr->data_size - highest_ofs));
     129             : 
     130         466 :         if (check_fn != NULL) {
     131         280 :                 ret = check_fn(tctx, ds);
     132             :         } else {
     133           0 :                 ret = true;
     134             :         }
     135             : 
     136         466 :         torture_ndrdump(tctx, ndr, data, data->ndr_flags, ds, "ds");
     137             : 
     138         466 :         if (data->push_fn != NULL) {
     139             :                 DATA_BLOB outblob;
     140          70 :                 torture_assert_ndr_success(tctx, torture_ndr_push_struct_blob_flags(&outblob, ndr, data->ndr_flags, ndr->flags, ds, data->push_fn), "pushing");
     141          70 :                 torture_assert_data_blob_equal(tctx, outblob, data->data, "ndr push compare");
     142             :         }
     143             : 
     144         466 :         talloc_free(ndr);
     145         466 :         return ret;
     146             : }
     147             : 
     148      548715 : _PUBLIC_ struct torture_test *_torture_suite_add_ndr_pullpush_test(
     149             :         struct torture_suite *suite,
     150             :         const char *name,
     151             :         ndr_pull_flags_fn_t pull_fn,
     152             :         ndr_push_flags_fn_t push_fn,
     153             :         ndr_print_fn_t print_fn,
     154             :         ndr_print_function_t print_function,
     155             :         const char *db_name,
     156             :         DATA_BLOB db,
     157             :         size_t struct_size,
     158             :         int ndr_flags,
     159             :         int flags,
     160             :         const char *check_fn_name,
     161             :         bool (*check_fn) (struct torture_context *ctx, void *data))
     162             : {
     163             :         struct torture_test *test;
     164             :         struct torture_tcase *tcase;
     165             :         struct ndr_pull_test_data *data;
     166             : 
     167      548715 :         tcase = torture_suite_add_tcase(suite, name);
     168             : 
     169      548715 :         test = talloc(tcase, struct torture_test);
     170             : 
     171      548715 :         test->name = talloc_strdup(test, check_fn_name);
     172      548715 :         test->description = talloc_asprintf(test, "db:%s",
     173             :                                             db_name);
     174      548715 :         test->run = wrap_ndr_pullpush_test;
     175             : 
     176      548715 :         data = talloc_zero(test, struct ndr_pull_test_data);
     177      548715 :         data->data = db;
     178      548715 :         data->ndr_flags = ndr_flags;
     179      548715 :         data->flags = flags;
     180      548715 :         data->struct_size = struct_size;
     181      548715 :         data->pull_fn = pull_fn;
     182      548715 :         data->push_fn = push_fn;
     183      548715 :         data->print_fn = print_fn;
     184      548715 :         data->print_function = print_function;
     185             : 
     186      548715 :         test->data = data;
     187      548715 :         test->fn = check_fn;
     188      548715 :         test->dangerous = false;
     189             : 
     190      548715 :         DLIST_ADD_END(tcase->tests, test);
     191             : 
     192      548715 :         return test;
     193             : }
     194             : 
     195             : 
     196          34 : static bool wrap_ndr_inout_pull_test(struct torture_context *tctx,
     197             :                                      struct torture_tcase *tcase,
     198             :                                      struct torture_test *test)
     199             : {
     200          34 :         bool (*check_fn) (struct torture_context *ctx, void *data) = test->fn;
     201          34 :         const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;
     202          34 :         void *ds = talloc_zero_size(tctx, data->struct_size);
     203             :         struct ndr_pull *ndr;
     204             :         uint32_t highest_ofs;
     205          34 :         bool ret = false;
     206             : 
     207           0 :         torture_assert(tctx, data, "out of memory");
     208          34 :         torture_assert(tctx, ds, "out of memory");
     209             : 
     210             :         /* handle NDR_IN context */
     211             : 
     212          34 :         ndr = ndr_pull_init_blob(&(data->data_context), tctx);
     213          34 :         torture_assert(tctx, ndr, "ndr init failed");
     214             : 
     215          34 :         ndr->flags |= data->flags;
     216          34 :         ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
     217             : 
     218          34 :         torture_assert_ndr_success(tctx,
     219             :                 data->pull_fn(ndr, NDR_IN, ds),
     220             :                 "ndr pull of context failed");
     221             : 
     222          34 :         if (ndr->offset > ndr->relative_highest_offset) {
     223           0 :                 highest_ofs = ndr->offset;
     224             :         } else {
     225           0 :                 highest_ofs = ndr->relative_highest_offset;
     226             :         }
     227             : 
     228          34 :         torture_assert(tctx, highest_ofs == ndr->data_size,
     229             :                 talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - highest_ofs));
     230             : 
     231          34 :         torture_ndrdump(tctx, ndr, data, NDR_IN, ds, "ds");
     232             : 
     233          34 :         talloc_free(ndr);
     234             : 
     235             :         /* handle NDR_OUT */
     236             : 
     237          34 :         ndr = ndr_pull_init_blob(&(data->data), tctx);
     238          34 :         torture_assert(tctx, ndr, "ndr init failed");
     239             : 
     240          34 :         ndr->flags |= data->flags;
     241          34 :         ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
     242             : 
     243          34 :         torture_assert_ndr_success(tctx,
     244             :                 data->pull_fn(ndr, NDR_OUT, ds),
     245             :                 "ndr pull failed");
     246             : 
     247          34 :         if (ndr->offset > ndr->relative_highest_offset) {
     248           0 :                 highest_ofs = ndr->offset;
     249             :         } else {
     250           0 :                 highest_ofs = ndr->relative_highest_offset;
     251             :         }
     252             : 
     253          34 :         torture_assert(tctx, highest_ofs == ndr->data_size,
     254             :                 talloc_asprintf(tctx, "%d unread bytes", ndr->data_size - highest_ofs));
     255             : 
     256          34 :         if (check_fn) {
     257          10 :                 ret = check_fn(tctx, ds);
     258             :         } else {
     259           0 :                 ret = true;
     260             :         }
     261             : 
     262          34 :         torture_ndrdump(tctx, ndr, data, NDR_OUT, ds, "ds");
     263             : 
     264          34 :         talloc_free(ndr);
     265             : 
     266          34 :         return ret;
     267             : }
     268             : 
     269       40035 : _PUBLIC_ struct torture_test *_torture_suite_add_ndr_pull_inout_test(
     270             :                                         struct torture_suite *suite,
     271             :                                         const char *name,
     272             :                                         ndr_pull_flags_fn_t pull_fn,
     273             :                                         ndr_print_function_t print_function,
     274             :                                         const char *db_in_name,
     275             :                                         DATA_BLOB db_in,
     276             :                                         const char *db_out_name,
     277             :                                         DATA_BLOB db_out,
     278             :                                         size_t struct_size,
     279             :                                         int flags,
     280             :                                         const char *check_fn_name,
     281             :                                         bool (*check_fn) (struct torture_context *ctx, void *data))
     282             : {
     283             :         struct torture_test *test;
     284             :         struct torture_tcase *tcase;
     285             :         struct ndr_pull_test_data *data;
     286             : 
     287       40035 :         tcase = torture_suite_add_tcase(suite, name);
     288             : 
     289       40035 :         test = talloc(tcase, struct torture_test);
     290             : 
     291       40035 :         test->name = talloc_strdup(test, check_fn_name);
     292       40035 :         test->description = talloc_asprintf(test, "db_in:%s db_out:%s",
     293             :                                             db_in_name,
     294             :                                             db_out_name);
     295       40035 :         test->run = wrap_ndr_inout_pull_test;
     296       40035 :         data = talloc_zero(test, struct ndr_pull_test_data);
     297       40035 :         data->data = db_out;
     298       40035 :         data->data_context = db_in;
     299       40035 :         data->ndr_flags = 0;
     300       40035 :         data->flags = flags;
     301       40035 :         data->struct_size = struct_size;
     302       40035 :         data->pull_fn = pull_fn;
     303       40035 :         data->print_function = print_function;
     304       40035 :         test->data = data;
     305       40035 :         test->fn = check_fn;
     306       40035 :         test->dangerous = false;
     307             : 
     308       40035 :         DLIST_ADD_END(tcase->tests, test);
     309             : 
     310       40035 :         return test;
     311             : }
     312             : 
     313           2 : static bool wrap_ndr_pull_invalid_data_test(struct torture_context *tctx,
     314             :                                             struct torture_tcase *tcase,
     315             :                                             struct torture_test *test)
     316             : {
     317           2 :         const struct ndr_pull_test_data *data = (const struct ndr_pull_test_data *)test->data;
     318           2 :         struct ndr_pull *ndr = ndr_pull_init_blob(&(data->data), tctx);
     319           2 :         void *ds = talloc_zero_size(ndr, data->struct_size);
     320           2 :         bool ret = true;
     321             : 
     322           0 :         torture_assert(tctx, data, "out of memory");
     323           2 :         torture_assert(tctx, ndr, "out of memory");
     324           2 :         torture_assert(tctx, ds, "out of memory");
     325             : 
     326           2 :         ndr->flags |= data->flags;
     327             : 
     328           2 :         ndr->flags |= LIBNDR_FLAG_REF_ALLOC;
     329             : 
     330           2 :         torture_assert_ndr_err_equal(
     331             :                 tctx,
     332             :                 data->pull_fn(ndr, data->ndr_flags, ds),
     333             :                 NDR_ERR_BUFSIZE,
     334             :                 "pulling invalid data");
     335             : 
     336           2 :         talloc_free(ndr);
     337           2 :         return ret;
     338             : }
     339             : 
     340        2355 : _PUBLIC_ struct torture_test *_torture_suite_add_ndr_pull_invalid_data_test(
     341             :         struct torture_suite *suite,
     342             :         const char *name,
     343             :         ndr_pull_flags_fn_t pull_fn,
     344             :         const char *db_name,
     345             :         DATA_BLOB db,
     346             :         size_t struct_size,
     347             :         int ndr_flags,
     348             :         int flags,
     349             :         enum ndr_err_code ndr_err)
     350             : {
     351             :         struct torture_test *test;
     352             :         struct torture_tcase *tcase;
     353             :         struct ndr_pull_test_data *data;
     354             : 
     355        2355 :         tcase = torture_suite_add_tcase(suite, name);
     356             : 
     357        2355 :         test = talloc(tcase, struct torture_test);
     358             : 
     359        2355 :         test->name = talloc_strdup(test, db_name);
     360        2355 :         test->description = NULL;
     361        2355 :         test->run = wrap_ndr_pull_invalid_data_test;
     362             : 
     363        2355 :         data = talloc_zero(test, struct ndr_pull_test_data);
     364        2355 :         data->data = db;
     365        2355 :         data->ndr_flags = ndr_flags;
     366        2355 :         data->flags = flags;
     367        2355 :         data->struct_size = struct_size;
     368        2355 :         data->pull_fn = pull_fn;
     369        2355 :         data->ndr_err = ndr_err;
     370             : 
     371        2355 :         test->data = data;
     372        2355 :         test->fn = NULL;
     373        2355 :         test->dangerous = false;
     374             : 
     375        2355 :         DLIST_ADD_END(tcase->tests, test);
     376             : 
     377        2355 :         return test;
     378             : }
     379             : 
     380           2 : static bool test_check_string_terminator(struct torture_context *tctx)
     381             : {
     382             :         struct ndr_pull *ndr;
     383             :         DATA_BLOB blob;
     384           2 :         TALLOC_CTX *mem_ctx = tctx;
     385             : 
     386             :         /* Simple test */
     387           2 :         blob = strhex_to_data_blob(tctx, "0000");
     388             : 
     389           2 :         ndr = ndr_pull_init_blob(&blob, mem_ctx);
     390             : 
     391           2 :         torture_assert_ndr_success(tctx, ndr_check_string_terminator(ndr, 1, 2),
     392             :                                    "simple check_string_terminator test failed");
     393             : 
     394           2 :         torture_assert(tctx, ndr->offset == 0,
     395             :                 "check_string_terminator did not reset offset");
     396             : 
     397           2 :         if (NDR_ERR_CODE_IS_SUCCESS(ndr_check_string_terminator(ndr, 1, 3))) {
     398           0 :                 torture_fail(tctx, "check_string_terminator checked beyond string boundaries");
     399             :         }
     400             : 
     401           2 :         torture_assert(tctx, ndr->offset == 0,
     402             :                 "check_string_terminator did not reset offset");
     403             : 
     404           2 :         talloc_free(ndr);
     405             : 
     406           2 :         blob = strhex_to_data_blob(tctx, "11220000");
     407           2 :         ndr = ndr_pull_init_blob(&blob, mem_ctx);
     408             : 
     409           2 :         torture_assert_ndr_success(tctx,
     410             :                 ndr_check_string_terminator(ndr, 4, 1),
     411             :                 "check_string_terminator failed to recognize terminator");
     412             : 
     413           2 :         torture_assert_ndr_success(tctx,
     414             :                 ndr_check_string_terminator(ndr, 3, 1),
     415             :                 "check_string_terminator failed to recognize terminator");
     416             : 
     417           2 :         if (NDR_ERR_CODE_IS_SUCCESS(ndr_check_string_terminator(ndr, 2, 1))) {
     418           0 :                 torture_fail(tctx, "check_string_terminator erroneously reported terminator");
     419             :         }
     420             : 
     421           2 :         torture_assert(tctx, ndr->offset == 0,
     422             :                 "check_string_terminator did not reset offset");
     423           0 :         return true;
     424             : }
     425             : 
     426           2 : static bool test_guid_from_string_valid(struct torture_context *tctx)
     427             : {
     428             :         /* FIXME */
     429           2 :         return true;
     430             : }
     431             : 
     432           2 : static bool test_guid_from_string_null(struct torture_context *tctx)
     433             : {
     434             :         struct GUID guid;
     435           2 :         torture_assert_ntstatus_equal(tctx, NT_STATUS_INVALID_PARAMETER,
     436             :                                       GUID_from_string(NULL, &guid),
     437             :                                       "NULL failed");
     438           2 :         return true;
     439             : }
     440             : 
     441           2 : static bool test_guid_from_string_invalid(struct torture_context *tctx)
     442             : {
     443             :         struct GUID g1;
     444           2 :         bool failed = false;
     445             :         int i;
     446           2 :         const char *bad_guids[] = {
     447             :                 "bla",
     448             :                 "",
     449             :                 /*
     450             :                 "00000001-0002-0003-0405-060708090a0b",  correct
     451             :                 */
     452             :                 "00000001-0002-0003-0405-060708090a0b1", /* too long */
     453             :                 "00000001-0002-0003-0405-060708090a0",  /* too short */
     454             :                 "00000001-0002-0003-0405--060708090a0",  /* negative */
     455             :                 "00000001-0002-0003--0405-060708090a0",  /* negative */
     456             :                 "-0000001-0002-0003-0405-060708090a0b",  /* negative */
     457             :                 "-0000001-0002-0003-04-5-060708090a0b",  /* negative */
     458             :                 "d0000001-0002-0003-0405-060708090a-b",  /* negative */
     459             :                 "00000001-  -2-0003-0405-060708090a0b",  /* negative, space */
     460             :                 "00000001-0002-0003-0405- 060708090a0",  /* whitespace */
     461             :                 " 0000001-0002-0003--0405-060708090a0",  /* whitespace */
     462             :                 "00000001-0002-0003--0405-060708090a ",  /* whitespace */
     463             :                 "0000001-00002-0003-04050-60708090a0b",  /* misshapen */
     464             :                 "00000010-0002-0003-04050-60708090a0b",  /* misshapen */
     465             :                 "00000001-0002-0003-0405-0z0708090a0b",  /* bad char */
     466             :                 "00000001-00x2-0x03-0405-060708090a0b",  /* bad char (00x) */
     467             :                 "0x000001-0002-0003-0405-060708090a0b",  /* 0x char */
     468             :                 "00000001-0x02-0x03-0405-060708090a0b",  /* 0x char */
     469             :         };
     470             : 
     471          40 :         for (i = 0; i < ARRAY_SIZE(bad_guids); i++) {
     472          38 :                 NTSTATUS status = GUID_from_string(bad_guids[i], &g1);
     473          38 :                 if (! NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
     474           0 :                         torture_comment(tctx, "bad guid %s parsed as OK\n",
     475             :                                         bad_guids[i]);
     476           0 :                         failed = true;
     477             :                 }
     478             :         }
     479           2 :         if (failed) {
     480           0 :                 torture_fail(tctx, "wrongly allowing invalid guids");
     481             :         }
     482           0 :         return true;
     483             : }
     484             : 
     485           2 : static bool test_guid_from_string(struct torture_context *tctx)
     486             : {
     487             :         struct GUID g1, exp;
     488             :         /* we are asserting all these guids are valid and equal */
     489           2 :         const char *guids[5] = {
     490             :                 "00000001-0002-0003-0405-060708090a0b",
     491             :                 "{00000001-0002-0003-0405-060708090a0b}",
     492             :                 "{00000001-0002-0003-0405-060708090a0B}", /* mixed */
     493             :                 "00000001-0002-0003-0405-060708090A0B",   /* upper */
     494             :                 "01000000020003000405060708090a0b",       /* hex string */
     495             :         };
     496             :         int i;
     497             : 
     498           2 :         torture_assert_ntstatus_ok(tctx,
     499             :                                    GUID_from_string(guids[0], &g1),
     500             :                                    "invalid return code");
     501           2 :         exp.time_low = 1;
     502           2 :         exp.time_mid = 2;
     503           2 :         exp.time_hi_and_version = 3;
     504           2 :         exp.clock_seq[0] = 4;
     505           2 :         exp.clock_seq[1] = 5;
     506           2 :         exp.node[0] = 6;
     507           2 :         exp.node[1] = 7;
     508           2 :         exp.node[2] = 8;
     509           2 :         exp.node[3] = 9;
     510           2 :         exp.node[4] = 10;
     511           2 :         exp.node[5] = 11;
     512             : 
     513          10 :         for (i = 1; i < ARRAY_SIZE(guids); i++) {
     514           8 :                 torture_assert_ntstatus_ok(tctx,
     515             :                                            GUID_from_string(guids[i], &g1),
     516             :                                            "invalid return code");
     517           8 :                 torture_assert(tctx, GUID_equal(&g1, &exp),
     518             :                                "UUID parsed incorrectly");
     519             :         }
     520           0 :         return true;
     521             : }
     522             : 
     523           2 : static bool test_guid_from_data_blob(struct torture_context *tctx)
     524             : {
     525             :         struct GUID g1, exp;
     526           2 :         const uint8_t bin[16] = {
     527             :                 0x01, 0x00, 0x00, 0x00,
     528             :                 0x02, 0x00,
     529             :                 0x03, 0x00,
     530             :                 0x04, 0x05,
     531             :                 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b };
     532           2 :         const char *hexstr = "01000000020003000405060708090a0b";
     533           2 :         const DATA_BLOB blobs[2] = {
     534           0 :                 data_blob_const(bin, sizeof(bin)),
     535           0 :                 data_blob_string_const(hexstr),
     536             :         };
     537             :         int i;
     538             : 
     539           2 :         exp.time_low = 1;
     540           2 :         exp.time_mid = 2;
     541           2 :         exp.time_hi_and_version = 3;
     542           2 :         exp.clock_seq[0] = 4;
     543           2 :         exp.clock_seq[1] = 5;
     544           2 :         exp.node[0] = 6;
     545           2 :         exp.node[1] = 7;
     546           2 :         exp.node[2] = 8;
     547           2 :         exp.node[3] = 9;
     548           2 :         exp.node[4] = 10;
     549           2 :         exp.node[5] = 11;
     550             : 
     551           4 :         for (i = 1; i < ARRAY_SIZE(blobs); i++) {
     552           2 :                 torture_assert_ntstatus_ok(tctx,
     553             :                                            GUID_from_data_blob(&blobs[i], &g1),
     554             :                                            "invalid return code");
     555           2 :                 torture_assert(tctx, GUID_equal(&g1, &exp),
     556             :                                "UUID parsed incorrectly");
     557             :         }
     558             : 
     559           0 :         return true;
     560             : }
     561             : 
     562           2 : static bool test_guid_string_valid(struct torture_context *tctx)
     563             : {
     564             :         struct GUID g;
     565           2 :         g.time_low = 1;
     566           2 :         g.time_mid = 2;
     567           2 :         g.time_hi_and_version = 3;
     568           2 :         g.clock_seq[0] = 4;
     569           2 :         g.clock_seq[1] = 5;
     570           2 :         g.node[0] = 6;
     571           2 :         g.node[1] = 7;
     572           2 :         g.node[2] = 8;
     573           2 :         g.node[3] = 9;
     574           2 :         g.node[4] = 10;
     575           2 :         g.node[5] = 11;
     576           2 :         torture_assert_str_equal(tctx, "00000001-0002-0003-0405-060708090a0b",
     577             :                                  GUID_string(tctx, &g),
     578             :                                  "parsing guid failed");
     579           0 :         return true;
     580             : }
     581             : 
     582           2 : static bool test_guid_string2_valid(struct torture_context *tctx)
     583             : {
     584             :         struct GUID g;
     585           2 :         g.time_low = 1;
     586           2 :         g.time_mid = 2;
     587           2 :         g.time_hi_and_version = 3;
     588           2 :         g.clock_seq[0] = 4;
     589           2 :         g.clock_seq[1] = 5;
     590           2 :         g.node[0] = 6;
     591           2 :         g.node[1] = 7;
     592           2 :         g.node[2] = 8;
     593           2 :         g.node[3] = 9;
     594           2 :         g.node[4] = 10;
     595           2 :         g.node[5] = 11;
     596           2 :         torture_assert_str_equal(tctx, "{00000001-0002-0003-0405-060708090a0b}",
     597             :                                  GUID_string2(tctx, &g),
     598             :                                  "parsing guid failed");
     599           0 :         return true;
     600             : }
     601             : 
     602           2 : static bool test_guid_into_blob(struct torture_context *tctx)
     603             : {
     604             :         enum ndr_err_code ndr_err;
     605             :         static const char exp_guid[16] =
     606             :                 { 0x1, 0x0, 0x0, 0x0,
     607             :                   0x2, 0x0, 0x3, 0x0,
     608             :                   0x4, 0x5, 0x6, 0x7,
     609             :                   0x8, 0x9, 0xa, 0xb };
     610           2 :         DATA_BLOB exp = data_blob_const(exp_guid, 16);
     611           2 :         char ndr_guid[16] =
     612             :                 { 0x0, 0x0, 0x0, 0x0,
     613             :                   0x0, 0x0, 0x0, 0x0,
     614             :                   0x0, 0x0, 0x0, 0x0,
     615             :                   0x0, 0x0, 0x0, 0x0 };
     616           2 :         DATA_BLOB b = data_blob_const(ndr_guid, 16);
     617             :         struct GUID guid;
     618           2 :         guid.time_low = 1;
     619           2 :         guid.time_mid = 2;
     620           2 :         guid.time_hi_and_version = 3;
     621           2 :         guid.clock_seq[0] = 4;
     622           2 :         guid.clock_seq[1] = 5;
     623           2 :         guid.node[0] = 6;
     624           2 :         guid.node[1] = 7;
     625           2 :         guid.node[2] = 8;
     626           2 :         guid.node[3] = 9;
     627           2 :         guid.node[4] = 10;
     628           2 :         guid.node[5] = 11;
     629             :         
     630           2 :         ndr_err = ndr_push_struct_into_fixed_blob(&b, &guid,
     631             :                                                   (ndr_push_flags_fn_t)ndr_push_GUID);
     632           2 :         torture_assert_ndr_err_equal(tctx, ndr_err, NDR_ERR_SUCCESS,
     633             :                                      "wrong NDR error");
     634           2 :         torture_assert_data_blob_equal(tctx, b, exp,
     635             :                                        "GUID packed wrongly");
     636             : 
     637           0 :         return true;
     638             : }
     639             : 
     640             : /* Really a test of ndr_push_struct_into_fixed_blob error handling */
     641           2 : static bool test_guid_into_long_blob(struct torture_context *tctx)
     642             : {
     643             :         enum ndr_err_code ndr_err;
     644           2 :         char ndr_guid[17] =
     645             :                 { 0x0, 0x0, 0x0, 0x0,
     646             :                   0x0, 0x0, 0x0, 0x0,
     647             :                   0x0, 0x0, 0x0, 0x0,
     648             :                   0x0, 0x0, 0x0, 0x0, 0x0 };
     649           2 :         DATA_BLOB b = data_blob_const(ndr_guid, 17);
     650             :         struct GUID guid;
     651           2 :         guid.time_low = 1;
     652           2 :         guid.time_mid = 2;
     653           2 :         guid.time_hi_and_version = 3;
     654           2 :         guid.clock_seq[0] = 4;
     655           2 :         guid.clock_seq[1] = 5;
     656           2 :         guid.node[0] = 6;
     657           2 :         guid.node[1] = 7;
     658           2 :         guid.node[2] = 8;
     659           2 :         guid.node[3] = 9;
     660           2 :         guid.node[4] = 10;
     661           2 :         guid.node[5] = 11;
     662             : 
     663           2 :         torture_assert(tctx, b.data != NULL, "data_blob_talloc failed");
     664           2 :         ndr_err = ndr_push_struct_into_fixed_blob(
     665             :                 &b, &guid, (ndr_push_flags_fn_t)ndr_push_GUID);
     666           2 :         torture_assert_ndr_err_equal(tctx, ndr_err, NDR_ERR_BUFSIZE,
     667             :                                      "wrong NDR error");
     668             : 
     669           0 :         return true;
     670             : }
     671             : 
     672           2 : static bool test_guid_into_short_blob(struct torture_context *tctx)
     673             : {
     674             :         enum ndr_err_code ndr_err;
     675           2 :         char ndr_guid[15] =
     676             :                 { 0x0, 0x0, 0x0, 0x0,
     677             :                   0x0, 0x0, 0x0, 0x0,
     678             :                   0x0, 0x0, 0x0, 0x0,
     679             :                   0x0, 0x0, 0x0 };
     680           2 :         DATA_BLOB b = data_blob_const(ndr_guid, 15);
     681             :         struct GUID guid;
     682           2 :         guid.time_low = 1;
     683           2 :         guid.time_mid = 2;
     684           2 :         guid.time_hi_and_version = 3;
     685           2 :         guid.clock_seq[0] = 4;
     686           2 :         guid.clock_seq[1] = 5;
     687           2 :         guid.node[0] = 6;
     688           2 :         guid.node[1] = 7;
     689           2 :         guid.node[2] = 8;
     690           2 :         guid.node[3] = 9;
     691           2 :         guid.node[4] = 10;
     692           2 :         guid.node[5] = 11;
     693             : 
     694           2 :         ndr_err = ndr_push_struct_into_fixed_blob(
     695             :                 &b, &guid, (ndr_push_flags_fn_t)ndr_push_GUID);
     696           2 :         torture_assert_ndr_err_equal(tctx, ndr_err, NDR_ERR_BUFSIZE,
     697             :                                      "wrong NDR error");
     698             : 
     699           0 :         return true;
     700             : }
     701             : 
     702           2 : static bool test_compare_uuid(struct torture_context *tctx)
     703             : {
     704             :         struct GUID g1, g2;
     705           2 :         ZERO_STRUCT(g1); ZERO_STRUCT(g2);
     706           2 :         torture_assert_int_equal(tctx, 0, GUID_compare(&g1, &g2),
     707             :                                  "GUIDs not equal");
     708           2 :         g1.time_low = 1;
     709           2 :         torture_assert_int_equal(tctx, 1, GUID_compare(&g1, &g2),
     710             :                                  "GUID diff invalid");
     711             : 
     712           2 :         g1.time_low = 10;
     713           2 :         torture_assert_int_equal(tctx, 1, GUID_compare(&g1, &g2),
     714             :                                  "GUID diff invalid");
     715             : 
     716           2 :         g1.time_low = 0;
     717           2 :         g1.clock_seq[1] = 20;
     718           2 :         torture_assert_int_equal(tctx, 1, GUID_compare(&g1, &g2),
     719             :                                  "GUID diff invalid");
     720             : 
     721           2 :         g1.time_low = ~0;
     722           2 :         torture_assert_int_equal(tctx, 1, GUID_compare(&g1, &g2),
     723             :                                  "GUID diff invalid");
     724             : 
     725           2 :         g1.time_low = 0;
     726           2 :         g2.time_low = ~0;
     727           2 :         torture_assert_int_equal(tctx, -1, GUID_compare(&g1, &g2),
     728             :                                  "GUID diff invalid");
     729           0 :         return true;
     730             : }
     731             : 
     732           2 : static bool test_syntax_id_from_string(struct torture_context *tctx)
     733             : {
     734             :         struct ndr_syntax_id s, exp;
     735           2 :         const char *id = "00000001-0002-0003-0405-060708090a0b/0x12345678";
     736             : 
     737           2 :         exp.uuid.time_low = 1;
     738           2 :         exp.uuid.time_mid = 2;
     739           2 :         exp.uuid.time_hi_and_version = 3;
     740           2 :         exp.uuid.clock_seq[0] = 4;
     741           2 :         exp.uuid.clock_seq[1] = 5;
     742           2 :         exp.uuid.node[0] = 6;
     743           2 :         exp.uuid.node[1] = 7;
     744           2 :         exp.uuid.node[2] = 8;
     745           2 :         exp.uuid.node[3] = 9;
     746           2 :         exp.uuid.node[4] = 10;
     747           2 :         exp.uuid.node[5] = 11;
     748           2 :         exp.if_version = 0x12345678;
     749             : 
     750           2 :         torture_assert(tctx,
     751             :                        ndr_syntax_id_from_string(id, &s),
     752             :                        "invalid return code");
     753           2 :         torture_assert(tctx, ndr_syntax_id_equal(&s, &exp),
     754             :                        "NDR syntax id parsed incorrectly");
     755           0 :         return true;
     756             : }
     757             : 
     758        2355 : struct torture_suite *torture_local_ndr(TALLOC_CTX *mem_ctx)
     759             : {
     760        2355 :         struct torture_suite *suite = torture_suite_create(mem_ctx, "ndr");
     761             : 
     762        2355 :         torture_suite_add_suite(suite, ndr_winreg_suite(suite));
     763        2355 :         torture_suite_add_suite(suite, ndr_atsvc_suite(suite));
     764        2355 :         torture_suite_add_suite(suite, ndr_lsa_suite(suite));
     765        2355 :         torture_suite_add_suite(suite, ndr_epmap_suite(suite));
     766        2355 :         torture_suite_add_suite(suite, ndr_dfs_suite(suite));
     767        2355 :         torture_suite_add_suite(suite, ndr_dfsblob_suite(suite));
     768        2355 :         torture_suite_add_suite(suite, ndr_netlogon_suite(suite));
     769        2355 :         torture_suite_add_suite(suite, ndr_drsuapi_suite(suite));
     770        2355 :         torture_suite_add_suite(suite, ndr_spoolss_suite(suite));
     771        2355 :         torture_suite_add_suite(suite, ndr_winspool_suite(suite));
     772        2355 :         torture_suite_add_suite(suite, ndr_ntprinting_suite(suite));
     773        2355 :         torture_suite_add_suite(suite, ndr_samr_suite(suite));
     774        2355 :         torture_suite_add_suite(suite, ndr_drsblobs_suite(suite));
     775        2355 :         torture_suite_add_suite(suite, ndr_dnsp_suite(suite));
     776        2355 :         torture_suite_add_suite(suite, ndr_nbt_suite(suite));
     777        2355 :         torture_suite_add_suite(suite, ndr_ntlmssp_suite(suite));
     778        2355 :         torture_suite_add_suite(suite, ndr_backupkey_suite(suite));
     779        2355 :         torture_suite_add_suite(suite, ndr_witness_suite(suite));
     780        2355 :         torture_suite_add_suite(suite, ndr_clusapi_suite(suite));
     781        2355 :         torture_suite_add_suite(suite, ndr_negoex_suite(suite));
     782        2355 :         torture_suite_add_suite(suite, ndr_string_suite(suite));
     783        2355 :         torture_suite_add_suite(suite, ndr_krb5pac_suite(suite));
     784        2355 :         torture_suite_add_suite(suite, ndr_cabinet_suite(suite));
     785        2355 :         torture_suite_add_suite(suite, ndr_charset_suite(suite));
     786        2355 :         torture_suite_add_suite(suite, ndr_svcctl_suite(suite));
     787        2355 :         torture_suite_add_suite(suite, ndr_ODJ_suite(suite));
     788             : 
     789        2355 :         torture_suite_add_simple_test(suite, "string terminator",
     790             :                                       test_check_string_terminator);
     791             : 
     792        2355 :         torture_suite_add_simple_test(suite, "guid_from_string_null",
     793             :                                       test_guid_from_string_null);
     794             : 
     795        2355 :         torture_suite_add_simple_test(suite, "guid_from_string",
     796             :                                       test_guid_from_string);
     797             : 
     798        2355 :         torture_suite_add_simple_test(suite, "guid_from_data_blob",
     799             :                                       test_guid_from_data_blob);
     800             : 
     801        2355 :         torture_suite_add_simple_test(suite, "guid_from_string_invalid",
     802             :                                       test_guid_from_string_invalid);
     803             : 
     804        2355 :         torture_suite_add_simple_test(suite, "guid_string_valid",
     805             :                                       test_guid_string_valid);
     806             : 
     807        2355 :         torture_suite_add_simple_test(suite, "guid_string2_valid",
     808             :                                       test_guid_string2_valid);
     809             : 
     810        2355 :         torture_suite_add_simple_test(suite, "guid_from_string_valid",
     811             :                                       test_guid_from_string_valid);
     812             : 
     813        2355 :         torture_suite_add_simple_test(suite, "compare_uuid",
     814             :                                       test_compare_uuid);
     815             : 
     816        2355 :         torture_suite_add_simple_test(suite, "guid_into_blob",
     817             :                                       test_guid_into_blob);
     818             : 
     819        2355 :         torture_suite_add_simple_test(suite, "guid_into_short_blob",
     820             :                                       test_guid_into_short_blob);
     821             : 
     822        2355 :         torture_suite_add_simple_test(suite, "guid_into_long_blob",
     823             :                                       test_guid_into_long_blob);
     824             : 
     825        2355 :         torture_suite_add_simple_test(suite, "syntax_id_from_string",
     826             :                                       test_syntax_id_from_string);
     827             : 
     828        2355 :         return suite;
     829             : }
     830             : 

Generated by: LCOV version 1.13