source3/rpc_parse/parse_rpc.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1997,
   5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
   6  *  Copyright (C) Paul Ashton                       1997.
   7  *  Copyright (C) Jeremy Allison                    1999.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 3 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "includes.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_RPC_PARSE
  27
  28 /*******************************************************************
  29  Inits an RPC_HDR structure.
  30 ********************************************************************/
  31
  32 void init_rpc_hdr(RPC_HDR *hdr, enum dcerpc_pkt_type pkt_type, uint8 flags,
  33                                 uint32 call_id, int data_len, int auth_len)
  34 {
  35         hdr->major        = 5;               /* RPC version 5 */
  36         hdr->minor        = 0;               /* minor version 0 */
  37         hdr->pkt_type     = pkt_type;        /* RPC packet type */
  38         hdr->flags        = flags;           /* dce/rpc flags */
  39         hdr->pack_type[0] = 0x10;            /* little-endian data representation */
  40         hdr->pack_type[1] = 0;               /* packed data representation */
  41         hdr->pack_type[2] = 0;               /* packed data representation */
  42         hdr->pack_type[3] = 0;               /* packed data representation */
  43         hdr->frag_len     = data_len;        /* fragment length, fill in later */
  44         hdr->auth_len     = auth_len;        /* authentication length */
  45         hdr->call_id      = call_id;         /* call identifier - match incoming RPC */
  46 }
  47
  48 /*******************************************************************
  49  Reads or writes an RPC_HDR structure.
  50 ********************************************************************/
  51
  52 bool smb_io_rpc_hdr(const char *desc,  RPC_HDR *rpc, prs_struct *ps, int depth)
  53 {
  54         if (rpc == NULL)
  55                 return False;
  56
  57         prs_debug(ps, depth, desc, "smb_io_rpc_hdr");
  58         depth++;
  59
  60         if(!prs_uint8 ("major     ", ps, depth, &rpc->major))
  61                 return False;
  62
  63         if(!prs_uint8 ("minor     ", ps, depth, &rpc->minor))
  64                 return False;
  65         if(!prs_uint8 ("pkt_type  ", ps, depth, &rpc->pkt_type))
  66                 return False;
  67         if(!prs_uint8 ("flags     ", ps, depth, &rpc->flags))
  68                 return False;
  69
  70         /* We always marshall in little endian format. */
  71         if (MARSHALLING(ps))
  72                 rpc->pack_type[0] = 0x10;
  73
  74         if(!prs_uint8("pack_type0", ps, depth, &rpc->pack_type[0]))
  75                 return False;
  76         if(!prs_uint8("pack_type1", ps, depth, &rpc->pack_type[1]))
  77                 return False;
  78         if(!prs_uint8("pack_type2", ps, depth, &rpc->pack_type[2]))
  79                 return False;
  80         if(!prs_uint8("pack_type3", ps, depth, &rpc->pack_type[3]))
  81                 return False;
  82
  83         /*
  84          * If reading and pack_type[0] == 0 then the data is in big-endian
  85          * format. Set the flag in the prs_struct to specify reverse-endainness.
  86          */
  87
  88         if (UNMARSHALLING(ps) && rpc->pack_type[0] == 0) {
  89                 DEBUG(10,("smb_io_rpc_hdr: PDU data format is big-endian. Setting flag.\n"));
  90                 prs_set_endian_data(ps, RPC_BIG_ENDIAN);
  91         }
  92
  93         if(!prs_uint16("frag_len  ", ps, depth, &rpc->frag_len))
  94                 return False;
  95         if(!prs_uint16("auth_len  ", ps, depth, &rpc->auth_len))
  96                 return False;
  97         if(!prs_uint32("call_id   ", ps, depth, &rpc->call_id))
  98                 return False;
  99         return True;
 100 }
 101
 102 /*******************************************************************
 103  Reads or writes an struct ndr_syntax_id structure.
 104 ********************************************************************/
 105
 106 static bool smb_io_rpc_iface(const char *desc, struct ndr_syntax_id *ifc,
 107                              prs_struct *ps, int depth)
 108 {
 109         if (ifc == NULL)
 110                 return False;
 111
 112         prs_debug(ps, depth, desc, "smb_io_rpc_iface");
 113         depth++;
 114
 115         if (!prs_align(ps))
 116                 return False;
 117
 118         if (!smb_io_uuid(  "uuid", &ifc->uuid, ps, depth))
 119                 return False;
 120
 121         if(!prs_uint32 ("version", ps, depth, &ifc->if_version))
 122                 return False;
 123
 124         return True;
 125 }
 126
 127 /*******************************************************************
 128  Inits an RPC_ADDR_STR structure.
 129 ********************************************************************/
 130
 131 static void init_rpc_addr_str(RPC_ADDR_STR *str, const char *name)
 132 {
 133         str->len = strlen(name) + 1;
 134         fstrcpy(str->str, name);
 135 }
 136
 137 /*******************************************************************
 138  Reads or writes an RPC_ADDR_STR structure.
 139 ********************************************************************/
 140
 141 static bool smb_io_rpc_addr_str(const char *desc,  RPC_ADDR_STR *str, prs_struct *ps, int depth)
 142 {
 143         if (str == NULL)
 144                 return False;
 145
 146         prs_debug(ps, depth, desc, "smb_io_rpc_addr_str");
 147         depth++;
 148         if(!prs_align(ps))
 149                 return False;
 150
 151         if(!prs_uint16 (      "len", ps, depth, &str->len))
 152                 return False;
 153         if(!prs_uint8s (True, "str", ps, depth, (uchar*)str->str, MIN(str->len, sizeof(str->str)) ))
 154                 return False;
 155         return True;
 156 }
 157
 158 /*******************************************************************
 159  Inits an RPC_HDR_BBA structure.
 160 ********************************************************************/
 161
 162 static void init_rpc_hdr_bba(RPC_HDR_BBA *bba, uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid)
 163 {
 164         bba->max_tsize = max_tsize; /* maximum transmission fragment size (0x1630) */
 165         bba->max_rsize = max_rsize; /* max receive fragment size (0x1630) */
 166         bba->assoc_gid = assoc_gid; /* associated group id (0x0) */
 167 }
 168
 169 /*******************************************************************
 170  Reads or writes an RPC_HDR_BBA structure.
 171 ********************************************************************/
 172
 173 static bool smb_io_rpc_hdr_bba(const char *desc,  RPC_HDR_BBA *rpc, prs_struct *ps, int depth)
 174 {
 175         if (rpc == NULL)
 176                 return False;
 177
 178         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_bba");
 179         depth++;
 180
 181         if(!prs_uint16("max_tsize", ps, depth, &rpc->max_tsize))
 182                 return False;
 183         if(!prs_uint16("max_rsize", ps, depth, &rpc->max_rsize))
 184                 return False;
 185         if(!prs_uint32("assoc_gid", ps, depth, &rpc->assoc_gid))
 186                 return False;
 187         return True;
 188 }
 189
 190 /*******************************************************************
 191  Reads or writes an RPC_CONTEXT structure.
 192 ********************************************************************/
 193
 194 bool smb_io_rpc_context(const char *desc, RPC_CONTEXT *rpc_ctx, prs_struct *ps, int depth)
 195 {
 196         int i;
 197
 198         if (rpc_ctx == NULL)
 199                 return False;
 200
 201         if(!prs_align(ps))
 202                 return False;
 203         if(!prs_uint16("context_id  ", ps, depth, &rpc_ctx->context_id ))
 204                 return False;
 205         if(!prs_uint8 ("num_transfer_syntaxes", ps, depth, &rpc_ctx->num_transfer_syntaxes))
 206                 return False;
 207
 208         /* num_transfer_syntaxes must not be zero. */
 209         if (rpc_ctx->num_transfer_syntaxes == 0)
 210                 return False;
 211
 212         if(!smb_io_rpc_iface("", &rpc_ctx->abstract, ps, depth))
 213                 return False;
 214
 215         if (UNMARSHALLING(ps)) {
 216                 if (!(rpc_ctx->transfer = PRS_ALLOC_MEM(ps, struct ndr_syntax_id, rpc_ctx->num_transfer_syntaxes))) {
 217                         return False;
 218                 }
 219         }
 220
 221         for (i = 0; i < rpc_ctx->num_transfer_syntaxes; i++ ) {
 222                 if (!smb_io_rpc_iface("", &rpc_ctx->transfer[i], ps, depth))
 223                         return False;
 224         }
 225         return True;
 226 }
 227
 228 /*******************************************************************
 229  Reads or writes an RPC_HDR_RB structure.
 230 ********************************************************************/
 231
 232 bool smb_io_rpc_hdr_rb(const char *desc, RPC_HDR_RB *rpc, prs_struct *ps, int depth)
 233 {
 234         int i;
 235
 236         if (rpc == NULL)
 237                 return False;
 238
 239         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_rb");
 240         depth++;
 241
 242         if(!smb_io_rpc_hdr_bba("", &rpc->bba, ps, depth))
 243                 return False;
 244
 245         if(!prs_uint8("num_contexts", ps, depth, &rpc->num_contexts))
 246                 return False;
 247
 248         /* 3 pad bytes following - will be mopped up by the prs_align in smb_io_rpc_context(). */
 249
 250         /* num_contexts must not be zero. */
 251         if (rpc->num_contexts == 0)
 252                 return False;
 253
 254         if (UNMARSHALLING(ps)) {
 255                 if (!(rpc->rpc_context = PRS_ALLOC_MEM(ps, RPC_CONTEXT, rpc->num_contexts))) {
 256                         return False;
 257                 }
 258         }
 259
 260         for (i = 0; i < rpc->num_contexts; i++ ) {
 261                 if (!smb_io_rpc_context("", &rpc->rpc_context[i], ps, depth))
 262                         return False;
 263         }
 264
 265         return True;
 266 }
 267
 268 /*******************************************************************
 269  Inits an RPC_RESULTS structure.
 270
 271  lkclXXXX only one reason at the moment!
 272 ********************************************************************/
 273
 274 static void init_rpc_results(RPC_RESULTS *res,
 275                                 uint8 num_results, uint16 result, uint16 reason)
 276 {
 277         res->num_results = num_results; /* the number of results (0x01) */
 278         res->result      = result     ;  /* result (0x00 = accept) */
 279         res->reason      = reason     ;  /* reason (0x00 = no reason specified) */
 280 }
 281
 282 /*******************************************************************
 283  Reads or writes an RPC_RESULTS structure.
 284
 285  lkclXXXX only one reason at the moment!
 286 ********************************************************************/
 287
 288 static bool smb_io_rpc_results(const char *desc, RPC_RESULTS *res, prs_struct *ps, int depth)
 289 {
 290         if (res == NULL)
 291                 return False;
 292
 293         prs_debug(ps, depth, desc, "smb_io_rpc_results");
 294         depth++;
 295
 296         if(!prs_align(ps))
 297                 return False;
 298
 299         if(!prs_uint8 ("num_results", ps, depth, &res->num_results))
 300                 return False;
 301
 302         if(!prs_align(ps))
 303                 return False;
 304
 305         if(!prs_uint16("result     ", ps, depth, &res->result))
 306                 return False;
 307         if(!prs_uint16("reason     ", ps, depth, &res->reason))
 308                 return False;
 309         return True;
 310 }
 311
 312 /*******************************************************************
 313  Init an RPC_HDR_BA structure.
 314
 315  lkclXXXX only one reason at the moment!
 316
 317 ********************************************************************/
 318
 319 void init_rpc_hdr_ba(RPC_HDR_BA *rpc,
 320                                 uint16 max_tsize, uint16 max_rsize, uint32 assoc_gid,
 321                                 const char *pipe_addr,
 322                                 uint8 num_results, uint16 result, uint16 reason,
 323                                 const struct ndr_syntax_id *transfer)
 324 {
 325         init_rpc_hdr_bba (&rpc->bba, max_tsize, max_rsize, assoc_gid);
 326         init_rpc_addr_str(&rpc->addr, pipe_addr);
 327         init_rpc_results (&rpc->res, num_results, result, reason);
 328
 329         /* the transfer syntax from the request */
 330         memcpy(&rpc->transfer, transfer, sizeof(rpc->transfer));
 331 }
 332
 333 /*******************************************************************
 334  Reads or writes an RPC_HDR_BA structure.
 335 ********************************************************************/
 336
 337 bool smb_io_rpc_hdr_ba(const char *desc, RPC_HDR_BA *rpc, prs_struct *ps, int depth)
 338 {
 339         if (rpc == NULL)
 340                 return False;
 341
 342         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_ba");
 343         depth++;
 344
 345         if(!smb_io_rpc_hdr_bba("", &rpc->bba, ps, depth))
 346                 return False;
 347         if(!smb_io_rpc_addr_str("", &rpc->addr, ps, depth))
 348                 return False;
 349         if(!smb_io_rpc_results("", &rpc->res, ps, depth))
 350                 return False;
 351         if(!smb_io_rpc_iface("", &rpc->transfer, ps, depth))
 352                 return False;
 353         return True;
 354 }
 355
 356 /*******************************************************************
 357  Init an RPC_HDR_REQ structure.
 358 ********************************************************************/
 359
 360 void init_rpc_hdr_req(RPC_HDR_REQ *hdr, uint32 alloc_hint, uint16 opnum)
 361 {
 362         hdr->alloc_hint   = alloc_hint; /* allocation hint */
 363         hdr->context_id   = 0;         /* presentation context identifier */
 364         hdr->opnum        = opnum;     /* opnum */
 365 }
 366
 367 /*******************************************************************
 368  Reads or writes an RPC_HDR_REQ structure.
 369 ********************************************************************/
 370
 371 bool smb_io_rpc_hdr_req(const char *desc, RPC_HDR_REQ *rpc, prs_struct *ps, int depth)
 372 {
 373         if (rpc == NULL)
 374                 return False;
 375
 376         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_req");
 377         depth++;
 378
 379         if(!prs_uint32("alloc_hint", ps, depth, &rpc->alloc_hint))
 380                 return False;
 381         if(!prs_uint16("context_id", ps, depth, &rpc->context_id))
 382                 return False;
 383         if(!prs_uint16("opnum     ", ps, depth, &rpc->opnum))
 384                 return False;
 385         return True;
 386 }
 387
 388 /*******************************************************************
 389  Reads or writes an RPC_HDR_RESP structure.
 390 ********************************************************************/
 391
 392 bool smb_io_rpc_hdr_resp(const char *desc, RPC_HDR_RESP *rpc, prs_struct *ps, int depth)
 393 {
 394         if (rpc == NULL)
 395                 return False;
 396
 397         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_resp");
 398         depth++;
 399
 400         if(!prs_uint32("alloc_hint", ps, depth, &rpc->alloc_hint))
 401                 return False;
 402         if(!prs_uint16("context_id", ps, depth, &rpc->context_id))
 403                 return False;
 404         if(!prs_uint8 ("cancel_ct ", ps, depth, &rpc->cancel_count))
 405                 return False;
 406         if(!prs_uint8 ("reserved  ", ps, depth, &rpc->reserved))
 407                 return False;
 408         return True;
 409 }
 410
 411 /*******************************************************************
 412  Inits an RPC_HDR_AUTH structure.
 413 ********************************************************************/
 414
 415 void init_rpc_hdr_auth(RPC_HDR_AUTH *rai,
 416                                 uint8 auth_type, uint8 auth_level,
 417                                 uint8 auth_pad_len,
 418                                 uint32 auth_context_id)
 419 {
 420         rai->auth_type     = auth_type;
 421         rai->auth_level    = auth_level;
 422         rai->auth_pad_len  = auth_pad_len;
 423         rai->auth_reserved = 0;
 424         rai->auth_context_id = auth_context_id;
 425 }
 426
 427 /*******************************************************************
 428  Reads or writes an RPC_HDR_AUTH structure.
 429  NB This writes UNALIGNED. Ensure you're correctly aligned before
 430  calling.
 431 ********************************************************************/
 432
 433 bool smb_io_rpc_hdr_auth(const char *desc, RPC_HDR_AUTH *rai, prs_struct *ps, int depth)
 434 {
 435         if (rai == NULL)
 436                 return False;
 437
 438         prs_debug(ps, depth, desc, "smb_io_rpc_hdr_auth");
 439         depth++;
 440
 441         if(!prs_uint8 ("auth_type    ", ps, depth, &rai->auth_type))
 442                 return False;
 443         if(!prs_uint8 ("auth_level   ", ps, depth, &rai->auth_level))
 444                 return False;
 445         if(!prs_uint8 ("auth_pad_len ", ps, depth, &rai->auth_pad_len))
 446                 return False;
 447         if(!prs_uint8 ("auth_reserved", ps, depth, &rai->auth_reserved))
 448                 return False;
 449         if(!prs_uint32("auth_context_id", ps, depth, &rai->auth_context_id))
 450                 return False;
 451
 452         return True;
 453 }