git.maemo.org Git - samba/blob - source/wrepld/parser.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Jean François Micouleau      1998-2002.
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include "includes.h"
  22 #include "wins_repl.h"
  23
  24 extern TALLOC_CTX *mem_ctx;
  25
  26 /****************************************************************************
  27 grow the send buffer if necessary
  28 ****************************************************************************/
  29 BOOL grow_buffer(struct BUFFER *buffer, int more)
  30 {
  31         char *temp;
  32
  33         DEBUG(10,("grow_buffer: size is: %d offet is:%d growing by %d\n", buffer->length, buffer->offset, more));
  34
  35         /* grow by at least 256 bytes */
  36         if (more<256)
  37                 more=256;
  38
  39         if (buffer->offset+more >= buffer->length) {
  40                 temp=talloc_realloc(mem_ctx, buffer->buffer, char, buffer->length + more);
  41                 if (temp==NULL) {
  42                         DEBUG(0,("grow_buffer: can't grow buffer\n"));
  43                         return False;
  44                 }
  45                 buffer->length+=more;
  46                 buffer->buffer=temp;
  47         }
  48
  49         return True;
  50 }
  51
  52 /****************************************************************************
  53 check if the buffer has that much data
  54 ****************************************************************************/
  55 static BOOL check_buffer(struct BUFFER *buffer, int more)
  56 {
  57         DEBUG(10,("check_buffer: size is: %d offet is:%d growing by %d\n", buffer->length, buffer->offset, more));
  58
  59         if (buffer->offset+more > buffer->length) {
  60                 DEBUG(10,("check_buffer: buffer smaller than requested, size is: %d needed: %d\n", buffer->length, buffer->offset+more));
  61                 return False;
  62         }
  63
  64         return True;
  65 }
  66
  67 /****************************************************************************
  68 decode a WINS_OWNER struct
  69 ****************************************************************************/
  70 static void decode_wins_owner(struct BUFFER *inbuf, WINS_OWNER *wins_owner)
  71 {
  72         if(!check_buffer(inbuf, 24))
  73                 return;
  74
  75         wins_owner->address.s_addr=IVAL(inbuf->buffer, inbuf->offset);
  76         wins_owner->max_version=((SMB_BIG_UINT)RIVAL(inbuf->buffer, inbuf->offset+4))<<32;
  77         wins_owner->max_version|=RIVAL(inbuf->buffer, inbuf->offset+8);
  78         wins_owner->min_version=((SMB_BIG_UINT)RIVAL(inbuf->buffer, inbuf->offset+12))<<32;
  79         wins_owner->min_version|=RIVAL(inbuf->buffer, inbuf->offset+16);
  80         wins_owner->type=RIVAL(inbuf->buffer, inbuf->offset+20);
  81         inbuf->offset+=24;
  82
  83 }
  84
  85 /****************************************************************************
  86 decode a WINS_NAME struct
  87 ****************************************************************************/
  88 static void decode_wins_name(struct BUFFER *outbuf, WINS_NAME *wins_name)
  89 {
  90         char *p;
  91         int i;
  92
  93         if(!check_buffer(outbuf, 40))
  94                 return;
  95
  96         wins_name->name_len=RIVAL(outbuf->buffer, outbuf->offset);
  97         outbuf->offset+=4;
  98         memcpy(wins_name->name,outbuf->buffer+outbuf->offset, 15);
  99         wins_name->name[15]='\0';
 100         if((p = strchr(wins_name->name,' ')) != NULL)
 101                 *p = 0;
 102
 103         outbuf->offset+=15;
 104
 105         wins_name->type=(int)outbuf->buffer[outbuf->offset++];
 106
 107         /*
 108          * fix to bug in WINS replication,
 109          * present in all versions including W2K SP2 !
 110          */
 111         if (wins_name->name[0]==0x1B) {
 112                 wins_name->name[0]=(char)wins_name->type;
 113                 wins_name->type=0x1B;
 114         }
 115
 116         wins_name->empty=RIVAL(outbuf->buffer, outbuf->offset);
 117         outbuf->offset+=4;
 118
 119         wins_name->name_flag=RIVAL(outbuf->buffer, outbuf->offset);
 120         outbuf->offset+=4;
 121         wins_name->group_flag=RIVAL(outbuf->buffer, outbuf->offset);
 122         outbuf->offset+=4;
 123         wins_name->id=((SMB_BIG_UINT)RIVAL(outbuf->buffer, outbuf->offset))<<32;
 124         outbuf->offset+=4;
 125         wins_name->id|=RIVAL(outbuf->buffer, outbuf->offset);
 126         outbuf->offset+=4;
 127
 128         /* special groups have multiple address */
 129         if (wins_name->name_flag & 2) {
 130                 if(!check_buffer(outbuf, 4))
 131                         return;
 132                 wins_name->num_ip=IVAL(outbuf->buffer, outbuf->offset);
 133                 outbuf->offset+=4;
 134         }
 135         else
 136                 wins_name->num_ip=1;
 137
 138         if(!check_buffer(outbuf, 4))
 139                 return;
 140         wins_name->owner.s_addr=IVAL(outbuf->buffer, outbuf->offset);
 141         outbuf->offset+=4;
 142
 143         if (wins_name->name_flag & 2) {
 144                 wins_name->others=talloc_array(mem_ctx, struct in_addr, wins_name->num_ip);
 145                 if (wins_name->others==NULL)
 146                         return;
 147
 148                 if(!check_buffer(outbuf, 4*wins_name->num_ip))
 149                         return;
 150                 for (i=0; i<wins_name->num_ip; i++) {
 151                         wins_name->others[i].s_addr=IVAL(outbuf->buffer, outbuf->offset);
 152                         outbuf->offset+=4;
 153                 }
 154         }
 155
 156         if(!check_buffer(outbuf, 4))
 157                 return;
 158         wins_name->foo=RIVAL(outbuf->buffer, outbuf->offset);
 159         outbuf->offset+=4;
 160
 161 }
 162
 163 /****************************************************************************
 164 decode a update notification request
 165 ****************************************************************************/
 166 static void decode_update_notify_request(struct BUFFER *inbuf, UPDATE_NOTIFY_REQUEST *un_rq)
 167 {
 168         int i;
 169
 170         if(!check_buffer(inbuf, 4))
 171                 return;
 172         un_rq->partner_count=RIVAL(inbuf->buffer, inbuf->offset);
 173         inbuf->offset+=4;
 174
 175         un_rq->wins_owner=talloc_array(mem_ctx, WINS_OWNER, un_rq->partner_count);
 176         if (un_rq->wins_owner==NULL)
 177                 return;
 178
 179         for (i=0; i<un_rq->partner_count; i++)
 180                 decode_wins_owner(inbuf, &un_rq->wins_owner[i]);
 181
 182         if(!check_buffer(inbuf, 4))
 183                 return;
 184         un_rq->initiating_wins_server.s_addr=IVAL(inbuf->buffer, inbuf->offset);
 185         inbuf->offset+=4;
 186 }
 187
 188 /****************************************************************************
 189 decode a send entries request
 190 ****************************************************************************/
 191 static void decode_send_entries_request(struct BUFFER *inbuf, SEND_ENTRIES_REQUEST *se_rq)
 192 {
 193         decode_wins_owner(inbuf, &se_rq->wins_owner);
 194 }
 195
 196 /****************************************************************************
 197 decode a send entries reply
 198 ****************************************************************************/
 199 static void decode_send_entries_reply(struct BUFFER *inbuf, SEND_ENTRIES_REPLY *se_rp)
 200 {
 201         int i;
 202
 203         if(!check_buffer(inbuf, 4))
 204                 return;
 205         se_rp->max_names = RIVAL(inbuf->buffer, inbuf->offset);
 206         inbuf->offset+=4;
 207
 208         se_rp->wins_name=talloc_array(mem_ctx, WINS_NAME, se_rp->max_names);
 209         if (se_rp->wins_name==NULL)
 210                 return;
 211
 212         for (i=0; i<se_rp->max_names; i++)
 213                 decode_wins_name(inbuf, &se_rp->wins_name[i]);
 214 }
 215
 216 /****************************************************************************
 217 decode a add version number map table reply
 218 ****************************************************************************/
 219 static void decode_add_version_number_map_table_reply(struct BUFFER *inbuf, AVMT_REP *avmt_rep)
 220 {
 221         int i;
 222
 223         if(!check_buffer(inbuf, 4))
 224                 return;
 225
 226         avmt_rep->partner_count=RIVAL(inbuf->buffer, inbuf->offset);
 227         inbuf->offset+=4;
 228
 229         avmt_rep->wins_owner=talloc_array(mem_ctx, WINS_OWNER, avmt_rep->partner_count);
 230         if (avmt_rep->wins_owner==NULL)
 231                 return;
 232
 233         for (i=0; i<avmt_rep->partner_count; i++)
 234                 decode_wins_owner(inbuf, &avmt_rep->wins_owner[i]);
 235
 236         if(!check_buffer(inbuf, 4))
 237                 return;
 238         avmt_rep->initiating_wins_server.s_addr=IVAL(inbuf->buffer, inbuf->offset);
 239         inbuf->offset+=4;
 240 }
 241
 242 /****************************************************************************
 243 decode a replicate packet and fill a structure
 244 ****************************************************************************/
 245 static void decode_replicate(struct BUFFER *inbuf, REPLICATE *rep)
 246 {
 247         if(!check_buffer(inbuf, 4))
 248                 return;
 249
 250         rep->msg_type = RIVAL(inbuf->buffer, inbuf->offset);
 251
 252         inbuf->offset+=4;
 253
 254         switch (rep->msg_type) {
 255                 case 0:
 256                         break;
 257                 case 1:
 258                         /* add version number map table reply */
 259                         decode_add_version_number_map_table_reply(inbuf, &rep->avmt_rep);
 260                         break;
 261                 case 2:
 262                         /* send entry request */
 263                         decode_send_entries_request(inbuf, &rep->se_rq);
 264                         break;
 265                 case 3:
 266                         /* send entry request */
 267                         decode_send_entries_reply(inbuf, &rep->se_rp);
 268                         break;
 269                 case 4:
 270                         /* update notification request */
 271                         decode_update_notify_request(inbuf, &rep->un_rq);
 272                         break;
 273                 default:
 274                         DEBUG(0,("decode_replicate: unknown message type:%d\n", rep->msg_type));
 275                         break;
 276         }
 277 }
 278
 279 /****************************************************************************
 280 read the generic header and fill the struct.
 281 ****************************************************************************/
 282 static void read_generic_header(struct BUFFER *inbuf, generic_header *q)
 283 {
 284         if(!check_buffer(inbuf, 16))
 285                 return;
 286
 287         q->data_size = RIVAL(inbuf->buffer, inbuf->offset+0);
 288         q->opcode    = RIVAL(inbuf->buffer, inbuf->offset+4);
 289         q->assoc_ctx = RIVAL(inbuf->buffer, inbuf->offset+8);
 290         q->mess_type = RIVAL(inbuf->buffer, inbuf->offset+12);
 291 }
 292
 293 /*******************************************************************
 294 decode a start association request
 295 ********************************************************************/
 296 static void decode_start_assoc_request(struct BUFFER *inbuf, START_ASSOC_REQUEST *q)
 297 {
 298         if(!check_buffer(inbuf, 8))
 299                 return;
 300
 301         q->assoc_ctx = RIVAL(inbuf->buffer, inbuf->offset+0);
 302         q->min_ver = RSVAL(inbuf->buffer, inbuf->offset+4);
 303         q->maj_ver = RSVAL(inbuf->buffer, inbuf->offset+6);
 304 }
 305
 306 /*******************************************************************
 307 decode a start association reply
 308 ********************************************************************/
 309 static void decode_start_assoc_reply(struct BUFFER *inbuf, START_ASSOC_REPLY *r)
 310 {
 311         if(!check_buffer(inbuf, 8))
 312                 return;
 313
 314         r->assoc_ctx=RIVAL(inbuf->buffer, inbuf->offset+0);
 315         r->min_ver = RSVAL(inbuf->buffer, inbuf->offset+4);
 316         r->maj_ver = RSVAL(inbuf->buffer, inbuf->offset+6);
 317 }
 318
 319 /*******************************************************************
 320 decode a start association reply
 321 ********************************************************************/
 322 static void decode_stop_assoc(struct BUFFER *inbuf, STOP_ASSOC *r)
 323 {
 324         if(!check_buffer(inbuf, 4))
 325                 return;
 326
 327         r->reason=RIVAL(inbuf->buffer, inbuf->offset);
 328 }
 329
 330 /****************************************************************************
 331 decode a packet and fill a generic structure
 332 ****************************************************************************/
 333 void decode_generic_packet(struct BUFFER *inbuf, GENERIC_PACKET *q)
 334 {
 335         read_generic_header(inbuf, &q->header);
 336
 337         inbuf->offset+=16;
 338
 339         switch (q->header.mess_type) {
 340                 case 0:
 341                         decode_start_assoc_request(inbuf, &q->sa_rq);
 342                         break;
 343                 case 1:
 344                         decode_start_assoc_reply(inbuf, &q->sa_rp);
 345                         break;
 346                 case 2:
 347                         decode_stop_assoc(inbuf, &q->so);
 348                         break;
 349                 case 3:
 350                         decode_replicate(inbuf, &q->rep);
 351                         break;
 352                 default:
 353                         DEBUG(0,("decode_generic_packet: unknown message type:%d\n", q->header.mess_type));
 354                         break;
 355         }
 356 }
 357
 358 /****************************************************************************
 359 encode a WINS_OWNER struct
 360 ****************************************************************************/
 361 static void encode_wins_owner(struct BUFFER *outbuf, WINS_OWNER *wins_owner)
 362 {
 363         if (!grow_buffer(outbuf, 24))
 364                 return;
 365
 366         SIVAL(outbuf->buffer, outbuf->offset, wins_owner->address.s_addr);
 367         outbuf->offset+=4;
 368         RSIVAL(outbuf->buffer, outbuf->offset, (int)(wins_owner->max_version>>32));
 369         outbuf->offset+=4;
 370         RSIVAL(outbuf->buffer, outbuf->offset, (int)(wins_owner->max_version&0xffffffff));
 371         outbuf->offset+=4;
 372         RSIVAL(outbuf->buffer, outbuf->offset, wins_owner->min_version>>32);
 373         outbuf->offset+=4;
 374         RSIVAL(outbuf->buffer, outbuf->offset, wins_owner->min_version&0xffffffff);
 375         outbuf->offset+=4;
 376         RSIVAL(outbuf->buffer, outbuf->offset, wins_owner->type);
 377         outbuf->offset+=4;
 378
 379 }
 380
 381 /****************************************************************************
 382 encode a WINS_NAME struct
 383 ****************************************************************************/
 384 static void encode_wins_name(struct BUFFER *outbuf, WINS_NAME *wins_name)
 385 {
 386         int i;
 387
 388         if (!grow_buffer(outbuf, 48+(4*wins_name->num_ip)))
 389                 return;
 390
 391         RSIVAL(outbuf->buffer, outbuf->offset, wins_name->name_len);
 392         outbuf->offset+=4;
 393
 394         memset(outbuf->buffer+outbuf->offset, ' ', 15);
 395
 396         /* to prevent copying the leading \0 */
 397         memcpy(outbuf->buffer+outbuf->offset, wins_name->name, strlen(wins_name->name));
 398         outbuf->offset+=15;
 399
 400         outbuf->buffer[outbuf->offset++]=(char)wins_name->type;
 401
 402         RSIVAL(outbuf->buffer, outbuf->offset, wins_name->empty);
 403         outbuf->offset+=4;
 404
 405         RSIVAL(outbuf->buffer, outbuf->offset, wins_name->name_flag);
 406         outbuf->offset+=4;
 407         RSIVAL(outbuf->buffer, outbuf->offset, wins_name->group_flag);
 408         outbuf->offset+=4;
 409         RSIVAL(outbuf->buffer, outbuf->offset, wins_name->id>>32);
 410         outbuf->offset+=4;
 411         RSIVAL(outbuf->buffer, outbuf->offset, wins_name->id);
 412         outbuf->offset+=4;
 413
 414         if (wins_name->name_flag & 2) {
 415                 SIVAL(outbuf->buffer, outbuf->offset, wins_name->num_ip);
 416                 outbuf->offset+=4;
 417         }
 418
 419         SIVAL(outbuf->buffer, outbuf->offset, wins_name->owner.s_addr);
 420         outbuf->offset+=4;
 421
 422         if (wins_name->name_flag & 2) {
 423                 for (i=0;i<wins_name->num_ip;i++) {
 424                         SIVAL(outbuf->buffer, outbuf->offset, wins_name->others[i].s_addr);
 425                         outbuf->offset+=4;
 426                 }
 427         }
 428
 429         RSIVAL(outbuf->buffer, outbuf->offset, wins_name->foo);
 430         outbuf->offset+=4;
 431 }
 432
 433 /****************************************************************************
 434 encode a update notification request
 435 ****************************************************************************/
 436 static void encode_update_notify_request(struct BUFFER *outbuf, UPDATE_NOTIFY_REQUEST *un_rq)
 437 {
 438         int i;
 439
 440         if (!grow_buffer(outbuf, 8))
 441                 return;
 442
 443         RSIVAL(outbuf->buffer, outbuf->offset, un_rq->partner_count);
 444         outbuf->offset+=4;
 445
 446         for (i=0; i<un_rq->partner_count; i++)
 447                 encode_wins_owner(outbuf,  &un_rq->wins_owner[i]);
 448
 449         SIVAL(outbuf->buffer, outbuf->offset, un_rq->initiating_wins_server.s_addr);
 450         outbuf->offset+=4;
 451
 452 }
 453
 454 /****************************************************************************
 455 decode a send entries request
 456 ****************************************************************************/
 457 static void encode_send_entries_request(struct BUFFER *outbuf, SEND_ENTRIES_REQUEST *se_rq)
 458 {
 459         encode_wins_owner(outbuf, &se_rq->wins_owner);
 460 }
 461
 462 /****************************************************************************
 463 decode a send entries reply
 464 ****************************************************************************/
 465 static void encode_send_entries_reply(struct BUFFER *outbuf, SEND_ENTRIES_REPLY *se_rp)
 466 {
 467         int i;
 468
 469         if (!grow_buffer(outbuf, 4))
 470                 return;
 471
 472         RSIVAL(outbuf->buffer, outbuf->offset, se_rp->max_names);
 473         outbuf->offset+=4;
 474
 475         for (i=0; i<se_rp->max_names; i++)
 476                 encode_wins_name(outbuf, &se_rp->wins_name[i]);
 477
 478 }
 479
 480 /****************************************************************************
 481 encode a add version number map table reply
 482 ****************************************************************************/
 483 static void encode_add_version_number_map_table_reply(struct BUFFER *outbuf, AVMT_REP *avmt_rep)
 484 {
 485         int i;
 486
 487         if (!grow_buffer(outbuf, 8))
 488                 return;
 489
 490         RSIVAL(outbuf->buffer, outbuf->offset, avmt_rep->partner_count);
 491         outbuf->offset+=4;
 492
 493         for (i=0; i<avmt_rep->partner_count; i++)
 494                 encode_wins_owner(outbuf, &avmt_rep->wins_owner[i]);
 495
 496         SIVAL(outbuf->buffer, outbuf->offset, avmt_rep->initiating_wins_server.s_addr);
 497         outbuf->offset+=4;
 498
 499 }
 500
 501 /****************************************************************************
 502 decode a replicate packet and fill a structure
 503 ****************************************************************************/
 504 static void encode_replicate(struct BUFFER *outbuf, REPLICATE *rep)
 505 {
 506         if (!grow_buffer(outbuf, 4))
 507                 return;
 508
 509         RSIVAL(outbuf->buffer, outbuf->offset, rep->msg_type);
 510         outbuf->offset+=4;
 511
 512         switch (rep->msg_type) {
 513                 case 0:
 514                         break;
 515                 case 1:
 516                         /* add version number map table reply */
 517                         encode_add_version_number_map_table_reply(outbuf, &rep->avmt_rep);
 518                         break;
 519                 case 2:
 520                         /* send entry request */
 521                         encode_send_entries_request(outbuf, &rep->se_rq);
 522                         break;
 523                 case 3:
 524                         /* send entry request */
 525                         encode_send_entries_reply(outbuf, &rep->se_rp);
 526                         break;
 527                 case 4:
 528                         /* update notification request */
 529                         encode_update_notify_request(outbuf, &rep->un_rq);
 530                         break;
 531                 default:
 532                         DEBUG(0,("encode_replicate: unknown message type:%d\n", rep->msg_type));
 533                         break;
 534         }
 535 }
 536
 537 /****************************************************************************
 538 write the generic header.
 539 ****************************************************************************/
 540 static void write_generic_header(struct BUFFER *outbuf, generic_header *r)
 541 {
 542         RSIVAL(outbuf->buffer, 0, r->data_size);
 543         RSIVAL(outbuf->buffer, 4, r->opcode);
 544         RSIVAL(outbuf->buffer, 8, r->assoc_ctx);
 545         RSIVAL(outbuf->buffer,12, r->mess_type);
 546 }
 547
 548 /*******************************************************************
 549 decode a start association request
 550 ********************************************************************/
 551 static void encode_start_assoc_request(struct BUFFER *outbuf, START_ASSOC_REQUEST *q)
 552 {
 553         if (!grow_buffer(outbuf, 45))
 554                 return;
 555
 556         RSIVAL(outbuf->buffer, outbuf->offset, q->assoc_ctx);
 557         RSSVAL(outbuf->buffer, outbuf->offset+4, q->min_ver);
 558         RSSVAL(outbuf->buffer, outbuf->offset+6, q->maj_ver);
 559
 560         outbuf->offset=45;
 561 }
 562
 563 /*******************************************************************
 564 decode a start association reply
 565 ********************************************************************/
 566 static void encode_start_assoc_reply(struct BUFFER *outbuf, START_ASSOC_REPLY *r)
 567 {
 568         if (!grow_buffer(outbuf, 45))
 569                 return;
 570
 571         RSIVAL(outbuf->buffer, outbuf->offset, r->assoc_ctx);
 572         RSSVAL(outbuf->buffer, outbuf->offset+4, r->min_ver);
 573         RSSVAL(outbuf->buffer, outbuf->offset+6, r->maj_ver);
 574
 575         outbuf->offset=45;
 576 }
 577
 578 /*******************************************************************
 579 decode a start association reply
 580 ********************************************************************/
 581 static void encode_stop_assoc(struct BUFFER *outbuf, STOP_ASSOC *r)
 582 {
 583         if (!grow_buffer(outbuf, 44))
 584                 return;
 585
 586         RSIVAL(outbuf->buffer, outbuf->offset, r->reason);
 587
 588         outbuf->offset=44;
 589 }
 590
 591 /****************************************************************************
 592 write the generic header size.
 593 ****************************************************************************/
 594 static void write_generic_header_size(generic_header *r, int size)
 595 {
 596         /* the buffer size is the total size minus the size field */
 597         r->data_size=size-4;
 598 }
 599
 600 /****************************************************************************
 601 encode a packet and read a generic structure
 602 ****************************************************************************/
 603 void encode_generic_packet(struct BUFFER *outbuf, GENERIC_PACKET *q)
 604 {
 605         if (!grow_buffer(outbuf, 16))
 606                 return;
 607
 608         outbuf->offset=16;
 609
 610         switch (q->header.mess_type) {
 611                 case 0:
 612                         encode_start_assoc_request(outbuf, &q->sa_rq);
 613                         break;
 614                 case 1:
 615                         encode_start_assoc_reply(outbuf, &q->sa_rp);
 616                         break;
 617                 case 2:
 618                         encode_stop_assoc(outbuf, &q->so);
 619                         break;
 620                 case 3:
 621                         encode_replicate(outbuf, &q->rep);
 622                         break;
 623                 default:
 624                         DEBUG(0,("encode_generic_packet: unknown message type:%d\n", q->header.mess_type));
 625                         break;
 626         }
 627
 628         write_generic_header_size(&q->header, outbuf->offset);
 629         write_generic_header(outbuf, &q->header);
 630 }
 631
 632
 633 /****************************************************************************
 634 dump a WINS_OWNER structure
 635 ****************************************************************************/
 636 static void dump_wins_owner(WINS_OWNER *wins_owner)
 637 {
 638         DEBUGADD(10,("\t\t\t\taddress         : %s\n", inet_ntoa(wins_owner->address)));
 639         DEBUGADD(10,("\t\t\t\tmax version: %d\n", (int)wins_owner->max_version));
 640         DEBUGADD(10,("\t\t\t\tmin version: %d\n", (int)wins_owner->min_version));
 641         DEBUGADD(10,("\t\t\t\ttype            : %d\n", wins_owner->type));
 642 }
 643
 644 /****************************************************************************
 645 dump a WINS_NAME structure
 646 ****************************************************************************/
 647 static void dump_wins_name(WINS_NAME *wins_name)
 648 {
 649         fstring name;
 650         int i;
 651
 652         strncpy(name, wins_name->name, 15);
 653
 654         DEBUGADD(10,("name: %d, %s<%02x> %x,%x, %d %s %d ", wins_name->name_len, name, wins_name->type,
 655                     wins_name->name_flag, wins_name->group_flag, (int)wins_name->id,
 656                     inet_ntoa(wins_name->owner), wins_name->num_ip));
 657
 658         if (wins_name->num_ip!=1)
 659                 for (i=0; i<wins_name->num_ip; i++)
 660                         DEBUGADD(10,("%s ", inet_ntoa(wins_name->others[i])));
 661
 662         DEBUGADD(10,("\n"));
 663 }
 664
 665 /****************************************************************************
 666 dump a replicate structure
 667 ****************************************************************************/
 668 static void dump_replicate(REPLICATE *rep)
 669 {
 670         int i;
 671
 672         DEBUGADD(5,("\t\tmsg_type: %d ", rep->msg_type));
 673
 674         switch (rep->msg_type) {
 675                 case 0:
 676                         DEBUGADD(5,("(Add Version Map Table Request)\n"));
 677                         break;
 678                 case 1:
 679                         DEBUGADD(5,("(Add Version Map Table Reply)\n"));
 680                         DEBUGADD(5,("\t\t\tpartner_count         : %d\n", rep->avmt_rep.partner_count));
 681                         for (i=0; i<rep->avmt_rep.partner_count; i++)
 682                                 dump_wins_owner(&rep->avmt_rep.wins_owner[i]);
 683                         DEBUGADD(5,("\t\t\tinitiating_wins_server: %s\n", inet_ntoa(rep->avmt_rep.initiating_wins_server)));
 684                         break;
 685                 case 2:
 686                         DEBUGADD(5,("(Send Entries Request)\n"));
 687                         dump_wins_owner(&rep->se_rq.wins_owner);
 688                         break;
 689                 case 3:
 690                         DEBUGADD(5,("(Send Entries Reply)\n"));
 691                         DEBUGADD(5,("\t\t\tmax_names         : %d\n", rep->se_rp.max_names));
 692                         for (i=0; i<rep->se_rp.max_names; i++)
 693                                 dump_wins_name(&rep->se_rp.wins_name[i]);
 694                         break;
 695                 case 4:
 696                         DEBUGADD(5,("(Update Notify Request)\n"));
 697                         DEBUGADD(5,("\t\t\tpartner_count         : %d\n", rep->un_rq.partner_count));
 698                         for (i=0; i<rep->un_rq.partner_count; i++)
 699                                 dump_wins_owner(&rep->un_rq.wins_owner[i]);
 700                         DEBUGADD(5,("\t\t\tinitiating_wins_server: %s\n", inet_ntoa(rep->un_rq.initiating_wins_server)));
 701                         break;
 702                 default:
 703                         DEBUG(5,("\n"));
 704                         break;
 705         }
 706 }
 707
 708 /****************************************************************************
 709 dump a generic structure
 710 ****************************************************************************/
 711 void dump_generic_packet(GENERIC_PACKET *q)
 712 {
 713         DEBUG(5,("dump_generic_packet:\n"));
 714         DEBUGADD(5,("\tdata_size: %08x\n", q->header.data_size));
 715         DEBUGADD(5,("\topcode   : %08x\n", q->header.opcode));
 716         DEBUGADD(5,("\tassoc_ctx: %08x\n", q->header.assoc_ctx));
 717         DEBUGADD(5,("\tmess_type: %08x ", q->header.mess_type));
 718
 719         switch (q->header.mess_type) {
 720                 case 0:
 721                         DEBUGADD(5,("(Start Association Request)\n"));
 722                         DEBUGADD(5,("\t\tassoc_ctx: %08x\n", q->sa_rq.assoc_ctx));
 723                         DEBUGADD(5,("\t\tmin_ver  : %04x\n", q->sa_rq.min_ver));
 724                         DEBUGADD(5,("\t\tmaj_ver  : %04x\n", q->sa_rq.maj_ver));
 725                         break;
 726                 case 1:
 727                         DEBUGADD(5,("(Start Association Reply)\n"));
 728                         DEBUGADD(5,("\t\tassoc_ctx: %08x\n", q->sa_rp.assoc_ctx));
 729                         DEBUGADD(5,("\t\tmin_ver  : %04x\n", q->sa_rp.min_ver));
 730                         DEBUGADD(5,("\t\tmaj_ver  : %04x\n", q->sa_rp.maj_ver));
 731                         break;
 732                 case 2:
 733                         DEBUGADD(5,("(Stop Association)\n"));
 734                         DEBUGADD(5,("\t\treason: %08x\n", q->so.reason));
 735                         break;
 736                 case 3:
 737                         DEBUGADD(5,("(Replication Message)\n"));
 738                         dump_replicate(&q->rep);
 739                         break;
 740                 default:
 741                         DEBUG(5,("\n"));
 742                         break;
 743         }
 744
 745 }
 746
 747 /****************************************************************************
 748 generate a stop packet
 749 ****************************************************************************/
 750 void stop_packet(GENERIC_PACKET *q, GENERIC_PACKET *r, int reason)
 751 {
 752         r->header.opcode=OPCODE_NON_NBT;
 753         r->header.assoc_ctx=get_server_assoc(q->header.assoc_ctx);
 754         r->header.mess_type=MESSAGE_TYPE_STOP_ASSOC;
 755         r->so.reason=reason;
 756
 757 }
 758
 759