2 Unix SMB/Netbios implementation.
4 Samba utility functions
5 Copyright (C) Andrew Tridgell 1992-1998
6 Copyright (C) Tim Potter 2000-2001
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.
26 #include <openssl/ssl.h>
27 #undef Realloc /* SSLeay defines this and samba has a function of this name */
32 /* the last IP received from */
33 struct in_addr lastip;
35 /* the last port received from */
38 int smb_read_error = 0;
40 /****************************************************************************
41 Determine if a file descriptor is in fact a socket.
42 ****************************************************************************/
44 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
62 smb_socket_option socket_options[] = {
63 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
64 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
65 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
67 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
70 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
72 #ifdef IPTOS_THROUGHPUT
73 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
76 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
79 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
82 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
85 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
88 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
91 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
94 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
98 /****************************************************************************
100 ****************************************************************************/
101 static void print_socket_options(int s)
104 smb_socket_option *p = &socket_options[0];
106 for (; p->name != NULL; p++) {
107 if (getsockopt(s, p->level, p->option, (void *)&value, &vlen) == -1) {
108 DEBUG(5,("Could not test socket option %s.\n", p->name));
110 DEBUG(5,("socket option %s = %d\n",p->name,value));
115 /****************************************************************************
116 Set user socket options.
117 ****************************************************************************/
119 void set_socket_options(int fd, char *options)
123 while (next_token(&options,tok," \t,", sizeof(tok))) {
127 BOOL got_value = False;
129 if ((p = strchr_m(tok,'='))) {
135 for (i=0;socket_options[i].name;i++)
136 if (strequal(socket_options[i].name,tok))
139 if (!socket_options[i].name) {
140 DEBUG(0,("Unknown socket option %s\n",tok));
144 switch (socket_options[i].opttype) {
147 ret = setsockopt(fd,socket_options[i].level,
148 socket_options[i].option,(char *)&value,sizeof(int));
153 DEBUG(0,("syntax error - %s does not take a value\n",tok));
156 int on = socket_options[i].value;
157 ret = setsockopt(fd,socket_options[i].level,
158 socket_options[i].option,(char *)&on,sizeof(int));
164 DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
167 print_socket_options(fd);
170 /****************************************************************************
172 ****************************************************************************/
174 ssize_t read_udp_socket(int fd,char *buf,size_t len)
177 struct sockaddr_in sock;
178 socklen_t socklen = sizeof(sock);
180 memset((char *)&sock,'\0',socklen);
181 memset((char *)&lastip,'\0',sizeof(lastip));
182 ret = (ssize_t)recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
184 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
188 lastip = sock.sin_addr;
189 lastport = ntohs(sock.sin_port);
191 DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
192 inet_ntoa(lastip), lastport, ret));
197 /*******************************************************************
198 checks if read data is outstanding.
199 ********************************************************************/
200 int read_data_outstanding(int fd, unsigned int time_out)
204 struct timeval timeout;
209 timeout.tv_sec = (time_t) (time_out / 1000);
210 timeout.tv_usec = (long)(1000 * (time_out % 1000));
212 selrtn = sys_select_intr(fd + 1, &fds, &timeout);
218 return FD_ISSET(fd, &fds) ? 1 : 0;
221 /****************************************************************************
222 Read data from a socket with a timout in msec.
223 mincount = if timeout, minimum to read before returning
224 maxcount = number to be read.
225 time_out = timeout in milliseconds
226 ****************************************************************************/
228 static ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
234 struct timeval timeout;
236 /* just checking .... */
244 if (mincnt == 0) mincnt = maxcnt;
246 while (nread < mincnt) {
249 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
251 readret = read(fd, buf + nread, maxcnt - nread);
254 readret = read(fd, buf + nread, maxcnt - nread);
255 #endif /* WITH_SSL */
258 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
259 smb_read_error = READ_EOF;
264 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
265 smb_read_error = READ_ERROR;
270 return((ssize_t)nread);
273 /* Most difficult - timeout read */
274 /* If this is ever called on a disk file and
275 mincnt is greater then the filesize then
276 system performance will suffer severely as
277 select always returns true on disk files */
279 /* Set initial timeout */
280 timeout.tv_sec = (time_t)(time_out / 1000);
281 timeout.tv_usec = (long)(1000 * (time_out % 1000));
283 for (nread=0; nread < mincnt; ) {
287 selrtn = sys_select_intr(fd+1,&fds,&timeout);
291 /* something is wrong. Maybe the socket is dead? */
292 DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
293 smb_read_error = READ_ERROR;
297 /* Did we timeout ? */
299 DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
300 smb_read_error = READ_TIMEOUT;
306 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
308 readret = read(fd, buf + nread, maxcnt - nread);
311 readret = read(fd, buf+nread, maxcnt-nread);
312 #endif /* WITH_SSL */
315 /* we got EOF on the file descriptor */
316 DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
317 smb_read_error = READ_EOF;
322 /* the descriptor is probably dead */
323 DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
324 smb_read_error = READ_ERROR;
331 /* Return the number we got */
332 return (ssize_t)nread;
335 /****************************************************************************
336 Read data from a fd with a timout in msec.
337 mincount = if timeout, minimum to read before returning
338 maxcount = number to be read.
339 time_out = timeout in milliseconds
340 ****************************************************************************/
342 ssize_t read_with_timeout(int fd, char *buf, size_t mincnt, size_t maxcnt,
343 unsigned int time_out)
348 /* just checking .... */
354 if (mincnt == 0) mincnt = maxcnt;
356 while (nread < mincnt) {
359 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
361 readret = read(fd, buf + nread, maxcnt - nread);
364 readret = read(fd, buf + nread, maxcnt - nread);
365 #endif /* WITH_SSL */
372 return((ssize_t)nread);
375 /* Most difficult - timeout read */
376 /* If this is ever called on a disk file and
377 mincnt is greater then the filesize then
378 system performance will suffer severely as
379 select always returns true on disk files */
381 for (nread=0; nread < mincnt; ) {
382 int selrtn = read_data_outstanding(fd, time_out);
389 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
391 readret = read(fd, buf + nread, maxcnt - nread);
394 readret = read(fd, buf+nread, maxcnt-nread);
395 #endif /* WITH_SSL */
403 /* Return the number we got */
404 return((ssize_t)nread);
407 /****************************************************************************
408 send a keepalive packet (rfc1002)
409 ****************************************************************************/
411 BOOL send_keepalive(int client)
413 unsigned char buf[4];
415 buf[0] = SMBkeepalive;
416 buf[1] = buf[2] = buf[3] = 0;
418 return(write_socket_data(client,(char *)buf,4) == 4);
421 /****************************************************************************
422 read data from the client, reading exactly N bytes.
423 ****************************************************************************/
425 ssize_t read_data(int fd,char *buffer,size_t N)
436 ret = SSL_read(ssl, buffer + total, N - total);
438 ret = read(fd,buffer + total,N - total);
441 ret = read(fd,buffer + total,N - total);
442 #endif /* WITH_SSL */
446 DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
447 smb_read_error = READ_EOF;
452 DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
453 smb_read_error = READ_ERROR;
458 return (ssize_t)total;
461 /****************************************************************************
462 Read data from a socket, reading exactly N bytes.
463 ****************************************************************************/
465 static ssize_t read_socket_data(int fd,char *buffer,size_t N)
476 ret = SSL_read(ssl, buffer + total, N - total);
478 ret = read(fd,buffer + total,N - total);
481 ret = read(fd,buffer + total,N - total);
482 #endif /* WITH_SSL */
486 DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
487 smb_read_error = READ_EOF;
492 DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
493 smb_read_error = READ_ERROR;
498 return (ssize_t)total;
501 /****************************************************************************
503 ****************************************************************************/
505 ssize_t write_data(int fd,char *buffer,size_t N)
514 ret = SSL_write(ssl,buffer + total,N - total);
516 ret = write(fd,buffer + total,N - total);
519 ret = write(fd,buffer + total,N - total);
520 #endif /* WITH_SSL */
523 DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
526 if (ret == 0) return total;
530 return (ssize_t)total;
533 /****************************************************************************
534 Write data to a socket - use send rather than write.
535 ****************************************************************************/
537 ssize_t write_socket_data(int fd,char *buffer,size_t N)
546 ret = SSL_write(ssl,buffer + total,N - total);
548 ret = send(fd,buffer + total,N - total, 0);
551 ret = send(fd,buffer + total,N - total,0);
552 #endif /* WITH_SSL */
555 DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
558 if (ret == 0) return total;
562 return (ssize_t)total;
565 /****************************************************************************
567 ****************************************************************************/
569 ssize_t write_socket(int fd,char *buf,size_t len)
573 DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
574 ret = write_socket_data(fd,buf,len);
576 DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
578 DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
579 (int)len, fd, strerror(errno) ));
584 /****************************************************************************
585 read 4 bytes of a smb packet and return the smb length of the packet
586 store the result in the buffer
587 This version of the function will return a length of zero on receiving
589 timeout is in milliseconds.
590 ****************************************************************************/
592 static ssize_t read_smb_length_return_keepalive(int fd,char *inbuf,unsigned int timeout)
601 ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
603 ok = (read_socket_data(fd,inbuf,4) == 4);
608 len = smb_len(inbuf);
609 msg_type = CVAL(inbuf,0);
611 if (msg_type == SMBkeepalive)
612 DEBUG(5,("Got keepalive packet\n"));
615 DEBUG(10,("got smb length of %d\n",len));
620 /****************************************************************************
621 read 4 bytes of a smb packet and return the smb length of the packet
622 store the result in the buffer. This version of the function will
623 never return a session keepalive (length of zero).
624 timeout is in milliseconds.
625 ****************************************************************************/
627 ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout)
633 len = read_smb_length_return_keepalive(fd, inbuf, timeout);
638 /* Ignore session keepalives. */
639 if(CVAL(inbuf,0) != SMBkeepalive)
643 DEBUG(10,("read_smb_length: got smb length of %d\n",len));
648 /****************************************************************************
649 read an smb from a fd. Note that the buffer *MUST* be of size
650 BUFFER_SIZE+SAFETY_MARGIN.
651 The timeout is in milliseconds.
652 This function will return on a
653 receipt of a session keepalive packet.
654 ****************************************************************************/
656 BOOL receive_smb(int fd,char *buffer, unsigned int timeout)
662 memset(buffer,'\0',smb_size + 100);
664 len = read_smb_length_return_keepalive(fd,buffer,timeout);
666 DEBUG(10,("receive_smb: length < 0!\n"));
671 * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
672 * of header. Don't print the error if this fits.... JRA.
675 if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
676 DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
677 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
678 smb_read_error = READ_ERROR;
684 ret = read_socket_data(fd,buffer+4,len);
686 smb_read_error = READ_ERROR;
694 /****************************************************************************
695 read an smb from a fd ignoring all keepalive packets. Note that the buffer
696 *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
697 The timeout is in milliseconds
699 This is exactly the same as receive_smb except that it never returns
700 a session keepalive packet (just as receive_smb used to do).
701 receive_smb was changed to return keepalives as the oplock processing means this call
702 should never go into a blocking read.
703 ****************************************************************************/
705 BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout)
711 ret = receive_smb(fd, buffer, timeout);
715 DEBUG(10,("client_receive_smb failed\n"));
720 /* Ignore session keepalive packets. */
721 if(CVAL(buffer,0) != SMBkeepalive)
728 /****************************************************************************
730 ****************************************************************************/
732 BOOL send_smb(int fd,char *buffer)
737 len = smb_len(buffer) + 4;
739 while (nwritten < len) {
740 ret = write_socket(fd,buffer+nwritten,len - nwritten);
742 DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
743 (int)len,(int)ret, strerror(errno) ));
752 /****************************************************************************
753 send a single packet to a port on another machine
754 ****************************************************************************/
756 BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
760 struct sockaddr_in sock_out;
762 /* create a socket to write to */
763 out_fd = socket(AF_INET, type, 0);
766 DEBUG(0,("socket failed"));
770 /* set the address and port */
771 memset((char *)&sock_out,'\0',sizeof(sock_out));
772 putip((char *)&sock_out.sin_addr,(char *)&ip);
773 sock_out.sin_port = htons( port );
774 sock_out.sin_family = AF_INET;
777 DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
778 len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
781 ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
784 DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
785 inet_ntoa(ip),port,strerror(errno)));
791 /****************************************************************************
792 Open a socket of the specified type, port, and address for incoming data.
793 ****************************************************************************/
795 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
797 struct sockaddr_in sock;
800 memset( (char *)&sock, '\0', sizeof(sock) );
802 #ifdef HAVE_SOCK_SIN_LEN
803 sock.sin_len = sizeof(sock);
805 sock.sin_port = htons( port );
806 sock.sin_family = AF_INET;
807 sock.sin_addr.s_addr = socket_addr;
809 res = socket( AF_INET, type, 0 );
812 dbgtext( "open_socket_in(): socket() call failed: " );
813 dbgtext( "%s\n", strerror( errno ) );
818 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
820 int val = rebind ? 1 : 0;
821 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
822 if( DEBUGLVL( dlevel ) ) {
823 dbgtext( "open_socket_in(): setsockopt: " );
824 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
825 dbgtext( "on port %d failed ", port );
826 dbgtext( "with error = %s\n", strerror(errno) );
830 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
831 if( DEBUGLVL( dlevel ) ) {
832 dbgtext( "open_socket_in(): setsockopt: ");
833 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
834 dbgtext( "on port %d failed ", port );
835 dbgtext( "with error = %s\n", strerror(errno) );
838 #endif /* SO_REUSEPORT */
841 /* now we've got a socket - we need to bind it */
842 if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
843 if( DEBUGLVL(dlevel) && (port == SMB_PORT || port == NMB_PORT) ) {
844 dbgtext( "bind failed on port %d ", port );
845 dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
846 dbgtext( "Error = %s\n", strerror(errno) );
852 DEBUG( 3, ( "bind succeeded on port %d\n", port ) );
857 /****************************************************************************
858 create an outgoing socket. timeout is in milliseconds.
859 **************************************************************************/
861 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
863 struct sockaddr_in sock_out;
865 int connect_loop = 250; /* 250 milliseconds */
866 int loops = (timeout) / connect_loop;
868 /* create a socket to write to */
869 res = socket(PF_INET, type, 0);
871 { DEBUG(0,("socket error\n")); return -1; }
873 if (type != SOCK_STREAM) return(res);
875 memset((char *)&sock_out,'\0',sizeof(sock_out));
876 putip((char *)&sock_out.sin_addr,(char *)addr);
878 sock_out.sin_port = htons( port );
879 sock_out.sin_family = PF_INET;
881 /* set it non-blocking */
882 set_blocking(res,False);
884 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
886 /* and connect it to the destination */
888 ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
890 /* Some systems return EAGAIN when they mean EINPROGRESS */
891 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
892 errno == EAGAIN) && loops--) {
893 msleep(connect_loop);
897 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
899 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
905 if (ret < 0 && errno == EISCONN) {
912 DEBUG(2,("error connecting to %s:%d (%s)\n",
913 inet_ntoa(*addr),port,strerror(errno)));
918 /* set it blocking again */
919 set_blocking(res,True);
925 open a connected UDP socket to host on port
927 int open_udp_socket(const char *host, int port)
929 int type = SOCK_DGRAM;
930 struct sockaddr_in sock_out;
932 struct in_addr *addr;
934 addr = interpret_addr2(host);
936 res = socket(PF_INET, type, 0);
941 memset((char *)&sock_out,'\0',sizeof(sock_out));
942 putip((char *)&sock_out.sin_addr,(char *)addr);
943 sock_out.sin_port = htons(port);
944 sock_out.sin_family = PF_INET;
946 if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
955 /* the following 3 client_*() functions are nasty ways of allowing
956 some generic functions to get info that really should be hidden in
957 particular modules */
958 static int client_fd = -1;
960 void client_setfd(int fd)
965 char *client_name(void)
967 return get_socket_name(client_fd);
970 char *client_addr(void)
972 return get_socket_addr(client_fd);
975 /*******************************************************************
976 matchname - determine if host name matches IP address. Used to
977 confirm a hostname lookup to prevent spoof attacks
978 ******************************************************************/
979 static BOOL matchname(char *remotehost,struct in_addr addr)
984 if ((hp = sys_gethostbyname(remotehost)) == 0) {
985 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
990 * Make sure that gethostbyname() returns the "correct" host name.
991 * Unfortunately, gethostbyname("localhost") sometimes yields
992 * "localhost.domain". Since the latter host name comes from the
993 * local DNS, we just have to trust it (all bets are off if the local
994 * DNS is perverted). We always check the address list, though.
997 if (strcasecmp(remotehost, hp->h_name)
998 && strcasecmp(remotehost, "localhost")) {
999 DEBUG(0,("host name/name mismatch: %s != %s\n",
1000 remotehost, hp->h_name));
1004 /* Look up the host address in the address list we just got. */
1005 for (i = 0; hp->h_addr_list[i]; i++) {
1006 if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
1011 * The host name does not map to the original host address. Perhaps
1012 * someone has compromised a name server. More likely someone botched
1013 * it, but that could be dangerous, too.
1016 DEBUG(0,("host name/address mismatch: %s != %s\n",
1017 inet_ntoa(addr), hp->h_name));
1022 /*******************************************************************
1023 return the DNS name of the remote end of a socket
1024 ******************************************************************/
1025 char *get_socket_name(int fd)
1027 static pstring name_buf;
1028 static fstring addr_buf;
1030 struct in_addr addr;
1033 /* reverse lookups can be *very* expensive, and in many
1034 situations won't work because many networks don't link dhcp
1035 with dns. To avoid the delay we avoid the lookup if
1037 if (!lp_hostname_lookups()) {
1038 return get_socket_addr(fd);
1041 p = get_socket_addr(fd);
1043 /* it might be the same as the last one - save some DNS work */
1044 if (strcmp(p, addr_buf) == 0) return name_buf;
1046 pstrcpy(name_buf,"UNKNOWN");
1047 if (fd == -1) return name_buf;
1049 fstrcpy(addr_buf, p);
1051 addr = *interpret_addr2(p);
1053 /* Look up the remote host name. */
1054 if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1055 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1056 pstrcpy(name_buf, p);
1058 pstrcpy(name_buf,(char *)hp->h_name);
1059 if (!matchname(name_buf, addr)) {
1060 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1061 pstrcpy(name_buf,"UNKNOWN");
1065 alpha_strcpy(name_buf, name_buf, "_-.", sizeof(name_buf));
1066 if (strstr(name_buf,"..")) {
1067 pstrcpy(name_buf, "UNKNOWN");
1073 /*******************************************************************
1074 return the IP addr of the remote end of a socket as a string
1075 ******************************************************************/
1076 char *get_socket_addr(int fd)
1079 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1080 int length = sizeof(sa);
1081 static fstring addr_buf;
1083 fstrcpy(addr_buf,"0.0.0.0");
1089 if (getpeername(fd, &sa, &length) < 0) {
1090 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1094 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1099 /*******************************************************************
1100 opens and connects to a unix pipe socket
1101 ******************************************************************/
1102 int open_pipe_sock(char *path)
1105 struct sockaddr_un sa;
1107 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1111 DEBUG(0, ("unix socket open failed\n"));
1116 sa.sun_family = AF_UNIX;
1117 safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1119 DEBUG(10, ("socket open succeeded. file name: %s\n", sa.sun_path));
1121 if (connect(sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1123 DEBUG(0,("socket connect to %s failed\n", sa.sun_path));
1131 /*******************************************************************
1132 Create protected unix domain socket.
1134 some unixen cannot set permissions on a ux-dom-sock, so we
1135 have to make sure that the directory contains the protection
1136 permissions, instead.
1137 ******************************************************************/
1138 int create_pipe_sock(const char *socket_dir,
1139 const char *socket_name,
1142 struct sockaddr_un sunaddr;
1148 /* Create the socket directory or reuse the existing one */
1150 if (lstat(socket_dir, &st) == -1) {
1152 if (errno == ENOENT) {
1154 /* Create directory */
1156 if (mkdir(socket_dir, dir_perms) == -1) {
1157 DEBUG(0, ("error creating socket directory "
1158 "%s: %s\n", socket_dir,
1165 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1166 socket_dir, strerror(errno)));
1172 /* Check ownership and permission on existing directory */
1174 if (!S_ISDIR(st.st_mode)) {
1175 DEBUG(0, ("socket directory %s isn't a directory\n",
1180 if ((st.st_uid != sec_initial_uid()) ||
1181 ((st.st_mode & 0777) != dir_perms)) {
1182 DEBUG(0, ("invalid permissions on socket directory "
1183 "%s\n", socket_dir));
1188 /* Create the socket file */
1190 old_umask = umask(0);
1192 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1200 snprintf(path, sizeof(path), "%s/%s", socket_dir, socket_name);
1203 memset(&sunaddr, 0, sizeof(sunaddr));
1204 sunaddr.sun_family = AF_UNIX;
1205 safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1207 if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1208 DEBUG(0, ("bind failed on pipe socket %s: %s\n",
1216 if (listen(sock, 5) == -1) {
1217 DEBUG(0, ("listen failed on pipe socket %s: %s\n",
1232 /*******************************************************************
1233 this is like socketpair but uses tcp. It is used by the Samba
1234 regression test code
1235 The function guarantees that nobody else can attach to the socket,
1236 or if they do that this function fails and the socket gets closed
1237 returns 0 on success, -1 on failure
1238 the resulting file descriptors are symmetrical
1239 ******************************************************************/
1240 static int socketpair_tcp(int fd[2])
1243 struct sockaddr_in sock;
1244 struct sockaddr_in sock2;
1245 socklen_t socklen = sizeof(sock);
1246 int connect_done = 0;
1248 fd[0] = fd[1] = listener = -1;
1250 memset(&sock, 0, sizeof(sock));
1252 if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1254 memset(&sock2, 0, sizeof(sock2));
1255 #ifdef HAVE_SOCK_SIN_LEN
1256 sock2.sin_len = sizeof(sock2);
1258 sock2.sin_family = PF_INET;
1260 bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
1262 if (listen(listener, 1) != 0) goto failed;
1264 if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
1266 if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1268 set_blocking(fd[1], 0);
1270 sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1272 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
1273 if (errno != EINPROGRESS) goto failed;
1278 if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
1281 if (connect_done == 0) {
1282 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
1283 && errno != EISCONN) goto failed;
1286 set_blocking(fd[1], 1);
1292 if (fd[0] != -1) close(fd[0]);
1293 if (fd[1] != -1) close(fd[1]);
1294 if (listener != -1) close(listener);
1299 /*******************************************************************
1300 run a program on a local tcp socket, this is used to launch smbd
1301 when regression testing
1302 the return value is a socket which is attached to a subprocess
1303 running "prog". stdin and stdout are attached. stderr is left
1304 attached to the original stderr
1305 ******************************************************************/
1306 int sock_exec(const char *prog)
1309 if (socketpair_tcp(fd) != 0) {
1310 DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno)));