source/pidl/lib/Parse/Pidl/Samba3/ClientNDR.pm

   1 ###################################################
   2 # Samba3 client generator for IDL structures
   3 # on top of Samba4 style NDR functions
   4 # Copyright jelmer@samba.org 2005-2006
   5 # Copyright gd@samba.org 2008
   6 # released under the GNU GPL
   7
   8 package Parse::Pidl::Samba3::ClientNDR;
   9
  10 use Exporter;
  11 @ISA = qw(Exporter);
  12 @EXPORT_OK = qw(ParseFunction $res $res_hdr);
  13
  14 use strict;
  15 use Parse::Pidl qw(fatal warning);
  16 use Parse::Pidl::Typelist qw(hasType getType mapTypeName scalar_is_reference);
  17 use Parse::Pidl::Util qw(has_property is_constant ParseExpr);
  18 use Parse::Pidl::NDR qw(GetPrevLevel GetNextLevel ContainsDeferred);
  19 use Parse::Pidl::Samba4 qw(DeclLong);
  20 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv);
  21
  22 use vars qw($VERSION);
  23 $VERSION = '0.01';
  24
  25 sub indent($) { my ($self) = @_; $self->{tabs}.="\t"; }
  26 sub deindent($) { my ($self) = @_; $self->{tabs} = substr($self->{tabs}, 1); }
  27 sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= $txt ? "$self->{tabs}$txt\n" : "\n"; }
  28 sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; }
  29 sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); }
  30
  31 sub genpad($)
  32 {
  33         my ($s) = @_;
  34         my $nt = int((length($s)+1)/8);
  35         my $lt = ($nt*8)-1;
  36         my $ns = (length($s)-$lt);
  37         return "\t"x($nt)." "x($ns);
  38 }
  39
  40 sub new($)
  41 {
  42         my ($class) = shift;
  43         my $self = { res => "", res_hdr => "", tabs => "" };
  44         bless($self, $class);
  45 }
  46
  47 sub ElementDirection($)
  48 {
  49         my ($e) = @_;
  50
  51         return "[in,out]" if (has_property($e, "in") and has_property($e, "out"));
  52         return "[in]" if (has_property($e, "in"));
  53         return "[out]" if (has_property($e, "out"));
  54         return "[in,out]";
  55 }
  56
  57 sub HeaderProperties($$)
  58 {
  59         my($props,$ignores) = @_;
  60         my $ret = "";
  61
  62         foreach my $d (keys %{$props}) {
  63                 next if (grep(/^$d$/, @$ignores));
  64                 if($props->{$d} ne "1") {
  65                         $ret.= "$d($props->{$d}),";
  66                 } else {
  67                         $ret.="$d,";
  68                 }
  69         }
  70
  71         if ($ret) {
  72                 return "[" . substr($ret, 0, -1) . "]";
  73         }
  74 }
  75
  76
  77 sub ParseFunction($$$)
  78 {
  79         my ($self, $if, $fn) = @_;
  80
  81         my $fn_args = "";
  82         my $uif = uc($if);
  83         my $ufn = "NDR_".uc($fn->{NAME});
  84         my $fn_str = "NTSTATUS rpccli_$fn->{NAME}";
  85         my $pad = genpad($fn_str);
  86
  87         $fn_args .= "struct rpc_pipe_client *cli,\n" . $pad . "TALLOC_CTX *mem_ctx";
  88
  89         foreach (@{$fn->{ELEMENTS}}) {
  90                 my $dir = ElementDirection($_);
  91                 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
  92                 $fn_args .= ",\n" . $pad . DeclLong($_) . " /* $dir $prop */";
  93         }
  94
  95         if (defined($fn->{RETURN_TYPE}) && ($fn->{RETURN_TYPE} eq "WERROR")) {
  96                 $fn_args .= ",\n" . $pad . "WERROR *werror";
  97         }
  98
  99         $self->fn_declare("$fn_str($fn_args)");
 100         $self->pidl("{");
 101         $self->indent;
 102         $self->pidl("struct $fn->{NAME} r;");
 103         $self->pidl("NTSTATUS status;");
 104         $self->pidl("");
 105         $self->pidl("/* In parameters */");
 106
 107         foreach (@{$fn->{ELEMENTS}}) {
 108                 if (grep(/in/, @{$_->{DIRECTION}})) {
 109                         $self->pidl("r.in.$_->{NAME} = $_->{NAME};");
 110                 }
 111         }
 112
 113         $self->pidl("");
 114         $self->pidl("if (DEBUGLEVEL >= 10) {");
 115         $self->indent;
 116         $self->pidl("NDR_PRINT_IN_DEBUG($fn->{NAME}, &r);");
 117         $self->deindent;
 118         $self->pidl("}");
 119         $self->pidl("");
 120         $self->pidl("status = cli_do_rpc_ndr(cli,");
 121         $self->pidl("\t\t\tmem_ctx,");
 122         $self->pidl("\t\t\tPI_$uif,");
 123         $self->pidl("\t\t\t&ndr_table_$if,");
 124         $self->pidl("\t\t\t$ufn,");
 125         $self->pidl("\t\t\t&r);");
 126         $self->pidl("");
 127
 128         $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
 129         $self->indent;
 130         $self->pidl("return status;");
 131         $self->deindent;
 132         $self->pidl("}");
 133
 134         $self->pidl("");
 135         $self->pidl("if (DEBUGLEVEL >= 10) {");
 136         $self->indent;
 137         $self->pidl("NDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);");
 138         $self->deindent;
 139         $self->pidl("}");
 140         $self->pidl("");
 141         $self->pidl("if (NT_STATUS_IS_ERR(status)) {");
 142         $self->indent;
 143         $self->pidl("return status;");
 144         $self->deindent;
 145         $self->pidl("}");
 146         $self->pidl("");
 147         $self->pidl("/* Return variables */");
 148         foreach my $e (@{$fn->{ELEMENTS}}) {
 149                 next unless (grep(/out/, @{$e->{DIRECTION}}));
 150                 my $level = 0;
 151
 152                 fatal($e->{ORIGINAL}, "[out] argument is not a pointer or array") if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY");
 153
 154                 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
 155                         $level = 1;
 156                         if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
 157                                 $self->pidl("if ($e->{NAME} && r.out.$e->{NAME}) {");
 158                                 $self->indent;
 159                         }
 160                 }
 161
 162                 if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") {
 163                         # This is a call to GenerateFunctionInEnv intentionally.
 164                         # Since the data is being copied into a user-provided data
 165                         # structure, the user should be able to know the size beforehand
 166                         # to allocate a structure of the right size.
 167                         my $env = GenerateFunctionInEnv($fn, "r.");
 168                         my $size_is = ParseExpr($e->{LEVELS}[$level]->{SIZE_IS}, $env, $e->{ORIGINAL});
 169                         $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, $size_is);");
 170                 } else {
 171                         $self->pidl("*$e->{NAME} = *r.out.$e->{NAME};");
 172                 }
 173
 174                 if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
 175                         if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
 176                                 $self->deindent;
 177                                 $self->pidl("}");
 178                         }
 179                 }
 180         }
 181
 182         $self->pidl("");
 183         $self->pidl("/* Return result */");
 184         if (not $fn->{RETURN_TYPE}) {
 185                 $self->pidl("return NT_STATUS_OK;");
 186         } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") {
 187                 $self->pidl("return r.out.result;");
 188         } elsif ($fn->{RETURN_TYPE} eq "WERROR") {
 189                 $self->pidl("if (werror) {");
 190                 $self->indent;
 191                 $self->pidl("*werror = r.out.result;");
 192                 $self->deindent;
 193                 $self->pidl("}");
 194                 $self->pidl("");
 195                 $self->pidl("return werror_to_ntstatus(r.out.result);");
 196         } else {
 197                 warning($fn->{ORIGINAL}, "Unable to convert $fn->{RETURN_TYPE} to NTSTATUS");
 198                 $self->pidl("return NT_STATUS_OK;");
 199         }
 200
 201         $self->deindent;
 202         $self->pidl("}");
 203         $self->pidl("");
 204 }
 205
 206 sub ParseInterface($$)
 207 {
 208         my ($self, $if) = @_;
 209
 210         my $uif = uc($if->{NAME});
 211
 212         $self->pidl_hdr("#ifndef __CLI_$uif\__");
 213         $self->pidl_hdr("#define __CLI_$uif\__");
 214         $self->ParseFunction($if->{NAME}, $_) foreach (@{$if->{FUNCTIONS}});
 215         $self->pidl_hdr("#endif /* __CLI_$uif\__ */");
 216 }
 217
 218 sub Parse($$$$)
 219 {
 220         my($self,$ndr,$header,$ndr_header) = @_;
 221
 222         $self->pidl("/*");
 223         $self->pidl(" * Unix SMB/CIFS implementation.");
 224         $self->pidl(" * client auto-generated by pidl. DO NOT MODIFY!");
 225         $self->pidl(" */");
 226         $self->pidl("");
 227         $self->pidl("#include \"includes.h\"");
 228         $self->pidl("#include \"$header\"");
 229         $self->pidl_hdr("#include \"$ndr_header\"");
 230         $self->pidl("");
 231
 232         foreach (@$ndr) {
 233                 $self->ParseInterface($_) if ($_->{TYPE} eq "INTERFACE");
 234         }
 235
 236         return ($self->{res}, $self->{res_hdr});
 237 }
 238
 239 1;