1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
26 */
27
28 /*
29 * Functions to setup connections (TCP and/or NetBIOS)
30 * This has the fall-back logic for IP6, IP4, NBT
31 */
32
33 #include <errno.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <strings.h>
37 #include <stdlib.h>
38 #include <unistd.h>
39 #include <netdb.h>
40 #include <libintl.h>
41 #include <xti.h>
42 #include <assert.h>
43
44 #include <sys/types.h>
45 #include <sys/time.h>
46 #include <sys/byteorder.h>
47 #include <sys/socket.h>
48 #include <sys/fcntl.h>
49
50 #include <netinet/in.h>
51 #include <netinet/tcp.h>
52 #include <arpa/inet.h>
53
54 #include <netsmb/smb.h>
55 #include <netsmb/smb_lib.h>
56 #include <netsmb/netbios.h>
57 #include <netsmb/nb_lib.h>
58 #include <netsmb/smb_dev.h>
59
60 #include "charsets.h"
61 #include "private.h"
62
63 /*
64 * SMB messages are up to 64K.
65 * Let's leave room for two.
66 */
67 static int smb_tcpsndbuf = 0x20000;
68 static int smb_tcprcvbuf = 0x20000;
69 static int smb_connect_timeout = 30; /* seconds */
70 int smb_recv_timeout = 30; /* seconds */
71
72 int conn_tcp6(struct smb_ctx *, const struct sockaddr *, int);
73 int conn_tcp4(struct smb_ctx *, const struct sockaddr *, int);
74 int conn_nbt(struct smb_ctx *, const struct sockaddr *, char *);
75
76 /*
77 * Internal set sockopt for int-sized options.
78 * Borrowed from: libnsl/rpc/ti_opts.c
79 */
80 static int
81 smb_setopt_int(int fd, int level, int name, int val)
82 {
83 struct t_optmgmt oreq, ores;
84 struct {
85 struct t_opthdr oh;
86 int ival;
87 } opts;
88
89 /* opt header */
90 opts.oh.len = sizeof (opts);
91 opts.oh.level = level;
92 opts.oh.name = name;
93 opts.oh.status = 0;
94 opts.ival = val;
95
96 oreq.flags = T_NEGOTIATE;
97 oreq.opt.buf = (void *)&opts;
98 oreq.opt.len = sizeof (opts);
99
100 ores.flags = 0;
101 ores.opt.buf = NULL;
102 ores.opt.maxlen = 0;
103
104 if (t_optmgmt(fd, &oreq, &ores) < 0) {
105 DPRINT("t_opgmgnt, t_errno = %d", t_errno);
106 if (t_errno == TSYSERR)
107 return (errno);
108 return (EPROTO);
109 }
110 if (ores.flags != T_SUCCESS) {
111 DPRINT("flags 0x%x, status 0x%x",
112 (int)ores.flags, (int)opts.oh.status);
113 return (EPROTO);
114 }
115
116 return (0);
117 }
118
119 static int
120 smb_setopts(int fd)
121 {
122 int err;
123
124 /*
125 * Set various socket/TCP options.
126 * Failures here are not fatal -
127 * just log a complaint.
128 *
129 * We don't need these two:
130 * SO_RCVTIMEO, SO_SNDTIMEO
131 */
132
133 err = smb_setopt_int(fd, SOL_SOCKET, SO_SNDBUF, smb_tcpsndbuf);
134 if (err) {
135 DPRINT("set SO_SNDBUF, err %d", err);
136 }
137
138 err = smb_setopt_int(fd, SOL_SOCKET, SO_RCVBUF, smb_tcprcvbuf);
139 if (err) {
140 DPRINT("set SO_RCVBUF, err %d", err);
141 }
142
143 err = smb_setopt_int(fd, SOL_SOCKET, SO_KEEPALIVE, 1);
144 if (err) {
145 DPRINT("set SO_KEEPALIVE, err %d", err);
146 }
147
148 err = smb_setopt_int(fd, IPPROTO_TCP, TCP_NODELAY, 1);
149 if (err) {
150 DPRINT("set TCP_NODELAY, err %d", err);
151 }
152
153 /* Set the connect timeout (in milliseconds). */
154 err = smb_setopt_int(fd, IPPROTO_TCP,
155 TCP_CONN_ABORT_THRESHOLD,
156 smb_connect_timeout * 1000);
157 if (err) {
158 DPRINT("set connect timeout, err %d", err);
159 }
160 return (0);
161 }
162
163
164 int
165 conn_tcp6(struct smb_ctx *ctx, const struct sockaddr *sa, int port)
166 {
167 struct sockaddr_in6 sin6;
168 char *dev = "/dev/tcp6";
169 char paddrbuf[INET6_ADDRSTRLEN];
170 struct t_call sndcall;
171 int fd, err;
172
173 if (sa->sa_family != AF_INET6) {
174 DPRINT("bad af %d", sa->sa_family);
175 return (EINVAL);
176 }
177 bcopy(sa, &sin6, sizeof (sin6));
178 sin6.sin6_port = htons(port);
179
180 DPRINT("tcp6: %s (%d)",
181 inet_ntop(AF_INET6, &sin6.sin6_addr,
182 paddrbuf, sizeof (paddrbuf)), port);
183
184 fd = t_open(dev, O_RDWR, NULL);
185 if (fd < 0) {
186 /* Assume t_errno = TSYSERR */
187 err = errno;
188 perror(dev);
189 return (err);
190 }
191 if ((err = smb_setopts(fd)) != 0)
192 goto errout;
193 if (t_bind(fd, NULL, NULL) < 0) {
194 DPRINT("t_bind t_errno %d", t_errno);
195 if (t_errno == TSYSERR)
196 err = errno;
197 else
198 err = EPROTO;
199 goto errout;
200 }
201 sndcall.addr.maxlen = sizeof (sin6);
202 sndcall.addr.len = sizeof (sin6);
203 sndcall.addr.buf = (void *) &sin6;
204 sndcall.opt.len = 0;
205 sndcall.udata.len = 0;
206 if (t_connect(fd, &sndcall, NULL) < 0) {
207 err = get_xti_err(fd);
208 DPRINT("connect, err %d", err);
209 goto errout;
210 }
211
212 DPRINT("tcp6: connected, fd=%d", fd);
213 ctx->ct_tran_fd = fd;
214 return (0);
215
216 errout:
217 close(fd);
218 return (err);
219 }
220
221 /*
222 * This is used for both SMB over TCP (port 445)
223 * and NetBIOS - see conn_nbt().
224 */
225 int
226 conn_tcp4(struct smb_ctx *ctx, const struct sockaddr *sa, int port)
227 {
228 struct sockaddr_in sin;
229 char *dev = "/dev/tcp";
230 char paddrbuf[INET_ADDRSTRLEN];
231 struct t_call sndcall;
232 int fd, err;
233
234 if (sa->sa_family != AF_INET) {
235 DPRINT("bad af %d", sa->sa_family);
236 return (EINVAL);
237 }
238 bcopy(sa, &sin, sizeof (sin));
239 sin.sin_port = htons(port);
240
241 DPRINT("tcp4: %s (%d)",
242 inet_ntop(AF_INET, &sin.sin_addr,
243 paddrbuf, sizeof (paddrbuf)), port);
244
245 fd = t_open(dev, O_RDWR, NULL);
246 if (fd < 0) {
247 /* Assume t_errno = TSYSERR */
248 err = errno;
249 perror(dev);
250 return (err);
251 }
252 if ((err = smb_setopts(fd)) != 0)
253 goto errout;
254 if (t_bind(fd, NULL, NULL) < 0) {
255 DPRINT("t_bind t_errno %d", t_errno);
256 if (t_errno == TSYSERR)
257 err = errno;
258 else
259 err = EPROTO;
260 goto errout;
261 }
262 sndcall.addr.maxlen = sizeof (sin);
263 sndcall.addr.len = sizeof (sin);
264 sndcall.addr.buf = (void *) &sin;
265 sndcall.opt.len = 0;
266 sndcall.udata.len = 0;
267 if (t_connect(fd, &sndcall, NULL) < 0) {
268 err = get_xti_err(fd);
269 DPRINT("connect, err %d", err);
270 goto errout;
271 }
272
273 DPRINT("tcp4: connected, fd=%d", fd);
274 ctx->ct_tran_fd = fd;
275 return (0);
276
277 errout:
278 close(fd);
279 return (err);
280 }
281
282 /*
283 * Open a NetBIOS connection (session, port 139)
284 *
285 * The optional name parameter, if passed, means
286 * we found the sockaddr via NetBIOS name lookup,
287 * and can just use that for our session request.
288 * Otherwise (if name is NULL), we're connecting
289 * by IP address, and need to come up with the
290 * NetBIOS name by other means.
291 */
292 int
293 conn_nbt(struct smb_ctx *ctx, const struct sockaddr *saarg, char *name)
294 {
295 struct sockaddr_in sin;
296 struct sockaddr *sa;
297 char server[NB_NAMELEN];
298 char workgroup[NB_NAMELEN];
299 int err, nberr, port;
300
301 bcopy(saarg, &sin, sizeof (sin));
302 sa = (struct sockaddr *)&sin;
303
304 switch (sin.sin_family) {
305 case AF_NETBIOS: /* our fake AF */
306 sin.sin_family = AF_INET;
307 break;
308 case AF_INET:
309 break;
310 default:
311 DPRINT("bad af %d", sin.sin_family);
312 return (EINVAL);
313 }
314 port = IPPORT_NETBIOS_SSN;
315
316 /*
317 * If we have a NetBIOS name, just use it.
318 * This is the path taken when we've done a
319 * NetBIOS name lookup on this name to get
320 * the IP address in the passed sa. Otherwise,
321 * we're connecting by IP address, and need to
322 * figure out what NetBIOS name to use.
323 */
324 if (name) {
325 strlcpy(server, name, sizeof (server));
326 DPRINT("given name: %s", server);
327 } else {
328 /*
329 *
330 * Try a NetBIOS node status query,
331 * which searches for a type=[20] name.
332 * If that doesn't work, just use the
333 * (fake) "*SMBSERVER" name.
334 */
335 DPRINT("try node status");
336 server[0] = '\0';
337 nberr = nbns_getnodestatus(ctx->ct_nb,
338 &sin.sin_addr, server, workgroup);
339 if (nberr == 0 && server[0] != '\0') {
340 /* Found the name. Save for reconnect. */
341 DPRINT("found name: %s", server);
342 strlcpy(ctx->ct_srvname, server,
343 sizeof (ctx->ct_srvname));
344 } else {
345 DPRINT("getnodestatus, nberr %d", nberr);
346 strlcpy(server, "*SMBSERVER", sizeof (server));
347 }
348 }
349
350 /*
351 * Establish the TCP connection.
352 * Careful to close it on errors.
353 */
354 if ((err = conn_tcp4(ctx, sa, port)) != 0) {
355 DPRINT("TCP connect: err=%d", err);
356 goto out;
357 }
358
359 /* Connected. Do NetBIOS session request. */
360 err = nb_ssn_request(ctx, server);
361 if (err)
362 DPRINT("ssn_rq, err %d", err);
363
364 out:
365 if (err) {
366 if (ctx->ct_tran_fd != -1) {
367 close(ctx->ct_tran_fd);
368 ctx->ct_tran_fd = -1;
369 }
370 }
371 return (err);
372 }
373
374 /*
375 * Make a new connection, or reconnect.
376 */
377 int
378 smb_iod_connect(smb_ctx_t *ctx)
379 {
380 struct sockaddr *sa;
381 int err, err2;
382 struct mbdata blob;
383
384 memset(&blob, 0, sizeof (blob));
385
386 if (ctx->ct_srvname[0] == '\0') {
387 DPRINT("sername not set!");
388 return (EINVAL);
389 }
390 DPRINT("server: %s", ctx->ct_srvname);
391
392 if (smb_debug)
393 dump_ctx("smb_iod_connect", ctx);
394
395 /*
396 * This may be a reconnect, so
397 * cleanup if necessary.
398 */
399 if (ctx->ct_tran_fd != -1) {
400 close(ctx->ct_tran_fd);
401 ctx->ct_tran_fd = -1;
402 }
403
404 /*
405 * Get local machine name.
406 * Full name - not a NetBIOS name.
407 */
408 if (ctx->ct_locname == NULL) {
409 err = smb_getlocalname(&ctx->ct_locname);
410 if (err) {
411 smb_error(dgettext(TEXT_DOMAIN,
412 "can't get local name"), err);
413 return (err);
414 }
415 }
416
417 /*
418 * We're called with each IP address
419 * already copied into ct_srvaddr.
420 */
421 ctx->ct_flags |= SMBCF_RESOLVED;
422
423 sa = &ctx->ct_srvaddr.sa;
424 switch (sa->sa_family) {
425
426 case AF_INET6:
427 err = conn_tcp6(ctx, sa, IPPORT_SMB);
428 break;
429
430 case AF_INET:
431 err = conn_tcp4(ctx, sa, IPPORT_SMB);
432 /*
433 * If port 445 was not listening, try port 139.
434 * Note: Not doing NetBIOS name lookup here.
435 * We already have the IP address.
436 */
437 switch (err) {
438 case ECONNRESET:
439 case ECONNREFUSED:
440 err2 = conn_nbt(ctx, sa, NULL);
441 if (err2 == 0)
442 err = 0;
443 }
444 break;
445
446 case AF_NETBIOS:
447 /* Like AF_INET, but use NetBIOS ssn. */
448 err = conn_nbt(ctx, sa, ctx->ct_srvname);
449 break;
450
451 default:
452 DPRINT("skipped family %d", sa->sa_family);
453 err = EPROTONOSUPPORT;
454 break;
455 }
456
457
458 if (err) {
459 DPRINT("connect, err=%d", err);
460 return (err);
461 }
462
463 /*
464 * Do SMB Negotiate Protocol.
465 */
466 err = smb_negprot(ctx, &blob);
467 if (err)
468 goto out;
469
470 /*
471 * Empty user name means an explicit request for
472 * NULL session setup, which is a special case.
473 * If negotiate determined that we want to do
474 * SMB signing, we have to turn that off for a
475 * NULL session. [MS-SMB 3.3.5.3].
476 */
477 if (ctx->ct_user[0] == '\0') {
478 /* Null user should have null domain too. */
479 ctx->ct_domain[0] = '\0';
480 ctx->ct_authflags = SMB_AT_ANON;
481 ctx->ct_clnt_caps &= ~SMB_CAP_EXT_SECURITY;
482 ctx->ct_vcflags &= ~SMBV_WILL_SIGN;
483 }
484
485 /*
486 * Do SMB Session Setup (authenticate)
487 *
488 * If the server negotiated extended security,
489 * run the SPNEGO state machine, otherwise do
490 * one of the old-style variants.
491 */
492 if (ctx->ct_clnt_caps & SMB_CAP_EXT_SECURITY) {
493 err = smb_ssnsetup_spnego(ctx, &blob);
494 } else {
495 /*
496 * Server did NOT negotiate extended security.
497 * Try NTLMv2, NTLMv1, or ANON (if enabled).
498 */
499 if (ctx->ct_authflags & SMB_AT_NTLM2) {
500 err = smb_ssnsetup_ntlm2(ctx);
501 } else if (ctx->ct_authflags & SMB_AT_NTLM1) {
502 err = smb_ssnsetup_ntlm1(ctx);
503 } else if (ctx->ct_authflags & SMB_AT_ANON) {
504 err = smb_ssnsetup_null(ctx);
505 } else {
506 /*
507 * Don't return EAUTH, because a new
508 * password prompt will not help.
509 */
510 DPRINT("No NTLM authflags");
511 err = ENOTSUP;
512 }
513 }
514
515 out:
516 mb_done(&blob);
517
518 if (err) {
519 close(ctx->ct_tran_fd);
520 ctx->ct_tran_fd = -1;
521 } else {
522 /* Tell library code we have a session. */
523 ctx->ct_flags |= SMBCF_SSNACTIVE;
524 DPRINT("tran_fd = %d", ctx->ct_tran_fd);
525 }
526
527 return (err);
528 }