Merge Samba3 and Samba4 together
[samba.git] / source3 / winbindd / winbindd_wins.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Winbind daemon - WINS related functions
5
6    Copyright (C) Andrew Tridgell 1999
7    Copyright (C) Herb Lewis 2002
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 3 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, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "winbindd.h"
25
26 #undef DBGC_CLASS
27 #define DBGC_CLASS DBGC_WINBIND
28
29 /* Use our own create socket code so we don't recurse.... */
30
31 static int wins_lookup_open_socket_in(void)
32 {
33         struct sockaddr_in sock;
34         int val=1;
35         int res;
36
37         memset((char *)&sock,'\0',sizeof(sock));
38
39 #ifdef HAVE_SOCK_SIN_LEN
40         sock.sin_len = sizeof(sock);
41 #endif
42         sock.sin_port = 0;
43         sock.sin_family = AF_INET;
44         sock.sin_addr.s_addr = interpret_addr("0.0.0.0");
45         res = socket(AF_INET, SOCK_DGRAM, 0);
46         if (res == -1)
47                 return -1;
48
49         setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val));
50 #ifdef SO_REUSEPORT
51         setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val));
52 #endif /* SO_REUSEPORT */
53
54         /* now we've got a socket - we need to bind it */
55
56         if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0) {
57                 close(res);
58                 return(-1);
59         }
60
61         set_socket_options(res,"SO_BROADCAST");
62
63         return res;
64 }
65
66
67 static NODE_STATUS_STRUCT *lookup_byaddr_backend(const char *addr, int *count)
68 {
69         int fd;
70         struct sockaddr_storage ss;
71         struct nmb_name nname;
72         NODE_STATUS_STRUCT *status;
73
74         fd = wins_lookup_open_socket_in();
75         if (fd == -1)
76                 return NULL;
77
78         make_nmb_name(&nname, "*", 0);
79         if (!interpret_string_addr(&ss, addr, AI_NUMERICHOST)) {
80                 return NULL;
81         }
82         status = node_status_query(fd, &nname, &ss, count, NULL);
83
84         close(fd);
85         return status;
86 }
87
88 static struct sockaddr_storage *lookup_byname_backend(const char *name,
89                                         int *count)
90 {
91         int fd;
92         struct ip_service *ret = NULL;
93         struct sockaddr_storage *return_ss = NULL;
94         int j, i, flags = 0;
95
96         *count = 0;
97
98         /* always try with wins first */
99         if (NT_STATUS_IS_OK(resolve_wins(name,0x20,&ret,count))) {
100                 if ( *count == 0 )
101                         return NULL;
102                 if ( (return_ss = SMB_MALLOC_ARRAY(struct sockaddr_storage, *count)) == NULL ) {
103                         free( ret );
104                         return NULL;
105                 }
106
107                 /* copy the IP addresses */
108                 for ( i=0; i<(*count); i++ )
109                         return_ss[i] = ret[i].ss;
110
111                 free( ret );
112                 return return_ss;
113         }
114
115         fd = wins_lookup_open_socket_in();
116         if (fd == -1) {
117                 return NULL;
118         }
119
120         /* uggh, we have to broadcast to each interface in turn */
121         for (j=iface_count() - 1;
122              j >= 0;
123              j--) {
124                 const struct sockaddr_storage *bcast_ss = iface_n_bcast(j);
125                 if (!bcast_ss) {
126                         continue;
127                 }
128                 return_ss = name_query(fd,name,0x20,True,True,bcast_ss,count, &flags, NULL);
129                 if (return_ss) {
130                         break;
131                 }
132         }
133
134         close(fd);
135         return return_ss;
136 }
137
138 /* Get hostname from IP  */
139
140 void winbindd_wins_byip(struct winbindd_cli_state *state)
141 {
142         fstring response;
143         int i, count, maxlen, size;
144         NODE_STATUS_STRUCT *status;
145
146         /* Ensure null termination */
147         state->request.data.winsreq[sizeof(state->request.data.winsreq)-1]='\0';
148
149         DEBUG(3, ("[%5lu]: wins_byip %s\n", (unsigned long)state->pid,
150                 state->request.data.winsreq));
151
152         *response = '\0';
153         maxlen = sizeof(response) - 1;
154
155         if ((status = lookup_byaddr_backend(state->request.data.winsreq, &count))){
156             size = strlen(state->request.data.winsreq);
157             if (size > maxlen) {
158                 SAFE_FREE(status);
159                 request_error(state);
160                 return;
161             }
162             fstrcat(response,state->request.data.winsreq);
163             fstrcat(response,"\t");
164             for (i = 0; i < count; i++) {
165                 /* ignore group names */
166                 if (status[i].flags & 0x80) continue;
167                 if (status[i].type == 0x20) {
168                         size = sizeof(status[i].name) + strlen(response);
169                         if (size > maxlen) {
170                             SAFE_FREE(status);
171                             request_error(state);
172                             return;
173                         }
174                         fstrcat(response, status[i].name);
175                         fstrcat(response, " ");
176                 }
177             }
178             /* make last character a newline */
179             response[strlen(response)-1] = '\n';
180             SAFE_FREE(status);
181         }
182         fstrcpy(state->response.data.winsresp,response);
183         request_ok(state);
184 }
185
186 /* Get IP from hostname */
187
188 void winbindd_wins_byname(struct winbindd_cli_state *state)
189 {
190         struct sockaddr_storage *ip_list = NULL;
191         int i, count, maxlen, size;
192         fstring response;
193         char addr[INET6_ADDRSTRLEN];
194
195         /* Ensure null termination */
196         state->request.data.winsreq[sizeof(state->request.data.winsreq)-1]='\0';
197
198         DEBUG(3, ("[%5lu]: wins_byname %s\n", (unsigned long)state->pid,
199                 state->request.data.winsreq));
200
201         *response = '\0';
202         maxlen = sizeof(response) - 1;
203
204         if ((ip_list = lookup_byname_backend(state->request.data.winsreq,&count))){
205                 for (i = count; i ; i--) {
206                         print_sockaddr(addr, sizeof(addr), &ip_list[i-1]);
207                         size = strlen(addr);
208                         if (size > maxlen) {
209                                 SAFE_FREE(ip_list);
210                                 request_error(state);
211                                 return;
212                         }
213                         if (i != 0) {
214                                 /* Clear out the newline character */
215                                 /* But only if there is something in there,
216                                 otherwise we clobber something in the stack */
217                                 if (strlen(response)) {
218                                         response[strlen(response)-1] = ' ';
219                                 }
220                         }
221                         fstrcat(response,addr);
222                         fstrcat(response,"\t");
223                 }
224                 size = strlen(state->request.data.winsreq) + strlen(response);
225                 if (size > maxlen) {
226                     SAFE_FREE(ip_list);
227                     request_error(state);
228                     return;
229                 }
230                 fstrcat(response,state->request.data.winsreq);
231                 fstrcat(response,"\n");
232                 SAFE_FREE(ip_list);
233         } else {
234                 request_error(state);
235                 return;
236         }
237
238         fstrcpy(state->response.data.winsresp,response);
239
240         request_ok(state);
241 }