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_namelistdb.c < prev    next >
C/C++ Source or Header  |  1998-05-12  |  19KB  |  587 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.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 2 of the License, or
  12.    (at your option) any later version.
  13.    
  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.
  18.    
  19.    You should have received a copy of the GNU General Public License
  20.    along with this program; if not, write to the Free Software
  21.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22.    
  23. */
  24.  
  25. #include "includes.h"
  26.  
  27. extern int DEBUGLEVEL;
  28.  
  29. extern pstring scope;
  30. extern char **my_netbios_names;
  31.  
  32. uint16 samba_nb_type = 0; /* samba's NetBIOS name type */
  33.  
  34.  
  35. /****************************************************************************
  36.   Set Samba's NetBIOS name type.
  37.   ****************************************************************************/
  38.  
  39. void set_samba_nb_type(void)
  40. {
  41.   if (lp_wins_support() || (*lp_wins_server()))
  42.     samba_nb_type = NB_MFLAG; /* samba is a 'hybrid' node type */
  43.   else
  44.     samba_nb_type = NB_BFLAG; /* samba is broadcast-only node type */
  45. }
  46.  
  47. /****************************************************************************
  48.   Returns True if the netbios name is ^1^2__MSBROWSE__^2^1.
  49.  
  50.   Note: This name is registered if as a master browser or backup browser
  51.   you are responsible for a workgroup (when you announce a domain by
  52.   broadcasting on your local subnet, you announce it as coming from this
  53.   name: see announce_host()).
  54.  
  55.   **************************************************************************/
  56.  
  57. BOOL ms_browser_name(char *name, int type)
  58. {
  59.   return (strequal(name,MSBROWSE) && (type == 0x01));
  60. }
  61.  
  62. /****************************************************************************
  63.   Add a netbios name into a namelist.
  64.   **************************************************************************/
  65.  
  66. static void add_name_to_namelist(struct subnet_record *subrec, 
  67.                                  struct name_record *namerec)
  68. {
  69.   struct name_record *namerec2;
  70.  
  71.   if (!subrec->namelist)
  72.   {
  73.     subrec->namelist = namerec;
  74.     namerec->prev = NULL;
  75.     namerec->next = NULL;
  76.     return;
  77.   }
  78.  
  79.   for (namerec2 = subrec->namelist; namerec2->next; namerec2 = namerec2->next) 
  80.     ;
  81.  
  82.   namerec2->next = namerec;
  83.   namerec->next = NULL;
  84.   namerec->prev = namerec2;
  85.   namerec->subnet = subrec;
  86.  
  87.   subrec->namelist_changed = True;
  88. }
  89.  
  90. /****************************************************************************
  91.   Remove a name from the namelist.
  92.   **************************************************************************/
  93.  
  94. void remove_name_from_namelist(struct subnet_record *subrec, 
  95.                                struct name_record *namerec)
  96. {
  97.   if (namerec->next)
  98.     namerec->next->prev = namerec->prev;
  99.   if (namerec->prev)
  100.     namerec->prev->next = namerec->next;
  101.  
  102.   if(namerec == subrec->namelist)
  103.     subrec->namelist = namerec->next;
  104.  
  105.   if(namerec->ip != NULL)
  106.     free((char *)namerec->ip);
  107.   free((char *)namerec);
  108.  
  109.   subrec->namelist_changed = True;
  110. }
  111.  
  112.  
  113. /****************************************************************************
  114.   Find a name in a subnet.
  115.   **************************************************************************/
  116.  
  117. struct name_record *find_name_on_subnet(struct subnet_record *subrec,
  118.                                       struct nmb_name *nmbname, BOOL self_only)
  119. {
  120.   struct name_record *namerec = subrec->namelist;
  121.   struct name_record *name_ret;
  122.   
  123.   for (name_ret = namerec; name_ret; name_ret = name_ret->next)
  124.   {
  125.     if (nmb_name_equal(&name_ret->name, nmbname))
  126.     {
  127.       /* Self names only - these include permanent names. */
  128.       if (self_only && (name_ret->source != SELF_NAME) && 
  129.               (name_ret->source != PERMANENT_NAME) )
  130.       {
  131.         continue;
  132.       }
  133.       DEBUG(9,("find_name_on_subnet: on subnet %s - found name %s source=%d\n", 
  134.                 subrec->subnet_name, namestr(nmbname), name_ret->source));
  135.       return name_ret;
  136.     }
  137.   }
  138.   DEBUG(9,("find_name_on_subnet: on subnet %s - name %s NOT FOUND\n", 
  139.             subrec->subnet_name, namestr(nmbname)));
  140.   return NULL;
  141. }
  142.  
  143. /****************************************************************************
  144.   Find a name over all known broadcast subnets.
  145. **************************************************************************/
  146.  
  147. struct name_record *find_name_for_remote_broadcast_subnet( struct nmb_name *nmbname, 
  148.                                                            BOOL self_only)
  149. {
  150.   struct subnet_record *subrec;
  151.   struct name_record *namerec = NULL;
  152.  
  153.   for( subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
  154.   {
  155.     if((namerec = find_name_on_subnet(subrec, nmbname, self_only))!= NULL)
  156.       break;
  157.   }
  158.  
  159.   return namerec;
  160. }    
  161.   
  162. /****************************************************************************
  163.   Update the ttl of an entry in a subnet name list.
  164.   ****************************************************************************/
  165.  
  166. void update_name_ttl(struct name_record *namerec, int ttl)
  167. {
  168.   time_t time_now = time(NULL);
  169.  
  170.   if(namerec->death_time != PERMANENT_TTL)
  171.     namerec->death_time = time_now + ttl;
  172.  
  173.   namerec->refresh_time = time_now + (ttl/2);
  174.  
  175.   namerec->subnet->namelist_changed = True;
  176. } 
  177.  
  178. /****************************************************************************
  179.   Add an entry to a subnet name list.
  180.   ****************************************************************************/
  181.  
  182. struct name_record *add_name_to_subnet(struct subnet_record *subrec,
  183.         char *name, int type, uint16 nb_flags, int ttl, 
  184.                 enum name_source source, int num_ips, struct in_addr *iplist)
  185. {
  186.   struct name_record *namerec;
  187.   time_t time_now = time(NULL);
  188.  
  189.   if((namerec = (struct name_record *)malloc(sizeof(*namerec))) == NULL)
  190.   {
  191.     DEBUG(0,("add_name_to_subnet: malloc fail.\n"));
  192.     return NULL;
  193.   }
  194.  
  195.   bzero((char *)namerec,sizeof(*namerec));
  196.  
  197.   namerec->subnet = subrec;
  198.  
  199.   namerec->num_ips = num_ips;
  200.   namerec->ip = (struct in_addr *)malloc(sizeof(struct in_addr) * namerec->num_ips);
  201.   if (!namerec->ip)
  202.   {
  203.      DEBUG(0,("add_name_to_subnet: malloc fail when creating ip_flgs.\n"));
  204.      free((char *)namerec);
  205.      return NULL;
  206.   }
  207.  
  208.   bzero((char *)namerec->ip, sizeof(struct in_addr) * namerec->num_ips);
  209.  
  210.   memcpy(&namerec->ip[0], iplist, num_ips * sizeof(struct in_addr));
  211.  
  212.   make_nmb_name(&namerec->name,name,type,scope);
  213.  
  214.   /* Setup the death_time and refresh_time. */
  215.   if(ttl == PERMANENT_TTL)
  216.     namerec->death_time = PERMANENT_TTL;
  217.   else
  218.     namerec->death_time = time_now + ttl;
  219.  
  220.   namerec->refresh_time = time_now + (ttl/2);
  221.  
  222.   /* Enter the name as active. */
  223.   namerec->nb_flags = nb_flags | NB_ACTIVE;
  224.  
  225.   /* If it's our primary name, flag it as so. */
  226.   if(strequal(my_netbios_names[0],name))
  227.     namerec->nb_flags |= NB_PERM;
  228.  
  229.   namerec->source = source;
  230.   
  231.   add_name_to_namelist(subrec,namerec);
  232.  
  233.   DEBUG(3,("add_name_to_subnet: Added netbios name %s with first IP %s ttl=%d nb_flags=%2x to subnet %s\n",
  234.        namestr(&namerec->name),inet_ntoa(*iplist),ttl,(unsigned int)nb_flags,
  235.        subrec->subnet_name));
  236.  
  237.   subrec->namelist_changed = True;
  238.  
  239.   return(namerec);
  240. }
  241.  
  242. /*******************************************************************
  243.  Utility function automatically called when a name refresh or register 
  244.  succeeds. By definition this is a SELF_NAME (or we wouldn't be registering
  245.  it).
  246.  ******************************************************************/
  247.  
  248. void standard_success_register(struct subnet_record *subrec, 
  249.                              struct userdata_struct *userdata,
  250.                              struct nmb_name *nmbname, uint16 nb_flags, int ttl,
  251.                              struct in_addr registered_ip)
  252. {
  253.   struct name_record *namerec = find_name_on_subnet(subrec, nmbname, FIND_SELF_NAME);
  254.  
  255.   if(namerec == NULL)
  256.     add_name_to_subnet(subrec, nmbname->name, nmbname->name_type,
  257.                      nb_flags, ttl, SELF_NAME, 1, ®istered_ip);
  258.   else
  259.     update_name_ttl(namerec, ttl);
  260. }
  261.  
  262. /*******************************************************************
  263.  Utility function automatically called when a name refresh or register 
  264.  fails.
  265.  ******************************************************************/
  266.  
  267. void standard_fail_register(struct subnet_record *subrec, 
  268.                              struct response_record *rrec, struct nmb_name *nmbname)
  269. {
  270.   struct name_record *namerec = find_name_on_subnet(subrec, nmbname, FIND_SELF_NAME);
  271.  
  272.   DEBUG(0,("standard_fail_register: Failed to register/refresh name %s on subnet %s\n",
  273.            namestr(nmbname), subrec->subnet_name));
  274.  
  275.   /* Remove the name from the subnet. */
  276.   if(namerec)
  277.     remove_name_from_namelist(subrec, namerec);
  278. }
  279.  
  280. /*******************************************************************
  281.  Utility function to remove an IP address from a name record.
  282.  ******************************************************************/
  283.  
  284. static void remove_nth_ip_in_record( struct name_record *namerec, int ind)
  285. {
  286.   if(ind != namerec->num_ips)
  287.     memmove( (char *)(&namerec->ip[ind]), (char *)(&namerec->ip[ind+1]), 
  288.               ( namerec->num_ips - ind - 1) * sizeof(struct in_addr));
  289.  
  290.   namerec->num_ips--;
  291.   namerec->subnet->namelist_changed = True;
  292. }
  293.  
  294. /*******************************************************************
  295.  Utility function to check if an IP address exists in a name record.
  296.  ******************************************************************/
  297.  
  298. BOOL find_ip_in_name_record(struct name_record *namerec, struct in_addr ip)
  299. {
  300.   int i;
  301.  
  302.   for(i = 0; i < namerec->num_ips; i++)
  303.     if(ip_equal( namerec->ip[i], ip))
  304.       return True;
  305.  
  306.   return False;
  307. }
  308.  
  309. /*******************************************************************
  310.  Utility function to add an IP address to a name record.
  311.  ******************************************************************/
  312.  
  313. void add_ip_to_name_record(struct name_record *namerec, struct in_addr new_ip)
  314. {
  315.   struct in_addr *new_list;
  316.  
  317.   /* Don't add one we already have. */
  318.   if(find_ip_in_name_record( namerec, new_ip))
  319.     return;
  320.   
  321.   if((new_list = (struct in_addr *)malloc( (namerec->num_ips + 1)*sizeof(struct in_addr)) )== NULL)
  322.   {
  323.     DEBUG(0,("add_ip_to_name_record: Malloc fail !\n"));
  324.     return;
  325.   }
  326.  
  327.   memcpy((char *)new_list, (char *)namerec->ip, namerec->num_ips *sizeof(struct in_addr));
  328.   new_list[namerec->num_ips] = new_ip;
  329.  
  330.   free((char *)namerec->ip);
  331.   namerec->ip = new_list;
  332.   namerec->num_ips += 1;
  333.  
  334.   namerec->subnet->namelist_changed = True;
  335. }
  336.  
  337. /*******************************************************************
  338.  Utility function to remove an IP address from a name record.
  339.  ******************************************************************/
  340.  
  341. void remove_ip_from_name_record( struct name_record *namerec, struct in_addr remove_ip)
  342. {
  343.   /* Try and find the requested ip address - remove it. */
  344.   int i;
  345.   int orig_num = namerec->num_ips;
  346.  
  347.   for(i = 0; i < orig_num; i++)
  348.     if( ip_equal( remove_ip, namerec->ip[i]) )
  349.     {
  350.       remove_nth_ip_in_record( namerec, i);
  351.       break;
  352.     }
  353. }
  354.  
  355. /*******************************************************************
  356.  Utility function that release_name callers can plug into as the
  357.  success function when a name release is successful. Used to save
  358.  duplication of success_function code.
  359.  ******************************************************************/
  360.  
  361. void standard_success_release(struct subnet_record *subrec, 
  362.                              struct userdata_struct *userdata,
  363.                              struct nmb_name *nmbname, struct in_addr released_ip)
  364. {
  365.   struct name_record *namerec = find_name_on_subnet(subrec, nmbname, FIND_ANY_NAME);
  366.  
  367.   if(namerec == NULL)
  368.   {
  369.     DEBUG(0,("standard_success_release: Name release for name %s IP %s on subnet %s. Name \
  370. was not found on subnet.\n", namestr(nmbname), inet_ntoa(released_ip), subrec->subnet_name));
  371.     return;
  372.   }
  373.   else
  374.   {
  375.     int orig_num = namerec->num_ips;
  376.  
  377.     remove_ip_from_name_record( namerec, released_ip);
  378.  
  379.     if(namerec->num_ips == orig_num)
  380.       DEBUG(0,("standard_success_release: Name release for name %s IP %s on subnet %s. This ip \
  381. is not known for this name.\n", namestr(nmbname), inet_ntoa(released_ip), subrec->subnet_name ));
  382.   }
  383.  
  384.   if (namerec->num_ips == 0)
  385.     remove_name_from_namelist(subrec, namerec);
  386. }
  387.  
  388. /*******************************************************************
  389.   Expires old names in a subnet namelist.
  390.   ******************************************************************/
  391.  
  392. void expire_names_on_subnet(struct subnet_record *subrec, time_t t)
  393. {
  394.   struct name_record *namerec;
  395.   struct name_record *next_namerec;
  396.  
  397.   for (namerec = subrec->namelist; namerec; namerec = next_namerec)
  398.   {
  399.     next_namerec = namerec->next;
  400.     if ((namerec->death_time != PERMANENT_TTL) && (namerec->death_time < t))
  401.     {
  402.       if (namerec->source == SELF_NAME)
  403.       {
  404.         DEBUG(3,("expire_names_on_subnet: Subnet %s not expiring SELF name %s\n", 
  405.              subrec->subnet_name, namestr(&namerec->name)));
  406.         namerec->death_time += 300;
  407.         namerec->subnet->namelist_changed = True;
  408.         continue;
  409.       }
  410.       DEBUG(3,("expire_names_on_subnet: Subnet %s - removing expired name %s\n", 
  411.                  subrec->subnet_name, namestr(&namerec->name)));
  412.   
  413.       remove_name_from_namelist(subrec, namerec);
  414.     }
  415.   }
  416. }
  417.  
  418. /*******************************************************************
  419.   Expires old names in all subnet namelists.
  420.   ******************************************************************/
  421.  
  422. void expire_names(time_t t)
  423. {
  424.   struct subnet_record *subrec;
  425.  
  426.   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_INCLUDING_UNICAST(subrec))
  427.   {
  428.     expire_names_on_subnet(subrec, t);
  429.   }
  430. }
  431.  
  432. /****************************************************************************
  433.   Add the magic samba names, useful for finding samba servers.
  434.   These go directly into the name list for a particular subnet,
  435.   without going through the normal registration process.
  436.   When adding them to the unicast subnet, add them as a list of
  437.   all broadcast subnet IP addresses.
  438. **************************************************************************/
  439.  
  440. void add_samba_names_to_subnet(struct subnet_record *subrec)
  441. {
  442.   struct in_addr *iplist = &subrec->myip;
  443.   int num_ips = 1;
  444.  
  445.   /* These names are added permanently (ttl of zero) and will NOT be
  446.      refreshed.  */
  447.  
  448.   if((subrec == unicast_subnet) || (subrec == wins_server_subnet))
  449.   {
  450.     struct subnet_record *bcast_subrecs;
  451.     int i;
  452.     /* Create an IP list containing all our known subnets. */
  453.  
  454.     num_ips = iface_count();
  455.     if((iplist = (struct in_addr *)malloc( num_ips * sizeof(struct in_addr) )) == NULL)
  456.     {
  457.       DEBUG(0,("add_samba_names_to_subnet: Malloc fail !\n"));
  458.       return;
  459.     }
  460.  
  461.     for(bcast_subrecs = FIRST_SUBNET, i = 0; bcast_subrecs; 
  462.                  bcast_subrecs = NEXT_SUBNET_EXCLUDING_UNICAST(bcast_subrecs), i++)
  463.       iplist[i] = bcast_subrecs->myip;
  464.  
  465.   }
  466.  
  467.   add_name_to_subnet(subrec,"*",0x0,samba_nb_type, PERMANENT_TTL,
  468.                      PERMANENT_NAME, num_ips, iplist);
  469.   add_name_to_subnet(subrec,"*",0x20,samba_nb_type,PERMANENT_TTL,
  470.                      PERMANENT_NAME, num_ips, iplist);
  471.   add_name_to_subnet(subrec,"__SAMBA__",0x20,samba_nb_type,PERMANENT_TTL,
  472.                    PERMANENT_NAME, num_ips, iplist);
  473.   add_name_to_subnet(subrec,"__SAMBA__",0x00,samba_nb_type,PERMANENT_TTL,
  474.                    PERMANENT_NAME, num_ips, iplist);
  475.  
  476.   if(iplist != &subrec->myip)
  477.     free((char *)iplist);
  478. }
  479.  
  480. /****************************************************************************
  481.  Dump the contents of the namelists on all the subnets (including unicast)
  482.  into a file. Initiated by SIGHUP - used to debug the state of the namelists.
  483. **************************************************************************/
  484.  
  485. static void dump_subnet_namelist( struct subnet_record *subrec, FILE *fp)
  486. {
  487.   struct name_record *namerec;
  488.   char *src_type;
  489.   struct tm *tm;
  490.   int i;
  491.  
  492.   fprintf(fp, "Subnet %s\n----------------------\n", subrec->subnet_name);
  493.   for (namerec = subrec->namelist; namerec; namerec = namerec->next)
  494.   {
  495.     fprintf(fp,"\tName = %s\t", namestr(&namerec->name));
  496.     switch(namerec->source)
  497.     {
  498.       case LMHOSTS_NAME:
  499.         src_type = "LMHOSTS_NAME";
  500.         break;
  501.       case WINS_PROXY_NAME:
  502.         src_type = "WINS_PROXY_NAME";
  503.         break;
  504.       case REGISTER_NAME:
  505.         src_type = "REGISTER_NAME";
  506.         break;
  507.       case SELF_NAME:
  508.         src_type = "SELF_NAME";
  509.         break;
  510.       case DNS_NAME:
  511.         src_type = "DNS_NAME";
  512.         break;
  513.       case DNSFAIL_NAME:
  514.         src_type = "DNSFAIL_NAME";
  515.         break;
  516.       case PERMANENT_NAME:
  517.         src_type = "PERMANENT_NAME";
  518.         break;
  519.       default:
  520.         src_type = "unknown!";
  521.         break;
  522.     }
  523.     fprintf(fp, "Source = %s\nb_flags = %x\t", src_type, namerec->nb_flags);
  524.  
  525.     if(namerec->death_time != PERMANENT_TTL)
  526.     {
  527.       tm = LocalTime(&namerec->death_time);
  528.       fprintf(fp, "death_time = %s\t", asctime(tm));
  529.     }
  530.     else
  531.       fprintf(fp, "death_time = PERMANENT\t");
  532.  
  533.     if(namerec->refresh_time != PERMANENT_TTL)
  534.     {
  535.       tm = LocalTime(&namerec->refresh_time);
  536.       fprintf(fp, "refresh_time = %s\n", asctime(tm));
  537.     }
  538.     else
  539.       fprintf(fp, "refresh_time = PERMANENT\n");
  540.  
  541.     fprintf(fp, "\t\tnumber of IPS = %d", namerec->num_ips);
  542.     for(i = 0; i < namerec->num_ips; i++)
  543.       fprintf(fp, "\t%s", inet_ntoa(namerec->ip[i]));
  544.  
  545.     fprintf(fp, "\n\n");
  546.   }
  547. }
  548.  
  549. /****************************************************************************
  550.  Dump the contents of the namelists on all the subnets (including unicast)
  551.  into a file. Initiated by SIGHUP - used to debug the state of the namelists.
  552. **************************************************************************/
  553.  
  554. void dump_all_namelists(void)
  555. {
  556.   pstring fname;
  557.   FILE *fp; 
  558.   struct subnet_record *subrec;
  559.  
  560.   pstrcpy(fname,lp_lockdir());
  561.   trim_string(fname,NULL,"/");
  562.   pstrcat(fname,"/"); 
  563.   pstrcat(fname,"namelist.debug");
  564.  
  565.   fp = fopen(fname,"w");
  566.      
  567.   if (!fp)
  568.   { 
  569.     DEBUG(0,("dump_all_namelists: Can't open file %s. Error was %s\n",
  570.               fname,strerror(errno)));
  571.     return;
  572.   }
  573.       
  574.   for (subrec = FIRST_SUBNET; subrec ; subrec = NEXT_SUBNET_INCLUDING_UNICAST(subrec))
  575.     dump_subnet_namelist( subrec, fp);
  576.  
  577.   if(!we_are_a_wins_client())
  578.     dump_subnet_namelist(unicast_subnet, fp);
  579.  
  580.   if(remote_broadcast_subnet->namelist != NULL)
  581.     dump_subnet_namelist(remote_broadcast_subnet, fp);
  582.  
  583.   if(wins_server_subnet != NULL)
  584.     dump_subnet_namelist( wins_server_subnet, fp);
  585.   fclose(fp);
  586. }
  587.