source: branches/samba-3.0/source/lib/util_sock.c

Last change on this file was 165, checked in by Paul Smedley, 16 years ago

Add 'missing' 3.0.34 diffs
File size: 36.3 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Tim Potter 2000-2001
6 Copyright (C) Jeremy Allison 1992-2005
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21*/
22
23#include "includes.h"
24
25/* the following 3 client_*() functions are nasty ways of allowing
26 some generic functions to get info that really should be hidden in
27 particular modules */
28static int client_fd = -1;
29/* What to print out on a client disconnect error. */
30static char client_ip_string[16];
31
32void client_setfd(int fd)
33{
34 client_fd = fd;
35 safe_strcpy(client_ip_string, get_peer_addr(client_fd), sizeof(client_ip_string)-1);
36}
37
38static char *get_socket_addr(int fd)
39{
40 struct sockaddr sa;
41 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
42 socklen_t length = sizeof(sa);
43 static fstring addr_buf;
44
45 fstrcpy(addr_buf,"0.0.0.0");
46
47 if (fd == -1) {
48 return addr_buf;
49 }
50
51 if (getsockname(fd, &sa, &length) < 0) {
52 DEBUG(0,("getsockname failed. Error was %s\n", strerror(errno) ));
53 return addr_buf;
54 }
55
56 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
57
58 return addr_buf;
59}
60
61static int get_socket_port(int fd)
62{
63 struct sockaddr sa;
64 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
65 socklen_t length = sizeof(sa);
66
67 if (fd == -1)
68 return -1;
69
70 if (getsockname(fd, &sa, &length) < 0) {
71 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
72 return -1;
73 }
74
75 return ntohs(sockin->sin_port);
76}
77
78char *client_name(void)
79{
80 return get_peer_name(client_fd,False);
81}
82
83char *client_addr(void)
84{
85 return get_peer_addr(client_fd);
86}
87
88char *client_socket_addr(void)
89{
90 return get_socket_addr(client_fd);
91}
92
93int client_socket_port(void)
94{
95 return get_socket_port(client_fd);
96}
97
98struct in_addr *client_inaddr(struct sockaddr *sa)
99{
100 struct sockaddr_in *sockin = (struct sockaddr_in *) (sa);
101 socklen_t length = sizeof(*sa);
102
103 if (getpeername(client_fd, sa, &length) < 0) {
104 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
105 return NULL;
106 }
107
108 return &sockin->sin_addr;
109}
110
111/* the last IP received from */
112struct in_addr lastip;
113
114/* the last port received from */
115int lastport=0;
116
117int smb_read_error = 0;
118
119/****************************************************************************
120 Determine if a file descriptor is in fact a socket.
121****************************************************************************/
122
123BOOL is_a_socket(int fd)
124{
125 int v;
126 socklen_t l;
127 l = sizeof(int);
128 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
129}
130
131enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
132
133typedef struct smb_socket_option {
134 const char *name;
135 int level;
136 int option;
137 int value;
138 int opttype;
139} smb_socket_option;
140
141static const smb_socket_option socket_options[] = {
142 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
143 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
144 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
145#ifdef TCP_NODELAY
146 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
147#endif
148#ifdef TCP_KEEPCNT
149 {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
150#endif
151#ifdef TCP_KEEPIDLE
152 {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
153#endif
154#ifdef TCP_KEEPINTVL
155 {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
156#endif
157#ifdef IPTOS_LOWDELAY
158 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
159#endif
160#ifdef IPTOS_THROUGHPUT
161 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
162#endif
163#ifdef SO_REUSEPORT
164 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
165#endif
166#ifdef SO_SNDBUF
167 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
168#endif
169#ifdef SO_RCVBUF
170 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
171#endif
172#ifdef SO_SNDLOWAT
173 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
174#endif
175#ifdef SO_RCVLOWAT
176 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
177#endif
178#ifdef SO_SNDTIMEO
179 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
180#endif
181#ifdef SO_RCVTIMEO
182 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
183#endif
184#ifdef TCP_FASTACK
185 {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
186#endif
187 {NULL,0,0,0,0}};
188
189/****************************************************************************
190 Print socket options.
191****************************************************************************/
192
193static void print_socket_options(int s)
194{
195 int value;
196 socklen_t vlen = 4;
197 const smb_socket_option *p = &socket_options[0];
198
199 /* wrapped in if statement to prevent streams leak in SCO Openserver 5.0 */
200 /* reported on samba-technical --jerry */
201 if ( DEBUGLEVEL >= 5 ) {
202 for (; p->name != NULL; p++) {
203 if (getsockopt(s, p->level, p->option, (void *)&value, &vlen) == -1) {
204 DEBUG(5,("Could not test socket option %s.\n", p->name));
205 } else {
206 DEBUG(5,("socket option %s = %d\n",p->name,value));
207 }
208 }
209 }
210 }
211
212/****************************************************************************
213 Set user socket options.
214****************************************************************************/
215
216void set_socket_options(int fd, const char *options)
217{
218 fstring tok;
219
220 while (next_token(&options,tok," \t,", sizeof(tok))) {
221 int ret=0,i;
222 int value = 1;
223 char *p;
224 BOOL got_value = False;
225
226 if ((p = strchr_m(tok,'='))) {
227 *p = 0;
228 value = atoi(p+1);
229 got_value = True;
230 }
231
232 for (i=0;socket_options[i].name;i++)
233 if (strequal(socket_options[i].name,tok))
234 break;
235
236 if (!socket_options[i].name) {
237 DEBUG(0,("Unknown socket option %s\n",tok));
238 continue;
239 }
240
241 switch (socket_options[i].opttype) {
242 case OPT_BOOL:
243 case OPT_INT:
244 ret = setsockopt(fd,socket_options[i].level,
245 socket_options[i].option,(char *)&value,sizeof(int));
246 break;
247
248 case OPT_ON:
249 if (got_value)
250 DEBUG(0,("syntax error - %s does not take a value\n",tok));
251
252 {
253 int on = socket_options[i].value;
254 ret = setsockopt(fd,socket_options[i].level,
255 socket_options[i].option,(char *)&on,sizeof(int));
256 }
257 break;
258 }
259
260 if (ret != 0)
261 DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
262 }
263
264 print_socket_options(fd);
265}
266
267/****************************************************************************
268 Read from a socket.
269****************************************************************************/
270
271ssize_t read_udp_socket(int fd,char *buf,size_t len)
272{
273 ssize_t ret;
274 struct sockaddr_in sock;
275 socklen_t socklen = sizeof(sock);
276
277 memset((char *)&sock,'\0',socklen);
278 memset((char *)&lastip,'\0',sizeof(lastip));
279 ret = (ssize_t)sys_recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
280 if (ret <= 0) {
281 /* Don't print a low debug error for a non-blocking socket. */
282 if (errno == EAGAIN) {
283 DEBUG(10,("read socket returned EAGAIN. ERRNO=%s\n",strerror(errno)));
284 } else {
285 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
286 }
287 return(0);
288 }
289
290 lastip = sock.sin_addr;
291 lastport = ntohs(sock.sin_port);
292
293 DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %lu\n",
294 inet_ntoa(lastip), lastport, (unsigned long)ret));
295
296 return(ret);
297}
298
299#if 0
300
301Socket routines from HEAD - maybe re-enable in future. JRA.
302
303/****************************************************************************
304 Work out if we've timed out.
305****************************************************************************/
306
307static BOOL timeout_until(struct timeval *timeout, const struct timeval *endtime)
308{
309 struct timeval now;
310 SMB_BIG_INT t_dif;
311
312 GetTimeOfDay(&now);
313
314 t_dif = usec_time_diff(endtime, &now);
315 if (t_dif <= 0) {
316 return False;
317 }
318
319 timeout->tv_sec = (t_dif / (SMB_BIG_INT)1000000);
320 timeout->tv_usec = (t_dif % (SMB_BIG_INT)1000000);
321 return True;
322}
323
324/****************************************************************************
325 Read data from the client, reading exactly N bytes, or until endtime timeout.
326 Use with a non-blocking socket if endtime != NULL.
327****************************************************************************/
328
329ssize_t read_data_until(int fd,char *buffer,size_t N, const struct timeval *endtime)
330{
331 ssize_t ret;
332 size_t total=0;
333
334#ifdef __OS2__
335 fd_set fds;
336#endif
337
338 smb_read_error = 0;
339#if __OS2__
340 while (total < N) {
341 FD_ZERO(&fds);
342 FD_SET(fd,&fds);
343
344 ret = sys_select_intr(fd+1,&fds,NULL,NULL,NULL);
345
346 /* Check if error */
347 if (ret == -1) {
348 /* something is wrong. Maybe the socket is dead? */
349 DEBUG(0,("read_socket_data: select error = %s.\n", strerror(errno) ));
350 smb_read_error = READ_ERROR;
351 return -1;
352 }
353
354 /* Did we timeout ? */
355 if (ret == 0) {
356 DEBUG(10,("read_socket_data: select timed out ??\n"));
357 smb_read_error = READ_TIMEOUT;
358 return -1;
359 }
360
361 ret = sys_read(fd,buffer + total,N - total);
362
363 if (ret == 0) {
364 DEBUG(10,("read_socket_data: recv of %d on %d returned 0. Error = %s\n", (int)(N - total), fd, strerror(errno) ));
365 smb_read_error = READ_EOF;
366 return 0;
367 }
368
369 if (ret == -1) {
370 DEBUG(0,("read_socket_data: recv failure for %d on %d. Error = %s\n", (int)(N - total), fd, strerror(errno) ));
371 smb_read_error = READ_ERROR;
372 return -1;
373 }
374 total += ret;
375 }
376#else
377 while (total < N) {
378
379 if (endtime != NULL) {
380 fd_set r_fds;
381 struct timeval timeout;
382 int selrtn;
383
384 if (!timeout_until(&timeout, endtime)) {
385 DEBUG(10,("read_data_until: read timed out\n"));
386 smb_read_error = READ_TIMEOUT;
387 return -1;
388 }
389
390 FD_ZERO(&r_fds);
391 FD_SET(fd, &r_fds);
392
393 /* Select but ignore EINTR. */
394 selrtn = sys_select_intr(fd+1, &r_fds, NULL, NULL, &timeout);
395 if (selrtn == -1) {
396 /* something is wrong. Maybe the socket is dead? */
397 DEBUG(0,("read_data_until: select error = %s.\n", strerror(errno) ));
398 smb_read_error = READ_ERROR;
399 return -1;
400 }
401
402 /* Did we timeout ? */
403 if (selrtn == 0) {
404 DEBUG(10,("read_data_until: select timed out.\n"));
405 smb_read_error = READ_TIMEOUT;
406 return -1;
407 }
408 }
409
410 ret = sys_read(fd,buffer + total,N - total);
411
412 if (ret == 0) {
413 DEBUG(10,("read_data_until: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
414 smb_read_error = READ_EOF;
415 return 0;
416 }
417
418 if (ret == -1) {
419 if (errno == EAGAIN) {
420 /* Non-blocking socket with no data available. Try select again. */
421 continue;
422 }
423 DEBUG(0,("read_data_until: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
424 smb_read_error = READ_ERROR;
425 return -1;
426 }
427 total += ret;
428 }
429#endif /* __OS2__ */
430 return (ssize_t)total;
431}
432#endif
433
434/****************************************************************************
435 Read data from a socket with a timout in msec.
436 mincount = if timeout, minimum to read before returning
437 maxcount = number to be read.
438 time_out = timeout in milliseconds
439****************************************************************************/
440
441ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
442{
443 fd_set fds;
444 int selrtn;
445 ssize_t readret;
446 size_t nread = 0;
447 struct timeval timeout;
448
449 /* just checking .... */
450 if (maxcnt <= 0)
451 return(0);
452
453 smb_read_error = 0;
454
455 /* Blocking read */
456 if (time_out == 0) {
457 if (mincnt == 0) {
458 mincnt = maxcnt;
459 }
460
461 while (nread < mincnt) {
462 readret = sys_read(fd, buf + nread, maxcnt - nread);
463
464 if (readret == 0) {
465 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
466 smb_read_error = READ_EOF;
467 return -1;
468 }
469
470 if (readret == -1) {
471 if (fd == client_fd) {
472 /* Try and give an error message saying what client failed. */
473 DEBUG(0,("read_socket_with_timeout: client %s read error = %s.\n",
474 client_ip_string, strerror(errno) ));
475 } else {
476 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
477 }
478 smb_read_error = READ_ERROR;
479 return -1;
480 }
481 nread += readret;
482 }
483 return((ssize_t)nread);
484 }
485
486 /* Most difficult - timeout read */
487 /* If this is ever called on a disk file and
488 mincnt is greater then the filesize then
489 system performance will suffer severely as
490 select always returns true on disk files */
491
492 /* Set initial timeout */
493 timeout.tv_sec = (time_t)(time_out / 1000);
494 timeout.tv_usec = (long)(1000 * (time_out % 1000));
495
496 for (nread=0; nread < mincnt; ) {
497 FD_ZERO(&fds);
498 FD_SET(fd,&fds);
499
500 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
501
502 /* Check if error */
503 if (selrtn == -1) {
504 /* something is wrong. Maybe the socket is dead? */
505 if (fd == client_fd) {
506 /* Try and give an error message saying what client failed. */
507 DEBUG(0,("read_socket_with_timeout: timeout read for client %s. select error = %s.\n",
508 client_ip_string, strerror(errno) ));
509 } else {
510 DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
511 }
512 smb_read_error = READ_ERROR;
513 return -1;
514 }
515
516 /* Did we timeout ? */
517 if (selrtn == 0) {
518 DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
519 smb_read_error = READ_TIMEOUT;
520 return -1;
521 }
522
523 readret = sys_read(fd, buf+nread, maxcnt-nread);
524
525 if (readret == 0) {
526 /* we got EOF on the file descriptor */
527 DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
528 smb_read_error = READ_EOF;
529 return -1;
530 }
531
532 if (readret == -1) {
533 /* the descriptor is probably dead */
534 if (fd == client_fd) {
535 /* Try and give an error message saying what client failed. */
536 DEBUG(0,("read_socket_with_timeout: timeout read to client %s. read error = %s.\n",
537 client_ip_string, strerror(errno) ));
538 } else {
539 DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
540 }
541 smb_read_error = READ_ERROR;
542 return -1;
543 }
544
545 nread += readret;
546 }
547
548 /* Return the number we got */
549 return (ssize_t)nread;
550}
551
552/****************************************************************************
553 Read data from the client, reading exactly N bytes.
554****************************************************************************/
555
556ssize_t read_data(int fd,char *buffer,size_t N)
557{
558 ssize_t ret;
559 size_t total=0;
560
561 smb_read_error = 0;
562
563 while (total < N) {
564 ret = sys_read(fd,buffer + total,N - total);
565
566 if (ret == 0) {
567 DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
568 smb_read_error = READ_EOF;
569 return 0;
570 }
571
572 if (ret == -1) {
573 if (fd == client_fd) {
574 /* Try and give an error message saying what client failed. */
575 DEBUG(0,("read_data: read failure for %d bytes to client %s. Error = %s\n",
576 (int)(N - total), client_ip_string, strerror(errno) ));
577 } else {
578 DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
579 }
580 smb_read_error = READ_ERROR;
581 return -1;
582 }
583 total += ret;
584 }
585 return (ssize_t)total;
586}
587
588/****************************************************************************
589 Write data to a fd.
590****************************************************************************/
591
592ssize_t write_data(int fd, const char *buffer, size_t N)
593{
594 size_t total=0;
595 ssize_t ret;
596
597 while (total < N) {
598 ret = sys_write(fd,buffer + total,N - total);
599
600 if (ret == -1) {
601 if (fd == client_fd) {
602 /* Try and give an error message saying what client failed. */
603 DEBUG(0,("write_data: write failure in writing to client %s. Error %s\n",
604 client_ip_string, strerror(errno) ));
605 } else {
606 DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
607 }
608 return -1;
609 }
610
611 if (ret == 0) {
612 return total;
613 }
614
615 total += ret;
616 }
617 return (ssize_t)total;
618}
619
620/****************************************************************************
621 Send a keepalive packet (rfc1002).
622****************************************************************************/
623
624BOOL send_keepalive(int client)
625{
626 unsigned char buf[4];
627
628 buf[0] = SMBkeepalive;
629 buf[1] = buf[2] = buf[3] = 0;
630
631 return(write_data(client,(char *)buf,4) == 4);
632}
633
634
635/****************************************************************************
636 Read 4 bytes of a smb packet and return the smb length of the packet.
637 Store the result in the buffer.
638 This version of the function will return a length of zero on receiving
639 a keepalive packet.
640 Timeout is in milliseconds.
641****************************************************************************/
642
643static ssize_t read_smb_length_return_keepalive(int fd, char *inbuf, unsigned int timeout)
644{
645 ssize_t len=0;
646 int msg_type;
647 BOOL ok = False;
648
649 while (!ok) {
650 if (timeout > 0)
651 ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
652 else
653 ok = (read_data(fd,inbuf,4) == 4);
654
655 if (!ok)
656 return(-1);
657
658 len = smb_len(inbuf);
659 msg_type = CVAL(inbuf,0);
660
661 if (msg_type == SMBkeepalive)
662 DEBUG(5,("Got keepalive packet\n"));
663 }
664
665 DEBUG(10,("got smb length of %lu\n",(unsigned long)len));
666
667 return(len);
668}
669
670/****************************************************************************
671 Read 4 bytes of a smb packet and return the smb length of the packet.
672 Store the result in the buffer. This version of the function will
673 never return a session keepalive (length of zero).
674 Timeout is in milliseconds.
675****************************************************************************/
676
677ssize_t read_smb_length(int fd, char *inbuf, unsigned int timeout)
678{
679 ssize_t len;
680
681 for(;;) {
682 len = read_smb_length_return_keepalive(fd, inbuf, timeout);
683
684 if(len < 0)
685 return len;
686
687 /* Ignore session keepalives. */
688 if(CVAL(inbuf,0) != SMBkeepalive)
689 break;
690 }
691
692 DEBUG(10,("read_smb_length: got smb length of %lu\n",
693 (unsigned long)len));
694
695 return len;
696}
697
698/****************************************************************************
699 Read an smb from a fd.
700 The timeout is in milliseconds.
701 This function will return on receipt of a session keepalive packet.
702 Doesn't check the MAC on signed packets.
703****************************************************************************/
704
705BOOL receive_smb_raw(int fd, char *buffer, size_t buflen, unsigned int timeout)
706{
707 ssize_t len,ret;
708
709 smb_read_error = 0;
710
711 len = read_smb_length_return_keepalive(fd,buffer,timeout);
712 if (len < 0) {
713 DEBUG(10,("receive_smb_raw: length < 0!\n"));
714
715 /*
716 * Correct fix. smb_read_error may have already been
717 * set. Only set it here if not already set. Global
718 * variables still suck :-). JRA.
719 */
720
721 if (smb_read_error == 0)
722 smb_read_error = READ_ERROR;
723 return False;
724 }
725
726 if (len > buflen) {
727 DEBUG(0,("Invalid packet length! (%lu bytes).\n",(unsigned long)len));
728
729 /*
730 * smb_read_error may have already been
731 * set. Only set it here if not already set. Global
732 * variables still suck :-). JRA.
733 */
734
735 if (smb_read_error == 0)
736 smb_read_error = READ_ERROR;
737 return False;
738 }
739
740 if(len > 0) {
741 if (timeout > 0) {
742 ret = read_socket_with_timeout(fd,buffer+4,len,len,timeout);
743 } else {
744 ret = read_data(fd,buffer+4,len);
745 }
746
747 if (ret != len) {
748 if (smb_read_error == 0) {
749 smb_read_error = READ_ERROR;
750 }
751 return False;
752 }
753
754 /* not all of samba3 properly checks for packet-termination of strings. This
755 ensures that we don't run off into empty space. */
756 SSVAL(buffer+4,len, 0);
757 }
758
759 return True;
760}
761
762/****************************************************************************
763 Wrapper for receive_smb_raw().
764 Checks the MAC on signed packets.
765****************************************************************************/
766
767BOOL receive_smb(int fd, char *buffer, size_t buflen, unsigned int timeout)
768{
769 if (!receive_smb_raw(fd, buffer, buflen, timeout)) {
770 return False;
771 }
772
773 /* Check the incoming SMB signature. */
774 if (!srv_check_sign_mac(buffer, True)) {
775 DEBUG(0, ("receive_smb: SMB Signature verification failed on incoming packet!\n"));
776 if (smb_read_error == 0)
777 smb_read_error = READ_BAD_SIG;
778 return False;
779 };
780
781 return(True);
782}
783
784/****************************************************************************
785 Send an smb to a fd.
786****************************************************************************/
787
788BOOL send_smb(int fd, char *buffer)
789{
790 size_t len;
791 size_t nwritten=0;
792 ssize_t ret;
793
794 /* Sign the outgoing packet if required. */
795 srv_calculate_sign_mac(buffer);
796
797 len = smb_len(buffer) + 4;
798
799 while (nwritten < len) {
800 ret = write_data(fd,buffer+nwritten,len - nwritten);
801 if (ret <= 0) {
802 DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
803 (int)len,(int)ret, strerror(errno) ));
804 return False;
805 }
806 nwritten += ret;
807 }
808
809 return True;
810}
811
812/****************************************************************************
813 Open a socket of the specified type, port, and address for incoming data.
814****************************************************************************/
815
816int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
817{
818 struct sockaddr_in sock;
819 int res;
820
821 memset( (char *)&sock, '\0', sizeof(sock) );
822
823#ifdef HAVE_SOCK_SIN_LEN
824 sock.sin_len = sizeof(sock);
825#endif
826 sock.sin_port = htons( port );
827 sock.sin_family = AF_INET;
828 sock.sin_addr.s_addr = socket_addr;
829
830 res = socket( AF_INET, type, 0 );
831 if( res == -1 ) {
832 if( DEBUGLVL(0) ) {
833 dbgtext( "open_socket_in(): socket() call failed: " );
834 dbgtext( "%s\n", strerror( errno ) );
835 }
836 return -1;
837 }
838
839 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
840 {
841 int val = rebind ? 1 : 0;
842 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
843 if( DEBUGLVL( dlevel ) ) {
844 dbgtext( "open_socket_in(): setsockopt: " );
845 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
846 dbgtext( "on port %d failed ", port );
847 dbgtext( "with error = %s\n", strerror(errno) );
848 }
849 }
850#ifdef SO_REUSEPORT
851 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
852 if( DEBUGLVL( dlevel ) ) {
853 dbgtext( "open_socket_in(): setsockopt: ");
854 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
855 dbgtext( "on port %d failed ", port );
856 dbgtext( "with error = %s\n", strerror(errno) );
857 }
858 }
859#endif /* SO_REUSEPORT */
860 }
861
862 /* now we've got a socket - we need to bind it */
863 if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
864 if( DEBUGLVL(dlevel) && (port == SMB_PORT1 || port == SMB_PORT2 || port == NMB_PORT) ) {
865 dbgtext( "bind failed on port %d ", port );
866 dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
867 dbgtext( "Error = %s\n", strerror(errno) );
868 }
869 close( res );
870 return( -1 );
871 }
872
873 DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
874
875 return( res );
876 }
877
878/****************************************************************************
879 Create an outgoing socket. timeout is in milliseconds.
880**************************************************************************/
881
882int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
883{
884 struct sockaddr_in sock_out;
885 int res,ret;
886 int connect_loop = 10;
887 int increment = 10;
888
889 /* create a socket to write to */
890 res = socket(PF_INET, type, 0);
891 if (res == -1) {
892 DEBUG(0,("socket error (%s)\n", strerror(errno)));
893 return -1;
894 }
895
896 if (type != SOCK_STREAM)
897 return(res);
898
899 memset((char *)&sock_out,'\0',sizeof(sock_out));
900 putip((char *)&sock_out.sin_addr,(char *)addr);
901
902 sock_out.sin_port = htons( port );
903 sock_out.sin_family = PF_INET;
904
905 /* set it non-blocking */
906 set_blocking(res,False);
907
908 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
909
910 /* and connect it to the destination */
911 connect_again:
912
913 ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
914
915 /* Some systems return EAGAIN when they mean EINPROGRESS */
916 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
917 errno == EAGAIN) && (connect_loop < timeout) ) {
918 smb_msleep(connect_loop);
919 timeout -= connect_loop;
920 connect_loop += increment;
921 if (increment < 250) {
922 /* After 8 rounds we end up at a max of 255 msec */
923 increment *= 1.5;
924 }
925 goto connect_again;
926 }
927
928 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
929 errno == EAGAIN)) {
930 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
931 close(res);
932 return -1;
933 }
934
935#ifdef EISCONN
936
937 if (ret < 0 && errno == EISCONN) {
938 errno = 0;
939 ret = 0;
940 }
941#endif
942
943 if (ret < 0) {
944 DEBUG(2,("error connecting to %s:%d (%s)\n",
945 inet_ntoa(*addr),port,strerror(errno)));
946 close(res);
947 return -1;
948 }
949
950 /* set it blocking again */
951 set_blocking(res,True);
952
953 return res;
954}
955
956/****************************************************************************
957 Create an outgoing TCP socket to any of the addrs. This is for
958 simultaneous connects to port 445 and 139 of a host or even a variety
959 of DC's all of which are equivalent for our purposes.
960**************************************************************************/
961
962BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs,
963 int timeout, int *fd_index, int *fd)
964{
965 int i, resulting_index, res;
966 int *sockets;
967 BOOL good_connect;
968
969 fd_set r_fds, wr_fds;
970 struct timeval tv;
971 int maxfd;
972
973 int connect_loop = 10000; /* 10 milliseconds */
974
975 timeout *= 1000; /* convert to microseconds */
976
977 sockets = SMB_MALLOC_ARRAY(int, num_addrs);
978
979 if (sockets == NULL)
980 return False;
981
982 resulting_index = -1;
983
984 for (i=0; i<num_addrs; i++)
985 sockets[i] = -1;
986
987 for (i=0; i<num_addrs; i++) {
988 sockets[i] = socket(PF_INET, SOCK_STREAM, 0);
989 if (sockets[i] < 0)
990 goto done;
991 set_blocking(sockets[i], False);
992 }
993
994 connect_again:
995 good_connect = False;
996
997 for (i=0; i<num_addrs; i++) {
998
999 if (sockets[i] == -1)
1000 continue;
1001
1002 if (connect(sockets[i], (struct sockaddr *)&(addrs[i]),
1003 sizeof(*addrs)) == 0) {
1004 /* Rather unlikely as we are non-blocking, but it
1005 * might actually happen. */
1006 resulting_index = i;
1007 goto done;
1008 }
1009
1010 if (errno == EINPROGRESS || errno == EALREADY ||
1011#ifdef EISCONN
1012 errno == EISCONN ||
1013#endif
1014 errno == EAGAIN || errno == EINTR) {
1015 /* These are the error messages that something is
1016 progressing. */
1017 good_connect = True;
1018 } else if (errno != 0) {
1019 /* There was a direct error */
1020 close(sockets[i]);
1021 sockets[i] = -1;
1022 }
1023 }
1024
1025 if (!good_connect) {
1026 /* All of the connect's resulted in real error conditions */
1027 goto done;
1028 }
1029
1030 /* Lets see if any of the connect attempts succeeded */
1031
1032 maxfd = 0;
1033 FD_ZERO(&wr_fds);
1034 FD_ZERO(&r_fds);
1035
1036 for (i=0; i<num_addrs; i++) {
1037 if (sockets[i] == -1)
1038 continue;
1039 FD_SET(sockets[i], &wr_fds);
1040 FD_SET(sockets[i], &r_fds);
1041 if (sockets[i]>maxfd)
1042 maxfd = sockets[i];
1043 }
1044
1045 tv.tv_sec = 0;
1046 tv.tv_usec = connect_loop;
1047
1048 res = sys_select_intr(maxfd+1, &r_fds, &wr_fds, NULL, &tv);
1049
1050 if (res < 0)
1051 goto done;
1052
1053 if (res == 0)
1054 goto next_round;
1055
1056 for (i=0; i<num_addrs; i++) {
1057
1058 if (sockets[i] == -1)
1059 continue;
1060
1061 /* Stevens, Network Programming says that if there's a
1062 * successful connect, the socket is only writable. Upon an
1063 * error, it's both readable and writable. */
1064
1065 if (FD_ISSET(sockets[i], &r_fds) &&
1066 FD_ISSET(sockets[i], &wr_fds)) {
1067 /* readable and writable, so it's an error */
1068 close(sockets[i]);
1069 sockets[i] = -1;
1070 continue;
1071 }
1072
1073 if (!FD_ISSET(sockets[i], &r_fds) &&
1074 FD_ISSET(sockets[i], &wr_fds)) {
1075 /* Only writable, so it's connected */
1076 resulting_index = i;
1077 goto done;
1078 }
1079 }
1080
1081 next_round:
1082
1083 timeout -= connect_loop;
1084 if (timeout <= 0)
1085 goto done;
1086 connect_loop *= 1.5;
1087 if (connect_loop > timeout)
1088 connect_loop = timeout;
1089 goto connect_again;
1090
1091 done:
1092 for (i=0; i<num_addrs; i++) {
1093 if (i == resulting_index)
1094 continue;
1095 if (sockets[i] >= 0)
1096 close(sockets[i]);
1097 }
1098
1099 if (resulting_index >= 0) {
1100 *fd_index = resulting_index;
1101 *fd = sockets[*fd_index];
1102 set_blocking(*fd, True);
1103 }
1104
1105 free(sockets);
1106
1107 return (resulting_index >= 0);
1108}
1109/****************************************************************************
1110 Open a connected UDP socket to host on port
1111**************************************************************************/
1112
1113int open_udp_socket(const char *host, int port)
1114{
1115 int type = SOCK_DGRAM;
1116 struct sockaddr_in sock_out;
1117 int res;
1118 struct in_addr *addr;
1119
1120 addr = interpret_addr2(host);
1121
1122 res = socket(PF_INET, type, 0);
1123 if (res == -1) {
1124 return -1;
1125 }
1126
1127 memset((char *)&sock_out,'\0',sizeof(sock_out));
1128 putip((char *)&sock_out.sin_addr,(char *)addr);
1129 sock_out.sin_port = htons(port);
1130 sock_out.sin_family = PF_INET;
1131
1132 if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
1133 close(res);
1134 return -1;
1135 }
1136
1137 return res;
1138}
1139
1140
1141/*******************************************************************
1142 Matchname - determine if host name matches IP address. Used to
1143 confirm a hostname lookup to prevent spoof attacks.
1144******************************************************************/
1145
1146static BOOL matchname(char *remotehost,struct in_addr addr)
1147{
1148 struct hostent *hp;
1149 int i;
1150
1151 if ((hp = sys_gethostbyname(remotehost)) == 0) {
1152 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
1153 return False;
1154 }
1155
1156 /*
1157 * Make sure that gethostbyname() returns the "correct" host name.
1158 * Unfortunately, gethostbyname("localhost") sometimes yields
1159 * "localhost.domain". Since the latter host name comes from the
1160 * local DNS, we just have to trust it (all bets are off if the local
1161 * DNS is perverted). We always check the address list, though.
1162 */
1163
1164 if (!strequal(remotehost, hp->h_name)
1165 && !strequal(remotehost, "localhost")) {
1166 DEBUG(0,("host name/name mismatch: %s != %s\n",
1167 remotehost, hp->h_name));
1168 return False;
1169 }
1170
1171 /* Look up the host address in the address list we just got. */
1172 for (i = 0; hp->h_addr_list[i]; i++) {
1173 if (memcmp(hp->h_addr_list[i], (char *) & addr, sizeof(addr)) == 0)
1174 return True;
1175 }
1176
1177 /*
1178 * The host name does not map to the original host address. Perhaps
1179 * someone has compromised a name server. More likely someone botched
1180 * it, but that could be dangerous, too.
1181 */
1182
1183 DEBUG(0,("host name/address mismatch: %s != %s\n",
1184 inet_ntoa(addr), hp->h_name));
1185 return False;
1186}
1187
1188/*******************************************************************
1189 Return the DNS name of the remote end of a socket.
1190******************************************************************/
1191
1192char *get_peer_name(int fd, BOOL force_lookup)
1193{
1194 static pstring name_buf;
1195 pstring tmp_name;
1196 static fstring addr_buf;
1197 struct hostent *hp;
1198 struct in_addr addr;
1199 char *p;
1200
1201 /* reverse lookups can be *very* expensive, and in many
1202 situations won't work because many networks don't link dhcp
1203 with dns. To avoid the delay we avoid the lookup if
1204 possible */
1205 if (!lp_hostname_lookups() && (force_lookup == False)) {
1206 return get_peer_addr(fd);
1207 }
1208
1209 p = get_peer_addr(fd);
1210
1211 /* it might be the same as the last one - save some DNS work */
1212 if (strcmp(p, addr_buf) == 0)
1213 return name_buf;
1214
1215 pstrcpy(name_buf,"UNKNOWN");
1216 if (fd == -1)
1217 return name_buf;
1218
1219 fstrcpy(addr_buf, p);
1220
1221 addr = *interpret_addr2(p);
1222
1223 /* Look up the remote host name. */
1224 if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1225 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1226 pstrcpy(name_buf, p);
1227 } else {
1228 pstrcpy(name_buf,(char *)hp->h_name);
1229 if (!matchname(name_buf, addr)) {
1230 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1231 pstrcpy(name_buf,"UNKNOWN");
1232 }
1233 }
1234
1235 /* can't pass the same source and dest strings in when you
1236 use --enable-developer or the clobber_region() call will
1237 get you */
1238
1239 pstrcpy( tmp_name, name_buf );
1240 alpha_strcpy(name_buf, tmp_name, "_-.", sizeof(name_buf));
1241 if (strstr(name_buf,"..")) {
1242 pstrcpy(name_buf, "UNKNOWN");
1243 }
1244
1245 return name_buf;
1246}
1247
1248/*******************************************************************
1249 Return the IP addr of the remote end of a socket as a string.
1250 ******************************************************************/
1251
1252char *get_peer_addr(int fd)
1253{
1254 struct sockaddr sa;
1255 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1256 socklen_t length = sizeof(sa);
1257 static fstring addr_buf;
1258
1259 fstrcpy(addr_buf,"0.0.0.0");
1260
1261 if (fd == -1) {
1262 return addr_buf;
1263 }
1264
1265 if (getpeername(fd, &sa, &length) < 0) {
1266 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1267 return addr_buf;
1268 }
1269
1270 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1271
1272 return addr_buf;
1273}
1274
1275/*******************************************************************
1276 Create protected unix domain socket.
1277
1278 Some unixes cannot set permissions on a ux-dom-sock, so we
1279 have to make sure that the directory contains the protection
1280 permissions instead.
1281 ******************************************************************/
1282
1283int create_pipe_sock(const char *socket_dir,
1284 const char *socket_name,
1285 mode_t dir_perms)
1286{
1287#ifdef HAVE_UNIXSOCKET
1288 struct sockaddr_un sunaddr;
1289 struct stat st;
1290 int sock;
1291 mode_t old_umask;
1292 pstring path;
1293
1294 old_umask = umask(0);
1295
1296 /* Create the socket directory or reuse the existing one */
1297
1298#ifndef __OS2__
1299 if (lstat(socket_dir, &st) == -1) {
1300 if (errno == ENOENT) {
1301 /* Create directory */
1302 if (mkdir(socket_dir, dir_perms) == -1) {
1303 DEBUG(0, ("error creating socket directory "
1304 "%s: %s\n", socket_dir,
1305 strerror(errno)));
1306 goto out_umask;
1307 }
1308 } else {
1309 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1310 socket_dir, strerror(errno)));
1311 goto out_umask;
1312 }
1313 } else {
1314 /* Check ownership and permission on existing directory */
1315 if (!S_ISDIR(st.st_mode)) {
1316 DEBUG(0, ("socket directory %s isn't a directory\n",
1317 socket_dir));
1318 goto out_umask;
1319 }
1320 if ((st.st_uid != sec_initial_uid()) ||
1321 ((st.st_mode & 0777) != dir_perms)) {
1322 DEBUG(0, ("invalid permissions on socket directory "
1323 "%s\n", socket_dir));
1324 goto out_umask;
1325 }
1326 }
1327#endif
1328 /* Create the socket file */
1329
1330 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1331
1332 if (sock == -1) {
1333 perror("socket");
1334 goto out_umask;
1335 }
1336
1337#ifdef __OS2__
1338 pstr_sprintf(path, "\\socket\\samba\\%s\\%s", socket_dir, socket_name);
1339#else
1340 pstr_sprintf(path, "%s/%s", socket_dir, socket_name);
1341#endif
1342
1343 unlink(path);
1344 memset(&sunaddr, 0, sizeof(sunaddr));
1345 sunaddr.sun_family = AF_UNIX;
1346 safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1347
1348 if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1349 DEBUG(0, ("bind failed on pipe socket %s: %s\n", path,
1350 strerror(errno)));
1351 goto out_close;
1352 }
1353
1354 if (listen(sock, 5) == -1) {
1355 DEBUG(0, ("listen failed on pipe socket %s: %s\n", path,
1356 strerror(errno)));
1357 goto out_close;
1358 }
1359
1360 umask(old_umask);
1361 return sock;
1362
1363out_close:
1364 close(sock);
1365
1366out_umask:
1367 umask(old_umask);
1368 return -1;
1369
1370#else
1371 DEBUG(0, ("create_pipe_sock: No Unix sockets on this system\n"));
1372 return -1;
1373#endif /* HAVE_UNIXSOCKET */
1374}
Note: See TracBrowser for help on using the repository browser.