source/namework.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NBT netbios routines and daemon - version 2
   5    Copyright (C) Andrew Tridgell 1994-1997
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21    Revision History:
  22
  23    14 jan 96: lkcl@pires.co.uk
  24    added multiple workgroup domain master support
  25
  26 */
  27
  28 #include "includes.h"
  29
  30 extern int ClientNMB;
  31 extern int ClientDGRAM;
  32
  33 #define TEST_CODE /* want to debug unknown browse packets */
  34
  35 extern int DEBUGLEVEL;
  36 extern pstring scope;
  37 extern BOOL CanRecurse;
  38
  39 extern pstring myname;
  40
  41 extern int ClientNMB;
  42 extern int ClientDGRAM;
  43
  44 extern struct in_addr ipzero;
  45
  46 extern int workgroup_count; /* total number of workgroups we know about */
  47
  48 /* this is our domain/workgroup/server database */
  49 extern struct subnet_record *subnetlist;
  50
  51 extern int  updatecount;
  52
  53 /* backup request types: which servers are to be included */
  54 #define MASTER_TYPE (SV_TYPE_MASTER_BROWSER)
  55 #define DOMCTL_TYPE (SV_TYPE_DOMAIN_CTRL   )
  56
  57 extern time_t StartupTime;
  58
  59 extern BOOL updatedlists;
  60
  61 /****************************************************************************
  62 tell a server to become a backup browser
  63 state - 0x01 become backup instead of master
  64       - 0x02 remove all entries in browse list and become non-master
  65       - 0x04 stop master browser service altogether. NT ignores this
  66 **************************************************************************/
  67 void reset_server(char *name, int state, struct in_addr ip)
  68 {
  69   char outbuf[20];
  70   char *p;
  71
  72   bzero(outbuf,sizeof(outbuf));
  73   p = outbuf;
  74
  75   CVAL(p,0) = ANN_ResetBrowserState;
  76   CVAL(p,2) = state;
  77   p += 2;
  78
  79   DEBUG(2,("sending reset to %s %s of state %d\n",
  80            name,inet_ntoa(ip),state));
  81
  82   send_mailslot_reply(False,BROWSE_MAILSLOT,ClientDGRAM,
  83               outbuf,PTR_DIFF(p,outbuf),
  84                       myname,name,0x20,0x1d,ip,*iface_ip(ip));
  85 }
  86
  87
  88 /****************************************************************************
  89 tell a server to become a backup browser
  90 **************************************************************************/
  91 void tell_become_backup(void)
  92 {
  93   /* XXXX note: this function is currently unsuitable for use, as it
  94      does not properly check that a server is in a fit state to become
  95      a backup browser before asking it to be one.
  96    */
  97
  98   struct subnet_record *d;
  99   for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_EXCLUDING_WINS(d))
 100     {
 101       struct work_record *work;
 102       for (work = d->workgrouplist; work; work = work->next)
 103         {
 104           struct server_record *s;
 105           int num_servers = 0;
 106           int num_backups = 0;
 107
 108           for (s = work->serverlist; s; s = s->next)
 109             {
 110               if (s->serv.type & SV_TYPE_DOMAIN_ENUM) continue;
 111
 112               num_servers++;
 113
 114               if (strequal(myname, s->serv.name)) continue;
 115
 116               if (s->serv.type & SV_TYPE_BACKUP_BROWSER) {
 117                 num_backups++;
 118                 continue;
 119               }
 120
 121               if (s->serv.type & SV_TYPE_MASTER_BROWSER) continue;
 122
 123               if (!(s->serv.type & SV_TYPE_POTENTIAL_BROWSER)) continue;
 124
 125               DEBUG(3,("num servers: %d num backups: %d\n",
 126                        num_servers, num_backups));
 127
 128               /* make first server a backup server. thereafter make every
 129                  tenth server a backup server */
 130               if (num_backups != 0 && (num_servers+9) / num_backups > 10)
 131                 {
 132                   continue;
 133                 }
 134
 135               DEBUG(2,("sending become backup to %s %s for %s\n",
 136                        s->serv.name, inet_ntoa(d->bcast_ip),
 137                        work->work_group));
 138
 139               /* type 11 request from MYNAME(20) to WG(1e) for SERVER */
 140               do_announce_request(s->serv.name, work->work_group,
 141                                   ANN_BecomeBackup, 0x20, 0x1e, d->bcast_ip);
 142             }
 143         }
 144     }
 145 }
 146
 147
 148 /*******************************************************************
 149   same context: scope. should check name_type as well, and makes sure
 150   we don't process messages from ourselves
 151   ******************************************************************/
 152 BOOL same_context(struct dgram_packet *dgram)
 153 {
 154   if (!strequal(dgram->dest_name  .scope,scope )) return(True);
 155   if ( strequal(dgram->source_name.name ,myname)) return(True);
 156
 157   return(False);
 158 }
 159
 160
 161 /*******************************************************************
 162   process a domain announcement frame
 163
 164   Announce frames come in 3 types. Servers send host announcements
 165   (command=1) to let the master browswer know they are
 166   available. Master browsers send local master announcements
 167   (command=15) to let other masters and backups that they are the
 168   master. They also send domain announcements (command=12) to register
 169   the domain
 170
 171   The comment field of domain announcements contains the master
 172   browser name. The servertype is used by NetServerEnum to select
 173   resources. We just have to pass it to smbd (via browser.dat) and let
 174   the client choose using bit masks.
 175   ******************************************************************/
 176 static void process_localnet_announce(struct packet_struct *p,uint16 command,char *buf)
 177 {
 178   struct dgram_packet *dgram = &p->packet.dgram;
 179   struct subnet_record *d = find_subnet(p->ip);  /* Explicitly exclude WINS - local nets only */
 180   int update_count = CVAL(buf,0);
 181
 182   int ttl = IVAL(buf,1)/1000;
 183   char *name = buf+5;
 184   int osmajor=CVAL(buf,21);
 185   int osminor=CVAL(buf,22);
 186   uint32 servertype = IVAL(buf,23);
 187   uint32 browse_type= CVAL(buf,27);
 188   uint32 browse_sig = CVAL(buf,29);
 189   char *comment = buf+31;
 190
 191   struct work_record *work;
 192   char *work_name;
 193   char *serv_name = dgram->source_name.name;
 194   BOOL add = False;
 195
 196   comment[43] = 0;
 197
 198   DEBUG(4,("Announce(%d) %s(%x)",command,name,name[15]));
 199   DEBUG(4,("%s count=%d ttl=%d OS=(%d,%d) type=%08x sig=%4x %4x comment=%s\n",
 200            namestr(&dgram->dest_name),update_count,ttl,osmajor,osminor,
 201            servertype,browse_type,browse_sig,comment));
 202
 203   name[15] = 0;
 204
 205   if (dgram->dest_name.name_type == 0 && command == ANN_HostAnnouncement)
 206     {
 207       DEBUG(2,("Announce to nametype(0) not supported yet\n"));
 208       return;
 209     }
 210
 211   if (command == ANN_DomainAnnouncement &&
 212       ((!strequal(dgram->dest_name.name, MSBROWSE)) ||
 213        dgram->dest_name.name_type != 0x1))
 214     {
 215       DEBUG(0,("Announce(%d) from %s should be __MSBROWSE__(1) not %s\n",
 216                 command, inet_ntoa(p->ip), namestr(&dgram->dest_name)));
 217       return;
 218     }
 219
 220   if (!strequal(dgram->dest_name.scope,scope )) return;
 221
 222   if (command == ANN_DomainAnnouncement) {
 223     /* XXXX if we are a master browser for the workgroup work_name,
 224        then there is a local subnet configuration problem. only
 225        we should be sending out such domain announcements, because
 226        as the master browser, that is our job.
 227
 228        stop being a master browser, and force an election. this will
 229        sort out the network problem. hopefully.
 230      */
 231
 232     work_name = name;
 233     add = True;
 234   } else {
 235     work_name = dgram->dest_name.name;
 236   }
 237
 238   /* we need some way of finding out about new workgroups
 239      that appear to be sending packets to us. The name_type checks make
 240      sure we don't add host names as workgroups */
 241   if (command == ANN_HostAnnouncement &&
 242       (dgram->dest_name.name_type == 0x1d ||
 243        dgram->dest_name.name_type == 0x1e))
 244     add = True;
 245
 246   DEBUG(4,("search for workgroup: %s (add? %s)\n",
 247             work_name, BOOLSTR(add)));
 248
 249   if (!(work = find_workgroupstruct(d, work_name,add)))
 250     return;
 251
 252   DEBUG(4, ("workgroup %s on %s\n", work->work_group, serv_name));
 253
 254   ttl = GET_TTL(ttl);
 255
 256   /* add them to our browse list, and update the browse.dat file */
 257   add_server_entry(d,work,name,servertype,ttl,comment,True);
 258   updatedlists = True;
 259
 260 #if 0
 261   /* the tell become backup code is broken, no great harm is done by
 262      disabling it */
 263   tell_become_backup();
 264 #endif
 265
 266 #if 0 /* JRA TEST - I Think this code should not be here */
 267   /* get the local_only browse list from the local master and add it
 268      to ours. */
 269   if (command == ANN_LocalMasterAnnouncement)
 270   {
 271     add_browser_entry(serv_name,dgram->dest_name.name_type,
 272                       work->work_group,30,p->ip,True);
 273   }
 274 #endif /* END JRA TEST */
 275 }
 276
 277 /*******************************************************************
 278   process a master announcement frame
 279   Domain master browsers recieve these from local masters. The Domain
 280   master should then issue a sync with the local master, asking for
 281   that machines local server list.
 282   ******************************************************************/
 283 static void process_master_announce(struct packet_struct *p,char *buf)
 284 {
 285   struct dgram_packet *dgram = &p->packet.dgram;
 286   char *name = buf;
 287   struct work_record *work;
 288   name[15] = 0;
 289
 290   DEBUG(3,("process_master_announce: Master Announce from %s (%s)\n",name,inet_ntoa(p->ip)));
 291
 292   if (same_context(dgram)) return;
 293
 294   if (!wins_subnet)
 295     {
 296       DEBUG(3,("process_master_announce: No wins subnet !\n"));
 297       return;
 298     }
 299
 300   if (!lp_domain_master())
 301     {
 302       DEBUG(3,("process_master_announce: Not configured as domain master - ignoring master announce.\n"));
 303       return;
 304     }
 305
 306   for (work = wins_subnet->workgrouplist; work; work = work->next)
 307   {
 308     if (AM_MASTER(work) || AM_DOMMST(work))
 309     {
 310           /* merge browse lists with them */
 311           add_browser_entry(name,0x1d, work->work_group,30,wins_subnet,p->ip,True);
 312     }
 313   }
 314 }
 315
 316 /*******************************************************************
 317   process a receive backup list request
 318
 319   we receive a list of servers, and we attempt to locate them all on
 320   our local subnet, and sync browse lists with them on the workgroup
 321   they are said to be in.
 322
 323   XXXX NOTE: this function is in overdrive. it should not really do
 324   half of what it actually does (it should pick _one_ name from the
 325   list received and sync with it at regular intervals, rather than
 326   sync with them all only once!)
 327
 328   ******************************************************************/
 329 static void process_rcv_backup_list(struct packet_struct *p,char *buf)
 330 {
 331   struct dgram_packet *dgram = &p->packet.dgram;
 332   int count = CVAL(buf,0);
 333   uint32 info = IVAL(buf,1); /* XXXX caller's incremental info */
 334   char *buf1;
 335
 336   DEBUG(3,("Receive Backup ack for %s from %s total=%d info=%d\n",
 337            namestr(&dgram->dest_name), inet_ntoa(p->ip),
 338            count, info));
 339
 340   if (same_context(dgram)) return;
 341
 342   if (count <= 0) return;
 343
 344   /* go through the list of servers attempting to sync browse lists */
 345   for (buf1 = buf+5; *buf1 && count; buf1 = skip_string(buf1, 1), --count)
 346   {
 347     struct in_addr back_ip;
 348     /* struct subnet_record *d; */
 349
 350     DEBUG(4,("Searching for backup browser %s at %s...\n",
 351                buf1, inet_ntoa(p->ip)));
 352
 353     /* XXXX assume name is a DNS name NOT a netbios name. a more complete
 354            approach is to use reply_name_query functionality to find the name */
 355
 356     back_ip = *interpret_addr2(buf1);
 357
 358     if (zero_ip(back_ip))
 359         {
 360           DEBUG(4,("Failed to find backup browser server using DNS\n"));
 361           continue;
 362         }
 363
 364       DEBUG(4,("Found browser server at %s\n", inet_ntoa(back_ip)));
 365       DEBUG(4,("END THIS LOOP: CODE NEEDS UPDATING\n"));
 366
 367 #if 0
 368       /* XXXX function needs work */
 369       continue;
 370
 371     if ((d = find_subnet(back_ip)))
 372         {
 373           struct subnet_record *d1;
 374           for (d1 = subnetlist; d1; d1 = d1->next)
 375           {
 376               struct work_record *work;
 377               for (work = d1->workgrouplist; work; work = work->next)
 378                 {
 379                   if (work->token == 0 /* token */)
 380                   {
 381                       queue_netbios_packet(d1,ClientNMB,NMB_QUERY,NAME_QUERY_SRV_CHK,
 382                                            work->work_group,0x1d,
 383                        0,0,0,NULL,NULL,
 384                                            False,False,back_ip,back_ip);
 385                       return;
 386                   }
 387                 }
 388           }
 389         }
 390 #endif
 391   }
 392 }
 393
 394
 395 /****************************************************************************
 396   send a backup list response.
 397   **************************************************************************/
 398 static void send_backup_list(char *work_name, struct nmb_name *src_name,
 399                              int token, uint32 info,
 400                              int name_type, struct in_addr ip)
 401 {
 402   char outbuf[1024];
 403   char *p, *countptr, *nameptr;
 404   int count = 0;
 405   char *theirname = src_name->name;
 406
 407   DEBUG(3,("sending backup list of %s to %s: %s(%x) %s(%x)\n",
 408            work_name, inet_ntoa(ip),
 409            myname,0x0,theirname,0x0));
 410
 411   if (name_type == 0x1d)
 412     {
 413       DEBUG(4,("master browsers: "));
 414     }
 415   else if (name_type == 0x1b)
 416     {
 417       DEBUG(4,("domain controllers: "));
 418     }
 419   else
 420     {
 421       DEBUG(0,("backup request for unknown type %0x\n", name_type));
 422       return;
 423     }
 424
 425   bzero(outbuf,sizeof(outbuf));
 426   p = outbuf;
 427
 428   CVAL(p,0) = ANN_GetBackupListResp;    /* backup list response */
 429
 430   p++;
 431   countptr = p;
 432
 433   SIVAL(p,1,info); /* the sender's unique info */
 434
 435   p += 5;
 436
 437   nameptr = p;
 438
 439 #if 0
 440
 441   for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
 442   {
 443       struct work_record *work;
 444
 445       for (work = d->workgrouplist; work; work = work->next)
 446         {
 447           struct server_record *s;
 448
 449           if (!strequal(work->work_group, work_name)) continue;
 450
 451           for (s = work->serverlist; s; s = s->next)
 452             {
 453               BOOL found = False;
 454               char *n;
 455
 456               if (s->serv.type & SV_TYPE_DOMAIN_ENUM) continue;
 457
 458               for (n = nameptr; n < p; n = skip_string(n, 1))
 459                 {
 460                   if (strequal(n, s->serv.name)) found = True;
 461                 }
 462
 463               if (found) continue; /* exclude names already added */
 464
 465               /* workgroup request: include all backup browsers in the list */
 466               /* domain request: include all domain members in the list */
 467
 468               if ((name_type == 0x1d && (s->serv.type & MASTER_TYPE)) ||
 469                       (name_type == 0x1b && (s->serv.type & DOMCTL_TYPE)))
 470                 {
 471                   DEBUG(4, ("%s ", s->serv.name));
 472
 473                   count++;
 474                   strcpy(p,s->serv.name);
 475                   strupper(p);
 476                   p = skip_string(p,1);
 477                 }
 478          }
 479         }
 480   }
 481
 482 #endif
 483
 484         count++;
 485         strcpy(p,myname);
 486         strupper(p);
 487         p = skip_string(p,1);
 488
 489   if (count == 0)
 490     {
 491       DEBUG(4, ("none\n"));
 492     }
 493   else
 494     {
 495       DEBUG(4, (" - count %d\n", count));
 496     }
 497
 498   CVAL(countptr, 0) = count;
 499
 500   {
 501     int len = PTR_DIFF(p, outbuf);
 502     debug_browse_data(outbuf, len);
 503   }
 504   send_mailslot_reply(False,BROWSE_MAILSLOT,ClientDGRAM,
 505               outbuf,PTR_DIFF(p,outbuf),
 506                       myname,theirname,0x0,0x0,ip,*iface_ip(ip));
 507 }
 508
 509
 510 /*******************************************************************
 511   process a send backup list request
 512
 513   A client sends a backup list request to ask for a list of servers on
 514   the net that maintain server lists for a domain. A server is then
 515   chosen from this list to send NetServerEnum commands to to list
 516   available servers.
 517
 518   Currently samba only sends back one name in the backup list, its
 519   own. For larger nets we'll have to add backups and send "become
 520   backup" requests occasionally.
 521   ******************************************************************/
 522 static void process_send_backup_list(struct packet_struct *p,char *buf)
 523 {
 524   struct dgram_packet *dgram = &p->packet.dgram;
 525   struct in_addr ip = dgram->header.source_ip;
 526   struct subnet_record *d;
 527   struct work_record *work;
 528
 529   int    token = CVAL(buf,0); /* sender's key index for the workgroup */
 530   uint32 info  = IVAL(buf,1); /* XXXX don't know: some sort of info */
 531   int name_type = dgram->dest_name.name_type;
 532
 533   if (same_context(dgram)) return;
 534
 535   if (name_type != 0x1b && name_type != 0x1d) {
 536     DEBUG(0,("backup request to wrong type %d from %s\n",
 537               name_type,inet_ntoa(ip)));
 538     return;
 539   }
 540
 541   for (d = subnetlist; d; d = d->next)
 542     {
 543       for (work = d->workgrouplist; work; work = work->next)
 544         {
 545           if (strequal(work->work_group, dgram->dest_name.name))
 546             {
 547               DEBUG(2,("sending backup list to %s %s id=%x\n",
 548                        namestr(&dgram->dest_name),inet_ntoa(ip),info));
 549
 550               send_backup_list(work->work_group,&dgram->source_name,
 551                                token,info,name_type,ip);
 552               return;
 553             }
 554         }
 555     }
 556 }
 557
 558
 559 /*******************************************************************
 560   process a reset browser state
 561
 562   diagnostic packet:
 563   0x1 - stop being a master browser and become a backup browser.
 564   0x2 - discard browse lists, stop being a master browser, try again.
 565   0x4 - stop being a master browser forever. no way. ain't gonna.
 566
 567   ******************************************************************/
 568 static void process_reset_browser(struct packet_struct *p,char *buf)
 569 {
 570   struct dgram_packet *dgram = &p->packet.dgram;
 571   int state = CVAL(buf,0);
 572
 573   DEBUG(1,("received diagnostic browser reset request to %s state=0x%X\n",
 574            namestr(&dgram->dest_name), state));
 575
 576   /* stop being a master but still deal with being a backup browser */
 577   if (state & 0x1)
 578     {
 579       struct subnet_record *d;
 580       for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_EXCLUDING_WINS(d))
 581         {
 582           struct work_record *work;
 583           for (work = d->workgrouplist; work; work = work->next)
 584             {
 585               if (AM_MASTER(work))
 586                 {
 587                   unbecome_local_master(d,work,SV_TYPE_MASTER_BROWSER);
 588                 }
 589             }
 590         }
 591     }
 592
 593   /* XXXX documentation inconsistency: the above description does not
 594      exactly tally with what is implemented for state & 0x2
 595    */
 596
 597   /* totally delete all servers and start afresh */
 598   if (state & 0x2)
 599     {
 600       struct subnet_record *d;
 601       for (d = FIRST_SUBNET; d; d = NEXT_SUBNET_INCLUDING_WINS(d))
 602         {
 603           struct work_record *work;
 604           for (work=d->workgrouplist;work;work=remove_workgroup(d,work,True));
 605         }
 606       add_my_subnets(lp_workgroup());
 607     }
 608
 609   /* stop browsing altogether. i don't think this is a good idea! */
 610   if (state & 0x4)
 611     {
 612       DEBUG(1,("ignoring request to stop being a browser. sorry!\n"));
 613     }
 614 }
 615
 616 /*******************************************************************
 617   process a announcement request
 618
 619   clients send these when they want everyone to send an announcement
 620   immediately. This can cause quite a storm of packets!
 621   ******************************************************************/
 622 static void process_announce_request(struct packet_struct *p,char *buf)
 623 {
 624   struct dgram_packet *dgram = &p->packet.dgram;
 625   struct work_record *work;
 626   struct in_addr ip = dgram->header.source_ip;
 627   struct subnet_record *d = find_subnet(ip); /* Explicitly NO WINS */
 628   int token = CVAL(buf,0);
 629   char *name = buf+1;
 630
 631   name[15] = 0;
 632
 633   DEBUG(3,("process_announce_request: Announce request from %s to %s token=0x%X\n",
 634            name,namestr(&dgram->dest_name), token));
 635
 636   if (strequal(dgram->source_name.name,myname)) return;
 637
 638   /* XXXX BUG or FEATURE?: need to ensure that we are a member of
 639      this workgroup before announcing, particularly as we only
 640      respond on local interfaces anyway.
 641
 642      if (strequal(dgram->dest_name, lp_workgroup()) return; ???
 643    */
 644
 645   if (!d)
 646     {
 647       DEBUG(3,("process_announce_request: No local interface to announce to %s\n",
 648                 name));
 649       return;
 650     }
 651
 652   for (work = d->workgrouplist; work; work = work->next)
 653     {
 654      /* XXXX BUG: the destination name type should also be checked,
 655         not just the name. e.g if the name is WORKGROUP(0x1d) then
 656         we should only respond if we own that name */
 657
 658       if (strequal(dgram->dest_name.name,work->work_group))
 659         {
 660           work->needannounce = True;
 661         }
 662     }
 663 }
 664
 665
 666
 667 /****************************************************************************
 668 process a browse frame
 669 ****************************************************************************/
 670 void process_browse_packet(struct packet_struct *p,char *buf,int len)
 671 {
 672   int command = CVAL(buf,0);
 673   switch (command)
 674     {
 675     case ANN_HostAnnouncement:
 676     case ANN_DomainAnnouncement:
 677     case ANN_LocalMasterAnnouncement:
 678       {
 679         debug_browse_data(buf, len);
 680         process_localnet_announce(p,command,buf+1);
 681         break;
 682       }
 683
 684     case ANN_AnnouncementRequest:
 685       {
 686         process_announce_request(p,buf+1);
 687         break;
 688       }
 689
 690     case ANN_Election:
 691       {
 692         process_election(p,buf+1);
 693         break;
 694       }
 695
 696     case ANN_GetBackupListReq:
 697       {
 698         debug_browse_data(buf, len);
 699         process_send_backup_list(p,buf+1);
 700         break;
 701       }
 702
 703     case ANN_GetBackupListResp:
 704     {
 705         debug_browse_data(buf, len);
 706         process_rcv_backup_list(p, buf+1);
 707         break;
 708     }
 709
 710     case ANN_ResetBrowserState:
 711       {
 712         process_reset_browser(p, buf+1);
 713         break;
 714       }
 715
 716     case ANN_MasterAnnouncement:
 717       {
 718         process_master_announce(p,buf+1);
 719         break;
 720       }
 721
 722     default:
 723       {
 724         struct dgram_packet *dgram = &p->packet.dgram;
 725         DEBUG(4,("ignoring browse packet %d from %s %s to %s\n",
 726                  command, namestr(&dgram->source_name),
 727                  inet_ntoa(p->ip), namestr(&dgram->dest_name)));
 728       }
 729     }
 730 }
 731
 732