2003-10-30 11:32:26 +03:00
/*
Unix SMB / CIFS implementation .
routines for marshalling / unmarshalling basic types
Copyright ( C ) Andrew Tridgell 2003
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 of the License , or
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
2003-12-31 04:32:33 +03:00
# define NDR_BE(ndr) (((ndr)->flags & (LIBNDR_FLAG_BIGENDIAN|LIBNDR_FLAG_LITTLE_ENDIAN)) == LIBNDR_FLAG_BIGENDIAN)
2003-12-16 12:02:58 +03:00
# define NDR_SVAL(ndr, ofs) (NDR_BE(ndr)?RSVAL(ndr->data,ofs):SVAL(ndr->data,ofs))
# define NDR_IVAL(ndr, ofs) (NDR_BE(ndr)?RIVAL(ndr->data,ofs):IVAL(ndr->data,ofs))
2004-10-15 11:19:09 +04:00
# define NDR_IVALS(ndr, ofs) (NDR_BE(ndr)?RIVALS(ndr->data,ofs):IVALS(ndr->data,ofs))
2003-12-16 12:02:58 +03:00
# define NDR_SSVAL(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSSVAL(ndr->data,ofs,v); } else SSVAL(ndr->data,ofs,v); } while (0)
# define NDR_SIVAL(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSIVAL(ndr->data,ofs,v); } else SIVAL(ndr->data,ofs,v); } while (0)
2004-10-15 11:19:09 +04:00
# define NDR_SIVALS(ndr, ofs, v) do { if (NDR_BE(ndr)) { RSIVALS(ndr->data,ofs,v); } else SIVALS(ndr->data,ofs,v); } while (0)
2003-12-16 12:02:58 +03:00
2004-09-02 14:45:58 +04:00
/*
check for data leaks from the server by looking for non - zero pad bytes
these could also indicate that real structure elements have been
mistaken for padding in the IDL
*/
void ndr_check_padding ( struct ndr_pull * ndr , size_t n )
{
size_t ofs2 = ( ndr - > offset + ( n - 1 ) ) & ~ ( n - 1 ) ;
int i ;
for ( i = ndr - > offset ; i < ofs2 ; i + + ) {
if ( ndr - > data [ i ] ! = 0 ) {
break ;
}
}
if ( i < ofs2 ) {
DEBUG ( 0 , ( " WARNING: Non-zero padding to %d: " , n ) ) ;
for ( i = ndr - > offset ; i < ofs2 ; i + + ) {
DEBUG ( 0 , ( " %02x " , ndr - > data [ i ] ) ) ;
}
DEBUG ( 0 , ( " \n " ) ) ;
}
}
2003-10-30 11:32:26 +03:00
/*
2003-11-06 15:34:04 +03:00
parse a uint8
2003-10-30 11:32:26 +03:00
*/
2004-05-25 21:50:17 +04:00
NTSTATUS ndr_pull_uint8 ( struct ndr_pull * ndr , uint8_t * v )
2003-10-30 11:32:26 +03:00
{
2003-11-03 09:22:45 +03:00
NDR_PULL_NEED_BYTES ( ndr , 1 ) ;
2003-10-30 11:32:26 +03:00
* v = CVAL ( ndr - > data , ndr - > offset ) ;
ndr - > offset + = 1 ;
return NT_STATUS_OK ;
}
/*
2003-11-06 15:34:04 +03:00
parse a uint16
2003-10-30 11:32:26 +03:00
*/
2004-05-25 21:24:24 +04:00
NTSTATUS ndr_pull_uint16 ( struct ndr_pull * ndr , uint16_t * v )
2003-10-30 11:32:26 +03:00
{
2003-11-03 09:22:45 +03:00
NDR_PULL_ALIGN ( ndr , 2 ) ;
NDR_PULL_NEED_BYTES ( ndr , 2 ) ;
2003-12-16 12:02:58 +03:00
* v = NDR_SVAL ( ndr , ndr - > offset ) ;
2003-10-30 11:32:26 +03:00
ndr - > offset + = 2 ;
return NT_STATUS_OK ;
}
/*
2004-05-25 20:24:13 +04:00
parse a uint32_t
2003-10-30 11:32:26 +03:00
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_pull_uint32 ( struct ndr_pull * ndr , uint32_t * v )
2003-10-30 11:32:26 +03:00
{
2003-11-03 09:22:45 +03:00
NDR_PULL_ALIGN ( ndr , 4 ) ;
NDR_PULL_NEED_BYTES ( ndr , 4 ) ;
2003-12-16 12:02:58 +03:00
* v = NDR_IVAL ( ndr , ndr - > offset ) ;
2003-11-03 12:18:38 +03:00
ndr - > offset + = 4 ;
return NT_STATUS_OK ;
}
2004-10-15 11:19:09 +04:00
/*
parse a int32_t
*/
NTSTATUS ndr_pull_int32 ( struct ndr_pull * ndr , int32_t * v )
{
NDR_PULL_ALIGN ( ndr , 4 ) ;
NDR_PULL_NEED_BYTES ( ndr , 4 ) ;
* v = NDR_IVALS ( ndr , ndr - > offset ) ;
ndr - > offset + = 4 ;
return NT_STATUS_OK ;
}
2004-06-14 11:27:22 +04:00
/*
parse a pointer
*/
NTSTATUS ndr_pull_ptr ( struct ndr_pull * ndr , uint32_t * v )
{
NTSTATUS status ;
status = ndr_pull_uint32 ( ndr , v ) ;
2004-08-12 09:15:41 +04:00
if ( * v ! = 0 ) {
ndr - > ptr_count + + ;
}
2004-06-14 11:27:22 +04:00
return status ;
}
2003-11-11 10:57:08 +03:00
/*
2004-05-25 17:57:39 +04:00
parse a uint64
2003-11-11 10:57:08 +03:00
*/
2004-05-25 17:57:39 +04:00
NTSTATUS ndr_pull_uint64 ( struct ndr_pull * ndr , uint64_t * v )
2003-11-11 10:57:08 +03:00
{
2004-05-25 17:57:39 +04:00
NDR_PULL_ALIGN ( ndr , 4 ) ;
2003-11-11 10:57:08 +03:00
NDR_PULL_NEED_BYTES ( ndr , 8 ) ;
2004-05-25 17:57:39 +04:00
* v = NDR_IVAL ( ndr , ndr - > offset ) ;
* v | = ( uint64_t ) ( NDR_IVAL ( ndr , ndr - > offset + 4 ) ) < < 32 ;
2003-11-11 10:57:08 +03:00
ndr - > offset + = 8 ;
return NT_STATUS_OK ;
}
2004-05-25 17:57:39 +04:00
/*
parse a int64
*/
NTSTATUS ndr_pull_int64 ( struct ndr_pull * ndr , int64_t * v )
{
return ndr_pull_uint64 ( ndr , ( uint64_t * ) v ) ;
}
/*
parse a HYPER_T
*/
NTSTATUS ndr_pull_HYPER_T ( struct ndr_pull * ndr , HYPER_T * v )
{
NDR_PULL_ALIGN ( ndr , 8 ) ;
return ndr_pull_uint64 ( ndr , v ) ;
}
2003-11-04 12:10:31 +03:00
/*
pull a NTSTATUS
*/
2003-11-08 16:23:20 +03:00
NTSTATUS ndr_pull_NTSTATUS ( struct ndr_pull * ndr , NTSTATUS * status )
2003-11-04 12:10:31 +03:00
{
2004-05-25 20:24:13 +04:00
uint32_t v ;
2003-11-06 15:34:04 +03:00
NDR_CHECK ( ndr_pull_uint32 ( ndr , & v ) ) ;
2003-11-04 12:10:31 +03:00
* status = NT_STATUS ( v ) ;
return NT_STATUS_OK ;
}
2003-11-22 11:11:32 +03:00
/*
push a NTSTATUS
*/
NTSTATUS ndr_push_NTSTATUS ( struct ndr_push * ndr , NTSTATUS status )
{
return ndr_push_uint32 ( ndr , NT_STATUS_V ( status ) ) ;
}
2003-11-18 04:18:24 +03:00
void ndr_print_NTSTATUS ( struct ndr_print * ndr , const char * name , NTSTATUS * r )
{
ndr - > print ( ndr , " %-25s: %s " , name , nt_errstr ( * r ) ) ;
}
2003-11-17 05:58:10 +03:00
/*
pull a WERROR
*/
NTSTATUS ndr_pull_WERROR ( struct ndr_pull * ndr , WERROR * status )
{
2004-05-25 20:24:13 +04:00
uint32_t v ;
2003-11-17 05:58:10 +03:00
NDR_CHECK ( ndr_pull_uint32 ( ndr , & v ) ) ;
* status = W_ERROR ( v ) ;
return NT_STATUS_OK ;
}
2003-11-22 11:11:32 +03:00
/*
push a WERROR
*/
NTSTATUS ndr_push_WERROR ( struct ndr_push * ndr , WERROR status )
{
return ndr_push_uint32 ( ndr , W_ERROR_V ( status ) ) ;
}
2004-11-01 15:40:43 +03:00
void ndr_print_WERROR ( struct ndr_print * ndr , const char * name , WERROR r )
2003-11-18 04:18:24 +03:00
{
2004-11-01 15:40:43 +03:00
ndr - > print ( ndr , " %-25s: %s " , name , win_errstr ( r ) ) ;
2003-11-18 04:18:24 +03:00
}
2003-11-03 12:18:38 +03:00
/*
parse a set of bytes
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_pull_bytes ( struct ndr_pull * ndr , char * data , uint32_t n )
2003-11-03 12:18:38 +03:00
{
NDR_PULL_NEED_BYTES ( ndr , n ) ;
2003-11-04 12:10:31 +03:00
memcpy ( data , ndr - > data + ndr - > offset , n ) ;
2003-11-03 12:18:38 +03:00
ndr - > offset + = n ;
2003-10-30 11:32:26 +03:00
return NT_STATUS_OK ;
}
2003-11-09 10:24:06 +03:00
/*
pull an array of uint8
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_pull_array_uint8 ( struct ndr_pull * ndr , int ndr_flags , char * data , uint32_t n )
2003-11-09 10:24:06 +03:00
{
2003-11-17 09:27:45 +03:00
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
2003-11-13 12:26:53 +03:00
return ndr_pull_bytes ( ndr , data , n ) ;
2003-11-09 10:24:06 +03:00
}
2003-11-11 09:22:58 +03:00
/*
pull an array of uint16
*/
2004-05-25 21:24:24 +04:00
NTSTATUS ndr_pull_array_uint16 ( struct ndr_pull * ndr , int ndr_flags , uint16_t * data , uint32_t n )
2003-11-11 09:22:58 +03:00
{
2004-05-25 20:24:13 +04:00
uint32_t i ;
2003-11-17 09:27:45 +03:00
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
2003-11-11 09:22:58 +03:00
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_pull_uint16 ( ndr , & data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2003-11-12 08:34:21 +03:00
/*
2004-05-25 20:24:13 +04:00
pull a const array of uint32_t
2003-11-12 08:34:21 +03:00
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_pull_array_uint32 ( struct ndr_pull * ndr , int ndr_flags , uint32_t * data , uint32_t n )
2003-11-12 08:34:21 +03:00
{
2004-05-25 20:24:13 +04:00
uint32_t i ;
2003-11-17 09:27:45 +03:00
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
2003-11-12 08:34:21 +03:00
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_pull_uint32 ( ndr , & data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2004-08-11 23:48:36 +04:00
/*
pull a const array of HYPER_T
*/
NTSTATUS ndr_pull_array_HYPER_T ( struct ndr_pull * ndr , int ndr_flags , HYPER_T * data , uint32_t n )
{
uint32_t i ;
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_pull_HYPER_T ( ndr , & data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2004-11-01 15:40:43 +03:00
/*
pull a const array of WERROR
*/
NTSTATUS ndr_pull_array_WERROR ( struct ndr_pull * ndr , int ndr_flags , WERROR * data , uint32_t n )
{
uint32_t i ;
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_pull_WERROR ( ndr , & data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2003-11-03 09:22:45 +03:00
/*
2003-11-06 15:34:04 +03:00
push a uint8
2003-11-03 09:22:45 +03:00
*/
2004-05-25 21:50:17 +04:00
NTSTATUS ndr_push_uint8 ( struct ndr_push * ndr , uint8_t v )
2003-11-03 09:22:45 +03:00
{
NDR_PUSH_NEED_BYTES ( ndr , 1 ) ;
SCVAL ( ndr - > data , ndr - > offset , v ) ;
ndr - > offset + = 1 ;
return NT_STATUS_OK ;
}
/*
2003-11-06 15:34:04 +03:00
push a uint16
2003-11-03 09:22:45 +03:00
*/
2004-05-25 21:24:24 +04:00
NTSTATUS ndr_push_uint16 ( struct ndr_push * ndr , uint16_t v )
2003-11-03 09:22:45 +03:00
{
NDR_PUSH_ALIGN ( ndr , 2 ) ;
NDR_PUSH_NEED_BYTES ( ndr , 2 ) ;
2003-12-16 12:02:58 +03:00
NDR_SSVAL ( ndr , ndr - > offset , v ) ;
2003-11-03 09:22:45 +03:00
ndr - > offset + = 2 ;
return NT_STATUS_OK ;
}
/*
2004-05-25 20:24:13 +04:00
push a uint32_t
2003-11-03 09:22:45 +03:00
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_push_uint32 ( struct ndr_push * ndr , uint32_t v )
2003-11-03 09:22:45 +03:00
{
NDR_PUSH_ALIGN ( ndr , 4 ) ;
NDR_PUSH_NEED_BYTES ( ndr , 4 ) ;
2003-12-16 12:02:58 +03:00
NDR_SIVAL ( ndr , ndr - > offset , v ) ;
2003-11-03 09:22:45 +03:00
ndr - > offset + = 4 ;
return NT_STATUS_OK ;
}
2003-11-03 12:18:38 +03:00
2004-10-15 11:19:09 +04:00
/*
push a int32_t
*/
NTSTATUS ndr_push_int32 ( struct ndr_push * ndr , int32_t v )
{
NDR_PUSH_ALIGN ( ndr , 4 ) ;
NDR_PUSH_NEED_BYTES ( ndr , 4 ) ;
NDR_SIVALS ( ndr , ndr - > offset , v ) ;
ndr - > offset + = 4 ;
return NT_STATUS_OK ;
}
2003-11-11 10:57:08 +03:00
/*
2004-05-25 17:57:39 +04:00
push a uint64
2003-11-11 10:57:08 +03:00
*/
2004-05-26 05:14:56 +04:00
NTSTATUS ndr_push_uint64 ( struct ndr_push * ndr , uint64_t v )
2003-11-11 10:57:08 +03:00
{
2004-05-25 17:57:39 +04:00
NDR_PUSH_ALIGN ( ndr , 4 ) ;
2003-11-11 10:57:08 +03:00
NDR_PUSH_NEED_BYTES ( ndr , 8 ) ;
2004-05-25 17:57:39 +04:00
NDR_SIVAL ( ndr , ndr - > offset , ( v & 0xFFFFFFFF ) ) ;
NDR_SIVAL ( ndr , ndr - > offset + 4 , ( v > > 32 ) ) ;
2003-11-11 10:57:08 +03:00
ndr - > offset + = 8 ;
return NT_STATUS_OK ;
}
2004-05-25 17:57:39 +04:00
/*
push a int64
*/
2004-05-26 05:14:56 +04:00
NTSTATUS ndr_push_int64 ( struct ndr_push * ndr , int64_t v )
2004-05-25 17:57:39 +04:00
{
return ndr_push_uint64 ( ndr , ( uint64_t ) v ) ;
}
/*
push a HYPER_T
*/
NTSTATUS ndr_push_HYPER_T ( struct ndr_push * ndr , HYPER_T v )
{
NDR_PUSH_ALIGN ( ndr , 8 ) ;
return ndr_push_uint64 ( ndr , v ) ;
}
2003-11-11 09:54:54 +03:00
NTSTATUS ndr_push_align ( struct ndr_push * ndr , size_t size )
2003-11-06 15:34:04 +03:00
{
2003-11-11 09:54:54 +03:00
NDR_PUSH_ALIGN ( ndr , size ) ;
return NT_STATUS_OK ;
}
NTSTATUS ndr_pull_align ( struct ndr_pull * ndr , size_t size )
{
NDR_PULL_ALIGN ( ndr , size ) ;
2003-11-06 15:34:04 +03:00
return NT_STATUS_OK ;
}
2003-11-03 12:18:38 +03:00
/*
push some bytes
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_push_bytes ( struct ndr_push * ndr , const char * data , uint32_t n )
2003-11-03 12:18:38 +03:00
{
NDR_PUSH_NEED_BYTES ( ndr , n ) ;
memcpy ( ndr - > data + ndr - > offset , data , n ) ;
ndr - > offset + = n ;
return NT_STATUS_OK ;
}
2003-11-04 12:10:31 +03:00
2003-11-26 04:16:41 +03:00
/*
push some zero bytes
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_push_zero ( struct ndr_push * ndr , uint32_t n )
2003-11-26 04:16:41 +03:00
{
NDR_PUSH_NEED_BYTES ( ndr , n ) ;
memset ( ndr - > data + ndr - > offset , 0 , n ) ;
ndr - > offset + = n ;
return NT_STATUS_OK ;
}
2003-11-09 10:24:06 +03:00
/*
push an array of uint8
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_push_array_uint8 ( struct ndr_push * ndr , int ndr_flags , const char * data , uint32_t n )
2003-11-09 10:24:06 +03:00
{
2003-11-17 09:27:45 +03:00
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
2003-11-09 10:24:06 +03:00
return ndr_push_bytes ( ndr , data , n ) ;
}
2003-12-12 09:26:34 +03:00
/*
push an array of uint16
*/
2004-05-25 21:24:24 +04:00
NTSTATUS ndr_push_array_uint16 ( struct ndr_push * ndr , int ndr_flags , const uint16_t * data , uint32_t n )
2003-12-12 09:26:34 +03:00
{
int i ;
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_push_uint16 ( ndr , data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2003-11-14 10:20:46 +03:00
/*
2004-05-25 20:24:13 +04:00
push an array of uint32_t
2003-11-14 10:20:46 +03:00
*/
2004-05-25 20:24:13 +04:00
NTSTATUS ndr_push_array_uint32 ( struct ndr_push * ndr , int ndr_flags , const uint32_t * data , uint32_t n )
2003-11-14 10:20:46 +03:00
{
int i ;
2003-11-17 09:27:45 +03:00
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
2003-11-14 10:20:46 +03:00
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_push_uint32 ( ndr , data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2004-08-11 23:48:36 +04:00
/*
push an array of HYPER_T
*/
NTSTATUS ndr_push_array_HYPER_T ( struct ndr_push * ndr , int ndr_flags , const HYPER_T * data , uint32_t n )
{
int i ;
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_push_HYPER_T ( ndr , data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2004-11-01 15:40:43 +03:00
/*
push an array of HYPER_T
*/
NTSTATUS ndr_push_array_WERROR ( struct ndr_push * ndr , int ndr_flags , const WERROR * data , uint32_t n )
{
int i ;
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
}
for ( i = 0 ; i < n ; i + + ) {
NDR_CHECK ( ndr_push_WERROR ( ndr , data [ i ] ) ) ;
}
return NT_STATUS_OK ;
}
2003-11-05 03:49:42 +03:00
/*
save the current position
*/
void ndr_push_save ( struct ndr_push * ndr , struct ndr_push_save * save )
{
save - > offset = ndr - > offset ;
}
/*
restore the position
*/
void ndr_push_restore ( struct ndr_push * ndr , struct ndr_push_save * save )
{
ndr - > offset = save - > offset ;
}
2003-11-04 12:10:31 +03:00
/*
push a 1 if a pointer is non - NULL , otherwise 0
*/
NTSTATUS ndr_push_ptr ( struct ndr_push * ndr , const void * p )
{
2004-05-25 20:24:13 +04:00
uint32_t ptr = 0 ;
2003-11-20 06:09:19 +03:00
if ( p ) {
/* we do this to ensure that we generate unique ref ids,
which means we can handle the case where a MS programmer
forgot to mark a pointer as unique */
ndr - > ptr_count + + ;
2003-11-21 16:14:17 +03:00
ptr = ndr - > ptr_count ;
2003-11-20 06:09:19 +03:00
}
return ndr_push_uint32 ( ndr , ptr ) ;
2003-11-04 12:10:31 +03:00
}
2003-11-21 05:19:47 +03:00
/*
2003-11-21 16:14:17 +03:00
pull a general string from the wire
2003-11-21 05:19:47 +03:00
*/
2003-11-21 16:14:17 +03:00
NTSTATUS ndr_pull_string ( struct ndr_pull * ndr , int ndr_flags , const char * * s )
2003-11-21 05:19:47 +03:00
{
2003-11-21 16:14:17 +03:00
char * as = NULL ;
2004-05-25 20:24:13 +04:00
uint32_t len1 , ofs , len2 ;
2004-05-25 21:24:24 +04:00
uint16_t len3 ;
2003-11-21 16:14:17 +03:00
int ret ;
2004-09-01 08:39:06 +04:00
int chset = CH_UTF16 ;
2004-10-11 13:27:19 +04:00
unsigned byte_mul = 2 ;
unsigned flags = ndr - > flags ;
2003-11-21 16:14:17 +03:00
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
2003-11-21 05:19:47 +03:00
}
2003-12-31 04:32:33 +03:00
if ( NDR_BE ( ndr ) ) {
2004-09-01 08:39:06 +04:00
chset = CH_UTF16BE ;
2003-12-16 12:20:34 +03:00
}
2004-10-11 13:27:19 +04:00
if ( flags & LIBNDR_FLAG_STR_ASCII ) {
chset = CH_DOS ;
byte_mul = 1 ;
flags & = ~ LIBNDR_FLAG_STR_ASCII ;
}
switch ( flags & LIBNDR_STRING_FLAGS ) {
2003-11-21 16:14:17 +03:00
case LIBNDR_FLAG_STR_LEN4 | LIBNDR_FLAG_STR_SIZE4 :
case LIBNDR_FLAG_STR_LEN4 | LIBNDR_FLAG_STR_SIZE4 | LIBNDR_FLAG_STR_NOTERM :
NDR_CHECK ( ndr_pull_uint32 ( ndr , & len1 ) ) ;
NDR_CHECK ( ndr_pull_uint32 ( ndr , & ofs ) ) ;
2004-10-11 13:27:19 +04:00
if ( ofs ! = 0 ) {
return ndr_pull_error ( ndr , NDR_ERR_STRING , " non-zero array offset with string flags 0x%x \n " ,
ndr - > flags & LIBNDR_STRING_FLAGS ) ;
}
2003-11-21 16:14:17 +03:00
NDR_CHECK ( ndr_pull_uint32 ( ndr , & len2 ) ) ;
if ( len2 > len1 ) {
2003-11-22 11:11:32 +03:00
return ndr_pull_error ( ndr , NDR_ERR_STRING ,
" Bad string lengths len1=%u ofs=%u len2=%u \n " ,
len1 , ofs , len2 ) ;
2003-11-21 16:14:17 +03:00
}
if ( len2 = = 0 ) {
2004-08-21 11:43:29 +04:00
* s = talloc_strdup ( ndr , " " ) ;
2003-11-21 16:14:17 +03:00
break ;
}
2004-10-11 13:27:19 +04:00
NDR_PULL_NEED_BYTES ( ndr , len2 * byte_mul ) ;
2004-08-21 11:43:29 +04:00
ret = convert_string_talloc ( ndr , chset , CH_UNIX ,
2003-11-21 16:14:17 +03:00
ndr - > data + ndr - > offset ,
2004-10-11 13:27:19 +04:00
len2 * byte_mul ,
r2552: Character set conversion and string handling updates.
The intial motivation for this commit was to merge in some of the
bugfixes present in Samba3's chrcnv and string handling code into
Samba4. However, along the way I found a lot of unused functions, and
decided to do a bit more...
The strlen_m code now does not use a fixed buffer, but more work is
needed to finish off other functions in str_util.c. These fixed
length buffers hav caused very nasty, hard to chase down bugs at some
sites.
The strupper_m() function has a strupper_talloc() to replace it (we
need to go around and fix more uses, but it's a start). Use of these
new functions will avoid bugs where the upper or lowercase version of
a string is a different length.
I have removed the push_*_allocate functions, which are replaced by
calls to push_*_talloc. Likewise, pstring and other 'fixed length'
wrappers are removed, where possible.
I have removed the first ('base pointer') argument, used by push_ucs2,
as the Samba4 way of doing things ensures that this is always on an
even boundary anyway. (It was used in only one place, in any case).
(This used to be commit dfecb0150627b500cb026b8a4932fe87902ca392)
2004-09-23 04:51:45 +04:00
( void * * ) & as ) ;
2003-11-21 16:14:17 +03:00
if ( ret = = - 1 ) {
return ndr_pull_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
NDR_CHECK ( ndr_pull_advance ( ndr , len2 * byte_mul ) ) ;
2004-05-28 17:23:30 +04:00
/* this is a way of detecting if a string is sent with the wrong
termination */
if ( ndr - > flags & LIBNDR_FLAG_STR_NOTERM ) {
if ( strlen ( as ) < len2 ) {
DEBUG ( 6 , ( " short string '%s' \n " , as ) ) ;
}
} else {
if ( strlen ( as ) = = len2 ) {
DEBUG ( 6 , ( " long string '%s' \n " , as ) ) ;
}
}
2003-11-21 16:14:17 +03:00
* s = as ;
break ;
case LIBNDR_FLAG_STR_SIZE4 :
2004-08-17 13:14:46 +04:00
case LIBNDR_FLAG_STR_SIZE4 | LIBNDR_FLAG_STR_NOTERM :
2003-11-21 16:14:17 +03:00
NDR_CHECK ( ndr_pull_uint32 ( ndr , & len1 ) ) ;
2004-10-11 13:27:19 +04:00
NDR_PULL_NEED_BYTES ( ndr , len1 * byte_mul ) ;
2003-11-21 16:14:17 +03:00
if ( len1 = = 0 ) {
2004-08-21 11:43:29 +04:00
* s = talloc_strdup ( ndr , " " ) ;
2003-11-21 16:14:17 +03:00
break ;
}
2004-08-21 11:43:29 +04:00
ret = convert_string_talloc ( ndr , chset , CH_UNIX ,
2003-11-21 16:14:17 +03:00
ndr - > data + ndr - > offset ,
2004-10-11 13:27:19 +04:00
len1 * byte_mul ,
r2552: Character set conversion and string handling updates.
The intial motivation for this commit was to merge in some of the
bugfixes present in Samba3's chrcnv and string handling code into
Samba4. However, along the way I found a lot of unused functions, and
decided to do a bit more...
The strlen_m code now does not use a fixed buffer, but more work is
needed to finish off other functions in str_util.c. These fixed
length buffers hav caused very nasty, hard to chase down bugs at some
sites.
The strupper_m() function has a strupper_talloc() to replace it (we
need to go around and fix more uses, but it's a start). Use of these
new functions will avoid bugs where the upper or lowercase version of
a string is a different length.
I have removed the push_*_allocate functions, which are replaced by
calls to push_*_talloc. Likewise, pstring and other 'fixed length'
wrappers are removed, where possible.
I have removed the first ('base pointer') argument, used by push_ucs2,
as the Samba4 way of doing things ensures that this is always on an
even boundary anyway. (It was used in only one place, in any case).
(This used to be commit dfecb0150627b500cb026b8a4932fe87902ca392)
2004-09-23 04:51:45 +04:00
( void * * ) & as ) ;
2003-11-21 16:14:17 +03:00
if ( ret = = - 1 ) {
return ndr_pull_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
NDR_CHECK ( ndr_pull_advance ( ndr , len1 * byte_mul ) ) ;
2004-08-17 13:14:46 +04:00
/* this is a way of detecting if a string is sent with the wrong
termination */
if ( ndr - > flags & LIBNDR_FLAG_STR_NOTERM ) {
if ( strlen ( as ) < len1 ) {
DEBUG ( 6 , ( " short string '%s' \n " , as ) ) ;
}
} else {
if ( strlen ( as ) = = len1 ) {
DEBUG ( 6 , ( " long string '%s' \n " , as ) ) ;
}
}
* s = as ;
break ;
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_LEN4 :
case LIBNDR_FLAG_STR_LEN4 | LIBNDR_FLAG_STR_NOTERM :
NDR_CHECK ( ndr_pull_uint32 ( ndr , & ofs ) ) ;
if ( ofs ! = 0 ) {
return ndr_pull_error ( ndr , NDR_ERR_STRING , " non-zero array offset with string flags 0x%x \n " ,
ndr - > flags & LIBNDR_STRING_FLAGS ) ;
}
NDR_CHECK ( ndr_pull_uint32 ( ndr , & len1 ) ) ;
NDR_PULL_NEED_BYTES ( ndr , len1 * byte_mul ) ;
if ( len1 = = 0 ) {
2004-08-21 11:43:29 +04:00
* s = talloc_strdup ( ndr , " " ) ;
2004-08-17 13:14:46 +04:00
break ;
}
2004-08-21 11:43:29 +04:00
ret = convert_string_talloc ( ndr , chset , CH_UNIX ,
2004-08-17 13:14:46 +04:00
ndr - > data + ndr - > offset ,
2004-10-11 13:27:19 +04:00
len1 * byte_mul ,
r2552: Character set conversion and string handling updates.
The intial motivation for this commit was to merge in some of the
bugfixes present in Samba3's chrcnv and string handling code into
Samba4. However, along the way I found a lot of unused functions, and
decided to do a bit more...
The strlen_m code now does not use a fixed buffer, but more work is
needed to finish off other functions in str_util.c. These fixed
length buffers hav caused very nasty, hard to chase down bugs at some
sites.
The strupper_m() function has a strupper_talloc() to replace it (we
need to go around and fix more uses, but it's a start). Use of these
new functions will avoid bugs where the upper or lowercase version of
a string is a different length.
I have removed the push_*_allocate functions, which are replaced by
calls to push_*_talloc. Likewise, pstring and other 'fixed length'
wrappers are removed, where possible.
I have removed the first ('base pointer') argument, used by push_ucs2,
as the Samba4 way of doing things ensures that this is always on an
even boundary anyway. (It was used in only one place, in any case).
(This used to be commit dfecb0150627b500cb026b8a4932fe87902ca392)
2004-09-23 04:51:45 +04:00
( void * * ) & as ) ;
2004-08-17 13:14:46 +04:00
if ( ret = = - 1 ) {
return ndr_pull_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
NDR_CHECK ( ndr_pull_advance ( ndr , len1 * byte_mul ) ) ;
/* this is a way of detecting if a string is sent with the wrong
termination */
if ( ndr - > flags & LIBNDR_FLAG_STR_NOTERM ) {
if ( strlen ( as ) < len1 ) {
DEBUG ( 6 , ( " short string '%s' \n " , as ) ) ;
}
} else {
if ( strlen ( as ) = = len1 ) {
DEBUG ( 6 , ( " long string '%s' \n " , as ) ) ;
}
}
2003-11-21 16:14:17 +03:00
* s = as ;
break ;
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_SIZE2 :
case LIBNDR_FLAG_STR_SIZE2 | LIBNDR_FLAG_STR_NOTERM :
NDR_CHECK ( ndr_pull_uint16 ( ndr , & len3 ) ) ;
NDR_PULL_NEED_BYTES ( ndr , len3 * byte_mul ) ;
if ( len3 = = 0 ) {
* s = talloc_strdup ( ndr , " " ) ;
break ;
}
2004-08-21 11:43:29 +04:00
ret = convert_string_talloc ( ndr , chset , CH_UNIX ,
2003-11-21 16:14:17 +03:00
ndr - > data + ndr - > offset ,
2004-10-11 13:27:19 +04:00
len3 * byte_mul ,
r2552: Character set conversion and string handling updates.
The intial motivation for this commit was to merge in some of the
bugfixes present in Samba3's chrcnv and string handling code into
Samba4. However, along the way I found a lot of unused functions, and
decided to do a bit more...
The strlen_m code now does not use a fixed buffer, but more work is
needed to finish off other functions in str_util.c. These fixed
length buffers hav caused very nasty, hard to chase down bugs at some
sites.
The strupper_m() function has a strupper_talloc() to replace it (we
need to go around and fix more uses, but it's a start). Use of these
new functions will avoid bugs where the upper or lowercase version of
a string is a different length.
I have removed the push_*_allocate functions, which are replaced by
calls to push_*_talloc. Likewise, pstring and other 'fixed length'
wrappers are removed, where possible.
I have removed the first ('base pointer') argument, used by push_ucs2,
as the Samba4 way of doing things ensures that this is always on an
even boundary anyway. (It was used in only one place, in any case).
(This used to be commit dfecb0150627b500cb026b8a4932fe87902ca392)
2004-09-23 04:51:45 +04:00
( void * * ) & as ) ;
2003-11-21 16:14:17 +03:00
if ( ret = = - 1 ) {
return ndr_pull_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
NDR_CHECK ( ndr_pull_advance ( ndr , len3 * byte_mul ) ) ;
2003-11-21 16:14:17 +03:00
2004-10-11 13:27:19 +04:00
/* this is a way of detecting if a string is sent with the wrong
termination */
if ( ndr - > flags & LIBNDR_FLAG_STR_NOTERM ) {
if ( strlen ( as ) < len3 ) {
DEBUG ( 6 , ( " short string '%s' \n " , as ) ) ;
}
} else {
if ( strlen ( as ) = = len3 ) {
DEBUG ( 6 , ( " long string '%s' \n " , as ) ) ;
}
2003-11-21 16:14:17 +03:00
}
2004-08-17 13:14:46 +04:00
* s = as ;
2003-11-21 16:14:17 +03:00
break ;
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_SIZE2 | LIBNDR_FLAG_STR_NOTERM | LIBNDR_FLAG_STR_BYTESIZE :
2003-11-23 09:28:12 +03:00
NDR_CHECK ( ndr_pull_uint16 ( ndr , & len3 ) ) ;
2004-10-11 13:27:19 +04:00
NDR_PULL_NEED_BYTES ( ndr , len3 ) ;
if ( len3 = = 0 ) {
* s = talloc_strdup ( ndr , " " ) ;
break ;
}
ret = convert_string_talloc ( ndr , chset , CH_UNIX ,
ndr - > data + ndr - > offset ,
len3 ,
( void * * ) & as ) ;
if ( ret = = - 1 ) {
return ndr_pull_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
NDR_CHECK ( ndr_pull_advance ( ndr , len3 ) ) ;
2004-08-17 13:14:46 +04:00
* s = as ;
2003-11-23 09:28:12 +03:00
break ;
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_NULLTERM :
if ( byte_mul = = 1 ) {
2004-10-20 06:02:00 +04:00
len1 = ascii_len_n ( ndr - > data + ndr - > offset , ndr - > data_size - ndr - > offset ) ;
2004-10-11 13:27:19 +04:00
} else {
len1 = utf16_len_n ( ndr - > data + ndr - > offset , ndr - > data_size - ndr - > offset ) ;
}
ret = convert_string_talloc ( ndr , chset , CH_UNIX ,
ndr - > data + ndr - > offset ,
len1 ,
( void * * ) & as ) ;
if ( ret = = - 1 ) {
return ndr_pull_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
2004-06-05 09:01:38 +04:00
}
2004-10-11 13:27:19 +04:00
NDR_CHECK ( ndr_pull_advance ( ndr , len1 ) ) ;
2004-08-17 13:14:46 +04:00
* s = as ;
2004-06-05 09:01:38 +04:00
break ;
2004-10-31 02:19:09 +03:00
case LIBNDR_FLAG_STR_FIXLEN32 :
len1 = 32 ;
NDR_PULL_NEED_BYTES ( ndr , len1 * byte_mul ) ;
ret = convert_string_talloc ( ndr , chset , CH_UNIX ,
ndr - > data + ndr - > offset ,
len1 * byte_mul ,
( void * * ) & as ) ;
if ( ret = = - 1 ) {
return ndr_pull_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
NDR_CHECK ( ndr_pull_advance ( ndr , len1 * byte_mul ) ) ;
* s = as ;
break ;
2003-11-21 16:14:17 +03:00
default :
return ndr_pull_error ( ndr , NDR_ERR_STRING , " Bad string flags 0x%x \n " ,
ndr - > flags & LIBNDR_STRING_FLAGS ) ;
2003-11-09 05:21:24 +03:00
}
2003-11-21 16:14:17 +03:00
2003-11-09 05:21:24 +03:00
return NT_STATUS_OK ;
}
2003-11-21 16:14:17 +03:00
2003-11-08 14:21:57 +03:00
/*
2003-11-21 16:14:17 +03:00
push a general string onto the wire
2003-11-08 14:21:57 +03:00
*/
2003-11-21 16:14:17 +03:00
NTSTATUS ndr_push_string ( struct ndr_push * ndr , int ndr_flags , const char * s )
2003-11-08 14:21:57 +03:00
{
2003-11-21 16:14:17 +03:00
ssize_t s_len , c_len ;
int ret ;
2004-09-01 08:39:06 +04:00
int chset = CH_UTF16 ;
2004-10-11 13:27:19 +04:00
unsigned flags = ndr - > flags ;
unsigned byte_mul = 2 ;
2003-11-08 14:21:57 +03:00
2003-11-21 16:14:17 +03:00
if ( ! ( ndr_flags & NDR_SCALARS ) ) {
return NT_STATUS_OK ;
2003-11-08 14:21:57 +03:00
}
2003-12-16 12:20:34 +03:00
2003-12-31 04:32:33 +03:00
if ( NDR_BE ( ndr ) ) {
2004-09-01 08:39:06 +04:00
chset = CH_UTF16BE ;
2003-12-16 12:20:34 +03:00
}
2003-11-21 16:14:17 +03:00
s_len = s ? strlen ( s ) : 0 ;
c_len = s ? strlen_m ( s ) : 0 ;
2003-11-08 14:21:57 +03:00
2004-10-11 13:27:19 +04:00
if ( flags & LIBNDR_FLAG_STR_ASCII ) {
chset = CH_DOS ;
byte_mul = 1 ;
flags & = ~ LIBNDR_FLAG_STR_ASCII ;
}
switch ( flags & LIBNDR_STRING_FLAGS ) {
2003-11-21 16:14:17 +03:00
case LIBNDR_FLAG_STR_LEN4 | LIBNDR_FLAG_STR_SIZE4 :
NDR_CHECK ( ndr_push_uint32 ( ndr , c_len + 1 ) ) ;
NDR_CHECK ( ndr_push_uint32 ( ndr , 0 ) ) ;
NDR_CHECK ( ndr_push_uint32 ( ndr , c_len + 1 ) ) ;
2004-10-11 13:27:19 +04:00
NDR_PUSH_NEED_BYTES ( ndr , byte_mul * ( c_len + 1 ) ) ;
2003-12-16 12:20:34 +03:00
ret = convert_string ( CH_UNIX , chset ,
2003-11-21 16:14:17 +03:00
s , s_len + 1 ,
2004-10-11 13:27:19 +04:00
ndr - > data + ndr - > offset ,
byte_mul * ( c_len + 1 ) ) ;
2003-11-21 16:14:17 +03:00
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
ndr - > offset + = byte_mul * ( c_len + 1 ) ;
2003-11-21 16:14:17 +03:00
break ;
case LIBNDR_FLAG_STR_LEN4 | LIBNDR_FLAG_STR_SIZE4 | LIBNDR_FLAG_STR_NOTERM :
NDR_CHECK ( ndr_push_uint32 ( ndr , c_len ) ) ;
NDR_CHECK ( ndr_push_uint32 ( ndr , 0 ) ) ;
NDR_CHECK ( ndr_push_uint32 ( ndr , c_len ) ) ;
2004-10-11 13:27:19 +04:00
NDR_PUSH_NEED_BYTES ( ndr , c_len * byte_mul ) ;
2003-12-16 12:20:34 +03:00
ret = convert_string ( CH_UNIX , chset ,
2003-11-21 16:14:17 +03:00
s , s_len ,
2004-10-11 13:27:19 +04:00
ndr - > data + ndr - > offset , c_len * byte_mul ) ;
2003-11-21 16:14:17 +03:00
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
ndr - > offset + = c_len * byte_mul ;
2003-11-21 16:14:17 +03:00
break ;
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_LEN4 :
NDR_CHECK ( ndr_push_uint32 ( ndr , 0 ) ) ;
2003-11-21 16:14:17 +03:00
NDR_CHECK ( ndr_push_uint32 ( ndr , c_len + 1 ) ) ;
2004-10-11 13:27:19 +04:00
NDR_PUSH_NEED_BYTES ( ndr , byte_mul * ( c_len + 1 ) ) ;
2003-12-16 12:20:34 +03:00
ret = convert_string ( CH_UNIX , chset ,
2003-11-21 16:14:17 +03:00
s , s_len + 1 ,
2004-10-11 13:27:19 +04:00
ndr - > data + ndr - > offset , byte_mul * ( c_len + 1 ) ) ;
2003-11-21 16:14:17 +03:00
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
ndr - > offset + = byte_mul * ( c_len + 1 ) ;
2003-11-21 16:14:17 +03:00
break ;
2004-08-17 13:14:46 +04:00
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_SIZE4 :
NDR_CHECK ( ndr_push_uint32 ( ndr , c_len + 1 ) ) ;
NDR_PUSH_NEED_BYTES ( ndr , byte_mul * ( c_len + 1 ) ) ;
2004-08-17 13:14:46 +04:00
ret = convert_string ( CH_UNIX , chset ,
2003-11-21 16:14:17 +03:00
s , s_len + 1 ,
2004-10-11 13:27:19 +04:00
ndr - > data + ndr - > offset , byte_mul * ( c_len + 1 ) ) ;
2004-04-19 09:48:03 +04:00
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
ndr - > offset + = byte_mul * ( c_len + 1 ) ;
2004-04-19 09:48:03 +04:00
break ;
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_SIZE2 :
NDR_CHECK ( ndr_push_uint16 ( ndr , c_len + 1 ) ) ;
NDR_PUSH_NEED_BYTES ( ndr , byte_mul * ( c_len + 1 ) ) ;
ret = convert_string ( CH_UNIX , chset ,
2003-11-21 16:14:17 +03:00
s , s_len + 1 ,
2004-10-11 13:27:19 +04:00
ndr - > data + ndr - > offset , byte_mul * ( c_len + 1 ) ) ;
2003-11-21 16:14:17 +03:00
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
ndr - > offset + = byte_mul * ( c_len + 1 ) ;
2003-11-21 16:14:17 +03:00
break ;
2003-11-21 05:19:47 +03:00
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_NULLTERM :
NDR_PUSH_NEED_BYTES ( ndr , byte_mul * ( c_len + 1 ) ) ;
ret = convert_string ( CH_UNIX , chset ,
s , s_len + 1 ,
ndr - > data + ndr - > offset , byte_mul * ( c_len + 1 ) ) ;
2003-11-23 09:28:12 +03:00
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
ndr - > offset + = byte_mul * ( c_len + 1 ) ;
2003-11-23 09:28:12 +03:00
break ;
2004-10-11 13:27:19 +04:00
case LIBNDR_FLAG_STR_SIZE2 | LIBNDR_FLAG_STR_NOTERM | LIBNDR_FLAG_STR_BYTESIZE :
NDR_CHECK ( ndr_push_uint16 ( ndr , c_len * byte_mul ) ) ;
NDR_PUSH_NEED_BYTES ( ndr , c_len * byte_mul ) ;
ret = convert_string ( CH_UNIX , chset ,
s , s_len ,
ndr - > data + ndr - > offset , c_len * byte_mul ) ;
2004-06-05 09:01:38 +04:00
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
2004-10-11 13:27:19 +04:00
ndr - > offset + = c_len * byte_mul ;
2004-06-05 09:01:38 +04:00
break ;
2004-10-31 02:19:09 +03:00
case LIBNDR_FLAG_STR_FIXLEN32 :
NDR_PUSH_NEED_BYTES ( ndr , byte_mul * 32 ) ;
ret = convert_string ( CH_UNIX , chset ,
s , s_len + 1 ,
ndr - > data + ndr - > offset , byte_mul * 32 ) ;
if ( ret = = - 1 ) {
return ndr_push_error ( ndr , NDR_ERR_CHARCNV ,
" Bad character conversion " ) ;
}
ndr - > offset + = byte_mul * 32 ;
break ;
2003-11-21 16:14:17 +03:00
default :
return ndr_push_error ( ndr , NDR_ERR_STRING , " Bad string flags 0x%x \n " ,
ndr - > flags & LIBNDR_STRING_FLAGS ) ;
2003-11-21 05:19:47 +03:00
}
2003-11-21 16:14:17 +03:00
return NT_STATUS_OK ;
2003-11-09 05:21:24 +03:00
}
2003-11-11 05:02:29 +03:00
/*
push a NTTIME
*/
NTSTATUS ndr_push_NTTIME ( struct ndr_push * ndr , NTTIME t )
{
2004-05-25 17:57:39 +04:00
NDR_CHECK ( ndr_push_uint64 ( ndr , t ) ) ;
2003-11-11 05:02:29 +03:00
return NT_STATUS_OK ;
}
/*
pull a NTTIME
*/
NTSTATUS ndr_pull_NTTIME ( struct ndr_pull * ndr , NTTIME * t )
{
2004-05-25 17:57:39 +04:00
NDR_CHECK ( ndr_pull_uint64 ( ndr , t ) ) ;
2003-11-11 05:02:29 +03:00
return NT_STATUS_OK ;
}
2003-11-11 07:04:36 +03:00
2003-12-01 04:41:38 +03:00
/*
push a time_t
*/
NTSTATUS ndr_push_time_t ( struct ndr_push * ndr , time_t t )
{
return ndr_push_uint32 ( ndr , t ) ;
}
/*
pull a time_t
*/
NTSTATUS ndr_pull_time_t ( struct ndr_pull * ndr , time_t * t )
{
2004-05-25 20:24:13 +04:00
uint32_t tt ;
2003-12-01 04:41:38 +03:00
NDR_CHECK ( ndr_pull_uint32 ( ndr , & tt ) ) ;
* t = tt ;
return NT_STATUS_OK ;
}
2003-11-11 07:04:36 +03:00
2003-11-11 07:38:51 +03:00
void ndr_print_struct ( struct ndr_print * ndr , const char * name , const char * type )
2003-11-11 07:04:36 +03:00
{
2003-11-11 07:38:51 +03:00
ndr - > print ( ndr , " %s: struct %s " , name , type ) ;
2003-11-11 07:04:36 +03:00
}
2004-05-25 21:50:17 +04:00
void ndr_print_uint8 ( struct ndr_print * ndr , const char * name , uint8_t v )
2003-11-11 07:04:36 +03:00
{
ndr - > print ( ndr , " %-25s: 0x%02x (%u) " , name , v , v ) ;
}
2004-05-25 21:24:24 +04:00
void ndr_print_uint16 ( struct ndr_print * ndr , const char * name , uint16_t v )
2003-11-11 07:04:36 +03:00
{
ndr - > print ( ndr , " %-25s: 0x%04x (%u) " , name , v , v ) ;
}
2004-05-25 20:24:13 +04:00
void ndr_print_uint32 ( struct ndr_print * ndr , const char * name , uint32_t v )
2003-11-11 07:04:36 +03:00
{
ndr - > print ( ndr , " %-25s: 0x%08x (%u) " , name , v , v ) ;
}
2004-10-15 11:19:09 +04:00
void ndr_print_int32 ( struct ndr_print * ndr , const char * name , int32_t v )
{
ndr - > print ( ndr , " %-25s: %d " , name , v ) ;
}
2004-05-26 05:14:56 +04:00
void ndr_print_uint64 ( struct ndr_print * ndr , const char * name , uint64_t v )
2004-05-25 17:57:39 +04:00
{
2004-05-25 20:24:13 +04:00
ndr - > print ( ndr , " %-25s: 0x%08x%08x " , name , ( uint32_t ) ( v > > 32 ) , ( uint32_t ) ( v & 0xFFFFFFFF ) ) ;
2004-05-25 17:57:39 +04:00
}
2004-05-26 05:14:56 +04:00
void ndr_print_int64 ( struct ndr_print * ndr , const char * name , int64_t v )
2004-05-25 17:57:39 +04:00
{
ndr - > print ( ndr , " %-25s: 0x%08x%08x (%lld) " , name ,
2004-05-25 20:24:13 +04:00
( uint32_t ) ( v > > 32 ) ,
( uint32_t ) ( v & 0xFFFFFFFF ) ,
2004-05-25 17:57:39 +04:00
v ) ;
}
2003-11-11 10:57:08 +03:00
void ndr_print_HYPER_T ( struct ndr_print * ndr , const char * name , HYPER_T v )
{
2004-05-25 20:24:13 +04:00
ndr - > print ( ndr , " %-25s: 0x%08x%08x " , name , ( uint32_t ) ( v > > 32 ) , ( uint32_t ) ( v & 0xFFFFFFFF ) ) ;
2003-11-11 10:57:08 +03:00
}
2003-11-11 07:04:36 +03:00
void ndr_print_ptr ( struct ndr_print * ndr , const char * name , const void * p )
{
if ( p ) {
ndr - > print ( ndr , " %-25s: * " , name ) ;
} else {
ndr - > print ( ndr , " %-25s: NULL " , name ) ;
}
}
2003-11-21 16:14:17 +03:00
void ndr_print_string ( struct ndr_print * ndr , const char * name , const char * s )
2003-11-11 07:04:36 +03:00
{
2003-11-17 05:18:11 +03:00
if ( s ) {
ndr - > print ( ndr , " %-25s: '%s' " , name , s ) ;
} else {
ndr - > print ( ndr , " %-25s: NULL " , name ) ;
}
2003-11-11 07:04:36 +03:00
}
void ndr_print_NTTIME ( struct ndr_print * ndr , const char * name , NTTIME t )
{
2004-08-21 11:43:29 +04:00
ndr - > print ( ndr , " %-25s: %s " , name , nt_time_string ( ndr , t ) ) ;
2003-11-11 07:04:36 +03:00
}
2003-11-11 07:38:51 +03:00
2003-12-01 04:41:38 +03:00
void ndr_print_time_t ( struct ndr_print * ndr , const char * name , time_t t )
{
if ( t = = ( time_t ) - 1 | | t = = 0 ) {
ndr - > print ( ndr , " %-25s: (time_t)%d " , name , ( int ) t ) ;
} else {
2004-08-21 11:43:29 +04:00
ndr - > print ( ndr , " %-25s: %s " , name , timestring ( ndr , t ) ) ;
2003-12-01 04:41:38 +03:00
}
}
2004-10-15 11:38:46 +04:00
void ndr_print_union ( struct ndr_print * ndr , const char * name , int level , const char * type )
2003-11-11 07:38:51 +03:00
{
2004-10-15 11:38:46 +04:00
ndr - > print ( ndr , " %-25s: union %s(case %d) " , name , type , level ) ;
2003-11-11 07:38:51 +03:00
}
2004-05-25 21:24:24 +04:00
void ndr_print_bad_level ( struct ndr_print * ndr , const char * name , uint16_t level )
2003-11-11 07:38:51 +03:00
{
ndr - > print ( ndr , " UNKNOWN LEVEL %u " , level ) ;
}
2003-11-11 09:22:58 +03:00
2004-11-01 15:40:43 +03:00
void ndr_print_array_WERROR ( struct ndr_print * ndr , const char * name ,
const WERROR * data , uint32_t count )
{
int i ;
ndr - > print ( ndr , " %s: ARRAY(%d) " , name , count ) ;
ndr - > depth + + ;
for ( i = 0 ; i < count ; i + + ) {
char * idx = NULL ;
asprintf ( & idx , " [%d] " , i ) ;
if ( idx ) {
ndr_print_WERROR ( ndr , idx , data [ i ] ) ;
free ( idx ) ;
}
}
ndr - > depth - - ;
}
2004-08-11 23:48:36 +04:00
void ndr_print_array_HYPER_T ( struct ndr_print * ndr , const char * name ,
const HYPER_T * data , uint32_t count )
{
int i ;
ndr - > print ( ndr , " %s: ARRAY(%d) " , name , count ) ;
ndr - > depth + + ;
for ( i = 0 ; i < count ; i + + ) {
char * idx = NULL ;
asprintf ( & idx , " [%d] " , i ) ;
if ( idx ) {
ndr_print_HYPER_T ( ndr , idx , data [ i ] ) ;
free ( idx ) ;
}
}
ndr - > depth - - ;
}
2003-11-11 09:22:58 +03:00
void ndr_print_array_uint32 ( struct ndr_print * ndr , const char * name ,
2004-05-25 20:24:13 +04:00
const uint32_t * data , uint32_t count )
2003-11-11 09:22:58 +03:00
{
int i ;
ndr - > print ( ndr , " %s: ARRAY(%d) " , name , count ) ;
ndr - > depth + + ;
for ( i = 0 ; i < count ; i + + ) {
char * idx = NULL ;
asprintf ( & idx , " [%d] " , i ) ;
if ( idx ) {
ndr_print_uint32 ( ndr , idx , data [ i ] ) ;
free ( idx ) ;
}
}
ndr - > depth - - ;
}
2003-11-11 10:57:08 +03:00
2003-12-12 09:26:34 +03:00
void ndr_print_array_uint16 ( struct ndr_print * ndr , const char * name ,
2004-05-25 21:24:24 +04:00
const uint16_t * data , uint32_t count )
2003-12-12 09:26:34 +03:00
{
int i ;
ndr - > print ( ndr , " %s: ARRAY(%d) " , name , count ) ;
ndr - > depth + + ;
for ( i = 0 ; i < count ; i + + ) {
char * idx = NULL ;
asprintf ( & idx , " [%d] " , i ) ;
if ( idx ) {
ndr_print_uint16 ( ndr , idx , data [ i ] ) ;
free ( idx ) ;
}
}
ndr - > depth - - ;
}
2003-11-15 13:58:29 +03:00
void ndr_print_array_uint8 ( struct ndr_print * ndr , const char * name ,
2004-05-25 21:50:17 +04:00
const uint8_t * data , uint32_t count )
2003-11-15 13:58:29 +03:00
{
int i ;
2004-04-19 09:48:03 +04:00
if ( count < = 600 & & ( ndr - > flags & LIBNDR_PRINT_ARRAY_HEX ) ) {
char s [ 1202 ] ;
2003-12-01 06:19:43 +03:00
for ( i = 0 ; i < count ; i + + ) {
snprintf ( & s [ i * 2 ] , 3 , " %02x " , data [ i ] ) ;
}
s [ i * 2 ] = 0 ;
ndr - > print ( ndr , " %-25s: %s " , name , s ) ;
return ;
}
2003-11-15 13:58:29 +03:00
ndr - > print ( ndr , " %s: ARRAY(%d) " , name , count ) ;
ndr - > depth + + ;
for ( i = 0 ; i < count ; i + + ) {
char * idx = NULL ;
asprintf ( & idx , " [%d] " , i ) ;
if ( idx ) {
ndr_print_uint8 ( ndr , idx , data [ i ] ) ;
free ( idx ) ;
}
}
ndr - > depth - - ;
}
2003-11-24 06:21:49 +03:00
/*
build a GUID from a string
*/
NTSTATUS GUID_from_string ( const char * s , struct GUID * guid )
{
2004-05-25 20:24:13 +04:00
uint32_t time_low ;
uint32_t time_mid , time_hi_and_version ;
uint32_t clock_seq [ 2 ] ;
uint32_t node [ 6 ] ;
2003-11-24 06:21:49 +03:00
int i ;
if ( 11 ! = sscanf ( s , " %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x " ,
& time_low , & time_mid , & time_hi_and_version ,
2003-12-16 12:02:58 +03:00
& clock_seq [ 0 ] , & clock_seq [ 1 ] ,
2003-11-24 06:21:49 +03:00
& node [ 0 ] , & node [ 1 ] , & node [ 2 ] , & node [ 3 ] , & node [ 4 ] , & node [ 5 ] ) ) {
return NT_STATUS_INVALID_PARAMETER ;
}
2003-12-16 12:02:58 +03:00
guid - > time_low = time_low ;
guid - > time_mid = time_mid ;
guid - > time_hi_and_version = time_hi_and_version ;
guid - > clock_seq [ 0 ] = clock_seq [ 0 ] ;
guid - > clock_seq [ 1 ] = clock_seq [ 1 ] ;
2003-11-24 06:21:49 +03:00
for ( i = 0 ; i < 6 ; i + + ) {
2003-12-16 12:02:58 +03:00
guid - > node [ i ] = node [ i ] ;
}
2003-11-24 06:21:49 +03:00
return NT_STATUS_OK ;
}
2003-11-26 04:16:41 +03:00
/*
its useful to be able to display these in debugging messages
*/
2003-11-24 04:24:29 +03:00
const char * GUID_string ( TALLOC_CTX * mem_ctx , const struct GUID * guid )
{
return talloc_asprintf ( mem_ctx ,
" %08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x " ,
2003-12-16 12:02:58 +03:00
guid - > time_low , guid - > time_mid ,
guid - > time_hi_and_version ,
guid - > clock_seq [ 0 ] ,
guid - > clock_seq [ 1 ] ,
guid - > node [ 0 ] , guid - > node [ 1 ] ,
guid - > node [ 2 ] , guid - > node [ 3 ] ,
guid - > node [ 4 ] , guid - > node [ 5 ] ) ;
2003-11-24 04:24:29 +03:00
}
2003-11-16 16:49:14 +03:00
void ndr_print_GUID ( struct ndr_print * ndr , const char * name , const struct GUID * guid )
2003-11-11 10:57:08 +03:00
{
2004-08-21 11:43:29 +04:00
ndr - > print ( ndr , " %-25s: %s " , name , GUID_string ( ndr , guid ) ) ;
2003-11-11 10:57:08 +03:00
}
2003-11-16 09:00:15 +03:00
2003-11-17 14:55:56 +03:00
void ndr_print_DATA_BLOB ( struct ndr_print * ndr , const char * name , DATA_BLOB r )
{
ndr - > print ( ndr , " %-25s: DATA_BLOB length=%u " , name , r . length ) ;
2003-11-24 13:15:17 +03:00
if ( r . length ) {
dump_data ( 10 , r . data , r . length ) ;
}
2003-11-17 14:55:56 +03:00
}
2003-11-17 05:18:11 +03:00
/*
push a DATA_BLOB onto the wire .
*/
NTSTATUS ndr_push_DATA_BLOB ( struct ndr_push * ndr , DATA_BLOB blob )
{
2003-11-23 09:28:12 +03:00
if ( ndr - > flags & LIBNDR_ALIGN_FLAGS ) {
if ( ndr - > flags & LIBNDR_FLAG_ALIGN2 ) {
blob . length = NDR_ALIGN ( ndr , 2 ) ;
} else if ( ndr - > flags & LIBNDR_FLAG_ALIGN4 ) {
blob . length = NDR_ALIGN ( ndr , 4 ) ;
} else if ( ndr - > flags & LIBNDR_FLAG_ALIGN8 ) {
blob . length = NDR_ALIGN ( ndr , 8 ) ;
}
NDR_PUSH_ALLOC_SIZE ( ndr , blob . data , blob . length ) ;
data_blob_clear ( & blob ) ;
} else if ( ! ( ndr - > flags & LIBNDR_FLAG_REMAINING ) ) {
NDR_CHECK ( ndr_push_uint32 ( ndr , blob . length ) ) ;
}
2003-11-17 05:18:11 +03:00
NDR_CHECK ( ndr_push_bytes ( ndr , blob . data , blob . length ) ) ;
return NT_STATUS_OK ;
}
/*
pull a DATA_BLOB from the wire .
*/
NTSTATUS ndr_pull_DATA_BLOB ( struct ndr_pull * ndr , DATA_BLOB * blob )
{
2004-05-25 20:24:13 +04:00
uint32_t length ;
2003-11-23 09:28:12 +03:00
if ( ndr - > flags & LIBNDR_ALIGN_FLAGS ) {
if ( ndr - > flags & LIBNDR_FLAG_ALIGN2 ) {
length = NDR_ALIGN ( ndr , 2 ) ;
} else if ( ndr - > flags & LIBNDR_FLAG_ALIGN4 ) {
length = NDR_ALIGN ( ndr , 4 ) ;
} else if ( ndr - > flags & LIBNDR_FLAG_ALIGN8 ) {
length = NDR_ALIGN ( ndr , 8 ) ;
}
if ( ndr - > data_size - ndr - > offset < length ) {
length = ndr - > data_size - ndr - > offset ;
}
} else if ( ndr - > flags & LIBNDR_FLAG_REMAINING ) {
length = ndr - > data_size - ndr - > offset ;
} else {
NDR_CHECK ( ndr_pull_uint32 ( ndr , & length ) ) ;
}
2003-11-17 05:18:11 +03:00
NDR_PULL_NEED_BYTES ( ndr , length ) ;
2004-08-21 11:43:29 +04:00
* blob = data_blob_talloc ( ndr , ndr - > data + ndr - > offset , length ) ;
2003-11-17 05:18:11 +03:00
ndr - > offset + = length ;
return NT_STATUS_OK ;
}
2004-10-15 13:22:21 +04:00
uint32 ndr_size_DATA_BLOB ( int ret , const DATA_BLOB * data , int flags )
{
return ret + data - > length ;
}
uint32 ndr_size_string ( int ret , const char * * string , int flags )
{
/* FIXME: Is this correct for all strings ? */
if ( ! ( * string ) ) return ret ;
return ret + strlen ( * string ) + 1 ;
}