an, awi, cue and kue don't use the miibus interface.
[dragonfly.git] / contrib / smbfs / lib / smb / nbns_rq.c
1 /*
2  * Copyright (c) 2000, Boris Popov
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  * 3. All advertising materials mentioning features or use of this software
14  *    must display the following acknowledgement:
15  *    This product includes software developed by Boris Popov.
16  * 4. Neither the name of the author nor the names of any co-contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * $Id: nbns_rq.c,v 1.5 2001/02/17 03:07:24 bp Exp $
33  */
34 #include <sys/param.h>
35 #include <sys/socket.h>
36 #include <sys/time.h>
37
38 #include <ctype.h>
39 #include <netdb.h>
40 #include <err.h>
41 #include <errno.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <stdio.h>
45 #include <unistd.h>
46
47 #define NB_NEEDRESOLVER
48 #include <netsmb/netbios.h>
49 #include <netsmb/smb_lib.h>
50 #include <netsmb/nb_lib.h>
51
52
53 static int  nbns_rq_create(int opcode, struct nb_ctx *ctx, struct nbns_rq **rqpp);
54 static void nbns_rq_done(struct nbns_rq *rqp);
55 static int  nbns_rq_getrr(struct nbns_rq *rqp, struct nbns_rr *rrp);
56 static int  nbns_rq_prepare(struct nbns_rq *rqp);
57 static int  nbns_rq(struct nbns_rq *rqp);
58
59 static struct nb_ifdesc *nb_iflist;
60
61 int
62 nbns_resolvename(const char *name, struct nb_ctx *ctx, struct sockaddr **adpp)
63 {
64         struct nbns_rq *rqp;
65         struct nb_name nn;
66         struct nbns_rr rr;
67         struct sockaddr_in *dest;
68         int error, rdrcount, len;
69
70         if (strlen(name) > NB_NAMELEN)
71                 return NBERROR(NBERR_NAMETOOLONG);
72         error = nbns_rq_create(NBNS_OPCODE_QUERY, ctx, &rqp);
73         if (error)
74                 return error;
75         bzero(&nn, sizeof(nn));
76         strcpy(nn.nn_name, name);
77         nn.nn_scope = ctx->nb_scope;
78         nn.nn_type = NBT_SERVER;
79         rqp->nr_nmflags = NBNS_NMFLAG_RD;
80         rqp->nr_qdname = &nn;
81         rqp->nr_qdtype = NBNS_QUESTION_TYPE_NB;
82         rqp->nr_qdclass = NBNS_QUESTION_CLASS_IN;
83         rqp->nr_qdcount = 1;
84         dest = &rqp->nr_dest;
85         *dest = ctx->nb_ns;
86         dest->sin_family = AF_INET;
87         dest->sin_len = sizeof(*dest);
88         if (dest->sin_port == 0)
89                 dest->sin_port = htons(137);
90         if (dest->sin_addr.s_addr == INADDR_ANY)
91                 dest->sin_addr.s_addr = htonl(INADDR_BROADCAST);
92         if (dest->sin_addr.s_addr == INADDR_BROADCAST)
93                 rqp->nr_flags |= NBRQF_BROADCAST;
94         error = nbns_rq_prepare(rqp);
95         if (error) {
96                 nbns_rq_done(rqp);
97                 return error;
98         }
99         rdrcount = NBNS_MAXREDIRECTS;
100         for (;;) {
101                 error = nbns_rq(rqp);
102                 if (error)
103                         break;
104                 if ((rqp->nr_rpnmflags & NBNS_NMFLAG_AA) == 0) {
105                         if (rdrcount-- == 0) {
106                                 error = NBERROR(NBERR_TOOMANYREDIRECTS);
107                                 break;
108                         }
109                         error = nbns_rq_getrr(rqp, &rr);
110                         if (error)
111                                 break;
112                         error = nbns_rq_getrr(rqp, &rr);
113                         if (error)
114                                 break;
115                         bcopy(rr.rr_data, &dest->sin_addr, 4);
116                         rqp->nr_flags &= ~NBRQF_BROADCAST;
117                         continue;
118                 }
119                 if (rqp->nr_rpancount == 0) {
120                         error = NBERROR(NBERR_HOSTNOTFOUND);
121                         break;
122                 }
123                 error = nbns_rq_getrr(rqp, &rr);
124                 if (error)
125                         break;
126                 len = sizeof(struct sockaddr_in);
127                 dest = malloc(len);
128                 if (dest == NULL)
129                         return ENOMEM;
130                 bzero(dest, len);
131                 dest->sin_len = len;
132                 dest->sin_family = AF_INET;
133                 bcopy(rr.rr_data + 2, &dest->sin_addr.s_addr, 4);
134                 dest->sin_port = htons(SMB_TCP_PORT);
135                 *adpp = (struct sockaddr*)dest;
136                 ctx->nb_lastns = rqp->nr_sender;
137                 break;
138         }
139         nbns_rq_done(rqp);
140         return error;
141 }
142
143 int
144 nbns_rq_create(int opcode, struct nb_ctx *ctx, struct nbns_rq **rqpp)
145 {
146         struct nbns_rq *rqp;
147         static u_int16_t trnid;
148         int error;
149
150         rqp = malloc(sizeof(*rqp));
151         if (rqp == NULL)
152                 return ENOMEM;
153         bzero(rqp, sizeof(*rqp));
154         error = mb_init(&rqp->nr_rq, NBDG_MAXSIZE);
155         if (error) {
156                 free(rqp);
157                 return error;
158         }
159         rqp->nr_opcode = opcode;
160         rqp->nr_nbd = ctx;
161         rqp->nr_trnid = trnid++;
162         *rqpp = rqp;
163         return 0;
164 }
165
166 void
167 nbns_rq_done(struct nbns_rq *rqp)
168 {
169         if (rqp == NULL)
170                 return;
171         if (rqp->nr_fd >= 0)
172                 close(rqp->nr_fd);
173         mb_done(&rqp->nr_rq);
174         mb_done(&rqp->nr_rp);
175         free(rqp);
176 }
177
178 /*
179  * Extract resource record from the packet. Assume that there is only
180  * one mbuf.
181  */
182 int
183 nbns_rq_getrr(struct nbns_rq *rqp, struct nbns_rr *rrp)
184 {
185         struct mbdata *mbp = &rqp->nr_rp;
186         u_char *cp;
187         int error, len;
188
189         bzero(rrp, sizeof(*rrp));
190         cp = mbp->mb_pos;
191         len = nb_encname_len(cp);
192         if (len < 1)
193                 return NBERROR(NBERR_INVALIDRESPONSE);
194         rrp->rr_name = cp;
195         error = mb_get_mem(mbp, NULL, len);
196         if (error)
197                 return error;
198         mb_get_uint16be(mbp, &rrp->rr_type);
199         mb_get_uint16be(mbp, &rrp->rr_class);
200         mb_get_uint32be(mbp, &rrp->rr_ttl);
201         mb_get_uint16be(mbp, &rrp->rr_rdlength);
202         rrp->rr_data = mbp->mb_pos;
203         error = mb_get_mem(mbp, NULL, rrp->rr_rdlength);
204         return error;
205 }
206
207 int
208 nbns_rq_prepare(struct nbns_rq *rqp)
209 {
210         struct nb_ctx *ctx = rqp->nr_nbd;
211         struct mbdata *mbp = &rqp->nr_rq;
212         u_int8_t nmflags;
213         u_char *cp;
214         int len, error;
215
216         error = mb_init(&rqp->nr_rp, NBDG_MAXSIZE);
217         if (error)
218                 return error;
219         if (rqp->nr_dest.sin_addr.s_addr == INADDR_BROADCAST) {
220                 rqp->nr_nmflags |= NBNS_NMFLAG_BCAST;
221                 if (nb_iflist == NULL) {
222                         error = nb_enum_if(&nb_iflist, 100);
223                         if (error)
224                                 return error;
225                 }
226         } else
227                 rqp->nr_nmflags &= ~NBNS_NMFLAG_BCAST;
228         mb_put_uint16be(mbp, rqp->nr_trnid);
229         nmflags = ((rqp->nr_opcode & 0x1F) << 3) | ((rqp->nr_nmflags & 0x70) >> 4);
230         mb_put_uint8(mbp, nmflags);
231         mb_put_uint8(mbp, (rqp->nr_nmflags & 0x0f) << 4 /* rcode */);
232         mb_put_uint16be(mbp, rqp->nr_qdcount);
233         mb_put_uint16be(mbp, rqp->nr_ancount);
234         mb_put_uint16be(mbp, rqp->nr_nscount);
235         mb_put_uint16be(mbp, rqp->nr_arcount);
236         if (rqp->nr_qdcount) {
237                 if (rqp->nr_qdcount > 1)
238                         return EINVAL;
239                 len = nb_name_len(rqp->nr_qdname);
240                 error = mb_fit(mbp, len, (char**)&cp);
241                 if (error)
242                         return error;
243                 nb_name_encode(rqp->nr_qdname, cp);
244                 mb_put_uint16be(mbp, rqp->nr_qdtype);
245                 mb_put_uint16be(mbp, rqp->nr_qdclass);
246         }
247         m_lineup(mbp->mb_top, &mbp->mb_top);
248         if (ctx->nb_timo == 0)
249                 ctx->nb_timo = 1;       /* by default 1 second */
250         return 0;
251 }
252
253 static int
254 nbns_rq_recv(struct nbns_rq *rqp)
255 {
256         struct mbdata *mbp = &rqp->nr_rp;
257         void *rpdata = mtod(mbp->mb_top, void *);
258         fd_set rd, wr, ex;
259         struct timeval tv;
260         struct sockaddr_in sender;
261         int s = rqp->nr_fd;
262         int n, len;
263
264         FD_ZERO(&rd);
265         FD_ZERO(&wr);
266         FD_ZERO(&ex);
267         FD_SET(s, &rd);
268
269         tv.tv_sec = rqp->nr_nbd->nb_timo;
270         tv.tv_usec = 0;
271
272         n = select(s + 1, &rd, &wr, &ex, &tv);
273         if (n == -1)
274                 return -1;
275         if (n == 0)
276                 return ETIMEDOUT;
277         if (FD_ISSET(s, &rd) == 0)
278                 return ETIMEDOUT;
279         len = sizeof(sender);
280         n = recvfrom(s, rpdata, mbp->mb_top->m_maxlen, 0,
281             (struct sockaddr*)&sender, &len);
282         if (n < 0)
283                 return errno;
284         mbp->mb_top->m_len = mbp->mb_count = n;
285         rqp->nr_sender = sender;
286         return 0;
287 }
288
289 static int
290 nbns_rq_opensocket(struct nbns_rq *rqp)
291 {
292         struct sockaddr_in locaddr;
293         int opt, s;
294
295         s = rqp->nr_fd = socket(AF_INET, SOCK_DGRAM, 0);
296         if (s < 0)
297                 return errno;
298         if (rqp->nr_flags & NBRQF_BROADCAST) {
299                 opt = 1;
300                 if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(opt)) < 0)
301                         return errno;
302                 if (rqp->nr_if == NULL)
303                         return NBERROR(NBERR_NOBCASTIFS);
304                 bzero(&locaddr, sizeof(locaddr));
305                 locaddr.sin_family = AF_INET;
306                 locaddr.sin_len = sizeof(locaddr);
307                 locaddr.sin_addr = rqp->nr_if->id_addr;
308                 rqp->nr_dest.sin_addr.s_addr = rqp->nr_if->id_addr.s_addr | ~rqp->nr_if->id_mask.s_addr;
309                 if (bind(s, (struct sockaddr*)&locaddr, sizeof(locaddr)) < 0)
310                         return errno;
311         }
312         return 0;
313 }
314
315 static int
316 nbns_rq_send(struct nbns_rq *rqp)
317 {
318         struct mbdata *mbp = &rqp->nr_rq;
319         int s = rqp->nr_fd;
320
321         if (sendto(s, mtod(mbp->mb_top, char *), mbp->mb_count, 0,
322               (struct sockaddr*)&rqp->nr_dest, sizeof(rqp->nr_dest)) < 0)
323                 return errno;
324         return 0;
325 }
326
327 int
328 nbns_rq(struct nbns_rq *rqp)
329 {
330         struct mbdata *mbp = &rqp->nr_rq;
331         u_int16_t rpid;
332         u_int8_t nmflags;
333         int error, retrycount;
334
335         rqp->nr_if = nb_iflist;
336 again:
337         error = nbns_rq_opensocket(rqp);
338         if (error)
339                 return error;
340         retrycount = 3; /* XXX - configurable */
341         for (;;) {
342                 error = nbns_rq_send(rqp);
343                 if (error)
344                         return error;
345                 error = nbns_rq_recv(rqp);
346                 if (error) {
347                         if (error != ETIMEDOUT || retrycount == 0) {
348                                 if ((rqp->nr_nmflags & NBNS_NMFLAG_BCAST) &&
349                                     rqp->nr_if != NULL &&
350                                     rqp->nr_if->id_next != NULL) {
351                                         rqp->nr_if = rqp->nr_if->id_next;
352                                         close(rqp->nr_fd);
353                                         goto again;
354                                 } else
355                                         return error;
356                         }
357                         retrycount--;
358                         continue;
359                 }
360                 mbp = &rqp->nr_rp;
361                 if (mbp->mb_count < 12)
362                         return NBERROR(NBERR_INVALIDRESPONSE);
363                 mb_get_uint16be(mbp, &rpid);
364                 if (rpid != rqp->nr_trnid)
365                         return NBERROR(NBERR_INVALIDRESPONSE);
366                 break;
367         }
368         mb_get_uint8(mbp, &nmflags);
369         rqp->nr_rpnmflags = (nmflags & 7) << 4;
370         mb_get_uint8(mbp, &nmflags);
371         rqp->nr_rpnmflags |= (nmflags & 0xf0) >> 4;
372         rqp->nr_rprcode = nmflags & 0xf;
373         if (rqp->nr_rprcode)
374                 return NBERROR(rqp->nr_rprcode);
375         mb_get_uint16be(mbp, &rpid);    /* QDCOUNT */
376         mb_get_uint16be(mbp, &rqp->nr_rpancount);
377         mb_get_uint16be(mbp, &rqp->nr_rpnscount);
378         mb_get_uint16be(mbp, &rqp->nr_rparcount);
379         return 0;
380 }