2 Unix SMB/Netbios implementation.
4 Samba utility functions
5 Copyright (C) Andrew Tridgell 1992-1998
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <openssl/ssl.h>
26 #undef Realloc /* SSLeay defines this and samba has a function of this name */
31 /* the last IP received from */
32 struct in_addr lastip
;
34 /* the last port received from */
37 int smb_read_error
= 0;
39 /****************************************************************************
40 Determine if a file descriptor is in fact a socket.
41 ****************************************************************************/
43 BOOL
is_a_socket(int fd
)
48 return(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&v
, &l
) == 0);
51 enum SOCK_OPT_TYPES
{OPT_BOOL
,OPT_INT
,OPT_ON
};
53 typedef struct smb_socket_option
{
61 smb_socket_option socket_options
[] = {
62 {"SO_KEEPALIVE", SOL_SOCKET
, SO_KEEPALIVE
, 0, OPT_BOOL
},
63 {"SO_REUSEADDR", SOL_SOCKET
, SO_REUSEADDR
, 0, OPT_BOOL
},
64 {"SO_BROADCAST", SOL_SOCKET
, SO_BROADCAST
, 0, OPT_BOOL
},
66 {"TCP_NODELAY", IPPROTO_TCP
, TCP_NODELAY
, 0, OPT_BOOL
},
69 {"IPTOS_LOWDELAY", IPPROTO_IP
, IP_TOS
, IPTOS_LOWDELAY
, OPT_ON
},
71 #ifdef IPTOS_THROUGHPUT
72 {"IPTOS_THROUGHPUT", IPPROTO_IP
, IP_TOS
, IPTOS_THROUGHPUT
, OPT_ON
},
75 {"SO_REUSEPORT", SOL_SOCKET
, SO_REUSEPORT
, 0, OPT_BOOL
},
78 {"SO_SNDBUF", SOL_SOCKET
, SO_SNDBUF
, 0, OPT_INT
},
81 {"SO_RCVBUF", SOL_SOCKET
, SO_RCVBUF
, 0, OPT_INT
},
84 {"SO_SNDLOWAT", SOL_SOCKET
, SO_SNDLOWAT
, 0, OPT_INT
},
87 {"SO_RCVLOWAT", SOL_SOCKET
, SO_RCVLOWAT
, 0, OPT_INT
},
90 {"SO_SNDTIMEO", SOL_SOCKET
, SO_SNDTIMEO
, 0, OPT_INT
},
93 {"SO_RCVTIMEO", SOL_SOCKET
, SO_RCVTIMEO
, 0, OPT_INT
},
97 /****************************************************************************
99 ****************************************************************************/
101 static void print_socket_options(int s
)
105 smb_socket_option
*p
= &socket_options
[0];
107 for (; p
->name
!= NULL
; p
++) {
108 if (getsockopt(s
, p
->level
, p
->option
, (void *)&value
, &vlen
) == -1) {
109 DEBUG(5,("Could not test socket option %s.\n", p
->name
));
111 DEBUG(5,("socket option %s = %d\n",p
->name
,value
));
116 /****************************************************************************
117 Set user socket options.
118 ****************************************************************************/
120 void set_socket_options(int fd
, char *options
)
124 while (next_token(&options
,tok
," \t,", sizeof(tok
))) {
128 BOOL got_value
= False
;
130 if ((p
= strchr(tok
,'='))) {
136 for (i
=0;socket_options
[i
].name
;i
++)
137 if (strequal(socket_options
[i
].name
,tok
))
140 if (!socket_options
[i
].name
) {
141 DEBUG(0,("Unknown socket option %s\n",tok
));
145 switch (socket_options
[i
].opttype
) {
148 ret
= setsockopt(fd
,socket_options
[i
].level
,
149 socket_options
[i
].option
,(char *)&value
,sizeof(int));
154 DEBUG(0,("syntax error - %s does not take a value\n",tok
));
157 int on
= socket_options
[i
].value
;
158 ret
= setsockopt(fd
,socket_options
[i
].level
,
159 socket_options
[i
].option
,(char *)&on
,sizeof(int));
165 DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok
, strerror(errno
) ));
168 print_socket_options(fd
);
171 /****************************************************************************
173 ****************************************************************************/
175 ssize_t
read_udp_socket(int fd
,char *buf
,size_t len
)
178 struct sockaddr_in sock
;
179 socklen_t socklen
= sizeof(sock
);
181 memset((char *)&sock
,'\0',socklen
);
182 memset((char *)&lastip
,'\0',sizeof(lastip
));
183 ret
= (ssize_t
)sys_recvfrom(fd
,buf
,len
,0,(struct sockaddr
*)&sock
,&socklen
);
185 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno
)));
189 lastip
= sock
.sin_addr
;
190 lastport
= ntohs(sock
.sin_port
);
192 DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
193 inet_ntoa(lastip
), lastport
, ret
));
198 /****************************************************************************
199 Read data from a socket with a timout in msec.
200 mincount = if timeout, minimum to read before returning
201 maxcount = number to be read.
202 time_out = timeout in milliseconds
203 ****************************************************************************/
205 static ssize_t
read_socket_with_timeout(int fd
,char *buf
,size_t mincnt
,size_t maxcnt
,unsigned int time_out
)
211 struct timeval timeout
;
213 /* just checking .... */
221 if (mincnt
== 0) mincnt
= maxcnt
;
223 while (nread
< mincnt
) {
226 readret
= SSL_read(ssl
, buf
+ nread
, maxcnt
- nread
);
228 readret
= sys_read(fd
, buf
+ nread
, maxcnt
- nread
);
231 readret
= sys_read(fd
, buf
+ nread
, maxcnt
- nread
);
232 #endif /* WITH_SSL */
235 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
236 smb_read_error
= READ_EOF
;
241 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno
) ));
242 smb_read_error
= READ_ERROR
;
247 return((ssize_t
)nread
);
250 /* Most difficult - timeout read */
251 /* If this is ever called on a disk file and
252 mincnt is greater then the filesize then
253 system performance will suffer severely as
254 select always returns true on disk files */
256 /* Set initial timeout */
257 timeout
.tv_sec
= (time_t)(time_out
/ 1000);
258 timeout
.tv_usec
= (long)(1000 * (time_out
% 1000));
260 for (nread
=0; nread
< mincnt
; ) {
264 selrtn
= sys_select_intr(fd
+1,&fds
,NULL
,NULL
,&timeout
);
268 /* something is wrong. Maybe the socket is dead? */
269 DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno
) ));
270 smb_read_error
= READ_ERROR
;
274 /* Did we timeout ? */
276 DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
277 smb_read_error
= READ_TIMEOUT
;
283 readret
= SSL_read(ssl
, buf
+ nread
, maxcnt
- nread
);
285 readret
= sys_read(fd
, buf
+ nread
, maxcnt
- nread
);
288 readret
= sys_read(fd
, buf
+nread
, maxcnt
-nread
);
289 #endif /* WITH_SSL */
292 /* we got EOF on the file descriptor */
293 DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
294 smb_read_error
= READ_EOF
;
299 /* the descriptor is probably dead */
300 DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno
) ));
301 smb_read_error
= READ_ERROR
;
308 /* Return the number we got */
309 return((ssize_t
)nread
);
312 /****************************************************************************
313 Read data from a fd with a timout in msec.
314 mincount = if timeout, minimum to read before returning
315 maxcount = number to be read.
316 time_out = timeout in milliseconds
317 ****************************************************************************/
319 ssize_t
read_with_timeout(int fd
,char *buf
,size_t mincnt
,size_t maxcnt
,unsigned int time_out
)
325 struct timeval timeout
;
327 /* just checking .... */
333 if (mincnt
== 0) mincnt
= maxcnt
;
335 while (nread
< mincnt
) {
338 readret
= SSL_read(ssl
, buf
+ nread
, maxcnt
- nread
);
340 readret
= sys_read(fd
, buf
+ nread
, maxcnt
- nread
);
343 readret
= sys_read(fd
, buf
+ nread
, maxcnt
- nread
);
344 #endif /* WITH_SSL */
351 return((ssize_t
)nread
);
354 /* Most difficult - timeout read */
355 /* If this is ever called on a disk file and
356 mincnt is greater then the filesize then
357 system performance will suffer severely as
358 select always returns true on disk files */
360 /* Set initial timeout */
361 timeout
.tv_sec
= (time_t)(time_out
/ 1000);
362 timeout
.tv_usec
= (long)(1000 * (time_out
% 1000));
364 for (nread
=0; nread
< mincnt
; ) {
368 selrtn
= sys_select_intr(fd
+1,&fds
,NULL
,NULL
,&timeout
);
375 readret
= SSL_read(ssl
, buf
+ nread
, maxcnt
- nread
);
377 readret
= sys_read(fd
, buf
+ nread
, maxcnt
- nread
);
380 readret
= sys_read(fd
, buf
+nread
, maxcnt
-nread
);
381 #endif /* WITH_SSL */
389 /* Return the number we got */
390 return((ssize_t
)nread
);
393 /****************************************************************************
394 send a keepalive packet (rfc1002)
395 ****************************************************************************/
397 BOOL
send_keepalive(int client
)
399 unsigned char buf
[4];
402 buf
[1] = buf
[2] = buf
[3] = 0;
404 return(write_socket_data(client
,(char *)buf
,4) == 4);
407 /****************************************************************************
408 read data from the client, reading exactly N bytes.
409 ****************************************************************************/
411 ssize_t
read_data(int fd
,char *buffer
,size_t N
)
421 ret
= SSL_read(ssl
, buffer
+ total
, N
- total
);
423 ret
= sys_read(fd
,buffer
+ total
,N
- total
);
426 ret
= sys_read(fd
,buffer
+ total
,N
- total
);
427 #endif /* WITH_SSL */
430 DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N
- total
), strerror(errno
) ));
431 smb_read_error
= READ_EOF
;
436 DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N
- total
), strerror(errno
) ));
437 smb_read_error
= READ_ERROR
;
442 return (ssize_t
)total
;
445 /****************************************************************************
447 ****************************************************************************/
449 ssize_t
write_data(int fd
,char *buffer
,size_t N
)
457 ret
= SSL_write(ssl
,buffer
+ total
,N
- total
);
459 ret
= sys_write(fd
,buffer
+ total
,N
- total
);
462 ret
= sys_write(fd
,buffer
+ total
,N
- total
);
463 #endif /* WITH_SSL */
466 DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno
) ));
470 return (ssize_t
)total
;
472 total
+= (size_t)ret
;
475 return (ssize_t
)total
;
478 /****************************************************************************
479 Write data to a socket - use send rather than write.
480 ****************************************************************************/
482 ssize_t
write_socket_data(int fd
,char *buffer
,size_t N
)
490 ret
= SSL_write(ssl
,buffer
+ total
,N
- total
);
492 ret
= sys_send(fd
,buffer
+ total
,N
- total
, 0);
495 ret
= sys_send(fd
,buffer
+ total
,N
- total
,0);
496 #endif /* WITH_SSL */
499 DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno
) ));
503 return (ssize_t
)total
;
507 return (ssize_t
)total
;
510 /****************************************************************************
512 ****************************************************************************/
514 ssize_t
write_socket(int fd
,char *buf
,size_t len
)
518 DEBUG(6,("write_socket(%d,%d)\n",fd
,(int)len
));
519 ret
= write_socket_data(fd
,buf
,len
);
521 DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd
,(int)len
,(int)ret
));
523 DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
524 (int)len
, fd
, strerror(errno
) ));
529 /****************************************************************************
530 read 4 bytes of a smb packet and return the smb length of the packet
531 store the result in the buffer
532 This version of the function will return a length of zero on receiving
534 timeout is in milliseconds.
535 ****************************************************************************/
537 static ssize_t
read_smb_length_return_keepalive(int fd
,char *inbuf
,unsigned int timeout
)
545 ok
= (read_socket_with_timeout(fd
,inbuf
,4,4,timeout
) == 4);
547 ok
= (read_data(fd
,inbuf
,4) == 4);
552 len
= smb_len(inbuf
);
553 msg_type
= CVAL(inbuf
,0);
555 if (msg_type
== 0x85)
556 DEBUG(5,("Got keepalive packet\n"));
559 DEBUG(10,("got smb length of %d\n",len
));
564 /****************************************************************************
565 read 4 bytes of a smb packet and return the smb length of the packet
566 store the result in the buffer. This version of the function will
567 never return a session keepalive (length of zero).
568 timeout is in milliseconds.
569 ****************************************************************************/
571 ssize_t
read_smb_length(int fd
,char *inbuf
,unsigned int timeout
)
576 len
= read_smb_length_return_keepalive(fd
, inbuf
, timeout
);
581 /* Ignore session keepalives. */
582 if(CVAL(inbuf
,0) != 0x85)
586 DEBUG(10,("read_smb_length: got smb length of %d\n",len
));
591 /****************************************************************************
592 read an smb from a fd. Note that the buffer *MUST* be of size
593 BUFFER_SIZE+SAFETY_MARGIN.
594 The timeout is in milliseconds.
595 This function will return on a
596 receipt of a session keepalive packet.
597 ****************************************************************************/
599 BOOL
receive_smb(int fd
,char *buffer
, unsigned int timeout
)
605 memset(buffer
,'\0',smb_size
+ 100);
607 len
= read_smb_length_return_keepalive(fd
,buffer
,timeout
);
609 DEBUG(10,("receive_smb: length < 0 !\n"));
612 * Correct fix. smb_read_error may have already been
613 * set. Only set it here if not already set. Global
614 * variables still suck :-). JRA.
617 if (smb_read_error
== 0)
618 smb_read_error
= READ_ERROR
;
623 * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
624 * of header. Don't print the error if this fits.... JRA.
627 if (len
> (BUFFER_SIZE
+ LARGE_WRITEX_HDR_SIZE
)) {
628 DEBUG(0,("Invalid packet length! (%d bytes).\n",len
));
629 if (len
> BUFFER_SIZE
+ (SAFETY_MARGIN
/2)) {
632 * Correct fix. smb_read_error may have already been
633 * set. Only set it here if not already set. Global
634 * variables still suck :-). JRA.
637 if (smb_read_error
== 0)
638 smb_read_error
= READ_ERROR
;
644 ret
= read_data(fd
,buffer
+4,len
);
646 if (smb_read_error
== 0)
647 smb_read_error
= READ_ERROR
;
655 /****************************************************************************
656 read an smb from a fd ignoring all keepalive packets. Note that the buffer
657 *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
658 The timeout is in milliseconds
660 This is exactly the same as receive_smb except that it never returns
661 a session keepalive packet (just as receive_smb used to do).
662 receive_smb was changed to return keepalives as the oplock processing means this call
663 should never go into a blocking read.
664 ****************************************************************************/
666 BOOL
client_receive_smb(int fd
,char *buffer
, unsigned int timeout
)
672 ret
= receive_smb(fd
, buffer
, timeout
);
676 DEBUG(10,("client_receive_smb failed\n"));
681 /* Ignore session keepalive packets. */
682 if(CVAL(buffer
,0) != 0x85)
689 /****************************************************************************
691 ****************************************************************************/
693 BOOL
send_smb(int fd
,char *buffer
)
698 len
= smb_len(buffer
) + 4;
700 while (nwritten
< len
) {
701 ret
= write_socket(fd
,buffer
+nwritten
,len
- nwritten
);
703 DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
704 (int)len
,(int)ret
, strerror(errno
) ));
713 /****************************************************************************
714 send a single packet to a port on another machine
715 ****************************************************************************/
717 BOOL
send_one_packet(char *buf
,int len
,struct in_addr ip
,int port
,int type
)
721 struct sockaddr_in sock_out
;
723 /* create a socket to write to */
724 out_fd
= socket(AF_INET
, type
, 0);
727 DEBUG(0,("socket failed"));
731 /* set the address and port */
732 memset((char *)&sock_out
,'\0',sizeof(sock_out
));
733 putip((char *)&sock_out
.sin_addr
,(char *)&ip
);
734 sock_out
.sin_port
= htons( port
);
735 sock_out
.sin_family
= AF_INET
;
738 DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
739 len
,inet_ntoa(ip
),port
,type
==SOCK_DGRAM
?"DGRAM":"STREAM"));
742 ret
= (sys_sendto(out_fd
,buf
,len
,0,(struct sockaddr
*)&sock_out
,sizeof(sock_out
)) >= 0);
745 DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
746 inet_ntoa(ip
),port
,strerror(errno
)));
752 /****************************************************************************
753 Open a socket of the specified type, port, and address for incoming data.
754 ****************************************************************************/
756 int open_socket_in( int type
, int port
, int dlevel
, uint32 socket_addr
, BOOL rebind
)
758 struct sockaddr_in sock
;
761 memset( (char *)&sock
, '\0', sizeof(sock
) );
763 #ifdef HAVE_SOCK_SIN_LEN
764 sock
.sin_len
= sizeof(sock
);
766 sock
.sin_port
= htons( port
);
767 sock
.sin_family
= AF_INET
;
768 sock
.sin_addr
.s_addr
= socket_addr
;
770 res
= socket( AF_INET
, type
, 0 );
773 dbgtext( "open_socket_in(): socket() call failed: " );
774 dbgtext( "%s\n", strerror( errno
) );
779 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
781 int val
= rebind
? 1 : 0;
782 if( setsockopt(res
,SOL_SOCKET
,SO_REUSEADDR
,(char *)&val
,sizeof(val
)) == -1 ) {
783 if( DEBUGLVL( dlevel
) ) {
784 dbgtext( "open_socket_in(): setsockopt: " );
785 dbgtext( "SO_REUSEADDR = %s ", val
?"True":"False" );
786 dbgtext( "on port %d failed ", port
);
787 dbgtext( "with error = %s\n", strerror(errno
) );
791 if( setsockopt(res
,SOL_SOCKET
,SO_REUSEPORT
,(char *)&val
,sizeof(val
)) == -1 ) {
792 if( DEBUGLVL( dlevel
) ) {
793 dbgtext( "open_socket_in(): setsockopt: ");
794 dbgtext( "SO_REUSEPORT = %s ", val
?"True":"False" );
795 dbgtext( "on port %d failed ", port
);
796 dbgtext( "with error = %s\n", strerror(errno
) );
799 #endif /* SO_REUSEPORT */
802 /* now we've got a socket - we need to bind it */
803 if( bind( res
, (struct sockaddr
*)&sock
, sizeof(sock
) ) == -1 ) {
804 if( DEBUGLVL(dlevel
) && (port
== SMB_PORT
|| port
== NMB_PORT
) ) {
805 dbgtext( "bind failed on port %d ", port
);
806 dbgtext( "socket_addr = %s.\n", inet_ntoa( sock
.sin_addr
) );
807 dbgtext( "Error = %s\n", strerror(errno
) );
813 DEBUG( 3, ( "bind succeeded on port %d\n", port
) );
818 /****************************************************************************
819 create an outgoing socket. timeout is in milliseconds.
820 **************************************************************************/
822 int open_socket_out(int type
, struct in_addr
*addr
, int port
,int timeout
)
824 struct sockaddr_in sock_out
;
826 int connect_loop
= 250; /* 250 milliseconds */
827 int loops
= (timeout
) / connect_loop
;
829 /* create a socket to write to */
830 res
= socket(PF_INET
, type
, 0);
832 { DEBUG(0,("socket error\n")); return -1; }
834 if (type
!= SOCK_STREAM
) return(res
);
836 memset((char *)&sock_out
,'\0',sizeof(sock_out
));
837 putip((char *)&sock_out
.sin_addr
,(char *)addr
);
839 sock_out
.sin_port
= htons( port
);
840 sock_out
.sin_family
= PF_INET
;
842 /* set it non-blocking */
843 set_blocking(res
,False
);
845 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr
),port
));
847 /* and connect it to the destination */
849 ret
= connect(res
,(struct sockaddr
*)&sock_out
,sizeof(sock_out
));
851 /* Some systems return EAGAIN when they mean EINPROGRESS */
852 if (ret
< 0 && (errno
== EINPROGRESS
|| errno
== EALREADY
||
853 errno
== EAGAIN
) && loops
--) {
854 msleep(connect_loop
);
858 if (ret
< 0 && (errno
== EINPROGRESS
|| errno
== EALREADY
||
860 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr
),port
));
866 if (ret
< 0 && errno
== EISCONN
) {
873 DEBUG(2,("error connecting to %s:%d (%s)\n",
874 inet_ntoa(*addr
),port
,strerror(errno
)));
879 /* set it blocking again */
880 set_blocking(res
,True
);
885 /* the following 3 client_*() functions are nasty ways of allowing
886 some generic functions to get info that really should be hidden in
887 particular modules */
888 static int client_fd
= -1;
890 void client_setfd(int fd
)
895 char *client_name(void)
897 return get_socket_name(client_fd
);
900 char *client_addr(void)
902 return get_socket_addr(client_fd
);
905 /*******************************************************************
906 matchname - determine if host name matches IP address. Used to
907 confirm a hostname lookup to prevent spoof attacks
908 ******************************************************************/
909 static BOOL
matchname(char *remotehost
,struct in_addr addr
)
914 if ((hp
= sys_gethostbyname(remotehost
)) == 0) {
915 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost
));
920 * Make sure that gethostbyname() returns the "correct" host name.
921 * Unfortunately, gethostbyname("localhost") sometimes yields
922 * "localhost.domain". Since the latter host name comes from the
923 * local DNS, we just have to trust it (all bets are off if the local
924 * DNS is perverted). We always check the address list, though.
927 if (strcasecmp(remotehost
, hp
->h_name
)
928 && strcasecmp(remotehost
, "localhost")) {
929 DEBUG(0,("host name/name mismatch: %s != %s\n",
930 remotehost
, hp
->h_name
));
934 /* Look up the host address in the address list we just got. */
935 for (i
= 0; hp
->h_addr_list
[i
]; i
++) {
936 if (memcmp(hp
->h_addr_list
[i
], (void *) & addr
, sizeof(addr
)) == 0)
941 * The host name does not map to the original host address. Perhaps
942 * someone has compromised a name server. More likely someone botched
943 * it, but that could be dangerous, too.
946 DEBUG(0,("host name/address mismatch: %s != %s\n",
947 inet_ntoa(addr
), hp
->h_name
));
952 /*******************************************************************
953 return the DNS name of the remote end of a socket
954 ******************************************************************/
955 char *get_socket_name(int fd
)
957 static pstring name_buf
;
958 static fstring addr_buf
;
963 p
= get_socket_addr(fd
);
965 /* it might be the same as the last one - save some DNS work */
966 if (strcmp(p
, addr_buf
) == 0) return name_buf
;
968 pstrcpy(name_buf
,"UNKNOWN");
969 if (fd
== -1) return name_buf
;
971 fstrcpy(addr_buf
, p
);
973 addr
= *interpret_addr2(p
);
975 /* Look up the remote host name. */
976 if ((hp
= gethostbyaddr((char *)&addr
.s_addr
, sizeof(addr
.s_addr
), AF_INET
)) == 0) {
977 DEBUG(1,("Gethostbyaddr failed for %s\n",p
));
978 pstrcpy(name_buf
, p
);
980 pstrcpy(name_buf
,(char *)hp
->h_name
);
981 if (!matchname(name_buf
, addr
)) {
982 DEBUG(0,("Matchname failed on %s %s\n",name_buf
,p
));
983 pstrcpy(name_buf
,"UNKNOWN");
987 alpha_strcpy(name_buf
, name_buf
, "_-.", sizeof(name_buf
));
988 if (strstr(name_buf
,"..")) {
989 pstrcpy(name_buf
, "UNKNOWN");
995 /*******************************************************************
996 return the IP addr of the remote end of a socket as a string
997 ******************************************************************/
998 char *get_socket_addr(int fd
)
1001 struct sockaddr_in
*sockin
= (struct sockaddr_in
*) (&sa
);
1002 socklen_t length
= sizeof(sa
);
1003 static fstring addr_buf
;
1005 fstrcpy(addr_buf
,"0.0.0.0");
1011 if (getpeername(fd
, &sa
, &length
) < 0) {
1012 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno
) ));
1016 fstrcpy(addr_buf
,(char *)inet_ntoa(sockin
->sin_addr
));
1021 /*******************************************************************
1022 Create protected unix domain socket.
1024 some unixen cannot set permissions on a ux-dom-sock, so we
1025 have to make sure that the directory contains the protection
1026 permissions, instead.
1027 ******************************************************************/
1028 int create_pipe_sock(const char *socket_dir
,
1029 const char *socket_name
,
1032 struct sockaddr_un sunaddr
;
1038 /* Create the socket directory or reuse the existing one */
1040 if (lstat(socket_dir
, &st
) == -1) {
1042 if (errno
== ENOENT
) {
1044 /* Create directory */
1046 if (mkdir(socket_dir
, dir_perms
) == -1) {
1047 DEBUG(0, ("error creating socket directory "
1048 "%s: %s\n", socket_dir
,
1055 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1056 socket_dir
, strerror(errno
)));
1062 /* Check ownership and permission on existing directory */
1064 if (!S_ISDIR(st
.st_mode
)) {
1065 DEBUG(0, ("socket directory %s isn't a directory\n",
1070 if ((st
.st_uid
!= sec_initial_uid()) ||
1071 ((st
.st_mode
& 0777) != dir_perms
)) {
1072 DEBUG(0, ("invalid permissions on socket directory "
1073 "%s\n", socket_dir
));
1078 /* Create the socket file */
1080 old_umask
= umask(0);
1082 sock
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1090 snprintf(path
, sizeof(path
), "%s/%s", socket_dir
, socket_name
);
1093 memset(&sunaddr
, 0, sizeof(sunaddr
));
1094 sunaddr
.sun_family
= AF_UNIX
;
1095 safe_strcpy(sunaddr
.sun_path
, path
, sizeof(sunaddr
.sun_path
)-1);
1097 if (bind(sock
, (struct sockaddr
*)&sunaddr
, sizeof(sunaddr
)) == -1) {
1098 DEBUG(0, ("bind failed on pipe socket %s: %s\n",
1106 if (listen(sock
, 5) == -1) {
1107 DEBUG(0, ("listen failed on pipe socket %s: %s\n",
1122 /*******************************************************************
1123 this is like socketpair but uses tcp. It is used by the Samba
1124 regression test code
1125 The function guarantees that nobody else can attach to the socket,
1126 or if they do that this function fails and the socket gets closed
1127 returns 0 on success, -1 on failure
1128 the resulting file descriptors are symmetrical
1129 ******************************************************************/
1130 static int socketpair_tcp(int fd
[2])
1133 struct sockaddr_in sock
;
1134 struct sockaddr_in sock2
;
1135 socklen_t socklen
= sizeof(sock
);
1136 int connect_done
= 0;
1138 fd
[0] = fd
[1] = listener
= -1;
1140 memset(&sock
, 0, sizeof(sock
));
1142 if ((listener
= socket(PF_INET
, SOCK_STREAM
, 0)) == -1) goto failed
;
1144 memset(&sock2
, 0, sizeof(sock2
));
1145 #ifdef HAVE_SOCK_SIN_LEN
1146 sock2
.sin_len
= sizeof(sock2
);
1148 sock2
.sin_family
= PF_INET
;
1150 bind(listener
, (struct sockaddr
*)&sock2
, sizeof(sock2
));
1152 if (listen(listener
, 1) != 0) goto failed
;
1154 if (getsockname(listener
, (struct sockaddr
*)&sock
, &socklen
) != 0) goto failed
;
1156 if ((fd
[1] = socket(PF_INET
, SOCK_STREAM
, 0)) == -1) goto failed
;
1158 set_blocking(fd
[1], 0);
1160 sock
.sin_addr
.s_addr
= htonl(INADDR_LOOPBACK
);
1162 if (connect(fd
[1],(struct sockaddr
*)&sock
,sizeof(sock
)) == -1) {
1163 if (errno
!= EINPROGRESS
) goto failed
;
1168 if ((fd
[0] = accept(listener
, (struct sockaddr
*)&sock
, &socklen
)) == -1) goto failed
;
1171 if (connect_done
== 0) {
1172 if (connect(fd
[1],(struct sockaddr
*)&sock
,sizeof(sock
)) != 0
1173 && errno
!= EISCONN
) goto failed
;
1176 set_blocking(fd
[1], 1);
1182 if (fd
[0] != -1) close(fd
[0]);
1183 if (fd
[1] != -1) close(fd
[1]);
1184 if (listener
!= -1) close(listener
);
1189 /*******************************************************************
1190 run a program on a local tcp socket, this is used to launch smbd
1191 when regression testing
1192 the return value is a socket which is attached to a subprocess
1193 running "prog". stdin and stdout are attached. stderr is left
1194 attached to the original stderr
1195 ******************************************************************/
1196 int sock_exec(const char *prog
)
1199 if (socketpair_tcp(fd
) != 0) {
1200 DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno
)));