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
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.
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.
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.
25 /* the following 3 client_*() functions are nasty ways of allowing
26 some generic functions to get info that really should be hidden in
28 static int client_fd = -1;
29 /* What to print out on a client disconnect error. */
30 static char client_ip_string[16];
32 void client_setfd(int fd)
35 safe_strcpy(client_ip_string, get_peer_addr(client_fd), sizeof(client_ip_string)-1);
38 static char *get_socket_addr(int fd)
41 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
42 socklen_t length = sizeof(sa);
43 static fstring addr_buf;
45 fstrcpy(addr_buf,"0.0.0.0");
51 if (getsockname(fd, &sa, &length) < 0) {
52 DEBUG(0,("getsockname failed. Error was %s\n", strerror(errno) ));
56 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
61 static int get_socket_port(int fd)
64 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
65 socklen_t length = sizeof(sa);
70 if (getsockname(fd, &sa, &length) < 0) {
71 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
75 return ntohs(sockin->sin_port);
78 char *client_name(void)
80 return get_peer_name(client_fd,False);
83 char *client_addr(void)
85 return get_peer_addr(client_fd);
88 char *client_socket_addr(void)
90 return get_socket_addr(client_fd);
93 int client_socket_port(void)
95 return get_socket_port(client_fd);
98 struct in_addr *client_inaddr(struct sockaddr *sa)
100 struct sockaddr_in *sockin = (struct sockaddr_in *) (sa);
101 socklen_t length = sizeof(*sa);
103 if (getpeername(client_fd, sa, &length) < 0) {
104 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
108 return &sockin->sin_addr;
111 /* the last IP received from */
112 struct in_addr lastip;
114 /* the last port received from */
117 int smb_read_error = 0;
119 /****************************************************************************
120 Determine if a file descriptor is in fact a socket.
121 ****************************************************************************/
123 BOOL is_a_socket(int fd)
128 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
131 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
133 typedef struct smb_socket_option {
141 static 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},
146 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
149 {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
152 {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
155 {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
157 #ifdef IPTOS_LOWDELAY
158 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
160 #ifdef IPTOS_THROUGHPUT
161 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
164 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
167 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
170 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
173 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
176 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
179 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
182 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
185 {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
189 /****************************************************************************
190 Print socket options.
191 ****************************************************************************/
193 static void print_socket_options(int s)
197 const smb_socket_option *p = &socket_options[0];
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));
206 DEBUG(5,("socket option %s = %d\n",p->name,value));
212 /****************************************************************************
213 Set user socket options.
214 ****************************************************************************/
216 void set_socket_options(int fd, const char *options)
220 while (next_token(&options,tok," \t,", sizeof(tok))) {
224 BOOL got_value = False;
226 if ((p = strchr_m(tok,'='))) {
232 for (i=0;socket_options[i].name;i++)
233 if (strequal(socket_options[i].name,tok))
236 if (!socket_options[i].name) {
237 DEBUG(0,("Unknown socket option %s\n",tok));
241 switch (socket_options[i].opttype) {
244 ret = setsockopt(fd,socket_options[i].level,
245 socket_options[i].option,(char *)&value,sizeof(int));
250 DEBUG(0,("syntax error - %s does not take a value\n",tok));
253 int on = socket_options[i].value;
254 ret = setsockopt(fd,socket_options[i].level,
255 socket_options[i].option,(char *)&on,sizeof(int));
261 DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
264 print_socket_options(fd);
267 /****************************************************************************
269 ****************************************************************************/
271 ssize_t read_udp_socket(int fd,char *buf,size_t len)
274 struct sockaddr_in sock;
275 socklen_t socklen = sizeof(sock);
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);
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)));
285 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
290 lastip = sock.sin_addr;
291 lastport = ntohs(sock.sin_port);
293 DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %lu\n",
294 inet_ntoa(lastip), lastport, (unsigned long)ret));
301 Socket routines from HEAD - maybe re-enable in future. JRA.
303 /****************************************************************************
304 Work out if we've timed out.
305 ****************************************************************************/
307 static BOOL timeout_until(struct timeval *timeout, const struct timeval *endtime)
314 t_dif = usec_time_diff(endtime, &now);
319 timeout->tv_sec = (t_dif / (SMB_BIG_INT)1000000);
320 timeout->tv_usec = (t_dif % (SMB_BIG_INT)1000000);
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 ****************************************************************************/
329 ssize_t read_data_until(int fd,char *buffer,size_t N, const struct timeval *endtime)
338 if (endtime != NULL) {
340 struct timeval timeout;
343 if (!timeout_until(&timeout, endtime)) {
344 DEBUG(10,("read_data_until: read timed out\n"));
345 smb_read_error = READ_TIMEOUT;
352 /* Select but ignore EINTR. */
353 selrtn = sys_select_intr(fd+1, &r_fds, NULL, NULL, &timeout);
355 /* something is wrong. Maybe the socket is dead? */
356 DEBUG(0,("read_data_until: select error = %s.\n", strerror(errno) ));
357 smb_read_error = READ_ERROR;
361 /* Did we timeout ? */
363 DEBUG(10,("read_data_until: select timed out.\n"));
364 smb_read_error = READ_TIMEOUT;
369 ret = sys_read(fd,buffer + total,N - total);
372 DEBUG(10,("read_data_until: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
373 smb_read_error = READ_EOF;
378 if (errno == EAGAIN) {
379 /* Non-blocking socket with no data available. Try select again. */
382 DEBUG(0,("read_data_until: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
383 smb_read_error = READ_ERROR;
388 return (ssize_t)total;
392 /****************************************************************************
393 Read data from a socket with a timout in msec.
394 mincount = if timeout, minimum to read before returning
395 maxcount = number to be read.
396 time_out = timeout in milliseconds
397 ****************************************************************************/
399 ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
405 struct timeval timeout;
407 /* just checking .... */
419 while (nread < mincnt) {
420 readret = sys_read(fd, buf + nread, maxcnt - nread);
423 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
424 smb_read_error = READ_EOF;
429 if (fd == client_fd) {
430 /* Try and give an error message saying what client failed. */
431 DEBUG(0,("read_socket_with_timeout: client %s read error = %s.\n",
432 client_ip_string, strerror(errno) ));
434 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
436 smb_read_error = READ_ERROR;
441 return((ssize_t)nread);
444 /* Most difficult - timeout read */
445 /* If this is ever called on a disk file and
446 mincnt is greater then the filesize then
447 system performance will suffer severely as
448 select always returns true on disk files */
450 /* Set initial timeout */
451 timeout.tv_sec = (time_t)(time_out / 1000);
452 timeout.tv_usec = (long)(1000 * (time_out % 1000));
454 for (nread=0; nread < mincnt; ) {
458 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
462 /* something is wrong. Maybe the socket is dead? */
463 if (fd == client_fd) {
464 /* Try and give an error message saying what client failed. */
465 DEBUG(0,("read_socket_with_timeout: timeout read for client %s. select error = %s.\n",
466 client_ip_string, strerror(errno) ));
468 DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
470 smb_read_error = READ_ERROR;
474 /* Did we timeout ? */
476 DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
477 smb_read_error = READ_TIMEOUT;
481 readret = sys_read(fd, buf+nread, maxcnt-nread);
484 /* we got EOF on the file descriptor */
485 DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
486 smb_read_error = READ_EOF;
491 /* the descriptor is probably dead */
492 if (fd == client_fd) {
493 /* Try and give an error message saying what client failed. */
494 DEBUG(0,("read_socket_with_timeout: timeout read to client %s. read error = %s.\n",
495 client_ip_string, strerror(errno) ));
497 DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
499 smb_read_error = READ_ERROR;
506 /* Return the number we got */
507 return (ssize_t)nread;
510 /****************************************************************************
511 Read data from the client, reading exactly N bytes.
512 ****************************************************************************/
514 ssize_t read_data(int fd,char *buffer,size_t N)
522 ret = sys_read(fd,buffer + total,N - total);
525 DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
526 smb_read_error = READ_EOF;
531 if (fd == client_fd) {
532 /* Try and give an error message saying what client failed. */
533 DEBUG(0,("read_data: read failure for %d bytes to client %s. Error = %s\n",
534 (int)(N - total), client_ip_string, strerror(errno) ));
536 DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
538 smb_read_error = READ_ERROR;
543 return (ssize_t)total;
546 /****************************************************************************
548 ****************************************************************************/
550 ssize_t write_data(int fd, const char *buffer, size_t N)
556 ret = sys_write(fd,buffer + total,N - total);
559 if (fd == client_fd) {
560 /* Try and give an error message saying what client failed. */
561 DEBUG(0,("write_data: write failure in writing to client %s. Error %s\n",
562 client_ip_string, strerror(errno) ));
564 DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
575 return (ssize_t)total;
578 /****************************************************************************
579 Send a keepalive packet (rfc1002).
580 ****************************************************************************/
582 BOOL send_keepalive(int client)
584 unsigned char buf[4];
586 buf[0] = SMBkeepalive;
587 buf[1] = buf[2] = buf[3] = 0;
589 return(write_data(client,(char *)buf,4) == 4);
593 /****************************************************************************
594 Read 4 bytes of a smb packet and return the smb length of the packet.
595 Store the result in the buffer.
596 This version of the function will return a length of zero on receiving
598 Timeout is in milliseconds.
599 ****************************************************************************/
601 static ssize_t read_smb_length_return_keepalive(int fd, char *inbuf, unsigned int timeout)
609 ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
611 ok = (read_data(fd,inbuf,4) == 4);
616 len = smb_len(inbuf);
617 msg_type = CVAL(inbuf,0);
619 if (msg_type == SMBkeepalive)
620 DEBUG(5,("Got keepalive packet\n"));
623 DEBUG(10,("got smb length of %lu\n",(unsigned long)len));
628 /****************************************************************************
629 Read 4 bytes of a smb packet and return the smb length of the packet.
630 Store the result in the buffer. This version of the function will
631 never return a session keepalive (length of zero).
632 Timeout is in milliseconds.
633 ****************************************************************************/
635 ssize_t read_smb_length(int fd, char *inbuf, unsigned int timeout)
640 len = read_smb_length_return_keepalive(fd, inbuf, timeout);
645 /* Ignore session keepalives. */
646 if(CVAL(inbuf,0) != SMBkeepalive)
650 DEBUG(10,("read_smb_length: got smb length of %lu\n",
651 (unsigned long)len));
656 /****************************************************************************
657 Read an smb from a fd. Note that the buffer *MUST* be of size
658 BUFFER_SIZE+SAFETY_MARGIN.
659 The timeout is in milliseconds.
660 This function will return on receipt of a session keepalive packet.
661 Doesn't check the MAC on signed packets.
662 ****************************************************************************/
664 BOOL receive_smb_raw(int fd, char *buffer, unsigned int timeout)
670 len = read_smb_length_return_keepalive(fd,buffer,timeout);
672 DEBUG(10,("receive_smb_raw: length < 0!\n"));
675 * Correct fix. smb_read_error may have already been
676 * set. Only set it here if not already set. Global
677 * variables still suck :-). JRA.
680 if (smb_read_error == 0)
681 smb_read_error = READ_ERROR;
686 * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
687 * of header. Don't print the error if this fits.... JRA.
690 if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
691 DEBUG(0,("Invalid packet length! (%lu bytes).\n",(unsigned long)len));
692 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
695 * Correct fix. smb_read_error may have already been
696 * set. Only set it here if not already set. Global
697 * variables still suck :-). JRA.
700 if (smb_read_error == 0)
701 smb_read_error = READ_ERROR;
708 ret = read_socket_with_timeout(fd,buffer+4,len,len,timeout);
710 ret = read_data(fd,buffer+4,len);
714 if (smb_read_error == 0) {
715 smb_read_error = READ_ERROR;
720 /* not all of samba3 properly checks for packet-termination of strings. This
721 ensures that we don't run off into empty space. */
722 SSVAL(buffer+4,len, 0);
728 /****************************************************************************
729 Wrapper for receive_smb_raw().
730 Checks the MAC on signed packets.
731 ****************************************************************************/
733 BOOL receive_smb(int fd, char *buffer, unsigned int timeout)
737 if (!receive_smb_raw(fd, buffer, timeout)) {
741 status = srv_decrypt_buffer(buffer);
742 if (!NT_STATUS_IS_OK(status)) {
743 DEBUG(0, ("receive_smb: SMB decryption failed on incoming packet! Error %s\n",
744 nt_errstr(status) ));
745 if (smb_read_error == 0) {
746 smb_read_error = READ_BAD_DECRYPT;
751 /* Check the incoming SMB signature. */
752 if (!srv_check_sign_mac(buffer, True)) {
753 DEBUG(0, ("receive_smb: SMB Signature verification failed on incoming packet!\n"));
754 if (smb_read_error == 0) {
755 smb_read_error = READ_BAD_SIG;
763 /****************************************************************************
765 ****************************************************************************/
767 BOOL send_smb(int fd, char *buffer)
775 /* Sign the outgoing packet if required. */
776 srv_calculate_sign_mac(buffer);
778 status = srv_encrypt_buffer(buffer, &buf_out);
779 if (!NT_STATUS_IS_OK(status)) {
780 DEBUG(0, ("send_smb: SMB encryption failed on outgoing packet! Error %s\n",
781 nt_errstr(status) ));
785 len = smb_len(buf_out) + 4;
787 while (nwritten < len) {
788 ret = write_data(fd,buf_out+nwritten,len - nwritten);
790 DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
791 (int)len,(int)ret, strerror(errno) ));
792 srv_free_enc_buffer(buf_out);
798 srv_free_enc_buffer(buf_out);
802 /****************************************************************************
803 Open a socket of the specified type, port, and address for incoming data.
804 ****************************************************************************/
806 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
808 struct sockaddr_in sock;
811 memset( (char *)&sock, '\0', sizeof(sock) );
813 #ifdef HAVE_SOCK_SIN_LEN
814 sock.sin_len = sizeof(sock);
816 sock.sin_port = htons( port );
817 sock.sin_family = AF_INET;
818 sock.sin_addr.s_addr = socket_addr;
820 res = socket( AF_INET, type, 0 );
823 dbgtext( "open_socket_in(): socket() call failed: " );
824 dbgtext( "%s\n", strerror( errno ) );
829 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
831 int val = rebind ? 1 : 0;
832 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
833 if( DEBUGLVL( dlevel ) ) {
834 dbgtext( "open_socket_in(): setsockopt: " );
835 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
836 dbgtext( "on port %d failed ", port );
837 dbgtext( "with error = %s\n", strerror(errno) );
841 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
842 if( DEBUGLVL( dlevel ) ) {
843 dbgtext( "open_socket_in(): setsockopt: ");
844 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
845 dbgtext( "on port %d failed ", port );
846 dbgtext( "with error = %s\n", strerror(errno) );
849 #endif /* SO_REUSEPORT */
852 /* now we've got a socket - we need to bind it */
853 if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
854 if( DEBUGLVL(dlevel) && (port == SMB_PORT1 || port == SMB_PORT2 || port == NMB_PORT) ) {
855 dbgtext( "bind failed on port %d ", port );
856 dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
857 dbgtext( "Error = %s\n", strerror(errno) );
863 DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
868 /****************************************************************************
869 Create an outgoing socket. timeout is in milliseconds.
870 **************************************************************************/
872 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
874 struct sockaddr_in sock_out;
876 int connect_loop = 10;
879 /* create a socket to write to */
880 res = socket(PF_INET, type, 0);
882 DEBUG(0,("socket error (%s)\n", strerror(errno)));
886 if (type != SOCK_STREAM)
889 memset((char *)&sock_out,'\0',sizeof(sock_out));
890 putip((char *)&sock_out.sin_addr,(char *)addr);
892 sock_out.sin_port = htons( port );
893 sock_out.sin_family = PF_INET;
895 /* set it non-blocking */
896 set_blocking(res,False);
898 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
900 /* and connect it to the destination */
903 ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
905 /* Some systems return EAGAIN when they mean EINPROGRESS */
906 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
907 errno == EAGAIN) && (connect_loop < timeout) ) {
908 smb_msleep(connect_loop);
909 timeout -= connect_loop;
910 connect_loop += increment;
911 if (increment < 250) {
912 /* After 8 rounds we end up at a max of 255 msec */
918 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
920 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
927 if (ret < 0 && errno == EISCONN) {
934 DEBUG(2,("error connecting to %s:%d (%s)\n",
935 inet_ntoa(*addr),port,strerror(errno)));
940 /* set it blocking again */
941 set_blocking(res,True);
946 /****************************************************************************
947 Create an outgoing TCP socket to any of the addrs. This is for
948 simultaneous connects to port 445 and 139 of a host or even a variety
949 of DC's all of which are equivalent for our purposes.
950 **************************************************************************/
952 BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs,
953 int timeout, int *fd_index, int *fd)
955 int i, resulting_index, res;
959 fd_set r_fds, wr_fds;
963 int connect_loop = 10000; /* 10 milliseconds */
965 timeout *= 1000; /* convert to microseconds */
967 sockets = SMB_MALLOC_ARRAY(int, num_addrs);
972 resulting_index = -1;
974 for (i=0; i<num_addrs; i++)
977 for (i=0; i<num_addrs; i++) {
978 sockets[i] = socket(PF_INET, SOCK_STREAM, 0);
981 set_blocking(sockets[i], False);
985 good_connect = False;
987 for (i=0; i<num_addrs; i++) {
989 if (sockets[i] == -1)
992 if (connect(sockets[i], (struct sockaddr *)&(addrs[i]),
993 sizeof(*addrs)) == 0) {
994 /* Rather unlikely as we are non-blocking, but it
995 * might actually happen. */
1000 if (errno == EINPROGRESS || errno == EALREADY ||
1001 errno == EAGAIN || errno == EINTR) {
1002 /* These are the error messages that something is
1004 good_connect = True;
1005 } else if (errno != 0) {
1006 /* There was a direct error */
1012 if (!good_connect) {
1013 /* All of the connect's resulted in real error conditions */
1017 /* Lets see if any of the connect attempts succeeded */
1023 for (i=0; i<num_addrs; i++) {
1024 if (sockets[i] == -1)
1026 FD_SET(sockets[i], &wr_fds);
1027 FD_SET(sockets[i], &r_fds);
1028 if (sockets[i]>maxfd)
1033 tv.tv_usec = connect_loop;
1035 res = sys_select_intr(maxfd+1, &r_fds, &wr_fds, NULL, &tv);
1043 for (i=0; i<num_addrs; i++) {
1045 if (sockets[i] == -1)
1048 /* Stevens, Network Programming says that if there's a
1049 * successful connect, the socket is only writable. Upon an
1050 * error, it's both readable and writable. */
1052 if (FD_ISSET(sockets[i], &r_fds) &&
1053 FD_ISSET(sockets[i], &wr_fds)) {
1054 /* readable and writable, so it's an error */
1060 if (!FD_ISSET(sockets[i], &r_fds) &&
1061 FD_ISSET(sockets[i], &wr_fds)) {
1062 /* Only writable, so it's connected */
1063 resulting_index = i;
1070 timeout -= connect_loop;
1073 connect_loop *= 1.5;
1074 if (connect_loop > timeout)
1075 connect_loop = timeout;
1079 for (i=0; i<num_addrs; i++) {
1080 if (i == resulting_index)
1082 if (sockets[i] >= 0)
1086 if (resulting_index >= 0) {
1087 *fd_index = resulting_index;
1088 *fd = sockets[*fd_index];
1089 set_blocking(*fd, True);
1094 return (resulting_index >= 0);
1096 /****************************************************************************
1097 Open a connected UDP socket to host on port
1098 **************************************************************************/
1100 int open_udp_socket(const char *host, int port)
1102 int type = SOCK_DGRAM;
1103 struct sockaddr_in sock_out;
1105 struct in_addr *addr;
1107 addr = interpret_addr2(host);
1109 res = socket(PF_INET, type, 0);
1114 memset((char *)&sock_out,'\0',sizeof(sock_out));
1115 putip((char *)&sock_out.sin_addr,(char *)addr);
1116 sock_out.sin_port = htons(port);
1117 sock_out.sin_family = PF_INET;
1119 if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
1128 /*******************************************************************
1129 Matchname - determine if host name matches IP address. Used to
1130 confirm a hostname lookup to prevent spoof attacks.
1131 ******************************************************************/
1133 static BOOL matchname(char *remotehost,struct in_addr addr)
1138 if ((hp = sys_gethostbyname(remotehost)) == 0) {
1139 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
1144 * Make sure that gethostbyname() returns the "correct" host name.
1145 * Unfortunately, gethostbyname("localhost") sometimes yields
1146 * "localhost.domain". Since the latter host name comes from the
1147 * local DNS, we just have to trust it (all bets are off if the local
1148 * DNS is perverted). We always check the address list, though.
1151 if (!strequal(remotehost, hp->h_name)
1152 && !strequal(remotehost, "localhost")) {
1153 DEBUG(0,("host name/name mismatch: %s != %s\n",
1154 remotehost, hp->h_name));
1158 /* Look up the host address in the address list we just got. */
1159 for (i = 0; hp->h_addr_list[i]; i++) {
1160 if (memcmp(hp->h_addr_list[i], (char *) & addr, sizeof(addr)) == 0)
1165 * The host name does not map to the original host address. Perhaps
1166 * someone has compromised a name server. More likely someone botched
1167 * it, but that could be dangerous, too.
1170 DEBUG(0,("host name/address mismatch: %s != %s\n",
1171 inet_ntoa(addr), hp->h_name));
1175 /*******************************************************************
1176 Return the DNS name of the remote end of a socket.
1177 ******************************************************************/
1179 char *get_peer_name(int fd, BOOL force_lookup)
1181 static pstring name_buf;
1183 static fstring addr_buf;
1185 struct in_addr addr;
1188 /* reverse lookups can be *very* expensive, and in many
1189 situations won't work because many networks don't link dhcp
1190 with dns. To avoid the delay we avoid the lookup if
1192 if (!lp_hostname_lookups() && (force_lookup == False)) {
1193 return get_peer_addr(fd);
1196 p = get_peer_addr(fd);
1198 /* it might be the same as the last one - save some DNS work */
1199 if (strcmp(p, addr_buf) == 0)
1202 pstrcpy(name_buf,"UNKNOWN");
1206 fstrcpy(addr_buf, p);
1208 addr = *interpret_addr2(p);
1210 /* Look up the remote host name. */
1211 if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1212 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1213 pstrcpy(name_buf, p);
1215 pstrcpy(name_buf,(char *)hp->h_name);
1216 if (!matchname(name_buf, addr)) {
1217 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1218 pstrcpy(name_buf,"UNKNOWN");
1222 /* can't pass the same source and dest strings in when you
1223 use --enable-developer or the clobber_region() call will
1226 pstrcpy( tmp_name, name_buf );
1227 alpha_strcpy(name_buf, tmp_name, "_-.", sizeof(name_buf));
1228 if (strstr(name_buf,"..")) {
1229 pstrcpy(name_buf, "UNKNOWN");
1235 /*******************************************************************
1236 Return the IP addr of the remote end of a socket as a string.
1237 ******************************************************************/
1239 char *get_peer_addr(int fd)
1242 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1243 socklen_t length = sizeof(sa);
1244 static fstring addr_buf;
1246 fstrcpy(addr_buf,"0.0.0.0");
1252 if (getpeername(fd, &sa, &length) < 0) {
1253 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1257 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1262 /*******************************************************************
1263 Create protected unix domain socket.
1265 Some unixes cannot set permissions on a ux-dom-sock, so we
1266 have to make sure that the directory contains the protection
1267 permissions instead.
1268 ******************************************************************/
1270 int create_pipe_sock(const char *socket_dir,
1271 const char *socket_name,
1274 #ifdef HAVE_UNIXSOCKET
1275 struct sockaddr_un sunaddr;
1281 old_umask = umask(0);
1283 /* Create the socket directory or reuse the existing one */
1285 if (lstat(socket_dir, &st) == -1) {
1286 if (errno == ENOENT) {
1287 /* Create directory */
1288 if (mkdir(socket_dir, dir_perms) == -1) {
1289 DEBUG(0, ("error creating socket directory "
1290 "%s: %s\n", socket_dir,
1295 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1296 socket_dir, strerror(errno)));
1300 /* Check ownership and permission on existing directory */
1301 if (!S_ISDIR(st.st_mode)) {
1302 DEBUG(0, ("socket directory %s isn't a directory\n",
1306 if ((st.st_uid != sec_initial_uid()) ||
1307 ((st.st_mode & 0777) != dir_perms)) {
1308 DEBUG(0, ("invalid permissions on socket directory "
1309 "%s\n", socket_dir));
1314 /* Create the socket file */
1316 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1323 pstr_sprintf(path, "%s/%s", socket_dir, socket_name);
1326 memset(&sunaddr, 0, sizeof(sunaddr));
1327 sunaddr.sun_family = AF_UNIX;
1328 safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1330 if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1331 DEBUG(0, ("bind failed on pipe socket %s: %s\n", path,
1336 if (listen(sock, 5) == -1) {
1337 DEBUG(0, ("listen failed on pipe socket %s: %s\n", path,
1353 DEBUG(0, ("create_pipe_sock: No Unix sockets on this system\n"));
1355 #endif /* HAVE_UNIXSOCKET */