← 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_spoolss.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_spoolss.c
18522
18522
        return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
18523
18523
}
18524
18524
 
 
18525
static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
 
18526
{
 
18527
        if (ndr_flags & NDR_SCALARS) {
 
18528
                int level = ndr_push_get_switch_value(ndr, r);
 
18529
                switch (level) {
 
18530
                        case 0: {
 
18531
                        break; }
 
18532
 
 
18533
                        case 1: {
 
18534
                        break; }
 
18535
 
 
18536
                        default: {
 
18537
                                {
 
18538
                                        uint32_t _flags_save_string_array = ndr->flags;
 
18539
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
18540
                                        NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
 
18541
                                        ndr->flags = _flags_save_string_array;
 
18542
                                }
 
18543
                        break; }
 
18544
 
 
18545
                }
 
18546
        }
 
18547
        if (ndr_flags & NDR_BUFFERS) {
 
18548
                int level = ndr_push_get_switch_value(ndr, r);
 
18549
                switch (level) {
 
18550
                        case 0:
 
18551
                        break;
 
18552
 
 
18553
                        case 1:
 
18554
                        break;
 
18555
 
 
18556
                        default:
 
18557
                        break;
 
18558
 
 
18559
                }
 
18560
        }
 
18561
        return NDR_ERR_SUCCESS;
 
18562
}
 
18563
 
 
18564
static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
 
18565
{
 
18566
        int level;
 
18567
        level = ndr_pull_get_switch_value(ndr, r);
 
18568
        if (ndr_flags & NDR_SCALARS) {
 
18569
                switch (level) {
 
18570
                        case 0: {
 
18571
                        break; }
 
18572
 
 
18573
                        case 1: {
 
18574
                        break; }
 
18575
 
 
18576
                        default: {
 
18577
                                {
 
18578
                                        uint32_t _flags_save_string_array = ndr->flags;
 
18579
                                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 
18580
                                        NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
 
18581
                                        ndr->flags = _flags_save_string_array;
 
18582
                                }
 
18583
                        break; }
 
18584
 
 
18585
                }
 
18586
        }
 
18587
        if (ndr_flags & NDR_BUFFERS) {
 
18588
                switch (level) {
 
18589
                        case 0:
 
18590
                        break;
 
18591
 
 
18592
                        case 1:
 
18593
                        break;
 
18594
 
 
18595
                        default:
 
18596
                        break;
 
18597
 
 
18598
                }
 
18599
        }
 
18600
        return NDR_ERR_SUCCESS;
 
18601
}
 
18602
 
 
18603
_PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
 
18604
{
 
18605
        int level;
 
18606
        level = ndr_print_get_switch_value(ndr, r);
 
18607
        ndr_print_union(ndr, name, level, "spoolss_KeyNames");
 
18608
        switch (level) {
 
18609
                case 0:
 
18610
                break;
 
18611
 
 
18612
                case 1:
 
18613
                break;
 
18614
 
 
18615
                default:
 
18616
                        ndr_print_string_array(ndr, "string_array", r->string_array);
 
18617
                break;
 
18618
 
 
18619
        }
 
18620
}
 
18621
 
18525
18622
_PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18526
18623
{
18527
18624
        NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
26631
26728
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26632
26729
        }
26633
26730
        if (flags & NDR_OUT) {
 
26731
                if (r->out._ndr_size == NULL) {
 
26732
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
26733
                }
 
26734
                NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
 
26735
                if (r->out.key_buffer == NULL) {
 
26736
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
 
26737
                }
26634
26738
                {
26635
 
                        uint32_t _flags_save_string_array = ndr->flags;
26636
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26637
 
                        if (r->out.key_buffer == NULL) {
26638
 
                                return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26639
 
                        }
26640
 
                        NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_buffer));
26641
 
                        if (*r->out.key_buffer) {
26642
 
                                {
26643
 
                                        struct ndr_push *_ndr_key_buffer;
26644
 
                                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26645
 
                                        NDR_CHECK(ndr_push_string_array(_ndr_key_buffer, NDR_SCALARS, *r->out.key_buffer));
26646
 
                                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26647
 
                                }
26648
 
                        }
