Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (12 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified vendor/current/pidl/lib/Parse/Pidl/NDR.pm

    r414 r740  
    3535$VERSION = '0.01';
    3636@ISA = qw(Exporter);
    37 @EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsString);
     37@EXPORT = qw(GetPrevLevel GetNextLevel ContainsDeferred ContainsPipe ContainsString);
    3838@EXPORT_OK = qw(GetElementLevelTable ParseElement ValidElement align_type mapToScalar ParseType can_contain_deferred is_charset_array);
    3939
    4040use strict;
    4141use Parse::Pidl qw(warning fatal);
    42 use Parse::Pidl::Typelist qw(hasType getType expandAlias);
     42use Parse::Pidl::Typelist qw(hasType getType typeIs expandAlias mapScalarType is_fixed_size_scalar);
    4343use Parse::Pidl::Util qw(has_property property_matches);
    4444
    … …  
    5555        'int32' => 4,
    5656        'uint32' => 4,
     57        'int3264' => 5,
     58        'uint3264' => 5,
    5759        'hyper' => 8,
    5860        'double' => 8,
    … …  
    6567        'string_array' => 4, #???
    6668        'time_t' => 4,
     69        'uid_t' => 8,
     70        'gid_t' => 8,
    6771        'NTTIME' => 4,
    6872        'NTTIME_1sec' => 4,
    … …  
    7175        'NTSTATUS' => 4,
    7276        'COMRESULT' => 4,
     77        'dns_string' => 4,
    7378        'nbt_string' => 4,
    7479        'wrepl_nbt_name' => 4,
    75         'ipv4address' => 4
     80        'ipv4address' => 4,
     81        'ipv6address' => 4, #16?
     82        'dnsp_name' => 1,
     83        'dnsp_string' => 1
    7684};
    7785
    78 sub GetElementLevelTable($$)
    79 {
    80         my ($e, $pointer_default) = @_;
     86sub GetElementLevelTable($$$)
     87{
     88        my ($e, $pointer_default, $ms_union) = @_;
    8189
    8290        my $order = [];
    … …  
    102110                my $needptrs = 1;
    103111
    104                 if (has_property($e, "string")) { $needptrs++; }
     112                if (has_property($e, "string") and not has_property($e, "in")) { $needptrs++; }
    105113                if ($#bracket_array >= 0) { $needptrs = 0; }
    106114
    107115                warning($e, "[out] argument `$e->{NAME}' not a pointer") if ($needptrs > $e->{POINTERS});
     116        }
     117
     118        my $allow_pipe = ($e->{PARENT}->{TYPE} eq "FUNCTION");
     119        my $is_pipe = typeIs($e->{TYPE}, "PIPE");
     120
     121        if ($is_pipe) {
     122                if (not $allow_pipe) {
     123                        fatal($e, "argument `$e->{NAME}' is a pipe and not allowed on $e->{PARENT}->{TYPE}");
     124                }
     125
     126                if ($e->{POINTERS} > 1) {
     127                        fatal($e, "$e->{POINTERS} are not allowed on pipe element $e->{NAME}");
     128                }
     129
     130                if ($e->{POINTERS} < 0) {
     131                        fatal($e, "pipe element $e->{NAME} needs pointer");
     132                }
     133
     134                if ($e->{POINTERS} == 1 and pointer_type($e) ne "ref") {
     135                        fatal($e, "pointer should be 'ref' on pipe element $e->{NAME}");
     136                }
     137
     138                if (scalar(@size_is) > 0) {
     139                        fatal($e, "size_is() on pipe element");
     140                }
     141
     142                if (scalar(@length_is) > 0) {
     143                        fatal($e, "length_is() on pipe element");
     144                }
     145
     146                if (scalar(@bracket_array) > 0) {
     147                        fatal($e, "brackets on pipe element");
     148                }
     149
     150                if (defined(has_property($e, "subcontext"))) {
     151                        fatal($e, "subcontext on pipe element");
     152                }
     153
     154                if (has_property($e, "switch_is")) {
     155                        fatal($e, "switch_is on pipe element");
     156                }
     157
     158                if (can_contain_deferred($e->{TYPE})) {
     159                        fatal($e, "$e->{TYPE} can_contain_deferred - not allowed on pipe element");
     160                }
    108161        }
    109162
    … …  
    123176                        $is_conformant = 1;
    124177                        if ($size = shift @size_is) {
     178                                if ($e->{POINTERS} < 1 and has_property($e, "string")) {
     179                                        $is_string = 1;
     180                                        delete($e->{PROPERTIES}->{string});
     181                                }
    125182                        } elsif ((scalar(@size_is) == 0) and has_property($e, "string")) {
    126183                                $is_string = 1;
    … …  
    248305        }
    249306
     307        if ($is_pipe) {
     308                push (@$order, {
     309                        TYPE => "PIPE",
     310                        IS_DEFERRED => 0,
     311                        CONTAINS_DEFERRED => 0,
     312                });
     313
     314                my $i = 0;
     315                foreach (@$order) { $_->{LEVEL_INDEX} = $i; $i+=1; }
     316
     317                return $order;
     318        }
     319
    250320        if (defined(has_property($e, "subcontext"))) {
    251321                my $hdr_size = has_property($e, "subcontext");
    … …  
    298368}
    299369
    300 sub GetTypedefLevelTable($$$)
    301 {
    302         my ($e, $data, $pointer_default) = @_;
     370sub GetTypedefLevelTable($$$$)
     371{
     372        my ($e, $data, $pointer_default, $ms_union) = @_;
    303373
    304374        my $order = [];
    … …  
    350420        return "unique" if (has_property($e, "unique"));
    351421        return "relative" if (has_property($e, "relative"));
     422        return "relative_short" if (has_property($e, "relative_short"));
    352423        return "ignore" if (has_property($e, "ignore"));
    353424
    … …  
    407478        if ($dt->{TYPE} eq "TYPEDEF") {
    408479                return align_type($dt->{DATA});
     480        } elsif ($dt->{TYPE} eq "CONFORMANCE") {
     481                return $dt->{DATA}->{ALIGN};
    409482        } elsif ($dt->{TYPE} eq "ENUM") {
    410483                return align_type(Parse::Pidl::Typelist::enum_type_fn($dt));
    … …  
    415488                return 4 unless (defined($dt->{ELEMENTS}));
    416489                return find_largest_alignment($dt);
     490        } elsif (($dt->{TYPE} eq "PIPE")) {
     491                return 5;
    417492        }
    418493
    … …  
    420495}
    421496
    422 sub ParseElement($$)
    423 {
    424         my ($e, $pointer_default) = @_;
     497sub ParseElement($$$)
     498{
     499        my ($e, $pointer_default, $ms_union) = @_;
    425500
    426501        $e->{TYPE} = expandAlias($e->{TYPE});
    427502
    428503        if (ref($e->{TYPE}) eq "HASH") {
    429                 $e->{TYPE} = ParseType($e->{TYPE}, $pointer_default);
     504                $e->{TYPE} = ParseType($e->{TYPE}, $pointer_default, $ms_union);
    430505        }
    431506
    … …  
    434509                TYPE => $e->{TYPE},
    435510                PROPERTIES => $e->{PROPERTIES},
    436                 LEVELS => GetElementLevelTable($e, $pointer_default),
     511                LEVELS => GetElementLevelTable($e, $pointer_default, $ms_union),
    437512                REPRESENTATION_TYPE => ($e->{PROPERTIES}->{represent_as} or $e->{TYPE}),
    438513                ALIGN => align_type($e->{TYPE}),
    … …  
    441516}
    442517
    443 sub ParseStruct($$)
    444 {
    445         my ($struct, $pointer_default) = @_;
     518sub ParseStruct($$$)
     519{
     520        my ($struct, $pointer_default, $ms_union) = @_;
    446521        my @elements = ();
    447522        my $surrounding = undef;
    … …  
    461536        foreach my $x (@{$struct->{ELEMENTS}})
    462537        {
    463                 my $e = ParseElement($x, $pointer_default);
     538                my $e = ParseElement($x, $pointer_default, $ms_union);
    464539                if ($x != $struct->{ELEMENTS}[-1] and
    465540                        $e->{LEVELS}[0]->{IS_SURROUNDING}) {
    … …  
    498573sub ParseUnion($$)
    499574{
    500         my ($e, $pointer_default) = @_;
     575        my ($e, $pointer_default, $ms_union) = @_;
    501576        my @elements = ();
     577        my $is_ms_union = $ms_union;
     578        $is_ms_union = 1 if has_property($e, "ms_union");
    502579        my $hasdefault = 0;
    503580        my $switch_type = has_property($e, "switch_type");
    … …  
    512589                PROPERTIES => $e->{PROPERTIES},
    513590                HAS_DEFAULT => $hasdefault,
     591                IS_MS_UNION => $is_ms_union,
    514592                ORIGINAL => $e,
    515593                ALIGN => undef
    … …  
    524602                        $t = { TYPE => "EMPTY" };
    525603                } else {
    526                         $t = ParseElement($x, $pointer_default);
     604                        $t = ParseElement($x, $pointer_default, $ms_union);
    527605                }
    528606                if (has_property($x, "default")) {
    … …  
    549627                PROPERTIES => $e->{PROPERTIES},
    550628                HAS_DEFAULT => $hasdefault,
     629                IS_MS_UNION => $is_ms_union,
    551630                ORIGINAL => $e,
    552631                ALIGN => $align
    … …  
    556635sub ParseEnum($$)
    557636{
    558         my ($e, $pointer_default) = @_;
     637        my ($e, $pointer_default, $ms_union) = @_;
    559638
    560639        return {
    … …  
    568647}
    569648
    570 sub ParseBitmap($$)
    571 {
    572         my ($e, $pointer_default) = @_;
     649sub ParseBitmap($$$)
     650{
     651        my ($e, $pointer_default, $ms_union) = @_;
    573652
    574653        return {
    … …  
    582661}
    583662
    584 sub ParseType($$)
    585 {
    586         my ($d, $pointer_default) = @_;
     663sub ParsePipe($$$)
     664{
     665        my ($pipe, $pointer_default, $ms_union) = @_;
     666
     667        my $pname = $pipe->{NAME};
     668        $pname = $pipe->{PARENT}->{NAME} unless defined $pname;
     669
     670        if (not defined($pipe->{PROPERTIES})
     671            and defined($pipe->{PARENT}->{PROPERTIES})) {
     672                $pipe->{PROPERTIES} = $pipe->{PARENT}->{PROPERTIES};
     673        }
     674
     675        if (ref($pipe->{DATA}) eq "HASH") {
     676                if (not defined($pipe->{DATA}->{PROPERTIES})
     677                    and defined($pipe->{PROPERTIES})) {
     678                        $pipe->{DATA}->{PROPERTIES} = $pipe->{PROPERTIES};
     679                }
     680        }
     681
     682        my $struct = ParseStruct($pipe->{DATA}, $pointer_default, $ms_union);
     683        $struct->{ALIGN} = 5;
     684        $struct->{NAME} = "$pname\_chunk";
     685
     686        # 'count' is element [0] and 'array' [1]
     687        my $e = $struct->{ELEMENTS}[1];
     688        # level [0] is of type "ARRAY"
     689        my $l = $e->{LEVELS}[1];
     690
     691        # here we check that pipe elements have a fixed size type
     692        while (defined($l)) {
     693                my $cl = $l;
     694                $l = GetNextLevel($e, $cl);
     695                if ($cl->{TYPE} ne "DATA") {
     696                        fatal($pipe, el_name($pipe) . ": pipe contains non DATA level");
     697                }
     698
     699                # for now we only support scalars
     700                next if is_fixed_size_scalar($cl->{DATA_TYPE});
     701
     702                fatal($pipe, el_name($pipe) . ": pipe contains non fixed size type[$cl->{DATA_TYPE}]");
     703        }
     704
     705        return {
     706                TYPE => "PIPE",
     707                NAME => $pipe->{NAME},
     708                DATA => $struct,
     709                PROPERTIES => $pipe->{PROPERTIES},
     710                ORIGINAL => $pipe,
     711        };
     712}
     713
     714sub ParseType($$$)
     715{
     716        my ($d, $pointer_default, $ms_union) = @_;
    587717
    588718        my $data = {
    … …  
    592722                BITMAP => \&ParseBitmap,
    593723                TYPEDEF => \&ParseTypedef,
    594         }->{$d->{TYPE}}->($d, $pointer_default);
     724                PIPE => \&ParsePipe,
     725        }->{$d->{TYPE}}->($d, $pointer_default, $ms_union);
    595726
    596727        return $data;
    … …  
    599730sub ParseTypedef($$)
    600731{
    601         my ($d, $pointer_default) = @_;
    602 
    603         if (defined($d->{DATA}->{PROPERTIES}) && !defined($d->{PROPERTIES})) {
    604                 $d->{PROPERTIES} = $d->{DATA}->{PROPERTIES};
    605         }
    606 
    607         my $data = ParseType($d->{DATA}, $pointer_default);
    608         $data->{ALIGN} = align_type($d->{NAME});
     732        my ($d, $pointer_default, $ms_union) = @_;
     733
     734        my $data;
     735
     736        if (ref($d->{DATA}) eq "HASH") {
     737                if (defined($d->{DATA}->{PROPERTIES})
     738                    and not defined($d->{PROPERTIES})) {
     739                        $d->{PROPERTIES} = $d->{DATA}->{PROPERTIES};
     740                }
     741
     742                $data = ParseType($d->{DATA}, $pointer_default, $ms_union);
     743                $data->{ALIGN} = align_type($d->{NAME});
     744        } else {
     745                $data = getType($d->{DATA});
     746        }
    609747
    610748        return {
    … …  
    612750                TYPE => $d->{TYPE},
    613751                PROPERTIES => $d->{PROPERTIES},
    614                 LEVELS => GetTypedefLevelTable($d, $data, $pointer_default),
     752                LEVELS => GetTypedefLevelTable($d, $data, $pointer_default, $ms_union),
    615753                DATA => $data,
    616754                ORIGINAL => $d
    … …  
    625763}
    626764
    627 sub ParseFunction($$$)
    628 {
    629         my ($ndr,$d,$opnum) = @_;
     765sub ParseFunction($$$$)
     766{
     767        my ($ndr,$d,$opnum,$ms_union) = @_;
    630768        my @elements = ();
    631769        my $rettype = undef;
    … …  
    640778
    641779        foreach my $x (@{$d->{ELEMENTS}}) {
    642                 my $e = ParseElement($x, $ndr->{PROPERTIES}->{pointer_default});
     780                my $e = ParseElement($x, $ndr->{PROPERTIES}->{pointer_default}, $ms_union);
    643781                push (@{$e->{DIRECTION}}, "in") if (has_property($x, "in"));
    644782                push (@{$e->{DIRECTION}}, "out") if (has_property($x, "out"));
    … …  
    650788                $rettype = expandAlias($d->{RETURN_TYPE});
    651789        }
    652        
    653         my $async = 0;
    654         if (has_property($d, "async")) { $async = 1; }
    655790       
    656791        return {
    … …  
    658793                        TYPE => "FUNCTION",
    659794                        OPNUM => $thisopnum,
    660                         ASYNC => $async,
    661795                        RETURN_TYPE => $rettype,
    662796                        PROPERTIES => $d->{PROPERTIES},
    … …  
    705839        my $opnum = 0;
    706840        my $version;
     841        my $ms_union = 0;
     842        $ms_union = 1 if has_property($idl, "ms_union");
    707843
    708844        if (not has_property($idl, "pointer_default")) {
    … …  
    714850        foreach my $d (@{$idl->{DATA}}) {
    715851                if ($d->{TYPE} eq "FUNCTION") {
    716                         push (@functions, ParseFunction($idl, $d, \$opnum));
     852                        push (@functions, ParseFunction($idl, $d, \$opnum, $ms_union));
    717853                } elsif ($d->{TYPE} eq "CONST") {
    718854                        push (@consts, ParseConst($idl, $d));
    719855                } else {
    720                         push (@types, ParseType($d, $idl->{PROPERTIES}->{pointer_default}));
     856                        push (@types, ParseType($d, $idl->{PROPERTIES}->{pointer_default}, $ms_union));
    721857                        FindNestedTypes(\@types, $d);
    722858                }
    … …  
    830966}
    831967
     968sub ContainsPipe($$)
     969{
     970        my ($e,$l) = @_;
     971
     972        return 1 if ($l->{TYPE} eq "PIPE");
     973
     974        while ($l = GetNextLevel($e,$l))
     975        {
     976                return 1 if ($l->{TYPE} eq "PIPE");
     977        }
     978
     979        return 0;
     980}
     981
    832982sub el_name($)
    833983{
    … …  
    8781028        "pyhelper"              => ["INTERFACE"],
    8791029        "authservice"           => ["INTERFACE"],
    880         "restricted"    => ["INTERFACE"],
     1030        "restricted"            => ["INTERFACE"],
     1031        "no_srv_register"       => ["INTERFACE"],
    8811032
    8821033        # dcom
    … …  
    8911042        "in"                    => ["ELEMENT"],
    8921043        "out"                   => ["ELEMENT"],
    893         "async"                 => ["FUNCTION"],
    8941044
    8951045        # pointer
    896         "ref"                   => ["ELEMENT"],
    897         "ptr"                   => ["ELEMENT"],
    898         "unique"                => ["ELEMENT"],
     1046        "ref"                   => ["ELEMENT", "TYPEDEF"],
     1047        "ptr"                   => ["ELEMENT", "TYPEDEF"],
     1048        "unique"                => ["ELEMENT", "TYPEDEF"],
    8991049        "ignore"                => ["ELEMENT"],
    900         "relative"              => ["ELEMENT"],
    901         "null_is_ffffffff" => ["ELEMENT"],
     1050        "relative"              => ["ELEMENT", "TYPEDEF"],
     1051        "relative_short"        => ["ELEMENT", "TYPEDEF"],
     1052        "null_is_ffffffff"      => ["ELEMENT"],
    9021053        "relative_base"         => ["TYPEDEF", "STRUCT", "UNION"],
    9031054
    9041055        "gensize"               => ["TYPEDEF", "STRUCT", "UNION"],
    9051056        "value"                 => ["ELEMENT"],
    906         "flag"                  => ["ELEMENT", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
     1057        "flag"                  => ["ELEMENT", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "PIPE"],
    9071058
    9081059        # generic
    909         "public"                => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
    910         "nopush"                => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
    911         "nopull"                => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
     1060        "public"                => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "PIPE"],
     1061        "nopush"                => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "PIPE"],
     1062        "nopull"                => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "PIPE"],
    9121063        "nosize"                => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
    913         "noprint"               => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "ELEMENT"],
     1064        "noprint"               => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP", "ELEMENT", "PIPE"],
     1065        "nopython"              => ["FUNCTION", "TYPEDEF", "STRUCT", "UNION", "ENUM", "BITMAP"],
    9141066        "todo"                  => ["FUNCTION"],
    9151067
    … …  
    9181070        "switch_type"           => ["ELEMENT", "UNION"],
    9191071        "nodiscriminant"        => ["UNION"],
     1072        "ms_union"              => ["INTERFACE", "UNION"],
    9201073        "case"                  => ["ELEMENT"],
    9211074        "default"               => ["ELEMENT"],
    … …  
    10071160                        $discriminator_type = "uint32" unless defined ($discriminator_type);
    10081161
    1009                         my $t1 = mapToScalar($discriminator_type);
     1162                        my $t1 = mapScalarType(mapToScalar($discriminator_type));
    10101163
    10111164                        if (not defined($t1)) {
    … …  
    10131166                        }
    10141167
    1015                         my $t2 = mapToScalar($e2->{TYPE});
     1168                        my $t2 = mapScalarType(mapToScalar($e2->{TYPE}));
    10161169                        if (not defined($t2)) {
    10171170                                fatal($e, el_name($e) . ": unable to map variable used for switch_is() to scalar");
    … …  
    10561209                has_property($e, "unique") or
    10571210                has_property($e, "relative") or
     1211                has_property($e, "relative_short") or
    10581212                has_property($e, "ref"))) {
    10591213                fatal($e, el_name($e) . " : pointer properties on non-pointer element\n");     
    … …  
    11371291{
    11381292        my ($pipe) = @_;
    1139         my $data = $pipe->{DATA};
     1293        my $struct = $pipe->{DATA};
    11401294
    11411295        ValidProperties($pipe, "PIPE");
    11421296
    1143         fatal($pipe, $pipe->{NAME} . ": 'pipe' is not yet supported by pidl");
     1297        $struct->{PARENT} = $pipe;
     1298
     1299        $struct->{FILE} = $pipe->{FILE} unless defined($struct->{FILE});
     1300        $struct->{LINE} = $pipe->{LINE} unless defined($struct->{LINE});
     1301
     1302        ValidType($struct);
    11441303}
    11451304
    … …  
    11531312        ValidProperties($typedef, "TYPEDEF");
    11541313
     1314        return unless (ref($data) eq "HASH");
     1315
    11551316        $data->{PARENT} = $typedef;
    11561317
    … …  
    11581319        $data->{LINE} = $typedef->{LINE} unless defined($data->{LINE});
    11591320
    1160         ValidType($data) if (ref($data) eq "HASH");
     1321        ValidType($data);
    11611322}
    11621323
Note: See TracChangeset for help on using the changeset viewer.