2 Unix SMB/CIFS implementation.
3 Samba utility functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Tim Potter 2000-2001
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.
24 /* the last IP received from */
25 struct in_addr lastip;
27 /* the last port received from */
30 int smb_read_error = 0;
32 /****************************************************************************
33 Determine if a file descriptor is in fact a socket.
34 ****************************************************************************/
36 BOOL is_a_socket(int fd)
40 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
43 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
45 typedef struct smb_socket_option {
53 static const smb_socket_option socket_options[] = {
54 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
55 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
56 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
58 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
61 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
63 #ifdef IPTOS_THROUGHPUT
64 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
67 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
70 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
73 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
76 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
79 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
82 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
85 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
89 /****************************************************************************
91 ****************************************************************************/
93 static void print_socket_options(int s)
96 const smb_socket_option *p = &socket_options[0];
98 for (; p->name != NULL; p++) {
99 if (getsockopt(s, p->level, p->option, (void *)&value, &vlen) == -1) {
100 DEBUG(5,("Could not test socket option %s.\n", p->name));
102 DEBUG(5,("socket option %s = %d\n",p->name,value));
107 /****************************************************************************
108 Set user socket options.
109 ****************************************************************************/
111 void set_socket_options(int fd, char *options)
115 while (next_token(&options,tok," \t,", sizeof(tok))) {
119 BOOL got_value = False;
121 if ((p = strchr_m(tok,'='))) {
127 for (i=0;socket_options[i].name;i++)
128 if (strequal(socket_options[i].name,tok))
131 if (!socket_options[i].name) {
132 DEBUG(0,("Unknown socket option %s\n",tok));
136 switch (socket_options[i].opttype) {
139 ret = setsockopt(fd,socket_options[i].level,
140 socket_options[i].option,(char *)&value,sizeof(int));
145 DEBUG(0,("syntax error - %s does not take a value\n",tok));
148 int on = socket_options[i].value;
149 ret = setsockopt(fd,socket_options[i].level,
150 socket_options[i].option,(char *)&on,sizeof(int));
156 DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
159 print_socket_options(fd);
162 /****************************************************************************
164 ****************************************************************************/
166 ssize_t read_udp_socket(int fd,char *buf,size_t len)
169 struct sockaddr_in sock;
170 socklen_t socklen = sizeof(sock);
172 memset((char *)&sock,'\0',socklen);
173 memset((char *)&lastip,'\0',sizeof(lastip));
174 ret = (ssize_t)sys_recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
176 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
180 lastip = sock.sin_addr;
181 lastport = ntohs(sock.sin_port);
183 DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
184 inet_ntoa(lastip), lastport, ret));
189 /*******************************************************************
190 checks if read data is outstanding.
191 ********************************************************************/
192 static int read_data_outstanding(int fd, unsigned int time_out)
196 struct timeval timeout;
201 timeout.tv_sec = (time_t) (time_out / 1000);
202 timeout.tv_usec = (long)(1000 * (time_out % 1000));
204 selrtn = sys_select_intr(fd + 1, &fds, NULL, NULL, &timeout);
210 return FD_ISSET(fd, &fds) ? 1 : 0;
213 /****************************************************************************
214 Read data from a socket with a timout in msec.
215 mincount = if timeout, minimum to read before returning
216 maxcount = number to be read.
217 time_out = timeout in milliseconds
218 ****************************************************************************/
220 static ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
226 struct timeval timeout;
228 /* just checking .... */
236 if (mincnt == 0) mincnt = maxcnt;
238 while (nread < mincnt) {
239 readret = sys_read(fd, buf + nread, maxcnt - nread);
242 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
243 smb_read_error = READ_EOF;
248 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
249 smb_read_error = READ_ERROR;
254 return((ssize_t)nread);
257 /* Most difficult - timeout read */
258 /* If this is ever called on a disk file and
259 mincnt is greater then the filesize then
260 system performance will suffer severely as
261 select always returns true on disk files */
263 /* Set initial timeout */
264 timeout.tv_sec = (time_t)(time_out / 1000);
265 timeout.tv_usec = (long)(1000 * (time_out % 1000));
267 for (nread=0; nread < mincnt; ) {
271 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
275 /* something is wrong. Maybe the socket is dead? */
276 DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
277 smb_read_error = READ_ERROR;
281 /* Did we timeout ? */
283 DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
284 smb_read_error = READ_TIMEOUT;
288 readret = sys_read(fd, buf+nread, maxcnt-nread);
291 /* we got EOF on the file descriptor */
292 DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
293 smb_read_error = READ_EOF;
298 /* the descriptor is probably dead */
299 DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
300 smb_read_error = READ_ERROR;
307 /* Return the number we got */
308 return (ssize_t)nread;
311 /****************************************************************************
312 Read data from a fd with a timout in msec.
313 mincount = if timeout, minimum to read before returning
314 maxcount = number to be read.
315 time_out = timeout in milliseconds
316 ****************************************************************************/
318 ssize_t read_with_timeout(int fd, char *buf, size_t mincnt, size_t maxcnt,
319 unsigned int time_out)
324 /* just checking .... */
330 if (mincnt == 0) mincnt = maxcnt;
332 while (nread < mincnt) {
333 readret = sys_read(fd, buf + nread, maxcnt - nread);
340 return((ssize_t)nread);
343 /* Most difficult - timeout read */
344 /* If this is ever called on a disk file and
345 mincnt is greater then the filesize then
346 system performance will suffer severely as
347 select always returns true on disk files */
349 for (nread=0; nread < mincnt; ) {
350 int selrtn = read_data_outstanding(fd, time_out);
355 readret = sys_read(fd, buf+nread, maxcnt-nread);
363 /* Return the number we got */
364 return((ssize_t)nread);
367 /****************************************************************************
368 read data from the client, reading exactly N bytes.
369 ****************************************************************************/
371 ssize_t read_data(int fd,char *buffer,size_t N)
379 ret = sys_read(fd,buffer + total,N - total);
382 DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
383 smb_read_error = READ_EOF;
388 DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
389 smb_read_error = READ_ERROR;
394 return (ssize_t)total;
397 /****************************************************************************
398 Read data from a socket, reading exactly N bytes.
399 ****************************************************************************/
401 static ssize_t read_socket_data(int fd,char *buffer,size_t N)
409 ret = sys_read(fd,buffer + total,N - total);
412 DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
413 smb_read_error = READ_EOF;
418 DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
419 smb_read_error = READ_ERROR;
424 return (ssize_t)total;
427 /****************************************************************************
429 ****************************************************************************/
431 ssize_t write_data(int fd,char *buffer,size_t N)
437 ret = sys_write(fd,buffer + total,N - total);
440 DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
448 return (ssize_t)total;
451 /****************************************************************************
452 Write data to a socket - use send rather than write.
453 ****************************************************************************/
455 static ssize_t write_socket_data(int fd,char *buffer,size_t N)
461 ret = sys_send(fd,buffer + total,N - total,0);
464 DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
472 return (ssize_t)total;
475 /****************************************************************************
477 ****************************************************************************/
479 ssize_t write_socket(int fd,char *buf,size_t len)
483 DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
484 ret = write_socket_data(fd,buf,len);
486 DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
488 DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
489 (int)len, fd, strerror(errno) ));
494 /****************************************************************************
495 send a keepalive packet (rfc1002)
496 ****************************************************************************/
498 BOOL send_keepalive(int client)
500 unsigned char buf[4];
502 buf[0] = SMBkeepalive;
503 buf[1] = buf[2] = buf[3] = 0;
505 return(write_socket_data(client,(char *)buf,4) == 4);
509 /****************************************************************************
510 read 4 bytes of a smb packet and return the smb length of the packet
511 store the result in the buffer
512 This version of the function will return a length of zero on receiving
514 timeout is in milliseconds.
515 ****************************************************************************/
517 static ssize_t read_smb_length_return_keepalive(int fd,char *inbuf,unsigned int timeout)
525 ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
527 ok = (read_socket_data(fd,inbuf,4) == 4);
532 len = smb_len(inbuf);
533 msg_type = CVAL(inbuf,0);
535 if (msg_type == SMBkeepalive)
536 DEBUG(5,("Got keepalive packet\n"));
539 DEBUG(10,("got smb length of %d\n",len));
544 /****************************************************************************
545 read 4 bytes of a smb packet and return the smb length of the packet
546 store the result in the buffer. This version of the function will
547 never return a session keepalive (length of zero).
548 timeout is in milliseconds.
549 ****************************************************************************/
551 ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout)
556 len = read_smb_length_return_keepalive(fd, inbuf, timeout);
561 /* Ignore session keepalives. */
562 if(CVAL(inbuf,0) != SMBkeepalive)
566 DEBUG(10,("read_smb_length: got smb length of %d\n",len));
571 /****************************************************************************
572 read an smb from a fd. Note that the buffer *MUST* be of size
573 BUFFER_SIZE+SAFETY_MARGIN.
574 The timeout is in milliseconds.
575 This function will return on a
576 receipt of a session keepalive packet.
577 ****************************************************************************/
579 BOOL receive_smb(int fd,char *buffer, unsigned int timeout)
585 memset(buffer,'\0',smb_size + 100);
587 len = read_smb_length_return_keepalive(fd,buffer,timeout);
589 DEBUG(10,("receive_smb: length < 0!\n"));
592 * Correct fix. smb_read_error may have already been
593 * set. Only set it here if not already set. Global
594 * variables still suck :-). JRA.
597 if (smb_read_error == 0)
598 smb_read_error = READ_ERROR;
603 * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
604 * of header. Don't print the error if this fits.... JRA.
607 if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
608 DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
609 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
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;
624 ret = read_socket_data(fd,buffer+4,len);
626 if (smb_read_error == 0)
627 smb_read_error = READ_ERROR;
635 /****************************************************************************
637 ****************************************************************************/
639 BOOL send_smb(int fd,char *buffer)
644 len = smb_len(buffer) + 4;
646 while (nwritten < len) {
647 ret = write_socket(fd,buffer+nwritten,len - nwritten);
649 DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
650 (int)len,(int)ret, strerror(errno) ));
659 /****************************************************************************
660 Open a socket of the specified type, port, and address for incoming data.
661 ****************************************************************************/
663 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
665 struct sockaddr_in sock;
668 memset( (char *)&sock, '\0', sizeof(sock) );
670 #ifdef HAVE_SOCK_SIN_LEN
671 sock.sin_len = sizeof(sock);
673 sock.sin_port = htons( port );
674 sock.sin_family = AF_INET;
675 sock.sin_addr.s_addr = socket_addr;
677 res = socket( AF_INET, type, 0 );
680 dbgtext( "open_socket_in(): socket() call failed: " );
681 dbgtext( "%s\n", strerror( errno ) );
686 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
688 int val = rebind ? 1 : 0;
689 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
690 if( DEBUGLVL( dlevel ) ) {
691 dbgtext( "open_socket_in(): setsockopt: " );
692 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
693 dbgtext( "on port %d failed ", port );
694 dbgtext( "with error = %s\n", strerror(errno) );
698 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
699 if( DEBUGLVL( dlevel ) ) {
700 dbgtext( "open_socket_in(): setsockopt: ");
701 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
702 dbgtext( "on port %d failed ", port );
703 dbgtext( "with error = %s\n", strerror(errno) );
706 #endif /* SO_REUSEPORT */
709 /* now we've got a socket - we need to bind it */
710 if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
711 if( DEBUGLVL(dlevel) && (port == SMB_PORT1 || port == SMB_PORT2 || port == NMB_PORT) ) {
712 dbgtext( "bind failed on port %d ", port );
713 dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
714 dbgtext( "Error = %s\n", strerror(errno) );
720 DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
725 /****************************************************************************
726 create an outgoing socket. timeout is in milliseconds.
727 **************************************************************************/
729 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
731 struct sockaddr_in sock_out;
733 int connect_loop = 250; /* 250 milliseconds */
734 int loops = (timeout) / connect_loop;
736 /* create a socket to write to */
737 res = socket(PF_INET, type, 0);
739 { DEBUG(0,("socket error\n")); return -1; }
741 if (type != SOCK_STREAM) return(res);
743 memset((char *)&sock_out,'\0',sizeof(sock_out));
744 putip((char *)&sock_out.sin_addr,(char *)addr);
746 sock_out.sin_port = htons( port );
747 sock_out.sin_family = PF_INET;
749 /* set it non-blocking */
750 set_blocking(res,False);
752 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
754 /* and connect it to the destination */
756 ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
758 /* Some systems return EAGAIN when they mean EINPROGRESS */
759 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
760 errno == EAGAIN) && loops--) {
761 msleep(connect_loop);
765 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
767 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
773 if (ret < 0 && errno == EISCONN) {
780 DEBUG(2,("error connecting to %s:%d (%s)\n",
781 inet_ntoa(*addr),port,strerror(errno)));
786 /* set it blocking again */
787 set_blocking(res,True);
793 open a connected UDP socket to host on port
795 int open_udp_socket(const char *host, int port)
797 int type = SOCK_DGRAM;
798 struct sockaddr_in sock_out;
800 struct in_addr *addr;
802 addr = interpret_addr2(host);
804 res = socket(PF_INET, type, 0);
809 memset((char *)&sock_out,'\0',sizeof(sock_out));
810 putip((char *)&sock_out.sin_addr,(char *)addr);
811 sock_out.sin_port = htons(port);
812 sock_out.sin_family = PF_INET;
814 if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
823 /* the following 3 client_*() functions are nasty ways of allowing
824 some generic functions to get info that really should be hidden in
825 particular modules */
826 static int client_fd = -1;
828 void client_setfd(int fd)
833 char *client_name(void)
835 return get_socket_name(client_fd);
838 char *client_addr(void)
840 return get_socket_addr(client_fd);
843 /*******************************************************************
844 matchname - determine if host name matches IP address. Used to
845 confirm a hostname lookup to prevent spoof attacks
846 ******************************************************************/
847 static BOOL matchname(char *remotehost,struct in_addr addr)
852 if ((hp = sys_gethostbyname(remotehost)) == 0) {
853 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
858 * Make sure that gethostbyname() returns the "correct" host name.
859 * Unfortunately, gethostbyname("localhost") sometimes yields
860 * "localhost.domain". Since the latter host name comes from the
861 * local DNS, we just have to trust it (all bets are off if the local
862 * DNS is perverted). We always check the address list, though.
865 if (strcasecmp(remotehost, hp->h_name)
866 && strcasecmp(remotehost, "localhost")) {
867 DEBUG(0,("host name/name mismatch: %s != %s\n",
868 remotehost, hp->h_name));
872 /* Look up the host address in the address list we just got. */
873 for (i = 0; hp->h_addr_list[i]; i++) {
874 if (memcmp(hp->h_addr_list[i], (char *) & addr, sizeof(addr)) == 0)
879 * The host name does not map to the original host address. Perhaps
880 * someone has compromised a name server. More likely someone botched
881 * it, but that could be dangerous, too.
884 DEBUG(0,("host name/address mismatch: %s != %s\n",
885 inet_ntoa(addr), hp->h_name));
890 /*******************************************************************
891 return the DNS name of the remote end of a socket
892 ******************************************************************/
893 char *get_socket_name(int fd)
895 static pstring name_buf;
896 static fstring addr_buf;
901 /* reverse lookups can be *very* expensive, and in many
902 situations won't work because many networks don't link dhcp
903 with dns. To avoid the delay we avoid the lookup if
905 if (!lp_hostname_lookups()) {
906 return get_socket_addr(fd);
909 p = get_socket_addr(fd);
911 /* it might be the same as the last one - save some DNS work */
912 if (strcmp(p, addr_buf) == 0) return name_buf;
914 pstrcpy(name_buf,"UNKNOWN");
915 if (fd == -1) return name_buf;
917 fstrcpy(addr_buf, p);
919 addr = *interpret_addr2(p);
921 /* Look up the remote host name. */
922 if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
923 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
924 pstrcpy(name_buf, p);
926 pstrcpy(name_buf,(char *)hp->h_name);
927 if (!matchname(name_buf, addr)) {
928 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
929 pstrcpy(name_buf,"UNKNOWN");
933 alpha_strcpy(name_buf, name_buf, "_-.", sizeof(name_buf));
934 if (strstr(name_buf,"..")) {
935 pstrcpy(name_buf, "UNKNOWN");
941 /*******************************************************************
942 return the IP addr of the remote end of a socket as a string
943 ******************************************************************/
944 char *get_socket_addr(int fd)
947 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
948 int length = sizeof(sa);
949 static fstring addr_buf;
951 fstrcpy(addr_buf,"0.0.0.0");
957 if (getpeername(fd, &sa, &length) < 0) {
958 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
962 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
968 /*******************************************************************
969 Create protected unix domain socket.
971 some unixen cannot set permissions on a ux-dom-sock, so we
972 have to make sure that the directory contains the protection
973 permissions, instead.
974 ******************************************************************/
975 int create_pipe_sock(const char *socket_dir,
976 const char *socket_name,
979 #ifdef HAVE_UNIXSOCKET
980 struct sockaddr_un sunaddr;
986 /* Create the socket directory or reuse the existing one */
988 if (lstat(socket_dir, &st) == -1) {
990 if (errno == ENOENT) {
992 /* Create directory */
994 if (mkdir(socket_dir, dir_perms) == -1) {
995 DEBUG(0, ("error creating socket directory "
996 "%s: %s\n", socket_dir,
1003 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1004 socket_dir, strerror(errno)));
1010 /* Check ownership and permission on existing directory */
1012 if (!S_ISDIR(st.st_mode)) {
1013 DEBUG(0, ("socket directory %s isn't a directory\n",
1018 if ((st.st_uid != sec_initial_uid()) ||
1019 ((st.st_mode & 0777) != dir_perms)) {
1020 DEBUG(0, ("invalid permissions on socket directory "
1021 "%s\n", socket_dir));
1026 /* Create the socket file */
1028 old_umask = umask(0);
1030 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1038 snprintf(path, sizeof(path), "%s/%s", socket_dir, socket_name);
1041 memset(&sunaddr, 0, sizeof(sunaddr));
1042 sunaddr.sun_family = AF_UNIX;
1043 safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1045 if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1046 DEBUG(0, ("bind failed on pipe socket %s: %s\n",
1054 if (listen(sock, 5) == -1) {
1055 DEBUG(0, ("listen failed on pipe socket %s: %s\n",
1069 DEBUG(0, ("create_pipe_sock: No Unix sockets on this system\n"));
1071 #endif /* HAVE_UNIXSOCKET */
1074 /*******************************************************************
1075 this is like socketpair but uses tcp. It is used by the Samba
1076 regression test code
1077 The function guarantees that nobody else can attach to the socket,
1078 or if they do that this function fails and the socket gets closed
1079 returns 0 on success, -1 on failure
1080 the resulting file descriptors are symmetrical
1081 ******************************************************************/
1082 static int socketpair_tcp(int fd[2])
1085 struct sockaddr_in sock;
1086 struct sockaddr_in sock2;
1087 socklen_t socklen = sizeof(sock);
1088 int connect_done = 0;
1090 fd[0] = fd[1] = listener = -1;
1092 memset(&sock, 0, sizeof(sock));
1094 if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1096 memset(&sock2, 0, sizeof(sock2));
1097 #ifdef HAVE_SOCK_SIN_LEN
1098 sock2.sin_len = sizeof(sock2);
1100 sock2.sin_family = PF_INET;
1102 bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
1104 if (listen(listener, 1) != 0) goto failed;
1106 if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
1108 if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1110 set_blocking(fd[1], 0);
1112 sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1114 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
1115 if (errno != EINPROGRESS) goto failed;
1120 if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
1123 if (connect_done == 0) {
1124 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
1125 && errno != EISCONN) goto failed;
1128 set_blocking(fd[1], 1);
1134 if (fd[0] != -1) close(fd[0]);
1135 if (fd[1] != -1) close(fd[1]);
1136 if (listener != -1) close(listener);
1141 /*******************************************************************
1142 run a program on a local tcp socket, this is used to launch smbd
1143 when regression testing
1144 the return value is a socket which is attached to a subprocess
1145 running "prog". stdin and stdout are attached. stderr is left
1146 attached to the original stderr
1147 ******************************************************************/
1148 int sock_exec(const char *prog)
1151 if (socketpair_tcp(fd) != 0) {
1152 DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno)));