26649
 
                        ndr->flags = _flags_save_string_array;
 
26739
                        struct ndr_push *_ndr_key_buffer;
 
26740
                        NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
 
26741
                        NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
 
26742
                        NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
 
26743
                        NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
26650
26744
                }
26651
26745
                if (r->out.needed == NULL) {
26652
26746
                        return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26659
26753
 
26660
26754
_PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26661
26755
{
26662
 
        uint32_t _ptr_key_buffer;
26663
26756
        TALLOC_CTX *_mem_save_handle_0;
 
26757
        TALLOC_CTX *_mem_save__ndr_size_0;
26664
26758
        TALLOC_CTX *_mem_save_key_buffer_0;
26665
 
        TALLOC_CTX *_mem_save_key_buffer_1;
26666
26759
        TALLOC_CTX *_mem_save_needed_0;
26667
26760
        if (flags & NDR_IN) {
26668
26761
                ZERO_STRUCT(r->out);
26682
26775
                NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26683
26776
                NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.key_name, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t), CH_UTF16));
26684
26777
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
 
26778
                NDR_PULL_ALLOC(ndr, r->out._ndr_size);
 
26779
                ZERO_STRUCTP(r->out._ndr_size);
26685
26780
                NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26686
26781
                ZERO_STRUCTP(r->out.key_buffer);
26687
26782
                NDR_PULL_ALLOC(ndr, r->out.needed);
26688
26783
                ZERO_STRUCTP(r->out.needed);
26689
26784
        }
26690
26785
        if (flags & NDR_OUT) {
 
26786
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
26787
                        NDR_PULL_ALLOC(ndr, r->out._ndr_size);
 
26788
                }
 
26789
                _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
26790
                NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
 
26791
                NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
 
26792
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
 
26793
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 
26794
                        NDR_PULL_ALLOC(ndr, r->out.key_buffer);
 
26795
                }
 
26796
                _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
 
26797
                NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26691
26798
                {
26692
 
                        uint32_t _flags_save_string_array = ndr->flags;
26693
 
                        ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26694
 
                        if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26695
 
                                NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26696
 
                        }
26697
 
                        _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26698
 
                        NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26699
 
                        NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_buffer));
26700
 
                        if (_ptr_key_buffer) {
26701
 
                                NDR_PULL_ALLOC(ndr, *r->out.key_buffer);
26702
 
                        } else {
26703
 
                                *r->out.key_buffer = NULL;
26704
 
                        }
26705
 
                        if (*r->out.key_buffer) {
26706
 
                                _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26707
 
                                NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_buffer, 0);
26708
 
                                {
26709
 
                                        struct ndr_pull *_ndr_key_buffer;
26710
 
                                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26711
 
                                        NDR_CHECK(ndr_pull_string_array(_ndr_key_buffer, NDR_SCALARS, r->out.key_buffer));
26712
 
                                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26713
 
                                }
26714
 
                                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26715
 
                        }
26716
 
                        NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26717
 
                        ndr->flags = _flags_save_string_array;
 
26799
                        struct ndr_pull *_ndr_key_buffer;
 
26800
                        NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
 
26801
                        NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
 
26802
                        NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
 
26803
                        NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
26718
26804
                }
 
26805
                NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26719
26806
                if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26720
26807
                        NDR_PULL_ALLOC(ndr, r->out.needed);
26721
26808
                }
26749
26836
        if (flags & NDR_OUT) {
26750
26837
                ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26751
26838
                ndr->depth++;
 
26839
                ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
 
26840
                ndr->depth++;
 
26841
                ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
 
26842
                ndr->depth--;
26752
26843
                ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26753
26844
                ndr->depth++;
26754
 
                ndr_print_ptr(ndr, "key_buffer", *r->out.key_buffer);
26755
 
                ndr->depth++;
26756
 
                if (*r->out.key_buffer) {
26757
 
                        ndr_print_string_array(ndr, "key_buffer", *r->out.key_buffer);
26758
 
                }
26759
 
                ndr->depth--;
 
26845
                ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
 
26846
                ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
26760
26847
                ndr->depth--;
26761
26848
                ndr_print_ptr(ndr, "needed", r->out.needed);
26762
26849
                ndr->depth++;