← Back to branch summary

~ubuntu-branches/ubuntu/maverick/samba/maverick-security

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/ndr_misc.c

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2010-01-29 06:16:15 UTC
  • mfrom: (0.27.9 upstream) (0.34.4 squeeze)
  • Revision ID: james.westby@ubuntu.com-20100129061615-37hs6xqpsdhjq3ld
Tags: 2:3.4.5~dfsg-1ubuntu1
https://launchpad.net/bugs/462169
https://launchpad.net/bugs/493565
* Merge from debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/smb.conf:
    - Add "(Samba, Ubuntu)" to server string.
    - Comment out the default [homes] share, and add a comment about "valid users = %s"
      to show users how to restrict access to \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are allowed to create
      public shares in additon to authenticated ones.
    - add map to guest = Bad user, maps bad username to gues access.
  + debian/samba-common.conf:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/mksambapasswd.awk:
    - Do not add user with UID less than 1000 to smbpasswd.
  + debian/control: 
    - Make libswbclient0 replace/conflict with hardy's likewise-open.
    - Don't build against ctdb, since its not in main yet.
  + debian/rules:
    - Enable "native" PIE hardening.
    - Add BIND_NOW to maximize benefit of RELRO hardening.
  + Add ufw integration:
    - Created debian/samba.ufw.profile.
    - debian/rules, debian/samba.dirs, debian/samba.files: install
  + Add apoort hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + debian/rules, debian/samba.if-up: allow "NetworkManager" as a recognized address
    family... it's obviously /not/ an address family, but it's what gets
    sent when using NM, so we'll cope for now.  (LP: #462169). Taken from karmic-proposed.
  + debian/control: Recommend keyutils for smbfs (LP: #493565)
  + Dropped patches:
    - debian/patches/security-CVE-2009-3297.patch: No longer needed
    - debian/patches/fix-too-many-open-files.patch: No longer needed

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/ndr_misc.c
168
168
        ndr->depth--;
169
169
}
170
170
 
 
171
_PUBLIC_ enum ndr_err_code ndr_push_winreg_Type(struct ndr_push *ndr, int ndr_flags, enum winreg_Type r)
 
172
{
 
173
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 
174
        return NDR_ERR_SUCCESS;
 
175
}
 
176
 
 
177
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Type(struct ndr_pull *ndr, int ndr_flags, enum winreg_Type *r)
 
178
{
 
179
        uint32_t v;
 
180
        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 
181
        *r = v;
 
182
        return NDR_ERR_SUCCESS;
 
183
}
 
184
 
 
185
_PUBLIC_ void ndr_print_winreg_Type(struct ndr_print *ndr, const char *name, enum winreg_Type r)
 
186
{
 
187
        const char *val = NULL;
 
188
 
 
189
        switch (r) {
 
190
                case REG_NONE: val = "REG_NONE"; break;
 
191
                case REG_SZ: val = "REG_SZ"; break;
 
192
                case REG_EXPAND_SZ: val = "REG_EXPAND_SZ"; break;
 
193
                case REG_BINARY: val = "REG_BINARY"; break;
 
194
                case REG_DWORD: val = "REG_DWORD"; break;
 
195
                case REG_DWORD_BIG_ENDIAN: val = "REG_DWORD_BIG_ENDIAN"; break;
 
196
                case REG_LINK: val = "REG_LINK"; break;
 
197
                case REG_MULTI_SZ: val = "REG_MULTI_SZ"; break;
 
198
                case REG_RESOURCE_LIST: val = "REG_RESOURCE_LIST"; break;
 
199
                case REG_FULL_RESOURCE_DESCRIPTOR: val = "REG_FULL_RESOURCE_DESCRIPTOR"; break;
 
200
                case REG_RESOURCE_REQUIREMENTS_LIST: val = "REG_RESOURCE_REQUIREMENTS_LIST"; break;
 
201
                case REG_QWORD: val = "REG_QWORD"; break;
 
202
        }
 
203
        ndr_print_enum(ndr, name, "ENUM", val, r);
 
204
}
 
205
 
 
206
_PUBLIC_ enum ndr_err_code ndr_push_winreg_Data(struct ndr_push *ndr, int ndr_flags, const union winreg_Data *r)
 
