import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / 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=(char *)talloc_realloc(mem_ctx, buffer->buffer, sizeof(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=(struct in_addr *)talloc(mem_ctx, sizeof(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=(WINS_OWNER *)talloc(mem_ctx, un_rq->partner_count*sizeof(WINS_OWNER));
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=(WINS_NAME *)talloc(mem_ctx, se_rp->max_names*sizeof(WINS_NAME));
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=(WINS_OWNER *)talloc(mem_ctx, avmt_rep->partner_count*sizeof(WINS_OWNER));
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