Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
1 deleted
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source4/lib/registry/tests/diff.c

    r414 r745  
    5353{
    5454        struct diff_tcase_data *td = tcase_data;
    55         struct smb_iconv_convenience *ic;
    5655        struct reg_diff_callbacks *callbacks;
    5756        void *data;
    5857        WERROR error;
    5958
    60         ic = lp_iconv_convenience(tctx->lp_ctx);
    61 
    62         error = reg_diff_load(td->filename, iconv_convenience, callbacks, data);
     59        error = reg_diff_load(td->filename, callbacks, data);
    6360        torture_assert_werr_ok(tctx, error, "reg_diff_load");
    6461
    … …  
    7269        WERROR error;
    7370
    74         error = reg_diff_apply(td->r1_ctx, lp_iconv_convenience(tctx->lp_ctx), td->filename);
     71        error = reg_diff_apply(td->r1_ctx, td->filename);
    7572        torture_assert_werr_ok(tctx, error, "reg_diff_apply");
    7673
    … …  
    228225        torture_assert_werr_ok(tctx, error, "Creating HKLM\\..\\Policies\\Explorer failed");
    229226
    230 
    231         blob.data = (void *)talloc(r2_ctx, uint32_t);
    232         SIVAL(blob.data, 0, 0x03ffffff);
    233         blob.length = sizeof(uint32_t);
     227        blob.data = talloc_array(r2_ctx, uint8_t, 4);
     228        /* set "0x03FFFFFF" in little endian format */
     229        blob.data[0] = 0xFF; blob.data[1] = 0xFF;
     230        blob.data[2] = 0xFF; blob.data[3] = 0x03;
     231        blob.length = 4;
    234232
    235233        r1_ctx->ops->set_value(newkey, "NoDrives", REG_DWORD, blob);
    … …  
    247245{
    248246        struct diff_tcase_data *td;
    249         struct smb_iconv_convenience *ic;
    250247        WERROR error;
    251248
    … …  
    253250        td = *data;
    254251
    255         ic = lp_iconv_convenience(tctx->lp_ctx);
    256 
    257252        td->filename = talloc_asprintf(tctx, "%s/test.pol", td->tempdir);
    258         error = reg_preg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
     253        error = reg_preg_diff_save(tctx, td->filename,  &td->callbacks,
     254                                                           &td->callback_data);
    259255        torture_assert_werr_ok(tctx, error, "reg_preg_diff_save");
    260256
    … …  
    265261{
    266262        struct diff_tcase_data *td;
    267         struct smb_iconv_convenience *ic;
    268263        WERROR error;
    269264
    … …  
    271266        td = *data;
    272267
    273         ic = lp_iconv_convenience(tctx->lp_ctx);
    274        
    275268        td->filename = talloc_asprintf(tctx, "%s/test.reg", td->tempdir);
    276         error = reg_dotreg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
     269        error = reg_dotreg_diff_save(tctx, td->filename, &td->callbacks,
     270                                                                 &td->callback_data);
    277271        torture_assert_werr_ok(tctx, error, "reg_dotreg_diff_save");
    278272
    … …  
    283277{
    284278        struct torture_tcase *tcase;
    285         struct torture_suite *suite = torture_suite_create(mem_ctx, "DIFF");
     279        struct torture_suite *suite = torture_suite_create(mem_ctx, "diff");
    286280
    287281        tcase = torture_suite_add_tcase(suite, "PReg");

  • trunk/server/source4/lib/registry/tests/generic.c

    r414 r745  
    3232static bool test_str_regtype(struct torture_context *ctx)
    3333{
     34        torture_assert_str_equal(ctx, str_regtype(0),
     35                                 "REG_NONE", "REG_NONE failed");
    3436        torture_assert_str_equal(ctx, str_regtype(1),
    3537                                 "REG_SZ", "REG_SZ failed");
     38        torture_assert_str_equal(ctx, str_regtype(2),
     39                                 "REG_EXPAND_SZ", "REG_EXPAND_SZ failed");
     40        torture_assert_str_equal(ctx, str_regtype(3),
     41                                 "REG_BINARY", "REG_BINARY failed");
    3642        torture_assert_str_equal(ctx, str_regtype(4),
    3743                                 "REG_DWORD", "REG_DWORD failed");
     44        torture_assert_str_equal(ctx, str_regtype(5),
     45                                 "REG_DWORD_BIG_ENDIAN", "REG_DWORD_BIG_ENDIAN failed");
     46        torture_assert_str_equal(ctx, str_regtype(6),
     47                                 "REG_LINK", "REG_LINK failed");
     48        torture_assert_str_equal(ctx, str_regtype(7),
     49                                 "REG_MULTI_SZ", "REG_MULTI_SZ failed");
     50        torture_assert_str_equal(ctx, str_regtype(8),
     51                                 "REG_RESOURCE_LIST", "REG_RESOURCE_LIST failed");
     52        torture_assert_str_equal(ctx, str_regtype(9),
     53                                 "REG_FULL_RESOURCE_DESCRIPTOR", "REG_FULL_RESOURCE_DESCRIPTOR failed");
     54        torture_assert_str_equal(ctx, str_regtype(10),
     55                                 "REG_RESOURCE_REQUIREMENTS_LIST", "REG_RESOURCE_REQUIREMENTS_LIST failed");
     56        torture_assert_str_equal(ctx, str_regtype(11),
     57                                 "REG_QWORD", "REG_QWORD failed");
    3858
    3959        return true;
    … …  
    4363static bool test_reg_val_data_string_dword(struct torture_context *ctx)
    4464{
    45         uint32_t d = 0x20;
    46         DATA_BLOB db = { (uint8_t *)&d, sizeof(d) };
    47         torture_assert_str_equal(ctx, "0x20",
    48                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_DWORD, db),
     65        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
     66        DATA_BLOB db = { d, 4 };
     67        torture_assert_str_equal(ctx, "0x00000020",
     68                                 reg_val_data_string(ctx, REG_DWORD, db),
    4969                                 "dword failed");
     70        return true;
     71}
     72
     73static bool test_reg_val_data_string_dword_big_endian(struct torture_context *ctx)
     74{
     75        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
     76        DATA_BLOB db = { d, 4 };
     77        torture_assert_str_equal(ctx, "0x00000020",
     78                                 reg_val_data_string(ctx, REG_DWORD_BIG_ENDIAN, db),
     79                                 "dword failed");
     80        return true;
     81}
     82
     83static bool test_reg_val_data_string_qword(struct torture_context *ctx)
     84{
     85        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
     86        DATA_BLOB db = { d, 8 };
     87        torture_assert_str_equal(ctx, "0x0000000000000020",
     88                                 reg_val_data_string(ctx, REG_QWORD, db),
     89                                 "qword failed");
    5090        return true;
    5191}
    … …  
    5494{
    5595        DATA_BLOB db;
    56         convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
     96        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
    5797                                          "bla", 3, (void **)&db.data, &db.length, false);
    5898        torture_assert_str_equal(ctx, "bla",
    59                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
     99                                 reg_val_data_string(ctx, REG_SZ, db),
    60100                                 "sz failed");
    61101        db.length = 4;
    62102        torture_assert_str_equal(ctx, "bl",
    63                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
     103                                 reg_val_data_string(ctx, REG_SZ, db),
    64104                                 "sz failed");
    65105        return true;
    … …  
    71111        DATA_BLOB db = { x, 4 };
    72112        torture_assert_str_equal(ctx, "01020304",
    73                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
     113                                 reg_val_data_string(ctx, REG_BINARY, db),
    74114                                 "binary failed");
    75115        return true;
    … …  
    81121        DATA_BLOB db = { NULL, 0 };
    82122        torture_assert_str_equal(ctx, "",
    83                                  reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
     123                                 reg_val_data_string(ctx, REG_BINARY, db),
    84124                                 "empty failed");
    85125        return true;
    … …  
    89129{
    90130        DATA_BLOB data;
    91         convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
     131        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
    92132                                            "stationary traveller",
    93133                                            strlen("stationary traveller"),
    94134                                            (void **)&data.data, &data.length, false);
    95135        torture_assert_str_equal(ctx, "camel = REG_SZ : stationary traveller",
    96                                  reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), "camel", REG_SZ, data),
     136                                 reg_val_description(ctx, "camel", REG_SZ, data),
    97137                                 "reg_val_description failed");
    98138        return true;
    … …  
    103143{
    104144        DATA_BLOB data;
    105         convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
     145        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
    106146                                            "west berlin",
    107147                                            strlen("west berlin"),
    108148                                            (void **)&data.data, &data.length, false);
    109149        torture_assert_str_equal(ctx, "<No Name> = REG_SZ : west berlin",
    110                                  reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), NULL, REG_SZ, data),
     150                                 reg_val_description(ctx, NULL, REG_SZ, data),
    111151                                 "description with null name failed");
    112152        return true;
    … …  
    115155struct torture_suite *torture_registry(TALLOC_CTX *mem_ctx)
    116156{
    117         struct torture_suite *suite = torture_suite_create(mem_ctx, "REGISTRY");
     157        struct torture_suite *suite = torture_suite_create(mem_ctx, "registry");
    118158        torture_suite_add_simple_test(suite, "str_regtype",
    119159                                      test_str_regtype);
    120160        torture_suite_add_simple_test(suite, "reg_val_data_string dword",
    121161                                      test_reg_val_data_string_dword);
     162        torture_suite_add_simple_test(suite, "reg_val_data_string dword_big_endian",
     163                                      test_reg_val_data_string_dword_big_endian);
     164        torture_suite_add_simple_test(suite, "reg_val_data_string qword",
     165                                      test_reg_val_data_string_qword);
    122166        torture_suite_add_simple_test(suite, "reg_val_data_string sz",
    123167                                      test_reg_val_data_string_sz);

  • trunk/server/source4/lib/registry/tests/hive.c

    r414 r745  
    3333{
    3434        const struct hive_key *root = (const struct hive_key *)test_data;
    35         WERROR error = hive_key_del(root, "bla");
     35        WERROR error = hive_key_del(tctx, root, "bla");
    3636        torture_assert_werr_equal(tctx, error, WERR_BADFILE,
    3737                                  "invalid return code");
    … …  
    7070        WERROR error;
    7171        struct hive_key *subkey;
    72         char data[4];
    73         SIVAL(data, 0, 42);
     72        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
     73        DATA_BLOB db = { d, 4 };
    7474
    7575        error = hive_key_add_name(tctx, root, "Nested Keyll", NULL,
    … …  
    7777        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
    7878
    79         error = hive_key_set_value(root, "Answer", REG_DWORD,
    80                                data_blob_talloc(tctx, data, sizeof(data)));
     79        error = hive_key_set_value(root, "Answer", REG_DWORD, db);
    8180        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
    8281
    … …  
    108107        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
    109108
    110         error = hive_key_del(root, "Nested Key");
     109        error = hive_key_del(mem_ctx, root, "Nested Key");
    111110        torture_assert_werr_ok(tctx, error, "reg_key_del");
    112111
    … …  
    122121        const struct hive_key *root = (const struct hive_key *)test_data;
    123122        TALLOC_CTX *mem_ctx = tctx;
    124         char data[4];
    125         SIVAL(data, 0, 42);
     123        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
     124        DATA_BLOB db = { d, 4 };
    126125
    127126        /* Create a new key under the root */
    … …  
    136135
    137136        /* Create a new value under "Child Key" */
    138         error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD,
    139                                data_blob_talloc(mem_ctx, data, sizeof(data)));
     137        error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD, db);
    140138        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
    141139
    142140        /* Deleting "Parent Key" will also delete "Child Key" and the value. */
    143         error = hive_key_del(root, "Parent Key");
     141        error = hive_key_del(mem_ctx, root, "Parent Key");
    144142        torture_assert_werr_ok(tctx, error, "hive_key_del");
    145143
    … …  
    167165        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
    168166
    169         error = hive_key_del(root, "Nested Key");
     167        error = hive_key_del(mem_ctx, root, "Nested Key");
    170168        torture_assert_werr_ok(tctx, error, "reg_key_del");
    171169
    172         error = hive_key_del(root, "Nested Key");
     170        error = hive_key_del(mem_ctx, root, "Nested Key");
    173171        torture_assert_werr_equal(tctx, error, WERR_BADFILE, "reg_key_del");
    174172
    … …  
    183181        const struct hive_key *root = (const struct hive_key *)test_data;
    184182        TALLOC_CTX *mem_ctx = tctx;
    185         char data[4];
    186         SIVAL(data, 0, 42);
     183        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
     184        DATA_BLOB db = { d, 4 };
    187185
    188186        error = hive_key_add_name(mem_ctx, root, "YA Nested Key", NULL,
    … …  
    190188        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
    191189
    192         error = hive_key_set_value(subkey, "Answer", REG_DWORD,
    193                                data_blob_talloc(mem_ctx, data, sizeof(data)));
     190        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
    194191        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
    195192
    … …  
    203200        const struct hive_key *root = (const struct hive_key *)test_data;
    204201        TALLOC_CTX *mem_ctx = tctx;
    205         char data[4];
    206202        uint32_t type;
    207         DATA_BLOB value;
    208 
    209         SIVAL(data, 0, 42);
     203        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
     204        DATA_BLOB db = { d, 4 }, data;
    210205
    211206        error = hive_key_add_name(mem_ctx, root, "EYA Nested Key", NULL,
    … …  
    213208        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
    214209
    215         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
     210        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
    216211        torture_assert_werr_equal(tctx, error, WERR_BADFILE,
    217212                                  "getting missing value");
    218213
    219         error = hive_key_set_value(subkey, "Answer", REG_DWORD,
    220                                data_blob_talloc(mem_ctx, data, sizeof(data)));
    221         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
    222 
    223         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
     214        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
     215        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
     216
     217        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
    224218        torture_assert_werr_ok(tctx, error, "getting value");
    225219
    226         torture_assert_int_equal(tctx, value.length, 4, "value length");
     220        torture_assert_int_equal(tctx, data.length, 4, "value length");
    227221        torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
    228222
    229         torture_assert_mem_equal(tctx, &data, value.data, sizeof(uint32_t),
    230                                  "value data");
     223        torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
    231224
    232225        return true;
    … …  
    239232        const struct hive_key *root = (const struct hive_key *)test_data;
    240233        TALLOC_CTX *mem_ctx = tctx;
    241         char data[4];
    242234        uint32_t type;
    243         DATA_BLOB value;
    244 
    245         SIVAL(data, 0, 42);
     235        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
     236        DATA_BLOB db = { d, 4 };
    246237
    247238        error = hive_key_add_name(mem_ctx, root, "EEYA Nested Key", NULL,
    … …  
    249240        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
    250241
    251         error = hive_key_set_value(subkey, "Answer", REG_DWORD,
    252                                data_blob_talloc(mem_ctx, data, sizeof(data)));
    253         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
    254 
    255         error = hive_key_del_value(subkey, "Answer");
     242        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
     243        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
     244
     245        error = hive_key_del_value(mem_ctx, subkey, "Answer");
    256246        torture_assert_werr_ok(tctx, error, "deleting value");
    257247
    258         error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
     248        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &db);
    259249        torture_assert_werr_equal(tctx, error, WERR_BADFILE, "getting value");
    260250
    261         error = hive_key_del_value(subkey, "Answer");
     251        error = hive_key_del_value(mem_ctx, subkey, "Answer");
    262252        torture_assert_werr_equal(tctx, error, WERR_BADFILE,
    263253                                  "deleting value");
    … …  
    273263        const struct hive_key *root = (const struct hive_key *)test_data;
    274264        TALLOC_CTX *mem_ctx = tctx;
    275         char data[4];
    276265        uint32_t type;
    277         DATA_BLOB value;
     266        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
     267        DATA_BLOB db = { d, 4 }, data;
    278268        const char *name;
    279         int data_val = 42;
    280         SIVAL(data, 0, data_val);
    281269
    282270        error = hive_key_add_name(mem_ctx, root, "AYAYA Nested Key", NULL,
    … …  
    284272        torture_assert_werr_ok(tctx, error, "hive_key_add_name");
    285273
    286         error = hive_key_set_value(subkey, "Answer", REG_DWORD,
    287                                data_blob_talloc(mem_ctx, data, sizeof(data)));
     274        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
    288275        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
    289276
    290277        error = hive_get_value_by_index(mem_ctx, subkey, 0, &name,
    291                                         &type, &value);
     278                                        &type, &data);
    292279        torture_assert_werr_ok(tctx, error, "getting value");
    293280
    294281        torture_assert_str_equal(tctx, name, "Answer", "value name");
    295282
    296         torture_assert_int_equal(tctx, value.length, 4, "value length");
     283        torture_assert_int_equal(tctx, data.length, 4, "value length");
    297284        torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
    298285       
     286        torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
    299287       
    300         torture_assert_int_equal(tctx, data_val, IVAL(value.data, 0), "value data");
    301 
    302288        error = hive_get_value_by_index(mem_ctx, subkey, 1, &name,
    303                                         &type, &value);
     289                                        &type, &data);
    304290        torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
    305291                                  "getting missing value");
    … …  
    450436        rmdir(dirname);
    451437
    452         error = reg_create_regf_file(tctx, lp_iconv_convenience(tctx->lp_ctx),
    453                                      dirname, 5, &key);
     438        error = reg_create_regf_file(tctx, dirname, 5, &key);
    454439        if (!W_ERROR_IS_OK(error)) {
    455440                fprintf(stderr, "Unable to create new regf file\n");
    … …  
    473458{
    474459        struct torture_tcase *tcase;
    475         struct torture_suite *suite = torture_suite_create(mem_ctx, "HIVE");
     460        struct torture_suite *suite = torture_suite_create(mem_ctx, "hive");
    476461
    477462        torture_suite_add_simple_test(suite, "dir-refuses-null-location",

  • trunk/server/source4/lib/registry/tests/registry.c

    r414 r745  
    118118{
    119119        struct registry_context *rctx = (struct registry_context *)_data;
    120         struct registry_key *root, *newkey1, *newkey2;
     120        struct registry_key *root, *newkey;
    121121        WERROR error;
    122122
    … …  
    125125                               "getting predefined key failed");
    126126
    127         error = reg_key_add_name(rctx, root, "Hamburg", NULL, NULL,
    128                                  &newkey1);
     127        error = reg_key_add_name(rctx, root, "Hamburg\\Hamburg", NULL, NULL,
     128                                 &newkey);
    129129        torture_assert_werr_ok(tctx, error, "Creating key return code");
    130         torture_assert(tctx, newkey1 != NULL, "Creating new key");
    131 
    132         error = reg_key_add_name(rctx, root, "Hamburg\\Hamburg", NULL, NULL,
    133                                  &newkey2);
    134         torture_assert_werr_ok(tctx, error, "Creating key return code");
    135         torture_assert(tctx, newkey2 != NULL, "Creating new key");
     130        torture_assert(tctx, newkey != NULL, "Creating new key");
    136131
    137132        return true;
    … …  
    201196        torture_assert(tctx, newkey != NULL, "Creating new key");
    202197
    203         error = reg_key_del(root, "Polen");
     198        error = reg_key_del(tctx, root, "Polen");
    204199        torture_assert_werr_ok(tctx, error, "Delete key");
    205200
    206         error = reg_key_del(root, "Polen");
     201        error = reg_key_del(tctx, root, "Polen");
    207202        torture_assert_werr_equal(tctx, error, WERR_BADFILE,
    208203                                  "Delete missing key");
    … …  
    465460        torture_assert_werr_ok (tctx, error, "setting value");
    466461
    467         error = reg_del_value(subkey, __FUNCTION__);
     462        error = reg_del_value(tctx, subkey, __FUNCTION__);
    468463        torture_assert_werr_ok (tctx, error, "unsetting value");
    469464
    … …  
    585580{
    586581        struct torture_tcase *tcase;
    587         struct torture_suite *suite = torture_suite_create(mem_ctx, "REGISTRY");
     582        struct torture_suite *suite = torture_suite_create(mem_ctx, "registry");
    588583
    589584        tcase = torture_suite_add_tcase(suite, "local");
Note: See TracChangeset for help on using the changeset viewer.