207
{
 
208
        {
 
209
                uint32_t _flags_save_UNION = ndr->flags;
 
210
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
211
                if (ndr_flags & NDR_SCALARS) {
 
212
                        int level = ndr_push_get_switch_value(ndr, r);
 
213
                        switch (level) {
 
214
                                case REG_NONE: {
 
215
                                break; }
 
216
 
 
217
                                case REG_SZ: {
 
218
                                        {
 
219
                                                uint32_t _flags_save_string = ndr->flags;
 
220
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
221
                                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 
222
                                                ndr->flags = _flags_save_string;
 
223
                                        }
 
224
                                break; }
 
225
 
 
226
                                case REG_EXPAND_SZ: {
 
227
                                        {
 
228
                                                uint32_t _flags_save_string = ndr->flags;
 
229
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
230
                                                NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
 
231
                                                ndr->flags = _flags_save_string;
 
232
                                        }
 
233
                                break; }
 
234
 
 
235
                                case REG_BINARY: {
 
236
                                        {
 
237
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
238
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
239
                                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
 
240
                                                ndr->flags = _flags_save_DATA_BLOB;
 
241
                                        }
 
242
                                break; }
 
243
 
 
244
                                case REG_DWORD: {
 
245
                                        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
 
246
                                break; }
 
247
 
 
248
                                case REG_DWORD_BIG_ENDIAN: {
 
249
                                        {
 
250
                                                uint32_t _flags_save_uint32 = ndr->flags;
 
251
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 
252
                                                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
 
253
                                                ndr->flags = _flags_save_uint32;
 
254
                                        }
 
255
                                break; }
 
256
 
 
257
                                case REG_MULTI_SZ: {
 
258
                                        {
 
259
                                                uint32_t _flags_save_string_array = ndr->flags;
 
260
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
261
                                                NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
 
262
                                                ndr->flags = _flags_save_string_array;
 
263
                                        }
 
264
                                break; }
 
265
 
 
266
                                default: {
 
267
                                        {
 
268
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
269
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
270
                                                NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
 
271
                                                ndr->flags = _flags_save_DATA_BLOB;
 
272
                                        }
 
273
                                break; }
 
274
 
 
275
                        }
 
276
                }
 
277
                if (ndr_flags & NDR_BUFFERS) {
 
278
                        int level = ndr_push_get_switch_value(ndr, r);
 
279
                        switch (level) {
 
280
                                case REG_NONE:
 
281
                                break;
 
282
 
 
283
                                case REG_SZ:
 
284
                                break;
 
285
 
 
286
                                case REG_EXPAND_SZ:
 
287
                                break;
 
288
 
 
289
                                case REG_BINARY:
 
290
                                break;
 
291
 
 
292
                                case REG_DWORD:
 
293
                                break;
 
294
 
 
295
                                case REG_DWORD_BIG_ENDIAN:
 
296
                                break;
 
297
 
 
298
                                case REG_MULTI_SZ:
 
299
                                break;
 
300
 
 
301
                                default:
 
302
                                break;
 
303
 
 
304
                        }
 
305
                }
 
306
                ndr->flags = _flags_save_UNION;
 
307
        }
 
308
        return NDR_ERR_SUCCESS;
 
309
}
 
310
 
 
311
_PUBLIC_ enum ndr_err_code ndr_pull_winreg_Data(struct ndr_pull *ndr, int ndr_flags, union winreg_Data *r)
 
