Line data    Source code

       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             : 
       4             :    TDR (Trivial Data Representation) helper functions
       5             :      Based loosely on ndr.c by Andrew Tridgell.
       6             : 
       7             :    Copyright (C) Jelmer Vernooij 2005
       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             : #include "system/filesys.h"
      25             : #include "system/network.h"
      26             : #include "lib/tdr/tdr.h"
      27             : 
      28             : #define TDR_BASE_MARSHALL_SIZE 1024
      29             : 
      30             : #define TDR_PUSH_NEED_BYTES(tdr, n) TDR_CHECK(tdr_push_expand(tdr, tdr->data.length+(n)))
      31             : 
      32             : #define TDR_PULL_NEED_BYTES(tdr, n) do { \
      33             :         if ((n) > tdr->data.length || tdr->offset + (n) > tdr->data.length) { \
      34             :                 return NT_STATUS_BUFFER_TOO_SMALL; \
      35             :         } \
      36             : } while(0)
      37             : 
      38             : #define TDR_BE(tdr) ((tdr)->flags & TDR_BIG_ENDIAN)
      39             : 
      40             : #define TDR_CVAL(tdr, ofs) CVAL(tdr->data.data,ofs)
      41             : #define TDR_SVAL(tdr, ofs) (TDR_BE(tdr)?RSVAL(tdr->data.data,ofs):SVAL(tdr->data.data,ofs))
      42             : #define TDR_IVAL(tdr, ofs) (TDR_BE(tdr)?RIVAL(tdr->data.data,ofs):IVAL(tdr->data.data,ofs))
      43             : #define TDR_SCVAL(tdr, ofs, v) SCVAL(tdr->data.data,ofs,v)
      44             : #define TDR_SSVAL(tdr, ofs, v) do { if (TDR_BE(tdr))  { RSSVAL(tdr->data.data,ofs,v); } else SSVAL(tdr->data.data,ofs,v); } while (0)
      45             : #define TDR_SIVAL(tdr, ofs, v) do { if (TDR_BE(tdr))  { RSIVAL(tdr->data.data,ofs,v); } else SIVAL(tdr->data.data,ofs,v); } while (0)
      46             : 
      47             : /**
      48             :   expand the available space in the buffer to 'size'
      49             : */
      50        9484 : NTSTATUS tdr_push_expand(struct tdr_push *tdr, uint32_t size)
      51             : {
      52        9484 :         if (talloc_get_size(tdr->data.data) >= size) {
      53        9411 :                 return NT_STATUS_OK;
      54             :         }
      55             : 
      56          73 :         tdr->data.data = talloc_realloc(tdr, tdr->data.data, uint8_t, tdr->data.length + TDR_BASE_MARSHALL_SIZE);
      57             : 
      58          73 :         if (tdr->data.data == NULL)
      59           0 :                 return NT_STATUS_NO_MEMORY;
      60             : 
      61          73 :         return NT_STATUS_OK;
      62             : }
      63             : 
      64             : 
      65         145 : NTSTATUS tdr_pull_uint8(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint8_t *v)
      66             : {
      67         145 :         TDR_PULL_NEED_BYTES(tdr, 1);
      68         145 :         *v = TDR_CVAL(tdr, tdr->offset);
      69         145 :         tdr->offset += 1;
      70         145 :         return NT_STATUS_OK;
      71             : }
      72             : 
      73        8177 : NTSTATUS tdr_push_uint8(struct tdr_push *tdr, const uint8_t *v)
      74             : {
      75        8177 :         TDR_PUSH_NEED_BYTES(tdr, 1);
      76        8177 :         TDR_SCVAL(tdr, tdr->data.length, *v);
      77        8177 :         tdr->data.length += 1;
      78        8177 :         return NT_STATUS_OK;
      79             : }
      80             : 
      81           0 : NTSTATUS tdr_print_uint8(struct tdr_print *tdr, const char *name, uint8_t *v)
      82             : {
      83           0 :         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
      84           0 :         return NT_STATUS_OK;
      85             : }
      86             : 
      87         167 : NTSTATUS tdr_pull_uint16(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v)
      88             : {
      89         167 :         TDR_PULL_NEED_BYTES(tdr, 2);
      90         167 :         *v = TDR_SVAL(tdr, tdr->offset);
      91         167 :         tdr->offset += 2;
      92         167 :         return NT_STATUS_OK;
      93             : }
      94             : 
      95          44 : NTSTATUS tdr_pull_uint1632(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint16_t *v)
      96             : {
      97          44 :         return tdr_pull_uint16(tdr, ctx, v);
      98             : }
      99             : 
     100         130 : NTSTATUS tdr_push_uint16(struct tdr_push *tdr, const uint16_t *v)
     101             : {
     102         130 :         TDR_PUSH_NEED_BYTES(tdr, 2);
     103         130 :         TDR_SSVAL(tdr, tdr->data.length, *v);
     104         130 :         tdr->data.length += 2;
     105         130 :         return NT_STATUS_OK;
     106             : }
     107             : 
     108          33 : NTSTATUS tdr_push_uint1632(struct tdr_push *tdr, const uint16_t *v)
     109             : {
     110          33 :         return tdr_push_uint16(tdr, v);
     111             : }
     112             : 
     113           0 : NTSTATUS tdr_print_uint16(struct tdr_print *tdr, const char *name, uint16_t *v)
     114             : {
     115           0 :         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
     116           0 :         return NT_STATUS_OK;
     117             : }
     118             : 
     119         768 : NTSTATUS tdr_pull_uint32(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint32_t *v)
     120             : {
     121         768 :         TDR_PULL_NEED_BYTES(tdr, 4);
     122         768 :         *v = TDR_IVAL(tdr, tdr->offset);
     123         768 :         tdr->offset += 4;
     124         768 :         return NT_STATUS_OK;
     125             : }
     126             : 
     127        1036 : NTSTATUS tdr_push_uint32(struct tdr_push *tdr, const uint32_t *v)
     128             : {
     129        1036 :         TDR_PUSH_NEED_BYTES(tdr, 4);
     130        1036 :         TDR_SIVAL(tdr, tdr->data.length, *v);
     131        1036 :         tdr->data.length += 4;
     132        1036 :         return NT_STATUS_OK;
     133             : }
     134             : 
     135           0 : NTSTATUS tdr_print_uint32(struct tdr_print *tdr, const char *name, uint32_t *v)
     136             : {
     137           0 :         tdr->print(tdr, "%-25s: 0x%02x (%u)", name, *v, *v);
     138           0 :         return NT_STATUS_OK;
     139             : }
     140             : 
     141         120 : NTSTATUS tdr_pull_charset(struct tdr_pull *tdr, TALLOC_CTX *ctx, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
     142             : {
     143         120 :         size_t ret;
     144             : 
     145         120 :         if (length == -1) {
     146           1 :                 switch (chset) {
     147           1 :                         case CH_DOS:
     148           1 :                                 length = ascii_len_n((const char*)tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
     149           1 :                                 break;
     150           0 :                         case CH_UTF16:
     151           0 :                                 length = utf16_null_terminated_len_n(tdr->data.data+tdr->offset, tdr->data.length-tdr->offset);
     152           0 :                                 break;
     153             : 
     154           0 :                         default:
     155           0 :                                 return NT_STATUS_INVALID_PARAMETER;
     156             :                 }
     157             :         }
     158             : 
     159         120 :         if (length == 0) {
     160           1 :                 *v = talloc_strdup(ctx, "");
     161           1 :                 return NT_STATUS_OK;
     162             :         }
     163             : 
     164         119 :         TDR_PULL_NEED_BYTES(tdr, el_size*length);
     165             : 
     166         119 :         if (!convert_string_talloc(ctx, chset, CH_UNIX, tdr->data.data+tdr->offset, el_size*length, v, &ret)) {
     167           0 :                 return NT_STATUS_INVALID_PARAMETER;
     168             :         }
     169             : 
     170         119 :         tdr->offset += length * el_size;
     171             : 
     172         119 :         return NT_STATUS_OK;
     173             : }
     174             : 
     175         102 : NTSTATUS tdr_push_charset(struct tdr_push *tdr, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
     176             : {
     177         102 :         size_t required, size = 0;
     178         102 :         bool ret;
     179             : 
     180         102 :         if (length == -1) {
     181           1 :                 length = strlen(*v) + 1; /* Extra element for null character */
     182             :         }
     183             : 
     184         102 :         required = el_size * length;
     185         102 :         TDR_PUSH_NEED_BYTES(tdr, required);
     186             : 
     187         102 :         ret = convert_string(CH_UNIX, chset, *v, strlen(*v), tdr->data.data+tdr->data.length, required, &size);
     188         102 :         if (ret == false) {
     189           0 :                 return NT_STATUS_INVALID_PARAMETER;
     190             :         }
     191             : 
     192             :         /* Make sure the remaining part of the string is filled with zeroes */
     193         102 :         if (size < required) {
     194           5 :                 memset(tdr->data.data+tdr->data.length+size, 0, required-size);
     195             :         }
     196             : 
     197         102 :         tdr->data.length += required;
     198             : 
     199         102 :         return NT_STATUS_OK;
     200             : }
     201             : 
     202           0 : NTSTATUS tdr_print_charset(struct tdr_print *tdr, const char *name, const char **v, uint32_t length, uint32_t el_size, charset_t chset)
     203             : {
     204           0 :         tdr->print(tdr, "%-25s: %s", name, *v);
     205           0 :         return NT_STATUS_OK;
     206             : }
     207             : 
     208             : /**
     209             :   parse a hyper
     210             : */
     211          44 : NTSTATUS tdr_pull_hyper(struct tdr_pull *tdr, TALLOC_CTX *ctx, uint64_t *v)
     212             : {
     213          44 :         TDR_PULL_NEED_BYTES(tdr, 8);
     214          44 :         *v = TDR_IVAL(tdr, tdr->offset);
     215          44 :         *v |= (uint64_t)(TDR_IVAL(tdr, tdr->offset+4)) << 32;
     216          44 :         tdr->offset += 8;
     217          44 :         return NT_STATUS_OK;
     218             : }
     219             : 
     220             : /**
     221             :   push a hyper
     222             : */
     223          39 : NTSTATUS tdr_push_hyper(struct tdr_push *tdr, uint64_t *v)
     224             : {
     225          39 :         TDR_PUSH_NEED_BYTES(tdr, 8);
     226          39 :         TDR_SIVAL(tdr, tdr->data.length, ((*v) & 0xFFFFFFFF));
     227          39 :         TDR_SIVAL(tdr, tdr->data.length+4, ((*v)>>32));
     228          39 :         tdr->data.length += 8;
     229          39 :         return NT_STATUS_OK;
     230             : }
     231             : 
     232             : /**
     233             :   push a NTTIME
     234             : */
     235          39 : NTSTATUS tdr_push_NTTIME(struct tdr_push *tdr, NTTIME *t)
     236             : {
     237          39 :         TDR_CHECK(tdr_push_hyper(tdr, t));
     238          39 :         return NT_STATUS_OK;
     239             : }
     240             : 
     241             : /**
     242             :   pull a NTTIME
     243             : */
     244          44 : NTSTATUS tdr_pull_NTTIME(struct tdr_pull *tdr, TALLOC_CTX *ctx, NTTIME *t)
     245             : {
     246          44 :         TDR_CHECK(tdr_pull_hyper(tdr, ctx, t));
     247          44 :         return NT_STATUS_OK;
     248             : }
     249             : 
     250             : /**
     251             :   push a time_t
     252             : */
     253           0 : NTSTATUS tdr_push_time_t(struct tdr_push *tdr, time_t *t)
     254             : {
     255           0 :         return tdr_push_uint32(tdr, (uint32_t *)t);
     256             : }
     257             : 
     258             : /**
     259             :   pull a time_t
     260             : */
     261           0 : NTSTATUS tdr_pull_time_t(struct tdr_pull *tdr, TALLOC_CTX *ctx, time_t *t)
     262             : {
     263           0 :         uint32_t tt;
     264           0 :         TDR_CHECK(tdr_pull_uint32(tdr, ctx, &tt));
     265           0 :         *t = tt;
     266           0 :         return NT_STATUS_OK;
     267             : }
     268             : 
     269           0 : NTSTATUS tdr_print_time_t(struct tdr_print *tdr, const char *name, time_t *t)
     270             : {
     271           0 :         if (*t == (time_t)-1 || *t == 0) {
     272           0 :                 tdr->print(tdr, "%-25s: (time_t)%d", name, (int)*t);
     273             :         } else {
     274           0 :                 tdr->print(tdr, "%-25s: %s", name, timestring(tdr, *t));
     275             :         }
     276             : 
     277           0 :         return NT_STATUS_OK;
     278             : }
     279             : 
     280           0 : NTSTATUS tdr_print_NTTIME(struct tdr_print *tdr, const char *name, NTTIME *t)
     281             : {
     282           0 :         tdr->print(tdr, "%-25s: %s", name, nt_time_string(tdr, *t));
     283             : 
     284           0 :         return NT_STATUS_OK;
     285             : }
     286             : 
     287           0 : NTSTATUS tdr_print_DATA_BLOB(struct tdr_print *tdr, const char *name, DATA_BLOB *r)
     288             : {
     289           0 :         tdr->print(tdr, "%-25s: DATA_BLOB length=%u", name, r->length);
     290           0 :         if (r->length) {
     291           0 :                 dump_data(10, r->data, r->length);
     292             :         }
     293             : 
     294           0 :         return NT_STATUS_OK;
     295             : }
     296             : 
     297             : #define TDR_ALIGN(l,n) (((l) & ((n)-1)) == 0?0:((n)-((l)&((n)-1))))
     298             : 
     299             : /*
     300             :   push a DATA_BLOB onto the wire.
     301             : */
     302           0 : NTSTATUS tdr_push_DATA_BLOB(struct tdr_push *tdr, DATA_BLOB *blob)
     303             : {
     304           0 :         if (tdr->flags & TDR_ALIGN2) {
     305           0 :                 blob->length = TDR_ALIGN(tdr->data.length, 2);
     306           0 :         } else if (tdr->flags & TDR_ALIGN4) {
     307           0 :                 blob->length = TDR_ALIGN(tdr->data.length, 4);
     308           0 :         } else if (tdr->flags & TDR_ALIGN8) {
     309           0 :                 blob->length = TDR_ALIGN(tdr->data.length, 8);
     310             :         }
     311             : 
     312           0 :         TDR_PUSH_NEED_BYTES(tdr, blob->length);
     313             : 
     314           0 :         memcpy(tdr->data.data+tdr->data.length, blob->data, blob->length);
     315           0 :         return NT_STATUS_OK;
     316             : }
     317             : 
     318             : /*
     319             :   pull a DATA_BLOB from the wire.
     320             : */
     321           0 : NTSTATUS tdr_pull_DATA_BLOB(struct tdr_pull *tdr, TALLOC_CTX *ctx, DATA_BLOB *blob)
     322             : {
     323           0 :         uint32_t length;
     324             : 
     325           0 :         if (tdr->flags & TDR_ALIGN2) {
     326           0 :                 length = TDR_ALIGN(tdr->offset, 2);
     327           0 :         } else if (tdr->flags & TDR_ALIGN4) {
     328           0 :                 length = TDR_ALIGN(tdr->offset, 4);
     329           0 :         } else if (tdr->flags & TDR_ALIGN8) {
     330           0 :                 length = TDR_ALIGN(tdr->offset, 8);
     331           0 :         } else if (tdr->flags & TDR_REMAINING) {
     332           0 :                 length = tdr->data.length - tdr->offset;
     333             :         } else {
     334           0 :                 return NT_STATUS_INVALID_PARAMETER;
     335             :         }
     336             : 
     337           0 :         if (tdr->data.length - tdr->offset < length) {
     338           0 :                 length = tdr->data.length - tdr->offset;
     339             :         }
     340             : 
     341           0 :         TDR_PULL_NEED_BYTES(tdr, length);
     342             : 
     343           0 :         *blob = data_blob_talloc(tdr, tdr->data.data+tdr->offset, length);
     344           0 :         tdr->offset += length;
     345           0 :         return NT_STATUS_OK;
     346             : }
     347             : 
     348          89 : struct tdr_push *tdr_push_init(TALLOC_CTX *mem_ctx)
     349             : {
     350          89 :         struct tdr_push *push = talloc_zero(mem_ctx, struct tdr_push);
     351             : 
     352          89 :         if (push == NULL)
     353           0 :                 return NULL;
     354             : 
     355           0 :         return push;
     356             : }
     357             : 
     358          73 : struct tdr_pull *tdr_pull_init(TALLOC_CTX *mem_ctx)
     359             : {
     360          73 :         struct tdr_pull *pull = talloc_zero(mem_ctx, struct tdr_pull);
     361             : 
     362          73 :         if (pull == NULL)
     363           0 :                 return NULL;
     364             : 
     365           0 :         return pull;
     366             : }
     367             : 
     368           4 : NTSTATUS tdr_push_to_fd(int fd, tdr_push_fn_t push_fn, const void *p)
     369             : {
     370           4 :         struct tdr_push *push = tdr_push_init(NULL);
     371             : 
     372           4 :         if (push == NULL)
     373           0 :                 return NT_STATUS_NO_MEMORY;
     374             : 
     375           4 :         if (NT_STATUS_IS_ERR(push_fn(push, p))) {
     376           0 :                 DEBUG(1, ("Error pushing data\n"));
     377           0 :                 talloc_free(push);
     378           0 :                 return NT_STATUS_UNSUCCESSFUL;
     379             :         }
     380             : 
     381           4 :         if (write(fd, push->data.data, push->data.length) < push->data.length) {
     382           0 :                 DEBUG(1, ("Error writing all data\n"));
     383           0 :                 return NT_STATUS_UNSUCCESSFUL;
     384             :         }
     385             : 
     386           4 :         talloc_free(push);
     387             : 
     388           4 :         return NT_STATUS_OK;
     389             : }
     390             : 
     391           0 : void tdr_print_debug_helper(struct tdr_print *tdr, const char *format, ...)
     392             : {
     393           0 :         va_list ap;
     394           0 :         char *s = NULL;
     395           0 :         int i, ret;
     396             : 
     397           0 :         va_start(ap, format);
     398           0 :         ret = vasprintf(&s, format, ap);
     399           0 :         va_end(ap);
     400             : 
     401           0 :         if (ret == -1) {
     402           0 :                 return;
     403             :         }
     404             : 
     405           0 :         for (i=0;i<tdr->level;i++) { DEBUG(0,("    ")); }
     406             : 
     407           0 :         DEBUG(0,("%s\n", s));
     408           0 :         free(s);
     409             : }