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 ParseOutputArgument);
  13
  14 use strict;
  15 use Parse::Pidl qw(fatal warning error);
  16 use Parse::Pidl::Util qw(has_property ParseExpr);
  17 use Parse::Pidl::Samba4 qw(DeclLong);
  18 use Parse::Pidl::Samba4::Header qw(GenerateFunctionInEnv GenerateFunctionOutEnv);
  19
  20 use vars qw($VERSION);
  21 $VERSION = '0.01';
  22
  23 sub indent($) { my ($self) = @_; $self->{tabs}.="\t"; }
  24 sub deindent($) { my ($self) = @_; $self->{tabs} = substr($self->{tabs}, 1); }
  25 sub pidl($$) { my ($self,$txt) = @_; $self->{res} .= $txt ? "$self->{tabs}$txt\n" : "\n"; }
  26 sub pidl_hdr($$) { my ($self, $txt) = @_; $self->{res_hdr} .= "$txt\n"; }
  27 sub fn_declare($$) { my ($self,$n) = @_; $self->pidl($n); $self->pidl_hdr("$n;"); }
  28
  29 sub genpad($)
  30 {
  31         my ($s) = @_;
  32         my $nt = int((length($s)+1)/8);
  33         my $lt = ($nt*8)-1;
  34         my $ns = (length($s)-$lt);
  35         return "\t"x($nt)." "x($ns);
  36 }
  37
  38 sub new($)
  39 {
  40         my ($class) = shift;
  41         my $self = { res => "", res_hdr => "", tabs => "" };
  42         bless($self, $class);
  43 }
  44
  45 sub ElementDirection($)
  46 {
  47         my ($e) = @_;
  48
  49         return "[in,out]" if (has_property($e, "in") and has_property($e, "out"));
  50         return "[in]" if (has_property($e, "in"));
  51         return "[out]" if (has_property($e, "out"));
  52         return "[in,out]";
  53 }
  54
  55 sub HeaderProperties($$)
  56 {
  57         my($props,$ignores) = @_;
  58         my $ret = "";
  59
  60         foreach my $d (keys %{$props}) {
  61                 next if (grep(/^$d$/, @$ignores));
  62                 if($props->{$d} ne "1") {
  63                         $ret.= "$d($props->{$d}),";
  64                 } else {
  65                         $ret.="$d,";
  66                 }
  67         }
  68
  69         if ($ret) {
  70                 return "[" . substr($ret, 0, -1) . "]";
  71         }
  72 }
  73
  74 sub ParseOutputArgument($$$)
  75 {
  76         my ($self, $fn, $e) = @_;
  77         my $level = 0;
  78
  79         if ($e->{LEVELS}[0]->{TYPE} ne "POINTER" and $e->{LEVELS}[0]->{TYPE} ne "ARRAY") {
  80                 $self->pidl("return NT_STATUS_NOT_SUPPORTED;");
  81                 error($e->{ORIGINAL}, "[out] argument is not a pointer or array");
  82                 return;
  83         }
  84
  85         if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
  86                 $level = 1;
  87                 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
  88                         $self->pidl("if ($e->{NAME} && r.out.$e->{NAME}) {");
  89                         $self->indent;
  90                 }
  91         }
  92
  93         if ($e->{LEVELS}[$level]->{TYPE} eq "ARRAY") {
  94                 # This is a call to GenerateFunctionInEnv intentionally.
  95                 # Since the data is being copied into a user-provided data
  96                 # structure, the user should be able to know the size beforehand
  97                 # to allocate a structure of the right size.
  98                 my $in_env = GenerateFunctionInEnv($fn, "r.");
  99                 my $out_env = GenerateFunctionOutEnv($fn, "r.");
 100                 my $l = $e->{LEVELS}[$level];
 101                 unless (defined($l->{SIZE_IS})) {
 102                         $self->pidl('#error No size known for [out] array `$e->{NAME}');
 103                         error($e->{ORIGINAL}, "no size known for [out] array `$e->{NAME}'");
 104                 } else {
 105                         my $in_size_is = ParseExpr($l->{SIZE_IS}, $in_env, $e->{ORIGINAL});
 106                         my $out_size_is = ParseExpr($l->{SIZE_IS}, $out_env, $e->{ORIGINAL});
 107                         my $out_length_is = $out_size_is;
 108                         if (defined($l->{LENGTH_IS})) {
 109                                 $out_length_is = ParseExpr($l->{LENGTH_IS}, $out_env, $e->{ORIGINAL});
 110                         }
 111                         if ($out_size_is ne $in_size_is) {
 112                                 $self->pidl("if (($out_size_is) > ($in_size_is)) {");
 113                                 $self->indent;
 114                                 $self->pidl("return NT_STATUS_INVALID_NETWORK_RESPONSE;");
 115                                 $self->deindent;
 116                                 $self->pidl("}");
 117                         }
 118                         if ($out_length_is ne $out_size_is) {
 119                                 $self->pidl("if (($out_length_is) > ($out_size_is)) {");
 120                                 $self->indent;
 121                                 $self->pidl("return NT_STATUS_INVALID_NETWORK_RESPONSE;");
 122                                 $self->deindent;
 123                                 $self->pidl("}");
 124                         }
 125                         if (has_property($e, "charset")) {
 126                                 $self->pidl("memcpy(discard_const_p(uint8_t *, $e->{NAME}), r.out.$e->{NAME}, ($out_length_is) * sizeof(*$e->{NAME}));");
 127                         } else {
 128                                 $self->pidl("memcpy($e->{NAME}, r.out.$e->{NAME}, ($out_length_is) * sizeof(*$e->{NAME}));");
 129                         }
 130                 }
 131         } else {
 132                 $self->pidl("*$e->{NAME} = *r.out.$e->{NAME};");
 133         }
 134
 135         if ($e->{LEVELS}[0]->{TYPE} eq "POINTER") {
 136                 if ($e->{LEVELS}[0]->{POINTER_TYPE} ne "ref") {
 137                         $self->deindent;
 138                         $self->pidl("}");
 139                 }
 140         }
 141 }
 142
 143 sub ParseFunction($$$)
 144 {
 145         my ($self, $if, $fn) = @_;
 146
 147         my $fn_args = "";
 148         my $uif = uc($if);
 149         my $ufn = "NDR_".uc($fn->{NAME});
 150         my $fn_str = "NTSTATUS rpccli_$fn->{NAME}";
 151         my $pad = genpad($fn_str);
 152
 153         $fn_args .= "struct rpc_pipe_client *cli,\n" . $pad . "TALLOC_CTX *mem_ctx";
 154
 155         foreach (@{$fn->{ELEMENTS}}) {
 156                 my $dir = ElementDirection($_);
 157                 my $prop = HeaderProperties($_->{PROPERTIES}, ["in", "out"]);
 158                 $fn_args .= ",\n" . $pad . DeclLong($_) . " /* $dir $prop */";
 159         }
 160
 161         if (defined($fn->{RETURN_TYPE}) && ($fn->{RETURN_TYPE} eq "WERROR")) {
 162                 $fn_args .= ",\n" . $pad . "WERROR *werror";
 163         }
 164
 165         $self->fn_declare("$fn_str($fn_args)");
 166         $self->pidl("{");
 167         $self->indent;
 168         $self->pidl("struct $fn->{NAME} r;");
 169         $self->pidl("NTSTATUS status;");
 170         $self->pidl("");
 171         $self->pidl("/* In parameters */");
 172
 173         foreach (@{$fn->{ELEMENTS}}) {
 174                 if (grep(/in/, @{$_->{DIRECTION}})) {
 175                         $self->pidl("r.in.$_->{NAME} = $_->{NAME};");
 176                 }
 177         }
 178
 179         $self->pidl("");
 180         $self->pidl("if (DEBUGLEVEL >= 10) {");
 181         $self->indent;
 182         $self->pidl("NDR_PRINT_IN_DEBUG($fn->{NAME}, &r);");
 183         $self->deindent;
 184         $self->pidl("}");
 185         $self->pidl("");
 186         $self->pidl("status = cli->dispatch(cli,");
 187         $self->pidl("\t\t\tmem_ctx,");
 188         $self->pidl("\t\t\t&ndr_table_$if,");
 189         $self->pidl("\t\t\t$ufn,");
 190         $self->pidl("\t\t\t&r);");
 191         $self->pidl("");
 192
 193         $self->pidl("if (!NT_STATUS_IS_OK(status)) {");
 194         $self->indent;
 195         $self->pidl("return status;");
 196         $self->deindent;
 197         $self->pidl("}");
 198
 199         $self->pidl("");
 200         $self->pidl("if (DEBUGLEVEL >= 10) {");
 201         $self->indent;
 202         $self->pidl("NDR_PRINT_OUT_DEBUG($fn->{NAME}, &r);");
 203         $self->deindent;
 204         $self->pidl("}");
 205         $self->pidl("");
 206         $self->pidl("if (NT_STATUS_IS_ERR(status)) {");
 207         $self->indent;
 208         $self->pidl("return status;");
 209         $self->deindent;
 210         $self->pidl("}");
 211         $self->pidl("");
 212         $self->pidl("/* Return variables */");
 213         foreach my $e (@{$fn->{ELEMENTS}}) {
 214                 next unless (grep(/out/, @{$e->{DIRECTION}}));
 215
 216                 $self->ParseOutputArgument($fn, $e);
 217
 218         }
 219
 220         $self->pidl("");
 221         $self->pidl("/* Return result */");
 222         if (not $fn->{RETURN_TYPE}) {
 223                 $self->pidl("return NT_STATUS_OK;");
 224         } elsif ($fn->{RETURN_TYPE} eq "NTSTATUS") {
 225                 $self->pidl("return r.out.result;");
 226         } elsif ($fn->{RETURN_TYPE} eq "WERROR") {
 227                 $self->pidl("if (werror) {");
 228                 $self->indent;
 229                 $self->pidl("*werror = r.out.result;");
 230                 $self->deindent;
 231                 $self->pidl("}");
 232                 $self->pidl("");
 233                 $self->pidl("return werror_to_ntstatus(r.out.result);");
 234         } else {
 235                 warning($fn->{ORIGINAL}, "Unable to convert $fn->{RETURN_TYPE} to NTSTATUS");
 236                 $self->pidl("return NT_STATUS_OK;");
 237         }
 238
 239         $self->deindent;
 240         $self->pidl("}");
 241         $self->pidl("");
 242 }
 243
 244 sub ParseInterface($$)
 245 {
 246         my ($self, $if) = @_;
 247
 248         my $uif = uc($if->{NAME});
 249
 250         $self->pidl_hdr("#ifndef __CLI_$uif\__");
 251         $self->pidl_hdr("#define __CLI_$uif\__");
 252         foreach (@{$if->{FUNCTIONS}}) {
 253                 next if ($_->{PROPERTIES}{noopnum});
 254                 $self->ParseFunction($if->{NAME}, $_);
 255         }
 256         $self->pidl_hdr("#endif /* __CLI_$uif\__ */");
 257 }
 258
 259 sub Parse($$$$)
 260 {
 261         my($self,$ndr,$header,$ndr_header) = @_;
 262
 263         $self->pidl("/*");
 264         $self->pidl(" * Unix SMB/CIFS implementation.");
 265         $self->pidl(" * client auto-generated by pidl. DO NOT MODIFY!");
 266         $self->pidl(" */");
 267         $self->pidl("");
 268         $self->pidl("#include \"includes.h\"");
 269         $self->pidl("#include \"$header\"");
 270         $self->pidl_hdr("#include \"$ndr_header\"");
 271         $self->pidl("");
 272
 273         foreach (@$ndr) {
 274                 $self->ParseInterface($_) if ($_->{TYPE} eq "INTERFACE");
 275         }
 276
 277         return ($self->{res}, $self->{res_hdr});
 278 }
 279
 280 1;