source/rpc_parse/parse_dfs.c

   1 /*
   2  *  Unix SMB/Netbios implementation.
   3  *  Version 1.9.
   4  *  MSDfs RPC Pipe client / server routines
   5  *  Copyright (C) Andrew Tridgell              1992-2000,
   6  *  Copyright (C) Luke Kenneth Casson Leighton 1996-2000,
   7  *  Copyright (C) Shirish Kalele               2000.
   8  *  Copyright (C) Jeremy Allison                                2001.
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or
  13  *  (at your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful,
  16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  *  GNU General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License
  21  *  along with this program; if not, write to the Free Software
  22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include "includes.h"
  26 #include "nterr.h"
  27 #include "rpc_parse.h"
  28
  29 extern int DEBUGLEVEL;
  30
  31 /*************************************************************
  32  Read/write a DFS_Q_DFS_EXIST structure - dummy...
  33  ************************************************************/
  34
  35 BOOL dfs_io_q_dfs_exist(char *desc, DFS_Q_DFS_EXIST *q_d, prs_struct *ps, int depth)
  36 {
  37         if(q_d == NULL)
  38                 return False;
  39
  40         prs_debug(ps, depth, desc, "dfs_io_q_dfs_exist");
  41
  42         return True;
  43 }
  44
  45 /*************************************************************
  46  Read/write a DFS_R_DFS_EXIST structure
  47  ************************************************************/
  48
  49 BOOL dfs_io_r_dfs_exist(char *desc, DFS_R_DFS_EXIST *q_d, prs_struct *ps, int depth)
  50 {
  51         if(q_d == NULL)
  52                 return False;
  53
  54         prs_debug(ps, depth, desc, "dfs_io_r_dfs_exist");
  55         depth++;
  56
  57         if(!prs_align(ps))
  58                 return False;
  59
  60         if(!prs_uint32("exist flag", ps, 0, &q_d->status))
  61                 return False;
  62
  63         return True;
  64 }
  65
  66 /*******************************************************************
  67 Make a DFS_Q_DFS_REMOVE structure
  68 *******************************************************************/
  69
  70 BOOL make_dfs_q_dfs_remove(DFS_Q_DFS_REMOVE *q_d, char *entrypath,
  71                            char *servername, char *sharename)
  72 {
  73         DEBUG(5,("make_dfs_q_dfs_remove\n"));
  74         init_unistr2(&q_d->DfsEntryPath, entrypath,  strlen(entrypath)+1);
  75         init_unistr2(&q_d->ServerName,   servername, strlen(servername)+1);
  76         init_unistr2(&q_d->ShareName,    sharename,  strlen(sharename)+1);
  77         q_d->ptr_ServerName = q_d->ptr_ShareName = 1;
  78         return True;
  79 }
  80
  81 /*******************************************************************
  82 Read/write a DFS_Q_DFS_REMOVE structure
  83 *******************************************************************/
  84
  85 BOOL dfs_io_q_dfs_remove(char *desc, DFS_Q_DFS_REMOVE *q_d, prs_struct *ps, int depth)
  86 {
  87         if(q_d == NULL)
  88                 return False;
  89
  90         prs_debug(ps, depth, desc, "dfs_io_q_dfs_remove");
  91         depth++;
  92
  93         if(!prs_align(ps))
  94                 return False;
  95
  96         if(!smb_io_unistr2("DfsEntryPath",&q_d->DfsEntryPath, 1, ps, depth))
  97                 return False;
  98
  99         if(!prs_align(ps))
 100                 return False;
 101
 102         if(!prs_uint32("ptr_ServerName", ps, depth, &q_d->ptr_ServerName))
 103                 return False;
 104         if(q_d->ptr_ServerName)
 105                 if (!smb_io_unistr2("ServerName",&q_d->ServerName, q_d->ptr_ServerName, ps, depth))
 106                         return False;
 107         if(!prs_align(ps))
 108                 return False;
 109
 110         if(!prs_uint32("ptr_ShareName", ps, depth, &q_d->ptr_ShareName))
 111                 return False;
 112         if(q_d->ptr_ShareName)
 113                 if (!smb_io_unistr2("ShareName",&q_d->ShareName,  q_d->ptr_ShareName, ps, depth))
 114                         return False;
 115         if(!prs_align(ps))
 116                 return False;
 117
 118         return True;
 119 }
 120
 121 /*******************************************************************
 122 Read/write a DFS_R_DFS_REMOVE structure
 123 *******************************************************************/
 124
 125 BOOL dfs_io_r_dfs_remove(char *desc, DFS_R_DFS_REMOVE *r_d, prs_struct *ps, int depth)
 126 {
 127         if(r_d == NULL)
 128                 return False;
 129
 130         prs_debug(ps, depth, desc, "dfs_io_r_dfs_remove");
 131         depth++;
 132
 133         if(!prs_uint32("status", ps, depth, &r_d->status))
 134                 return False;
 135
 136         return True;
 137 }
 138
 139 /*******************************************************************
 140 Make a DFS_Q_DFS_ADD structure
 141 *******************************************************************/
 142
 143 BOOL make_dfs_q_dfs_add(DFS_Q_DFS_ADD *q_d, char *entrypath, char *servername,
 144                         char *sharename, char *comment, uint32 flags)
 145 {
 146         DEBUG(5,("make_dfs_q_dfs_add\n"));
 147         q_d->ptr_DfsEntryPath = q_d->ptr_ServerName = q_d->ptr_ShareName = 1;
 148         init_unistr2(&q_d->DfsEntryPath, entrypath,  strlen(entrypath)+1);
 149         init_unistr2(&q_d->ServerName,   servername, strlen(servername)+1);
 150         init_unistr2(&q_d->ShareName,    sharename,  strlen(sharename)+1);
 151         if(comment != NULL) {
 152                 init_unistr2(&q_d->Comment,      comment,    strlen(comment)+1);
 153                 q_d->ptr_Comment = 1;
 154         } else {
 155                 q_d->ptr_Comment = 0;
 156         }
 157
 158         q_d->Flags = flags;
 159         return True;
 160 }
 161
 162 /************************************************************
 163  Read/write a DFS_Q_DFS_ADD structure
 164  ************************************************************/
 165
 166 BOOL dfs_io_q_dfs_add(char *desc, DFS_Q_DFS_ADD *q_d, prs_struct *ps, int depth)
 167 {
 168         if(q_d == NULL)
 169                 return False;
 170
 171         prs_debug(ps, depth, desc, "dfs_io_q_dfs_add");
 172         depth++;
 173
 174         if(!prs_align(ps))
 175                 return False;
 176
 177         if(!smb_io_unistr2("DfsEntryPath",&q_d->DfsEntryPath, 1, ps, depth))
 178                 return False;
 179         if(!prs_align(ps))
 180                 return False;
 181
 182         if(!smb_io_unistr2("ServerName",&q_d->ServerName, 1, ps, depth))
 183                 return False;
 184         if(!prs_align(ps))
 185                 return False;
 186
 187         if(!prs_uint32("ptr_ShareName", ps, depth, &q_d->ptr_ShareName))
 188                 return False;
 189         if(!smb_io_unistr2("ShareName",&q_d->ShareName,  1, ps, depth))
 190                 return False;
 191         if(!prs_align(ps))
 192                 return False;
 193
 194         if(!prs_uint32("ptr_Comment", ps, depth, &q_d->ptr_Comment))
 195                 return False;
 196         if(!smb_io_unistr2("",&q_d->Comment, q_d->ptr_Comment , ps, depth))
 197                 return False;
 198         if(!prs_align(ps))
 199                 return False;
 200
 201         if(!prs_uint32("Flags", ps, depth, &q_d->Flags))
 202                 return True;
 203
 204         return True;
 205 }
 206
 207 /************************************************************
 208  Read/write a DFS_R_DFS_ADD structure
 209  ************************************************************/
 210
 211 BOOL dfs_io_r_dfs_add(char *desc, DFS_R_DFS_ADD *r_d, prs_struct *ps, int depth)
 212 {
 213         if(r_d == NULL)
 214                 return False;
 215
 216         prs_debug(ps, depth, desc, "dfs_io_r_dfs_add");
 217         depth++;
 218
 219         if(!prs_uint32("status", ps, depth, &r_d->status))
 220                 return False;
 221
 222         return True;
 223 }
 224
 225 /************************************************************
 226  Read/write a DFS_Q_GET_INFO structure
 227  ************************************************************/
 228
 229 BOOL dfs_io_q_dfs_get_info(char* desc, DFS_Q_DFS_GET_INFO* q_i, prs_struct* ps, int depth)
 230 {
 231         if(q_i == NULL)
 232                 return False;
 233
 234         prs_debug(ps, depth, desc, "dfs_io_q_dfs_get_info");
 235         depth++;
 236
 237         if(!smb_io_unistr2("",&q_i->uni_path, 1, ps, depth))
 238                 return False;
 239
 240         if(!prs_align(ps))
 241                 return False;
 242
 243         if(!prs_uint32("ptr_server", ps, depth, &q_i->ptr_server))
 244                 return False;
 245
 246         if(q_i->ptr_server)
 247                 if (!smb_io_unistr2("",&q_i->uni_server, q_i->ptr_server, ps, depth))
 248                         return False;
 249         if(!prs_align(ps))
 250                 return False;
 251
 252         if(!prs_uint32("ptr_share", ps, depth, &q_i->ptr_share))
 253                 return False;
 254         if(q_i->ptr_share)
 255                 if(!smb_io_unistr2("", &q_i->uni_share, q_i->ptr_share, ps, depth))
 256                         return False;
 257         if(!prs_align(ps))
 258                 return False;
 259
 260         if(!prs_uint32("level", ps, depth, &q_i->level))
 261                 return False;
 262         return True;
 263 }
 264
 265 /************************************************************
 266  Read/write a DFS_R_GET_INFO structure
 267  ************************************************************/
 268
 269 BOOL dfs_io_r_dfs_get_info(char* desc, DFS_R_DFS_GET_INFO* r_i, prs_struct* ps, int depth)
 270 {
 271         if(r_i == NULL)
 272                 return False;
 273
 274         if(!prs_uint32("level", ps, depth, &r_i->level))
 275                 return False;
 276         if(!prs_uint32("ptr_ctr", ps, depth, &r_i->ptr_ctr))
 277                 return False;
 278
 279         if(!dfs_io_dfs_info_ctr("", &r_i->ctr, 1, r_i->level, ps, depth))
 280                 return False;
 281         if(!prs_uint32("status", ps, depth, &r_i->status))
 282                 return False;
 283         return True;
 284 }
 285
 286 /************************************************************
 287  Make a DFS_Q_DFS_ENUM structure
 288  ************************************************************/
 289 BOOL make_dfs_q_dfs_enum(DFS_Q_DFS_ENUM *q_d, uint32 level, DFS_INFO_CTR *ctr)
 290 {
 291         q_d->level = level;
 292         q_d->maxpreflen = -1;
 293         q_d->ptr_buffer = 1;
 294         q_d->level2 = level;
 295
 296         q_d->ptr_num_entries = 1;
 297         q_d->num_entries = 0;
 298         q_d->num_entries2 = 0;
 299         q_d->reshnd.ptr_hnd = 1;
 300         q_d->reshnd.handle = 0;
 301         return True;
 302 }
 303
 304 /************************************************************
 305  Read or write the DFS_Q_DFS_ENUM structure
 306  ************************************************************/
 307
 308 BOOL dfs_io_q_dfs_enum(char *desc, DFS_Q_DFS_ENUM *q_d, prs_struct *ps, int depth)
 309 {
 310         if(q_d == NULL)
 311                 return False;
 312
 313         prs_debug(ps, depth, desc, "dfs_io_q_dfs_enum");
 314         depth++;
 315
 316         if(!prs_align(ps))
 317                 return False;
 318
 319         if(!prs_uint32("level", ps, depth, &q_d->level))
 320                 return False;
 321         if(!prs_uint32("maxpreflen", ps, depth, &q_d->maxpreflen))
 322                 return False;
 323         if(!prs_uint32("ptr_buffer", ps, depth, &q_d->ptr_buffer))
 324                 return False;
 325         if(!prs_uint32("level2", ps, depth, &q_d->level2))
 326                 return False;
 327         if(!prs_uint32("level3", ps, depth, &q_d->level2))
 328                 return False;
 329
 330         if(!prs_uint32("ptr_num_entries", ps, depth, &q_d->ptr_num_entries))
 331                 return False;
 332         if(!prs_uint32("num_entries", ps, depth, &q_d->num_entries))
 333                 return False;
 334         if(!prs_uint32("num_entries2", ps, depth, &q_d->num_entries2))
 335                 return False;
 336         if(!smb_io_enum_hnd("resume_hnd",&q_d->reshnd, ps, depth))
 337                 return False;
 338         return True;
 339 }
 340
 341 /************************************************************
 342  Read/write a DFS_INFO_CTR structure
 343  ************************************************************/
 344
 345 BOOL dfs_io_dfs_info_ctr(char* desc, DFS_INFO_CTR* ctr, uint32 num_entries, uint32 level, prs_struct* ps, int depth)
 346 {
 347         int i=0;
 348
 349         switch(level) {
 350         case 1:
 351                 depth++;
 352                 /* should depend on whether marshalling or unmarshalling! */
 353                 if(UNMARSHALLING(ps)) {
 354                         ctr->dfs.info1 = (DFS_INFO_1 *)prs_alloc_mem(ps, sizeof(DFS_INFO_1)*num_entries);
 355                         if (!ctr->dfs.info1)
 356                                 return False;
 357                 }
 358
 359                 for(i=0;i<num_entries;i++) {
 360                         if(!prs_uint32("ptr_entrypath",ps, depth, &ctr->dfs.info1[i].ptr_entrypath))
 361                                 return False;
 362                 }
 363                 for(i=0;i<num_entries;i++) {
 364                         if(!smb_io_unistr2("", &ctr->dfs.info1[i].entrypath, ctr->dfs.info1[i].ptr_entrypath, ps, depth))
 365                                 return False;
 366                         if(!prs_align(ps))
 367                                 return False;
 368                 }
 369                 depth--;
 370                 break;
 371         case 2:
 372                 depth++;
 373                 if(UNMARSHALLING(ps)) {
 374                         ctr->dfs.info2 = (DFS_INFO_2 *)prs_alloc_mem(ps, num_entries*sizeof(DFS_INFO_2));
 375                         if (!ctr->dfs.info2)
 376                                 return False;
 377                 }
 378
 379                 for(i=0;i<num_entries;i++) {
 380                         if(!prs_uint32("ptr_entrypath", ps, depth, &ctr->dfs.info2[i].ptr_entrypath))
 381                                 return False;
 382                         if(!prs_uint32("ptr_comment", ps, depth, &ctr->dfs.info2[i].ptr_comment))
 383                                 return False;
 384                         if(!prs_uint32("state", ps, depth, &ctr->dfs.info2[i].state))
 385                                 return False;
 386                         if(!prs_uint32("num_storages", ps, depth, &ctr->dfs.info2[i].num_storages))
 387                                 return False;
 388                 }
 389                 for(i=0;i<num_entries;i++) {
 390                         if(!smb_io_unistr2("", &ctr->dfs.info2[i].entrypath, ctr->dfs.info2[i].ptr_entrypath, ps, depth))
 391                                 return False;
 392                         if(!prs_align(ps))
 393                                 return False;
 394                         if(!smb_io_unistr2("",&ctr->dfs.info2[i].comment, ctr->dfs.info2[i].ptr_comment, ps, depth))
 395                                 return False;
 396                         if(!prs_align(ps))
 397                                 return False;
 398                 }
 399                 depth--;
 400                 break;
 401         case 3:
 402                 depth++;
 403                 if(UNMARSHALLING(ps)) {
 404                         ctr->dfs.info3 = (DFS_INFO_3 *)prs_alloc_mem(ps, num_entries*sizeof(DFS_INFO_3));
 405                         if (!ctr->dfs.info3)
 406                                 return False;
 407                 }
 408
 409                 for(i=0;i<num_entries;i++) {
 410                         if(!prs_uint32("ptr_entrypath", ps, depth, &ctr->dfs.info3[i].ptr_entrypath))
 411                                 return False;
 412                         if(!prs_uint32("ptr_comment", ps, depth, &ctr->dfs.info3[i].ptr_comment))
 413                                 return False;
 414                         if(!prs_uint32("state", ps, depth, &ctr->dfs.info3[i].state))
 415                                 return False;
 416                         if(!prs_uint32("num_storages", ps, depth, &ctr->dfs.info3[i].num_storages))
 417                                 return False;
 418                         if(!prs_uint32("ptr_storages", ps, depth, &ctr->dfs.info3[i].ptr_storages))
 419                                 return False;
 420                 }
 421                 for(i=0;i<num_entries;i++) {
 422                         if(!smb_io_unistr2("", &ctr->dfs.info3[i].entrypath, ctr->dfs.info3[i].ptr_entrypath, ps, depth))
 423                                 return False;
 424                         if(!prs_align(ps))
 425                                 return False;
 426                         if(!smb_io_unistr2("", &ctr->dfs.info3[i].comment, ctr->dfs.info3[i].ptr_comment, ps, depth))
 427                                 return False;
 428                         if(!prs_align(ps))
 429                                 return False;
 430                         if(!prs_uint32("num_storage_infos", ps, depth, &ctr->dfs.info3[i].num_storage_infos))
 431                                 return False;
 432
 433                         if(!dfs_io_dfs_storage_info("storage_info", &ctr->dfs.info3[i], ps, depth))
 434                                 return False;
 435                 }
 436         }
 437
 438         return True;
 439 }
 440
 441 /************************************************************
 442  Read/write a DFS_R_DFS_ENUM structure
 443  ************************************************************/
 444
 445 BOOL dfs_io_r_dfs_enum(char *desc, DFS_R_DFS_ENUM *q_d, prs_struct *ps, int depth)
 446 {
 447         DFS_INFO_CTR *ctr;
 448         if(q_d == NULL)
 449                 return False;
 450         ctr = q_d->ctr;
 451         if(ctr == NULL)
 452                 return False;
 453
 454         prs_debug(ps, depth, desc, "dfs_io_r_dfs_enum");
 455         depth++;
 456
 457         if(!prs_align(ps))
 458                 return False;
 459
 460         if(!prs_uint32("ptr_buffer", ps, depth, &q_d->ptr_buffer))
 461                 return False;
 462         if(!prs_uint32("level", ps, depth, &q_d->level))
 463                 return False;
 464         if(!prs_uint32("level2", ps, depth, &ctr->switch_value))
 465                 return False;
 466         if(!prs_uint32("ptr_num_entries", ps, depth, &q_d->ptr_num_entries))
 467                 return False;
 468         if(q_d->ptr_num_entries)
 469                 if(!prs_uint32("num_entries", ps, depth, &q_d->num_entries))
 470                         return False;
 471         if(!prs_uint32("ptr_num_entries2", ps, depth, &q_d->ptr_num_entries2))
 472                 return False;
 473         if(q_d->ptr_num_entries2)
 474                 if(!prs_uint32("num_entries2", ps, depth, &ctr->num_entries))
 475                         return False;
 476
 477         if(!dfs_io_dfs_info_ctr("", ctr, q_d->num_entries, q_d->level, ps, depth))
 478                 return False;
 479
 480         if(!smb_io_enum_hnd("resume_hnd", &q_d->reshnd, ps, depth))
 481                 return False;
 482         if(!prs_uint32("status", ps, depth, &q_d->status))
 483                 return False;
 484         return True;
 485 }
 486
 487 BOOL dfs_io_dfs_storage_info(char *desc, DFS_INFO_3* info3, prs_struct *ps, int depth)
 488 {
 489         int i=0;
 490         if(info3 == NULL)
 491                 return False;
 492
 493         prs_debug(ps, depth, desc, "smb_io_dfs_storage_info");
 494         depth++;
 495
 496         if(UNMARSHALLING(ps)) {
 497                 info3->storages = (DFS_STORAGE_INFO *)prs_alloc_mem(ps, info3->num_storage_infos*sizeof(DFS_STORAGE_INFO));
 498                 if (!info3->storages)
 499                         return False;
 500         }
 501
 502         for(i=0;i<info3->num_storage_infos;i++) {
 503                 if(!prs_uint32("storage_state", ps, depth, &info3->storages[i].state))
 504                         return False;
 505                 if(!prs_uint32("ptr_servername", ps, depth, &info3->storages[i].ptr_servername))
 506                         return False;
 507                 if(!prs_uint32("ptr_sharename", ps, depth, &info3->storages[i].ptr_sharename))
 508                         return False;
 509         }
 510
 511         for(i=0;i<info3->num_storage_infos;i++) {
 512                 if(!smb_io_unistr2("servername", &info3->storages[i].servername, info3->storages[i].ptr_servername, ps, depth))
 513                         return False;
 514                 if(!prs_align(ps))
 515                         return False;
 516                 if(!smb_io_unistr2("sharename", &info3->storages[i].sharename, info3->storages[i].ptr_sharename, ps, depth))
 517                         return False;
 518                 if(!prs_align(ps))
 519                         return False;
 520         }
 521
 522         return True;
 523 }