312
{
 
313
        int level;
 
314
        {
 
315
                uint32_t _flags_save_UNION = ndr->flags;
 
316
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
317
                level = ndr_pull_get_switch_value(ndr, r);
 
318
                if (ndr_flags & NDR_SCALARS) {
 
319
                        switch (level) {
 
320
                                case REG_NONE: {
 
321
                                break; }
 
322
 
 
323
                                case REG_SZ: {
 
324
                                        {
 
325
                                                uint32_t _flags_save_string = ndr->flags;
 
326
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
327
                                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 
328
                                                ndr->flags = _flags_save_string;
 
329
                                        }
 
330
                                break; }
 
331
 
 
332
                                case REG_EXPAND_SZ: {
 
333
                                        {
 
334
                                                uint32_t _flags_save_string = ndr->flags;
 
335
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
336
                                                NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
 
337
                                                ndr->flags = _flags_save_string;
 
338
                                        }
 
339
                                break; }
 
340
 
 
341
                                case REG_BINARY: {
 
342
                                        {
 
343
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
344
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
345
                                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
 
346
                                                ndr->flags = _flags_save_DATA_BLOB;
 
347
                                        }
 
348
                                break; }
 
349
 
 
350
                                case REG_DWORD: {
 
351
                                        NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
 
352
                                break; }
 
353
 
 
354
                                case REG_DWORD_BIG_ENDIAN: {
 
355
                                        {
 
356
                                                uint32_t _flags_save_uint32 = ndr->flags;
 
357
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_BIGENDIAN);
 
358
                                                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
 
359
                                                ndr->flags = _flags_save_uint32;
 
360
                                        }
 
361
                                break; }
 
362
 
 
363
                                case REG_MULTI_SZ: {
 
364
                                        {
 
365
                                                uint32_t _flags_save_string_array = ndr->flags;
 
366
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
367
                                                NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
 
368
                                                ndr->flags = _flags_save_string_array;
 
369
                                        }
 
370
                                break; }
 
371
 
 
372
                                default: {
 
373
                                        {
 
374
                                                uint32_t _flags_save_DATA_BLOB = ndr->flags;
 
375
                                                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 
376
                                                NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
 
377
                                                ndr->flags = _flags_save_DATA_BLOB;
 
378
                                        }
 
379
                                break; }
 
380
 
 
381
                        }
 
382
                }
 
383
                if (ndr_flags & NDR_BUFFERS) {
 
384
                        switch (level) {
 
385
                                case REG_NONE:
 
386
                                break;
 
387
 
 
388
                                case REG_SZ:
 
389
                                break;
 
390
 
 
391
                                case REG_EXPAND_SZ:
 
392
                                break;
 
393
 
 
394
                                case REG_BINARY:
 
395
                                break;
 
396
 
 
397
                                case REG_DWORD:
 
398
                                break;
 
399
 
 
400
                                case REG_DWORD_BIG_ENDIAN:
 
401
                                break;
 
402
 
 
403
                                case REG_MULTI_SZ:
 
404
                                break;
 
405
 
 
406
                                default:
 
407
                                break;
 
408
 
 
409
                        }
 
410
                }
 
411
                ndr->flags = _flags_save_UNION;
 
412
        }
 
413
        return NDR_ERR_SUCCESS;
 
414
}
 
415
 
 
416
_PUBLIC_ void ndr_print_winreg_Data(struct ndr_print *ndr, const char *name, const union winreg_Data *r)
 
417
{
 
418
        int level;
 
419
        {
 
420
                uint32_t _flags_save_UNION = ndr->flags;
 
421
                ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN);
 
422
                level = ndr_print_get_switch_value(ndr, r);
 
423
                ndr_print_union(ndr, name, level, "winreg_Data");
 
424
                switch (level) {
 
425
                        case REG_NONE:
 
426
                        break;
 
427
 
 
428
                        case REG_SZ:
 
429
                                ndr_print_string(ndr, "string", r->string);
 
430
                        break;
 
431
 
 
432
                        case REG_EXPAND_SZ:
 
433
                                ndr_print_string(ndr, "string", r->string);
 
434
                        break;
 
435
 
 
436
                        case REG_BINARY:
 
437
                                ndr_print_DATA_BLOB(ndr, "binary", r->binary);
 
438
                        break;
 
439
 
 
440
                        case REG_DWORD:
 
441
                                ndr_print_uint32(ndr, "value", r->value);
 
442
                        break;
 
443
 
 
444
                        case REG_DWORD_BIG_ENDIAN:
 
445
                                ndr_print_uint32(ndr, "value", r->value);
 
446
                        break;
 
447
 
 
448
                        case REG_MULTI_SZ:
 
449
                                ndr_print_string_array(ndr, "string_array", r->string_array);
 
450
                        break;
 
451
 
 
452
                        default:
 
453
                                ndr_print_DATA_BLOB(ndr, "data", r->data);
 
454
                        break;
 
455
 
 
456
                }
 
457
                ndr->flags = _flags_save_UNION;
 
458
        }
 
459
}
 
460