1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 24 */ 25 26 #include <assert.h> 27 #include <strings.h> 28 #include <sys/param.h> 29 30 #include <libmlrpc.h> 31 32 #ifdef _BIG_ENDIAN 33 static const int ndr_native_byte_order = NDR_REPLAB_INTG_BIG_ENDIAN; 34 #else 35 static const int ndr_native_byte_order = NDR_REPLAB_INTG_LITTLE_ENDIAN; 36 #endif 37 38 static int ndr_decode_hdr_common(ndr_stream_t *, ndr_common_header_t *); 39 static int ndr_decode_pac_hdr(ndr_stream_t *, ndr_pac_hdr_t *); 40 41 static int 42 ndr_encode_decode_common(ndr_stream_t *nds, unsigned opnum, 43 ndr_typeinfo_t *ti, void *datum) 44 { 45 int rc; 46 47 /* 48 * Perform the (un)marshalling 49 */ 50 if (ndo_operation(nds, ti, opnum, datum)) 51 return (NDR_DRC_OK); 52 53 switch (nds->error) { 54 case NDR_ERR_MALLOC_FAILED: 55 rc = NDR_DRC_FAULT_OUT_OF_MEMORY; 56 break; 57 58 case NDR_ERR_SWITCH_VALUE_INVALID: 59 rc = NDR_DRC_FAULT_PARAM_0_INVALID; 60 break; 61 62 case NDR_ERR_UNDERFLOW: 63 rc = NDR_DRC_FAULT_RECEIVED_RUNT; 64 break; 65 66 case NDR_ERR_GROW_FAILED: 67 rc = NDR_DRC_FAULT_ENCODE_TOO_BIG; 68 break; 69 70 default: 71 if (nds->m_op == NDR_M_OP_MARSHALL) 72 rc = NDR_DRC_FAULT_ENCODE_FAILED; 73 else 74 rc = NDR_DRC_FAULT_DECODE_FAILED; 75 break; 76 } 77 78 return (rc); 79 } 80 81 ndr_buf_t * 82 ndr_buf_init(ndr_typeinfo_t *ti) 83 { 84 ndr_buf_t *nbuf; 85 86 if ((nbuf = calloc(1, sizeof (ndr_buf_t))) == NULL) 87 return (NULL); 88 89 if ((nbuf->nb_heap = ndr_heap_create()) == NULL) { 90 free(nbuf); 91 return (NULL); 92 } 93 94 nbuf->nb_ti = ti; 95 nbuf->nb_magic = NDR_BUF_MAGIC; 96 return (nbuf); 97 } 98 99 void 100 ndr_buf_fini(ndr_buf_t *nbuf) 101 { 102 assert(nbuf->nb_magic == NDR_BUF_MAGIC); 103 104 nds_destruct(&nbuf->nb_nds); 105 ndr_heap_destroy(nbuf->nb_heap); 106 nbuf->nb_magic = 0; 107 free(nbuf); 108 } 109 110 /* 111 * Decode an NDR encoded buffer. The buffer is expected to contain 112 * a single fragment packet with a valid PDU header followed by NDR 113 * encoded data. The structure to which result points should be 114 * of the appropriate type to hold the decoded output. For example: 115 * 116 * pac_info_t info; 117 * 118 * if ((nbuf = ndr_buf_init(&TYPEINFO(ndr_pac)) != NULL) { 119 * rc = ndr_decode_buf(nbuf, opnum, data, datalen, &info); 120 * ... 121 * ndr_buf_fini(nbuf); 122 * } 123 */ 124 int 125 ndr_buf_decode(ndr_buf_t *nbuf, unsigned hdr_type, unsigned opnum, 126 const char *data, size_t datalen, void *result) 127 { 128 ndr_common_header_t hdr; 129 ndr_pac_hdr_t pac_hdr; 130 unsigned pdu_size_hint; 131 int rc; 132 133 assert(nbuf->nb_magic == NDR_BUF_MAGIC); 134 assert(nbuf->nb_heap != NULL); 135 assert(nbuf->nb_ti != NULL); 136 137 if (datalen < NDR_PDU_SIZE_HINT_DEFAULT) 138 pdu_size_hint = NDR_PDU_SIZE_HINT_DEFAULT; 139 else 140 pdu_size_hint = datalen; 141 142 rc = nds_initialize(&nbuf->nb_nds, pdu_size_hint, NDR_MODE_BUF_DECODE, 143 nbuf->nb_heap); 144 if (NDR_DRC_IS_FAULT(rc)) 145 return (rc); 146 147 bcopy(data, nbuf->nb_nds.pdu_base_addr, datalen); 148 149 switch (hdr_type) { 150 case NDR_PTYPE_COMMON: 151 rc = ndr_decode_hdr_common(&nbuf->nb_nds, &hdr); 152 if (NDR_DRC_IS_FAULT(rc)) 153 return (rc); 154 155 if (!NDR_IS_SINGLE_FRAG(hdr.pfc_flags)) 156 return (NDR_DRC_FAULT_DECODE_FAILED); 157 break; 158 159 case NDR_PTYPE_PAC: 160 rc = ndr_decode_pac_hdr(&nbuf->nb_nds, &pac_hdr); 161 if (NDR_DRC_IS_FAULT(rc)) 162 return (rc); 163 164 if (pac_hdr.common_hdr.hdrlen != sizeof (ndr_serialtype1_hdr_t)) 165 return (NDR_DRC_FAULT_DECODE_FAILED); 166 break; 167 168 default: 169 return (NDR_ERR_UNIMPLEMENTED); 170 } 171 172 rc = ndr_encode_decode_common(&nbuf->nb_nds, opnum, nbuf->nb_ti, 173 result); 174 return (rc); 175 } 176 177 /* 178 * Use the receive stream to unmarshall data (NDR_MODE_CALL_RECV). 179 */ 180 int 181 ndr_decode_call(ndr_xa_t *mxa, void *params) 182 { 183 ndr_stream_t *nds = &mxa->recv_nds; 184 int rc; 185 186 if (!NDR_MODE_MATCH(nds, NDR_MODE_CALL_RECV)) 187 return (NDR_DRC_FAULT_MODE_MISMATCH); 188 189 rc = ndr_encode_decode_common(nds, mxa->opnum, 190 mxa->binding->service->interface_ti, params); 191 192 return (rc + NDR_PTYPE_REQUEST); 193 } 194 195 /* 196 * Use the send stream to marshall data (NDR_MODE_RETURN_SEND). 197 */ 198 int 199 ndr_encode_return(ndr_xa_t *mxa, void *params) 200 { 201 ndr_stream_t *nds = &mxa->send_nds; 202 int rc; 203 204 if (!NDR_MODE_MATCH(nds, NDR_MODE_RETURN_SEND)) 205 return (NDR_DRC_FAULT_MODE_MISMATCH); 206 207 rc = ndr_encode_decode_common(nds, mxa->opnum, 208 mxa->binding->service->interface_ti, params); 209 210 return (rc + NDR_PTYPE_RESPONSE); 211 } 212 213 /* 214 * Use the send stream to marshall data (NDR_MODE_CALL_SEND). 215 */ 216 int 217 ndr_encode_call(ndr_xa_t *mxa, void *params) 218 { 219 ndr_stream_t *nds = &mxa->send_nds; 220 int rc; 221 222 if (!NDR_MODE_MATCH(nds, NDR_MODE_CALL_SEND)) 223 return (NDR_DRC_FAULT_MODE_MISMATCH); 224 225 rc = ndr_encode_decode_common(nds, mxa->opnum, 226 mxa->binding->service->interface_ti, params); 227 228 return (rc + NDR_PTYPE_REQUEST); 229 } 230 231 /* 232 * Use the receive stream to unmarshall data (NDR_MODE_RETURN_RECV). 233 */ 234 int 235 ndr_decode_return(ndr_xa_t *mxa, void *params) 236 { 237 ndr_stream_t *nds = &mxa->recv_nds; 238 int rc; 239 240 if (!NDR_MODE_MATCH(nds, NDR_MODE_RETURN_RECV)) 241 return (NDR_DRC_FAULT_MODE_MISMATCH); 242 243 rc = ndr_encode_decode_common(nds, mxa->opnum, 244 mxa->binding->service->interface_ti, params); 245 246 return (rc + NDR_PTYPE_RESPONSE); 247 } 248 249 int 250 ndr_decode_pdu_hdr(ndr_xa_t *mxa) 251 { 252 ndr_common_header_t *hdr = &mxa->recv_hdr.common_hdr; 253 ndr_stream_t *nds = &mxa->recv_nds; 254 int rc; 255 256 rc = ndr_decode_hdr_common(nds, hdr); 257 if (NDR_DRC_IS_FAULT(rc)) 258 return (rc); 259 260 /* 261 * Verify the protocol version. 262 */ 263 if ((hdr->rpc_vers != 5) || (hdr->rpc_vers_minor != 0)) 264 return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED); 265 266 mxa->ptype = hdr->ptype; 267 return (NDR_DRC_OK); 268 } 269 270 static int 271 ndr_decode_hdr_common(ndr_stream_t *nds, ndr_common_header_t *hdr) 272 { 273 int ptype; 274 int rc; 275 int charset; 276 int byte_order; 277 278 if (nds->m_op != NDR_M_OP_UNMARSHALL) 279 return (NDR_DRC_FAULT_RPCHDR_MODE_MISMATCH); 280 281 /* 282 * All PDU headers are at least this big 283 */ 284 rc = NDS_GROW_PDU(nds, sizeof (ndr_common_header_t), 0); 285 if (!rc) 286 return (NDR_DRC_FAULT_RPCHDR_RECEIVED_RUNT); 287 288 /* 289 * Peek at the first eight bytes to figure out what we're doing. 290 */ 291 rc = NDS_GET_PDU(nds, 0, 8, (char *)hdr, 0, 0); 292 if (!rc) 293 return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED); 294 295 /* 296 * Check for ASCII as the character set. This is an ASCII 297 * versus EBCDIC option and has nothing to do with Unicode. 298 */ 299 charset = hdr->packed_drep.intg_char_rep & NDR_REPLAB_CHAR_MASK; 300 if (charset != NDR_REPLAB_CHAR_ASCII) 301 return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED); 302 303 /* 304 * Set the byte swap flag if the PDU byte-order 305 * is different from the local byte-order. 306 */ 307 byte_order = hdr->packed_drep.intg_char_rep & NDR_REPLAB_INTG_MASK; 308 nds->swap = (byte_order != ndr_native_byte_order) ? 1 : 0; 309 310 ptype = hdr->ptype; 311 if (ptype == NDR_PTYPE_REQUEST && 312 (hdr->pfc_flags & NDR_PFC_OBJECT_UUID) != 0) { 313 ptype = NDR_PTYPE_REQUEST_WITH; /* fake for sizing */ 314 } 315 316 rc = ndr_encode_decode_common(nds, ptype, &TYPEINFO(ndr_hdr), hdr); 317 318 return (NDR_DRC_PTYPE_RPCHDR(rc)); 319 } 320 321 static int 322 ndr_decode_pac_hdr(ndr_stream_t *nds, ndr_pac_hdr_t *hdr) 323 { 324 int rc; 325 326 if (nds->m_op != NDR_M_OP_UNMARSHALL) 327 return (NDR_DRC_FAULT_RPCHDR_MODE_MISMATCH); 328 329 /* 330 * All PDU headers are at least this big 331 */ 332 rc = NDS_GROW_PDU(nds, sizeof (ndr_pac_hdr_t), 0); 333 if (!rc) 334 return (NDR_DRC_FAULT_RPCHDR_RECEIVED_RUNT); 335 336 /* 337 * Peek at the first eight bytes to figure out what we're doing. 338 */ 339 rc = NDS_GET_PDU(nds, 0, 8, (char *)hdr, 0, 0); 340 if (!rc) 341 return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED); 342 343 /* Must be set to 1 to indicate type serialization version 1. */ 344 if (hdr->common_hdr.version != 1) 345 return (NDR_DRC_FAULT_RPCHDR_DECODE_FAILED); 346 347 /* 348 * Set the byte swap flag if the PDU byte-order 349 * is different from the local byte-order. 350 */ 351 nds->swap = 352 (hdr->common_hdr.endianness != ndr_native_byte_order) ? 1 : 0; 353 354 rc = ndr_encode_decode_common(nds, NDR_PTYPE_PAC, 355 &TYPEINFO(ndr_hdr), hdr); 356 357 return (NDR_DRC_PTYPE_RPCHDR(rc)); 358 } 359 360 /* 361 * Decode an RPC fragment header. Use ndr_decode_pdu_hdr() to process 362 * the first fragment header then this function to process additional 363 * fragment headers. 364 */ 365 void 366 ndr_decode_frag_hdr(ndr_stream_t *nds, ndr_common_header_t *hdr) 367 { 368 ndr_common_header_t *tmp; 369 uint8_t *pdu; 370 int byte_order; 371 372 pdu = (uint8_t *)nds->pdu_base_offset + nds->pdu_scan_offset; 373 bcopy(pdu, hdr, NDR_RSP_HDR_SIZE); 374 375 /* 376 * Swap non-byte fields if the PDU byte-order 377 * is different from the local byte-order. 378 */ 379 byte_order = hdr->packed_drep.intg_char_rep & NDR_REPLAB_INTG_MASK; 380 381 if (byte_order != ndr_native_byte_order) { 382 /*LINTED E_BAD_PTR_CAST_ALIGN*/ 383 tmp = (ndr_common_header_t *)pdu; 384 385 nds_bswap(&tmp->frag_length, &hdr->frag_length, 386 sizeof (WORD)); 387 nds_bswap(&tmp->auth_length, &hdr->auth_length, 388 sizeof (WORD)); 389 nds_bswap(&tmp->call_id, &hdr->call_id, sizeof (DWORD)); 390 } 391 } 392 393 /* 394 * Remove an RPC fragment header from the received data stream. 395 * 396 * NDR stream on entry: 397 * 398 * |<--- frag --->| 399 * +-----+--------+-----+--------+-----+---------+-----+ 400 * | hdr | data | hdr | data | hdr | data | ... | 401 * +-----+--------+-----+--------+-----+---------+-----+ 402 * <---- 403 * 404 * NDR stream on return: 405 * 406 * +-----+----------------+-----+---------+-----+ 407 * | hdr | data | hdr | data | ... | 408 * +-----+----------------+-----+---------+-----+ 409 */ 410 void 411 ndr_remove_frag_hdr(ndr_stream_t *nds) 412 { 413 char *hdr; 414 char *data; 415 int nbytes; 416 417 hdr = (char *)nds->pdu_base_offset + nds->pdu_scan_offset; 418 data = hdr + NDR_RSP_HDR_SIZE; 419 nbytes = nds->pdu_size - nds->pdu_scan_offset - NDR_RSP_HDR_SIZE; 420 421 bcopy(data, hdr, nbytes); 422 nds->pdu_size -= NDR_RSP_HDR_SIZE; 423 } 424 425 void 426 ndr_show_hdr(ndr_common_header_t *hdr) 427 { 428 char *fragtype; 429 430 if (hdr == NULL) { 431 ndo_printf(NULL, NULL, "ndr hdr: <null>"); 432 return; 433 } 434 435 if (NDR_IS_SINGLE_FRAG(hdr->pfc_flags)) 436 fragtype = "single"; 437 else if (NDR_IS_FIRST_FRAG(hdr->pfc_flags)) 438 fragtype = "first"; 439 else if (NDR_IS_LAST_FRAG(hdr->pfc_flags)) 440 fragtype = "last"; 441 else 442 fragtype = "intermediate"; 443 444 ndo_printf(NULL, NULL, 445 "ndr hdr: %d.%d ptype=%d, %s frag (flags=0x%08x) len=%d", 446 hdr->rpc_vers, hdr->rpc_vers_minor, hdr->ptype, 447 fragtype, hdr->pfc_flags, hdr->frag_length); 448 } 449 450 int 451 ndr_encode_pdu_hdr(ndr_xa_t *mxa) 452 { 453 ndr_common_header_t *hdr = &mxa->send_hdr.common_hdr; 454 ndr_stream_t *nds = &mxa->send_nds; 455 int ptype; 456 int rc; 457 458 if (nds->m_op != NDR_M_OP_MARSHALL) 459 return (NDR_DRC_FAULT_RPCHDR_MODE_MISMATCH); 460 461 ptype = hdr->ptype; 462 if (ptype == NDR_PTYPE_REQUEST && 463 (hdr->pfc_flags & NDR_PFC_OBJECT_UUID) != 0) { 464 ptype = NDR_PTYPE_REQUEST_WITH; /* fake for sizing */ 465 } 466 467 rc = ndr_encode_decode_common(nds, ptype, &TYPEINFO(ndr_hdr), hdr); 468 469 return (NDR_DRC_PTYPE_RPCHDR(rc)); 470 } 471 472 /* 473 * This is a hand-coded derivative of the automatically generated 474 * (un)marshalling routine for bind_ack headers. bind_ack headers 475 * have an interior conformant array, which is inconsistent with 476 * IDL/NDR rules. 477 */ 478 extern struct ndr_typeinfo ndt__uchar; 479 extern struct ndr_typeinfo ndt__ushort; 480 extern struct ndr_typeinfo ndt__ulong; 481 482 int ndr__ndr_bind_ack_hdr(ndr_ref_t *encl_ref); 483 ndr_typeinfo_t ndt__ndr_bind_ack_hdr = { 484 1, /* NDR version */ 485 3, /* alignment */ 486 NDR_F_STRUCT, /* flags */ 487 ndr__ndr_bind_ack_hdr, /* ndr_func */ 488 68, /* pdu_size_fixed_part */ 489 0, /* pdu_size_variable_part */ 490 68, /* c_size_fixed_part */ 491 0, /* c_size_variable_part */ 492 }; 493 494 /* 495 * [_no_reorder] 496 */ 497 int 498 ndr__ndr_bind_ack_hdr(ndr_ref_t *encl_ref) 499 { 500 ndr_stream_t *nds = encl_ref->stream; 501 struct ndr_bind_ack_hdr *val = /*LINTED E_BAD_PTR_CAST_ALIGN*/ 502 (struct ndr_bind_ack_hdr *)encl_ref->datum; 503 ndr_ref_t myref; 504 unsigned long offset; 505 506 bzero(&myref, sizeof (myref)); 507 myref.enclosing = encl_ref; 508 myref.stream = encl_ref->stream; 509 myref.packed_alignment = 0; 510 511 /* do all members in order */ 512 NDR_MEMBER(_ndr_common_header, common_hdr, 0UL); 513 NDR_MEMBER(_ushort, max_xmit_frag, 16UL); 514 NDR_MEMBER(_ushort, max_recv_frag, 18UL); 515 NDR_MEMBER(_ulong, assoc_group_id, 20UL); 516 517 /* port any is the conformant culprit */ 518 offset = 24UL; 519 520 switch (nds->m_op) { 521 case NDR_M_OP_MARSHALL: 522 val->sec_addr.length = 523 strlen((char *)val->sec_addr.port_spec) + 1; 524 break; 525 526 case NDR_M_OP_UNMARSHALL: 527 break; 528 529 default: 530 NDR_SET_ERROR(encl_ref, NDR_ERR_M_OP_INVALID); 531 return (0); 532 } 533 534 NDR_MEMBER(_ushort, sec_addr.length, offset); 535 NDR_MEMBER_ARR_WITH_DIMENSION(_uchar, sec_addr.port_spec, 536 offset+2UL, val->sec_addr.length); 537 538 offset += 2; 539 offset += val->sec_addr.length; 540 offset += NDR_ALIGN4(offset); 541 542 NDR_MEMBER(_ndr_p_result_list, p_result_list, offset); 543 return (1); 544 } 545 546 /* 547 * Assume a single presentation context element in the result list. 548 */ 549 unsigned 550 ndr_bind_ack_hdr_size(ndr_xa_t *mxa) 551 { 552 ndr_bind_ack_hdr_t *bahdr = &mxa->send_hdr.bind_ack_hdr; 553 unsigned offset; 554 unsigned length; 555 556 /* port any is the conformant culprit */ 557 offset = 24UL; 558 559 length = strlen((char *)bahdr->sec_addr.port_spec) + 1; 560 561 offset += 2; 562 offset += length; 563 offset += NDR_ALIGN4(offset); 564 offset += sizeof (ndr_p_result_list_t); 565 return (offset); 566 } 567 568 /* 569 * This is a hand-coded derivative of the automatically generated 570 * (un)marshalling routine for alter_context_rsp headers. 571 * Alter context response headers have an interior conformant array, 572 * which is inconsistent with IDL/NDR rules. 573 */ 574 int ndr__ndr_alter_context_rsp_hdr(ndr_ref_t *encl_ref); 575 ndr_typeinfo_t ndt__ndr_alter_context_rsp_hdr = { 576 1, /* NDR version */ 577 3, /* alignment */ 578 NDR_F_STRUCT, /* flags */ 579 ndr__ndr_alter_context_rsp_hdr, /* ndr_func */ 580 56, /* pdu_size_fixed_part */ 581 0, /* pdu_size_variable_part */ 582 56, /* c_size_fixed_part */ 583 0, /* c_size_variable_part */ 584 }; 585 586 /* 587 * [_no_reorder] 588 */ 589 int 590 ndr__ndr_alter_context_rsp_hdr(ndr_ref_t *encl_ref) 591 { 592 ndr_stream_t *nds = encl_ref->stream; 593 ndr_alter_context_rsp_hdr_t *val = /*LINTED E_BAD_PTR_CAST_ALIGN*/ 594 (ndr_alter_context_rsp_hdr_t *)encl_ref->datum; 595 ndr_ref_t myref; 596 unsigned long offset; 597 598 bzero(&myref, sizeof (myref)); 599 myref.enclosing = encl_ref; 600 myref.stream = encl_ref->stream; 601 myref.packed_alignment = 0; 602 603 /* do all members in order */ 604 NDR_MEMBER(_ndr_common_header, common_hdr, 0UL); 605 NDR_MEMBER(_ushort, max_xmit_frag, 16UL); 606 NDR_MEMBER(_ushort, max_recv_frag, 18UL); 607 NDR_MEMBER(_ulong, assoc_group_id, 20UL); 608 609 offset = 24UL; /* offset of sec_addr */ 610 611 switch (nds->m_op) { 612 case NDR_M_OP_MARSHALL: 613 val->sec_addr.length = 0; 614 break; 615 616 case NDR_M_OP_UNMARSHALL: 617 break; 618 619 default: 620 NDR_SET_ERROR(encl_ref, NDR_ERR_M_OP_INVALID); 621 return (0); 622 } 623 624 NDR_MEMBER(_ushort, sec_addr.length, offset); 625 NDR_MEMBER_ARR_WITH_DIMENSION(_uchar, sec_addr.port_spec, 626 offset+2UL, val->sec_addr.length); 627 628 offset += 2; /* sizeof (sec_addr.length) */ 629 offset += NDR_ALIGN4(offset); 630 631 NDR_MEMBER(_ndr_p_result_list, p_result_list, offset); 632 return (1); 633 } 634 635 /* 636 * Assume a single presentation context element in the result list. 637 */ 638 unsigned 639 ndr_alter_context_rsp_hdr_size(void) 640 { 641 unsigned offset; 642 643 offset = 24UL; /* offset of sec_addr */ 644 offset += 2; /* sizeof (sec_addr.length) */ 645 offset += NDR_ALIGN4(offset); 646 offset += sizeof (ndr_p_result_list_t); 647 return (offset); 648 } 649