home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / samba-1.9.18p7.tar.gz / samba-1.9.18p7.tar / samba-1.9.18p7 / source / nmbd_sendannounce.c < prev    next >
C/C++ Source or Header  |  1998-05-04  |  21KB  |  606 lines
  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    NBT netbios routines and daemon - version 2
  5.    Copyright (C) Andrew Tridgell 1994-1998
  6.    Copyright (C) Luke Kenneth Casson Leighton 1994-1998
  7.    Copyright (C) Jeremy Allison 1994-1998
  8.  
  9.    SMB Version handling
  10.    Copyright (C) John H Terpstra 1995-1998
  11.    
  12.    This program is free software; you can redistribute it and/or modify
  13.    it under the terms of the GNU General Public License as published by
  14.    the Free Software Foundation; either version 2 of the License, or
  15.    (at your option) any later version.
  16.    
  17.    This program is distributed in the hope that it will be useful,
  18.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.    GNU General Public License for more details.
  21.    
  22.    You should have received a copy of the GNU General Public License
  23.    along with this program; if not, write to the Free Software
  24.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.    
  26. */
  27.  
  28. #include "includes.h"
  29.  
  30. extern int DEBUGLEVEL;
  31. extern pstring myname;
  32. extern fstring myworkgroup;
  33. extern char **my_netbios_names;
  34. extern int  updatecount;
  35. extern BOOL found_lm_clients;
  36.  
  37. /****************************************************************************
  38.  Send a browser reset packet.
  39. **************************************************************************/
  40.  
  41. void send_browser_reset(int reset_type, char *to_name, int to_type, struct in_addr to_ip)
  42. {
  43.   pstring outbuf;
  44.   char *p;
  45.  
  46.   DEBUG(3,("send_browser_reset: sending reset request type %d to %s<%02x> IP %s.\n",
  47.        reset_type, to_name, to_type, inet_ntoa(to_ip) ));
  48.  
  49.   bzero(outbuf,sizeof(outbuf));
  50.   p = outbuf;
  51.   CVAL(p,0) = ANN_ResetBrowserState;
  52.   p++;
  53.   CVAL(p,0) = reset_type;
  54.   p++;
  55.  
  56.   send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
  57.                 myname, 0x0, to_name, to_type, to_ip, FIRST_SUBNET->myip);
  58. }
  59.  
  60. /****************************************************************************
  61.   Broadcast a packet to the local net requesting that all servers in this
  62.   workgroup announce themselves to us.
  63.   **************************************************************************/
  64.  
  65. void broadcast_announce_request(struct subnet_record *subrec, struct work_record *work)
  66. {
  67.   pstring outbuf;
  68.   char *p;
  69.  
  70.   work->needannounce = True;
  71.  
  72.   DEBUG(3,("broadcast_announce_request: sending announce request for workgroup %s \
  73. to subnet %s\n", work->work_group, subrec->subnet_name));
  74.  
  75.   bzero(outbuf,sizeof(outbuf));
  76.   p = outbuf;
  77.   CVAL(p,0) = ANN_AnnouncementRequest;
  78.   p++;
  79.  
  80.   CVAL(p,0) = work->token; /* (local) Unique workgroup token id. */
  81.   p++;
  82.   StrnCpy(p,myname,15);
  83.   strupper(p);
  84.   p = skip_string(p,1);
  85.   
  86.   send_mailslot(False, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
  87.                 myname, 0x0, work->work_group,0x1e, subrec->bcast_ip, subrec->myip);
  88. }
  89.  
  90. /****************************************************************************
  91.   Broadcast an announcement.
  92.   **************************************************************************/
  93.  
  94. static void send_announcement(struct subnet_record *subrec, int announce_type,
  95.                               char *from_name, char *to_name, int to_type, struct in_addr to_ip,
  96.                               time_t announce_interval,
  97.                               char *server_name, int server_type, char *server_comment)
  98. {
  99.   pstring outbuf;
  100.   char *p;
  101.  
  102.   bzero(outbuf,sizeof(outbuf));
  103.   p = outbuf+1;
  104.  
  105.   CVAL(outbuf,0) = announce_type;
  106.  
  107.   /* Announcement parameters. */
  108.   CVAL(p,0) = updatecount;
  109.   SIVAL(p,1,announce_interval*1000); /* Milliseconds - despite the spec. */
  110.  
  111.   StrnCpy(p+5,server_name,15);
  112.   strupper(p+5);
  113.  
  114.   CVAL(p,21) = lp_major_announce_version(); /* Major version. */
  115.   CVAL(p,22) = lp_minor_announce_version(); /* Minor version. */
  116.  
  117.   SIVAL(p,23,server_type & ~SV_TYPE_LOCAL_LIST_ONLY);
  118.   /* Browse version: got from NT/AS 4.00  - Value defined in smb.h (JHT). */
  119.   SSVAL(p,27,BROWSER_ELECTION_VERSION);
  120.   SSVAL(p,29,BROWSER_CONSTANT); /* Browse signature. */
  121.  
  122.   pstrcpy(p+31,server_comment);
  123.   p += 31;
  124.   p = skip_string(p,1);
  125.  
  126.   send_mailslot(False,BROWSE_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
  127.                 from_name, 0x0, to_name, to_type, to_ip, subrec->myip);
  128. }
  129.  
  130. /****************************************************************************
  131.   Broadcast a LanMan announcement.
  132. **************************************************************************/
  133.  
  134. static void send_lm_announcement(struct subnet_record *subrec, int announce_type,
  135.                               char *from_name, char *to_name, int to_type, struct in_addr to_ip,
  136.                               time_t announce_interval,
  137.                               char *server_name, int server_type, char *server_comment)
  138. {
  139.   pstring outbuf;
  140.   char *p=outbuf;
  141.  
  142.   bzero(outbuf,sizeof(outbuf));
  143.  
  144.   SSVAL(p,0,announce_type);
  145.   SIVAL(p,2,server_type & ~SV_TYPE_LOCAL_LIST_ONLY);
  146.   CVAL(p,6) = lp_major_announce_version(); /* Major version. */
  147.   CVAL(p,7) = lp_minor_announce_version(); /* Minor version. */
  148.   SSVAL(p,8,announce_interval);            /* In seconds - according to spec. */
  149.  
  150.   p += 10;
  151.   StrnCpy(p,server_name,15);
  152.   strupper(p);
  153.   p = skip_string(p,1);
  154.   pstrcpy(p,server_comment);
  155.   p = skip_string(p,1);
  156.  
  157.   send_mailslot(False,LANMAN_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
  158.                 from_name, 0x0, to_name, to_type, to_ip, subrec->myip);
  159. }
  160.  
  161. /****************************************************************************
  162.  We are a local master browser. Announce this to WORKGROUP<1e>.
  163. ****************************************************************************/
  164.  
  165. static void send_local_master_announcement(struct subnet_record *subrec, struct work_record *work,
  166.                                            struct server_record *servrec)
  167. {
  168.   /* Ensure we don't have the prohibited bit set. */
  169.   uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
  170.  
  171.   DEBUG(3,("send_local_master_announcement: type %x for name %s on subnet %s for workgroup %s\n",
  172.             type, myname, subrec->subnet_name, work->work_group));
  173.  
  174.   send_announcement(subrec, ANN_LocalMasterAnnouncement,
  175.                     myname,                          /* From nbt name. */
  176.                     work->work_group, 0x1e,          /* To nbt name. */
  177.                     subrec->bcast_ip,                /* To ip. */
  178.                     work->announce_interval,         /* Time until next announce. */
  179.                     myname,                          /* Name to announce. */
  180.                     type,                            /* Type field. */
  181.                     servrec->serv.comment);
  182. }
  183.  
  184. /****************************************************************************
  185.  Announce the workgroup WORKGROUP to MSBROWSE<01>.
  186. ****************************************************************************/
  187.  
  188. static void send_workgroup_announcement(struct subnet_record *subrec, struct work_record *work)
  189. {
  190.   DEBUG(3,("send_workgroup_announcement: on subnet %s for workgroup %s\n",
  191.             subrec->subnet_name, work->work_group));
  192.  
  193.   send_announcement(subrec, ANN_DomainAnnouncement,
  194.                     myname,                          /* From nbt name. */
  195.                     MSBROWSE, 0x1,                   /* To nbt name. */
  196.                     subrec->bcast_ip,                /* To ip. */
  197.                     work->announce_interval,         /* Time until next announce. */
  198.                     work->work_group,                /* Name to announce. */
  199.                     SV_TYPE_DOMAIN_ENUM|SV_TYPE_NT,  /* workgroup announce flags. */
  200.                     myname);                         /* From name as comment. */
  201. }
  202.  
  203. /****************************************************************************
  204.  Announce the given host to WORKGROUP<1d>.
  205. ****************************************************************************/
  206.  
  207. static void send_host_announcement(struct subnet_record *subrec, struct work_record *work,
  208.                                    struct server_record *servrec)
  209. {
  210.   /* Ensure we don't have the prohibited bits set. */
  211.   uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
  212.  
  213.   DEBUG(3,("send_host_announcement: type %x for host %s on subnet %s for workgroup %s\n",
  214.             type, servrec->serv.name, subrec->subnet_name, work->work_group));
  215.  
  216.   send_announcement(subrec, ANN_HostAnnouncement,
  217.                     servrec->serv.name,              /* From nbt name. */
  218.                     work->work_group, 0x1d,          /* To nbt name. */
  219.                     subrec->bcast_ip,                /* To ip. */
  220.                     work->announce_interval,         /* Time until next announce. */
  221.                     servrec->serv.name,              /* Name to announce. */
  222.                     type,                            /* Type field. */
  223.                     servrec->serv.comment);
  224. }
  225.  
  226. /****************************************************************************
  227.  Announce the given LanMan host
  228. ****************************************************************************/
  229.  
  230. static void send_lm_host_announcement(struct subnet_record *subrec, struct work_record *work,
  231.                                    struct server_record *servrec, int lm_interval)
  232. {
  233.   /* Ensure we don't have the prohibited bits set. */
  234.   uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
  235.  
  236.   DEBUG(3,("send_lm_host_announcement: type %x for host %s on subnet %s for workgroup %s, ttl: %d\n",
  237.             type, servrec->serv.name, subrec->subnet_name, work->work_group, lm_interval));
  238.  
  239.   send_lm_announcement(subrec, ANN_HostAnnouncement,
  240.                     servrec->serv.name,              /* From nbt name. */
  241.                     work->work_group, 0x00,          /* To nbt name. */
  242.                     subrec->bcast_ip,                /* To ip. */
  243.                     lm_interval,                     /* Time until next announce. */
  244.                     servrec->serv.name,              /* Name to announce. */
  245.                     type,                            /* Type field. */
  246.                     servrec->serv.comment);
  247. }
  248.  
  249. /****************************************************************************
  250.   Announce a server record.
  251.   ****************************************************************************/
  252.  
  253. static void announce_server(struct subnet_record *subrec, struct work_record *work,
  254.                      struct server_record *servrec)
  255. {
  256.   /* Only do domain announcements if we are a master and it's
  257.      our primary name we're being asked to announce. */
  258.  
  259.   if (AM_LOCAL_MASTER_BROWSER(work) && strequal(myname,servrec->serv.name))
  260.   {
  261.     send_local_master_announcement(subrec, work, servrec);
  262.     send_workgroup_announcement(subrec, work);
  263.   }
  264.   else
  265.   {
  266.     send_host_announcement(subrec, work, servrec);
  267.   }
  268. }
  269.  
  270. /****************************************************************************
  271.   Go through all my registered names on all broadcast subnets and announce
  272.   them if the timeout requires it.
  273.   **************************************************************************/
  274.  
  275. void announce_my_server_names(time_t t)
  276. {
  277.   struct subnet_record *subrec;
  278.  
  279.   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
  280.   {
  281.     struct work_record *work = find_workgroup_on_subnet(subrec, myworkgroup);
  282.  
  283.     if(work)
  284.     {
  285.       struct server_record *servrec;
  286.  
  287.       if (work->needannounce)
  288.       {
  289.         /* Drop back to a max 3 minute announce. This is to prevent a
  290.            single lost packet from breaking things for too long. */
  291.  
  292.         work->announce_interval = MIN(work->announce_interval,
  293.                                     CHECK_TIME_MIN_HOST_ANNCE*60);
  294.         work->lastannounce_time = t - (work->announce_interval+1);
  295.         work->needannounce = False;
  296.       }
  297.  
  298.       /* Announce every minute at first then progress to every 12 mins */
  299.       if ((t - work->lastannounce_time) < work->announce_interval)
  300.         continue;
  301.  
  302.       if (work->announce_interval < (CHECK_TIME_MAX_HOST_ANNCE * 60))
  303.         work->announce_interval += 60;
  304.  
  305.       work->lastannounce_time = t;
  306.  
  307.       for (servrec = work->serverlist; servrec; servrec = servrec->next)
  308.       {
  309.         if (is_myname(servrec->serv.name))
  310.           announce_server(subrec, work, servrec);
  311.       }
  312.     } /* if work */
  313.   } /* for subrec */
  314. }
  315.  
  316. /****************************************************************************
  317.   Go through all my registered names on all broadcast subnets and announce
  318.   them as a LanMan server if the timeout requires it.
  319. **************************************************************************/
  320.  
  321. void announce_my_lm_server_names(time_t t)
  322. {
  323.   struct subnet_record *subrec;
  324.   static time_t last_lm_announce_time=0;
  325.   int announce_interval = lp_lm_interval();
  326.   int lm_announce = lp_lm_announce();
  327.  
  328.   if ((announce_interval <= 0) || (lm_announce <= 0))
  329.   {
  330.     /* user absolutely does not want LM announcements to be sent. */
  331.     return;
  332.   }
  333.  
  334.   if ((lm_announce >= 2) && (!found_lm_clients))
  335.   {
  336.     /* has been set to 2 (Auto) but no LM clients detected (yet). */
  337.     return;
  338.   }
  339.  
  340.   /* Otherwise: must have been set to 1 (Yes), or LM clients *have*
  341.      been detected. */
  342.  
  343.   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
  344.   {
  345.     struct work_record *work = find_workgroup_on_subnet(subrec, myworkgroup);
  346.  
  347.     if(work)
  348.     {
  349.       struct server_record *servrec;
  350.  
  351.       if (last_lm_announce_time && ((t - last_lm_announce_time) < announce_interval ))
  352.         continue;
  353.  
  354.       last_lm_announce_time = t;
  355.  
  356.       for (servrec = work->serverlist; servrec; servrec = servrec->next)
  357.       {
  358.         if (is_myname(servrec->serv.name))
  359.           /* skipping equivalent of announce_server() */
  360.           send_lm_host_announcement(subrec, work, servrec, announce_interval);
  361.       }
  362.     } /* if work */
  363.   } /* for subrec */
  364. }
  365.  
  366. /* Announce timer. Moved into global static so it can be reset
  367.    when a machine becomes a local master browser. */
  368. static time_t announce_timer_last=0;
  369.  
  370. /****************************************************************************
  371.  Reset the announce_timer so that a local master browser announce will be done
  372.  immediately.
  373.  ****************************************************************************/
  374.  
  375. void reset_announce_timer(void)
  376. {
  377.   announce_timer_last = time(NULL) - (CHECK_TIME_MST_ANNOUNCE * 60);
  378. }
  379.  
  380. /****************************************************************************
  381.   Announce myself as a local master browser to a domain master browser.
  382.   **************************************************************************/
  383.  
  384. void announce_myself_to_domain_master_browser(time_t t)
  385. {
  386.   struct subnet_record *subrec;
  387.   struct work_record *work;
  388.  
  389.   if(!we_are_a_wins_client())
  390.   {
  391.     DEBUG(10,("announce_myself_to_domain_master_browser: no unicast subnet, ignoring.\n"));
  392.     return;
  393.   }
  394.  
  395.   if (!announce_timer_last)
  396.     announce_timer_last = t;
  397.  
  398.   if ((t-announce_timer_last) < (CHECK_TIME_MST_ANNOUNCE * 60))
  399.   {
  400.     DEBUG(10,("announce_myself_to_domain_master_browser: t (%d) - last(%d) < %d\n",
  401.                t, announce_timer_last, CHECK_TIME_MST_ANNOUNCE * 60 ));
  402.     return;
  403.   }
  404.  
  405.   announce_timer_last = t;
  406.  
  407.   /* Look over all our broadcast subnets to see if any of them
  408.      has the state set as local master browser. */
  409.  
  410.   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
  411.   {
  412.     for (work = subrec->workgrouplist; work; work = work->next)
  413.     {
  414.       if (AM_LOCAL_MASTER_BROWSER(work))
  415.       {
  416.         DEBUG(4,( "announce_myself_to_domain_master_browser: I am a local master browser for \
  417. workgroup %s on subnet %s\n", work->work_group, subrec->subnet_name));
  418.  
  419.         /* Look in nmbd_browsersync.c for the rest of this code. */
  420.         announce_and_sync_with_domain_master_browser(subrec, work);
  421.       }
  422.     }
  423.   }
  424. }
  425.  
  426. /****************************************************************************
  427. Announce all samba's server entries as 'gone'.
  428. This must *only* be called on shutdown.
  429. ****************************************************************************/
  430.  
  431. void announce_my_servers_removed(void)
  432. {
  433.   int announce_interval = lp_lm_interval();
  434.   int lm_announce = lp_lm_announce();
  435.   struct subnet_record *subrec; 
  436.  
  437.   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
  438.   {
  439.     struct work_record *work;
  440.     for (work = subrec->workgrouplist; work; work = work->next)
  441.     {
  442.       struct server_record *servrec;
  443.  
  444.       work->announce_interval = 0;
  445.       for (servrec = work->serverlist; servrec; servrec = servrec->next)
  446.       {
  447.         if (!is_myname(servrec->serv.name))
  448.           continue;
  449.         servrec->serv.type = 0;
  450.         if(AM_LOCAL_MASTER_BROWSER(work))
  451.           send_local_master_announcement(subrec, work, servrec);
  452.         send_host_announcement(subrec, work, servrec);
  453.  
  454.  
  455.         if ((announce_interval <= 0) || (lm_announce <= 0))
  456.         {
  457.           /* user absolutely does not want LM announcements to be sent. */
  458.           continue;
  459.         }
  460.  
  461.         if ((lm_announce >= 2) && (!found_lm_clients))
  462.         {
  463.           /* has been set to 2 (Auto) but no LM clients detected (yet). */
  464.           continue;
  465.         }
  466.  
  467.         /* 
  468.          * lm announce was set or we have seen lm announcements, so do
  469.          * a lm announcement of host removed.
  470.          */
  471.  
  472.         send_lm_host_announcement(subrec, work, servrec, 0);
  473.       }
  474.     }
  475.   }
  476. }
  477.  
  478. /****************************************************************************
  479.   Do all the "remote" announcements. These are used to put ourselves
  480.   on a remote browse list. They are done blind, no checking is done to
  481.   see if there is actually a local master browser at the other end.
  482.   **************************************************************************/
  483.  
  484. void announce_remote(time_t t)
  485. {
  486.   char *s,*ptr;
  487.   static time_t last_time = 0;
  488.   pstring s2;
  489.   struct in_addr addr;
  490.   char *comment;
  491.   int stype = lp_default_server_announce();
  492.  
  493.   if (last_time && (t < (last_time + REMOTE_ANNOUNCE_INTERVAL)))
  494.     return;
  495.  
  496.   last_time = t;
  497.  
  498.   s = lp_remote_announce();
  499.   if (!*s)
  500.     return;
  501.  
  502.   comment = lp_serverstring();
  503.  
  504.   for (ptr=s; next_token(&ptr,s2,NULL); ) 
  505.   {
  506.     /* The entries are of the form a.b.c.d/WORKGROUP with 
  507.        WORKGROUP being optional */
  508.     char *wgroup;
  509.     int i;
  510.  
  511.     wgroup = strchr(s2,'/');
  512.     if (wgroup)
  513.       *wgroup++ = 0;
  514.     if (!wgroup || !*wgroup)
  515.       wgroup = myworkgroup;
  516.  
  517.     addr = *interpret_addr2(s2);
  518.     
  519.     /* Announce all our names including aliases */
  520.     /* Give the ip address as the address of our first
  521.        broadcast subnet. */
  522.  
  523.     for(i=0; my_netbios_names[i]; i++) 
  524.     {
  525.       char *name = my_netbios_names[i];
  526.  
  527.       DEBUG(5,("announce_remote: Doing remote announce for server %s to IP %s.\n",
  528.                  name, inet_ntoa(addr) ));
  529.  
  530.       send_announcement(FIRST_SUBNET, ANN_HostAnnouncement,
  531.                     name,                      /* From nbt name. */
  532.                     wgroup, 0x1d,              /* To nbt name. */
  533.                     addr,                      /* To ip. */
  534.                     REMOTE_ANNOUNCE_INTERVAL,  /* Time until next announce. */
  535.                     name,                      /* Name to announce. */
  536.                     stype,                     /* Type field. */
  537.                     comment);
  538.     }
  539.   }
  540. }
  541.  
  542. /****************************************************************************
  543.   Implement the 'remote browse sync' feature Andrew added.
  544.   These are used to put our browse lists into remote browse lists.
  545.   **************************************************************************/
  546.  
  547. void browse_sync_remote(time_t t)
  548. {  
  549.   char *s,*ptr;
  550.   static time_t last_time = 0; 
  551.   pstring s2;
  552.   struct in_addr addr;
  553.   struct work_record *work;
  554.   pstring outbuf;
  555.   char *p;
  556.  
  557.   if (last_time && (t < (last_time + REMOTE_ANNOUNCE_INTERVAL)))
  558.     return;
  559.    
  560.   last_time = t;
  561.  
  562.   s = lp_remote_browse_sync();
  563.   if (!*s)
  564.     return;
  565.  
  566.   /*
  567.    * We only do this if we are the local master browser
  568.    * for our workgroup on the firsst subnet.
  569.    */
  570.  
  571.   if((work = find_workgroup_on_subnet(FIRST_SUBNET, myworkgroup)) == NULL)
  572.   {   
  573.     DEBUG(0,("browse_sync_remote: Cannot find workgroup %s on subnet %s\n",
  574.            myworkgroup, FIRST_SUBNET->subnet_name ));
  575.     return;
  576.   }   
  577.          
  578.   if(!AM_LOCAL_MASTER_BROWSER(work))
  579.   {
  580.     DEBUG(5,("browse_sync_remote: We can only do this if we are a local master browser \
  581. for workgroup %s on subnet %s.\n", myworkgroup, FIRST_SUBNET->subnet_name ));
  582.     return;
  583.   } 
  584.  
  585.   bzero(outbuf,sizeof(outbuf));
  586.   p = outbuf;
  587.   CVAL(p,0) = ANN_MasterAnnouncement;
  588.   p++;
  589.  
  590.   StrnCpy(p,myname,15);
  591.   strupper(p);
  592.   p = skip_string(p,1);
  593.  
  594.   for (ptr=s; next_token(&ptr,s2,NULL); ) 
  595.   {
  596.     /* The entries are of the form a.b.c.d */
  597.     addr = *interpret_addr2(s2);
  598.  
  599.     DEBUG(5,("announce_remote: Doing remote browse sync announce for server %s to IP %s.\n",
  600.                  myname, inet_ntoa(addr) ));
  601.  
  602.     send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
  603.           myname, 0x0, "*", 0x0, addr, FIRST_SUBNET->myip);
  604.   }
  605. }
  606.