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.
26 #undef Realloc /* SSLeay defines this and samba has a function of this name */
31 extern int DEBUGLEVEL;
33 /* the last IP received from */
34 struct in_addr lastip;
36 /* the last port received from */
39 int smb_read_error = 0;
41 /****************************************************************************
42 Determine if a file descriptor is in fact a socket.
43 ****************************************************************************/
45 BOOL is_a_socket(int fd)
49 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
52 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
54 typedef struct smb_socket_option
63 smb_socket_option socket_options[] = {
64 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
65 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
66 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
68 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
71 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
73 #ifdef IPTOS_THROUGHPUT
74 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
77 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
80 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
83 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
86 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
89 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
92 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
95 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
99 /****************************************************************************
100 Print socket options.
101 ****************************************************************************/
102 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;
181 socklen = sizeof(sock);
182 memset((char *)&sock,'\0',socklen);
183 memset((char *)&lastip,'\0',sizeof(lastip));
184 ret = (ssize_t)recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
186 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
190 lastip = sock.sin_addr;
191 lastport = ntohs(sock.sin_port);
193 DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
194 inet_ntoa(lastip), lastport, ret));
199 /****************************************************************************
200 Read data from a socket with a timout in msec.
201 mincount = if timeout, minimum to read before returning
202 maxcount = number to be read.
203 time_out = timeout in milliseconds
204 ****************************************************************************/
206 static ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
212 struct timeval timeout;
214 /* just checking .... */
222 if (mincnt == 0) mincnt = maxcnt;
224 while (nread < mincnt) {
227 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
229 readret = read(fd, buf + nread, maxcnt - nread);
232 readret = read(fd, buf + nread, maxcnt - nread);
233 #endif /* WITH_SSL */
236 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
237 smb_read_error = READ_EOF;
242 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
243 smb_read_error = READ_ERROR;
248 return((ssize_t)nread);
251 /* Most difficult - timeout read */
252 /* If this is ever called on a disk file and
253 mincnt is greater then the filesize then
254 system performance will suffer severely as
255 select always returns true on disk files */
257 /* Set initial timeout */
258 timeout.tv_sec = (time_t)(time_out / 1000);
259 timeout.tv_usec = (long)(1000 * (time_out % 1000));
261 for (nread=0; nread < mincnt; ) {
265 selrtn = sys_select_intr(fd+1,&fds,&timeout);
269 /* something is wrong. Maybe the socket is dead? */
270 DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
271 smb_read_error = READ_ERROR;
275 /* Did we timeout ? */
277 DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
278 smb_read_error = READ_TIMEOUT;
284 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
286 readret = read(fd, buf + nread, maxcnt - nread);
289 readret = read(fd, buf+nread, maxcnt-nread);
290 #endif /* WITH_SSL */
293 /* we got EOF on the file descriptor */
294 DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
295 smb_read_error = READ_EOF;
300 /* the descriptor is probably dead */
301 DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
302 smb_read_error = READ_ERROR;
309 /* Return the number we got */
310 return((ssize_t)nread);
313 /****************************************************************************
314 Read data from a fd with a timout in msec.
315 mincount = if timeout, minimum to read before returning
316 maxcount = number to be read.
317 time_out = timeout in milliseconds
318 ****************************************************************************/
320 ssize_t read_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
326 struct timeval timeout;
328 /* just checking .... */
334 if (mincnt == 0) mincnt = maxcnt;
336 while (nread < mincnt) {
339 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
341 readret = read(fd, buf + nread, maxcnt - nread);
344 readret = read(fd, buf + nread, maxcnt - nread);
345 #endif /* WITH_SSL */
352 return((ssize_t)nread);
355 /* Most difficult - timeout read */
356 /* If this is ever called on a disk file and
357 mincnt is greater then the filesize then
358 system performance will suffer severely as
359 select always returns true on disk files */
361 /* Set initial timeout */
362 timeout.tv_sec = (time_t)(time_out / 1000);
363 timeout.tv_usec = (long)(1000 * (time_out % 1000));
365 for (nread=0; nread < mincnt; ) {
369 selrtn = sys_select_intr(fd+1,&fds,&timeout);
376 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
378 readret = read(fd, buf + nread, maxcnt - nread);
381 readret = read(fd, buf+nread, maxcnt-nread);
382 #endif /* WITH_SSL */
390 /* Return the number we got */
391 return((ssize_t)nread);
394 /****************************************************************************
395 send a keepalive packet (rfc1002)
396 ****************************************************************************/
398 BOOL send_keepalive(int client)
400 unsigned char buf[4];
403 buf[1] = buf[2] = buf[3] = 0;
405 return(write_socket_data(client,(char *)buf,4) == 4);
408 /****************************************************************************
409 read data from the client, reading exactly N bytes.
410 ****************************************************************************/
412 ssize_t read_data(int fd,char *buffer,size_t N)
423 ret = SSL_read(ssl, buffer + total, N - total);
425 ret = read(fd,buffer + total,N - total);
428 ret = read(fd,buffer + total,N - total);
429 #endif /* WITH_SSL */
433 DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
434 smb_read_error = READ_EOF;
439 DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
440 smb_read_error = READ_ERROR;
445 return (ssize_t)total;
448 /****************************************************************************
449 Read data from a socket, reading exactly N bytes.
450 ****************************************************************************/
452 static ssize_t read_socket_data(int fd,char *buffer,size_t N)
463 ret = SSL_read(ssl, buffer + total, N - total);
465 ret = read(fd,buffer + total,N - total);
468 ret = read(fd,buffer + total,N - total);
469 #endif /* WITH_SSL */
473 DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
474 smb_read_error = READ_EOF;
479 DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
480 smb_read_error = READ_ERROR;
485 return (ssize_t)total;
488 /****************************************************************************
490 ****************************************************************************/
492 ssize_t write_data(int fd,char *buffer,size_t N)
501 ret = SSL_write(ssl,buffer + total,N - total);
503 ret = write(fd,buffer + total,N - total);
506 ret = write(fd,buffer + total,N - total);
507 #endif /* WITH_SSL */
510 DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
513 if (ret == 0) return total;
517 return (ssize_t)total;
520 /****************************************************************************
521 Write data to a socket - use send rather than write.
522 ****************************************************************************/
524 ssize_t write_socket_data(int fd,char *buffer,size_t N)
533 ret = SSL_write(ssl,buffer + total,N - total);
535 ret = send(fd,buffer + total,N - total, 0);
538 ret = send(fd,buffer + total,N - total,0);
539 #endif /* WITH_SSL */
542 DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
545 if (ret == 0) return total;
549 return (ssize_t)total;
552 /****************************************************************************
554 ****************************************************************************/
556 ssize_t write_socket(int fd,char *buf,size_t len)
560 DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
561 ret = write_socket_data(fd,buf,len);
563 DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
565 DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
566 (int)len, fd, strerror(errno) ));
571 /****************************************************************************
572 read 4 bytes of a smb packet and return the smb length of the packet
573 store the result in the buffer
574 This version of the function will return a length of zero on receiving
576 timeout is in milliseconds.
577 ****************************************************************************/
579 static ssize_t read_smb_length_return_keepalive(int fd,char *inbuf,unsigned int timeout)
588 ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
590 ok = (read_socket_data(fd,inbuf,4) == 4);
595 len = smb_len(inbuf);
596 msg_type = CVAL(inbuf,0);
598 if (msg_type == 0x85)
599 DEBUG(5,("Got keepalive packet\n"));
602 DEBUG(10,("got smb length of %d\n",len));
607 /****************************************************************************
608 read 4 bytes of a smb packet and return the smb length of the packet
609 store the result in the buffer. This version of the function will
610 never return a session keepalive (length of zero).
611 timeout is in milliseconds.
612 ****************************************************************************/
614 ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout)
620 len = read_smb_length_return_keepalive(fd, inbuf, timeout);
625 /* Ignore session keepalives. */
626 if(CVAL(inbuf,0) != 0x85)
630 DEBUG(10,("read_smb_length: got smb length of %d\n",len));
635 /****************************************************************************
636 read an smb from a fd. Note that the buffer *MUST* be of size
637 BUFFER_SIZE+SAFETY_MARGIN.
638 The timeout is in milliseconds.
639 This function will return on a
640 receipt of a session keepalive packet.
641 ****************************************************************************/
643 BOOL receive_smb(int fd,char *buffer, unsigned int timeout)
649 memset(buffer,'\0',smb_size + 100);
651 len = read_smb_length_return_keepalive(fd,buffer,timeout);
653 DEBUG(10,("receive_smb: length < 0!\n"));
658 * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
659 * of header. Don't print the error if this fits.... JRA.
662 if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
663 DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
664 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
665 smb_read_error = READ_ERROR;
671 ret = read_socket_data(fd,buffer+4,len);
673 smb_read_error = READ_ERROR;
681 /****************************************************************************
682 read an smb from a fd ignoring all keepalive packets. Note that the buffer
683 *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
684 The timeout is in milliseconds
686 This is exactly the same as receive_smb except that it never returns
687 a session keepalive packet (just as receive_smb used to do).
688 receive_smb was changed to return keepalives as the oplock processing means this call
689 should never go into a blocking read.
690 ****************************************************************************/
692 BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout)
698 ret = receive_smb(fd, buffer, timeout);
702 DEBUG(10,("client_receive_smb failed\n"));
707 /* Ignore session keepalive packets. */
708 if(CVAL(buffer,0) != 0x85)
715 /****************************************************************************
717 ****************************************************************************/
719 BOOL send_smb(int fd,char *buffer)
724 len = smb_len(buffer) + 4;
726 while (nwritten < len) {
727 ret = write_socket(fd,buffer+nwritten,len - nwritten);
729 DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
730 (int)len,(int)ret, strerror(errno) ));
739 /****************************************************************************
740 send a single packet to a port on another machine
741 ****************************************************************************/
743 BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
747 struct sockaddr_in sock_out;
749 /* create a socket to write to */
750 out_fd = socket(AF_INET, type, 0);
753 DEBUG(0,("socket failed"));
757 /* set the address and port */
758 memset((char *)&sock_out,'\0',sizeof(sock_out));
759 putip((char *)&sock_out.sin_addr,(char *)&ip);
760 sock_out.sin_port = htons( port );
761 sock_out.sin_family = AF_INET;
764 DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
765 len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
768 ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
771 DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
772 inet_ntoa(ip),port,strerror(errno)));
778 /****************************************************************************
779 open a socket of the specified type, port and address for incoming data
780 ****************************************************************************/
782 int open_socket_in(int type, int port, int dlevel,uint32 socket_addr, BOOL rebind)
785 struct sockaddr_in sock;
789 /* get my host name */
790 if (gethostname(host_name, MAXHOSTNAMELEN) == -1)
791 { DEBUG(0,("gethostname failed\n")); return -1; }
794 if ((hp = sys_gethostbyname(host_name)) == 0)
796 DEBUG(0,( "sys_gethostbyname: Unknown host %s\n",host_name));
800 memset((char *)&sock,'\0',sizeof(sock));
801 memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);
803 #ifdef HAVE_SOCK_SIN_LEN
804 sock.sin_len = sizeof(sock);
806 sock.sin_port = htons( port );
807 sock.sin_family = hp->h_addrtype;
808 sock.sin_addr.s_addr = socket_addr;
809 res = socket(hp->h_addrtype, type, 0);
811 { DEBUG(0,("socket failed\n")); return -1; }
819 if(setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1)
820 DEBUG(dlevel,("setsockopt: SO_REUSEADDR=%d on port %d failed with error = %s\n",
821 val, port, strerror(errno) ));
823 if(setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1)
824 DEBUG(dlevel,("setsockopt: SO_REUSEPORT=%d on port %d failed with error = %s\n",
825 val, port, strerror(errno) ));
826 #endif /* SO_REUSEPORT */
829 /* now we've got a socket - we need to bind it */
830 if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0)
833 if (port == SMB_PORT || port == NMB_PORT)
834 DEBUG(dlevel,("bind failed on port %d socket_addr=%s (%s)\n",
835 port,inet_ntoa(sock.sin_addr),strerror(errno)));
838 if (dlevel > 0 && port < 1000)
841 if (port >= 1000 && port < 9000)
842 return(open_socket_in(type,port+1,dlevel,socket_addr,rebind));
847 DEBUG(3,("bind succeeded on port %d\n",port));
852 /****************************************************************************
853 create an outgoing socket. timeout is in milliseconds.
854 **************************************************************************/
856 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
858 struct sockaddr_in sock_out;
860 int connect_loop = 250; /* 250 milliseconds */
861 int loops = (timeout) / connect_loop;
863 /* create a socket to write to */
864 res = socket(PF_INET, type, 0);
866 { DEBUG(0,("socket error\n")); return -1; }
868 if (type != SOCK_STREAM) return(res);
870 memset((char *)&sock_out,'\0',sizeof(sock_out));
871 putip((char *)&sock_out.sin_addr,(char *)addr);
873 sock_out.sin_port = htons( port );
874 sock_out.sin_family = PF_INET;
876 /* set it non-blocking */
877 set_blocking(res,False);
879 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
881 /* and connect it to the destination */
883 ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
885 /* Some systems return EAGAIN when they mean EINPROGRESS */
886 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
887 errno == EAGAIN) && loops--) {
888 msleep(connect_loop);
892 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
894 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
900 if (ret < 0 && errno == EISCONN) {
907 DEBUG(1,("error connecting to %s:%d (%s)\n",
908 inet_ntoa(*addr),port,strerror(errno)));
913 /* set it blocking again */
914 set_blocking(res,True);
919 /* the following 3 client_*() functions are nasty ways of allowing
920 some generic functions to get info that really should be hidden in
921 particular modules */
922 static int client_fd = -1;
924 void client_setfd(int fd)
929 char *client_name(void)
931 return get_socket_name(client_fd);
934 char *client_addr(void)
936 return get_socket_addr(client_fd);
939 /*******************************************************************
940 matchname - determine if host name matches IP address. Used to
941 confirm a hostname lookup to prevent spoof attacks
942 ******************************************************************/
943 static BOOL matchname(char *remotehost,struct in_addr addr)
948 if ((hp = sys_gethostbyname(remotehost)) == 0) {
949 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
954 * Make sure that gethostbyname() returns the "correct" host name.
955 * Unfortunately, gethostbyname("localhost") sometimes yields
956 * "localhost.domain". Since the latter host name comes from the
957 * local DNS, we just have to trust it (all bets are off if the local
958 * DNS is perverted). We always check the address list, though.
961 if (strcasecmp(remotehost, hp->h_name)
962 && strcasecmp(remotehost, "localhost")) {
963 DEBUG(0,("host name/name mismatch: %s != %s\n",
964 remotehost, hp->h_name));
968 /* Look up the host address in the address list we just got. */
969 for (i = 0; hp->h_addr_list[i]; i++) {
970 if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
975 * The host name does not map to the original host address. Perhaps
976 * someone has compromised a name server. More likely someone botched
977 * it, but that could be dangerous, too.
980 DEBUG(0,("host name/address mismatch: %s != %s\n",
981 inet_ntoa(addr), hp->h_name));
986 /*******************************************************************
987 return the DNS name of the remote end of a socket
988 ******************************************************************/
989 char *get_socket_name(int fd)
991 static pstring name_buf;
992 static fstring addr_buf;
997 p = get_socket_addr(fd);
999 /* it might be the same as the last one - save some DNS work */
1000 if (strcmp(p, addr_buf) == 0) return name_buf;
1002 pstrcpy(name_buf,"UNKNOWN");
1003 if (fd == -1) return name_buf;
1005 fstrcpy(addr_buf, p);
1007 addr = *interpret_addr2(p);
1009 /* Look up the remote host name. */
1010 if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1011 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1012 pstrcpy(name_buf, p);
1014 pstrcpy(name_buf,(char *)hp->h_name);
1015 if (!matchname(name_buf, addr)) {
1016 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1017 pstrcpy(name_buf,"UNKNOWN");
1023 /*******************************************************************
1024 return the IP addr of the remote end of a socket as a string
1025 ******************************************************************/
1026 char *get_socket_addr(int fd)
1029 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1030 int length = sizeof(sa);
1031 static fstring addr_buf;
1033 fstrcpy(addr_buf,"0.0.0.0");
1039 if (getpeername(fd, &sa, &length) < 0) {
1040 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1044 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1049 /*******************************************************************
1050 opens and connects to a unix pipe socket
1051 ******************************************************************/
1052 int open_pipe_sock(char *path)
1055 struct sockaddr_un sa;
1057 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1061 DEBUG(0, ("unix socket open failed\n"));
1066 sa.sun_family = AF_UNIX;
1067 safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1069 DEBUG(10, ("socket open succeeded. file name: %s\n", sa.sun_path));
1071 if (connect(sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1073 DEBUG(0,("socket connect to %s failed\n", sa.sun_path));
1081 int create_pipe_socket(char *dir, int dir_perms,
1082 char *path, int path_perms)
1085 struct sockaddr_un sa;
1087 DEBUG(0,("create_pipe_socket: %s %d %s %d\n",
1088 dir, dir_perms, path, path_perms));
1090 DEBUG(0,("*** RACE CONDITION. PLEASE SOMEONE EXAMINE create_pipe_Socket AND FIX IT ***\n"));
1092 mkdir(dir, dir_perms);
1094 if (chmod(dir, dir_perms) < 0)
1096 DEBUG(0, ("chmod on %s failed\n", dir));
1102 DEBUG(0, ("remove on %s failed\n", path));
1105 /* start listening on unix socket */
1106 s = socket(AF_UNIX, SOCK_STREAM, 0);
1110 DEBUG(0, ("socket open failed\n"));
1115 sa.sun_family = AF_UNIX;
1116 safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1118 if (bind(s, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1120 DEBUG(0, ("socket bind to %s failed\n", sa.sun_path));
1128 DEBUG(0,("bind failed\n"));
1133 if (path_perms != 0)
1135 chmod(path, path_perms);
1138 if (listen(s, 5) == -1)
1140 DEBUG(0,("listen failed\n"));
1144 DEBUG(5,("unix socket opened: %s\n", path));
1149 /*******************************************************************
1150 this is like socketpair but uses tcp. It is used by the Samba
1151 regression test code
1152 The function guarantees that nobody else can attach to the socket,
1153 or if they do that this function fails and the socket gets closed
1154 returns 0 on success, -1 on failure
1155 the resulting file descriptors are symmetrical
1156 ******************************************************************/
1157 static int socketpair_tcp(int fd[2])
1160 struct sockaddr sock;
1161 socklen_t socklen = sizeof(sock);
1162 int connect_done = 0;
1164 fd[0] = fd[1] = listener = -1;
1166 memset(&sock, 0, sizeof(sock));
1168 if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1170 if (listen(listener, 1) != 0) goto failed;
1172 if (getsockname(listener, &sock, &socklen) != 0) goto failed;
1174 if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1176 set_blocking(fd[1], 0);
1178 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
1179 if (errno != EINPROGRESS) goto failed;
1184 if ((fd[0] = accept(listener, &sock, &socklen)) == -1) goto failed;
1187 if (connect_done == 0) {
1188 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
1189 && errno != EISCONN) goto failed;
1192 set_blocking(fd[1], 1);
1198 if (fd[0] != -1) close(fd[0]);
1199 if (fd[1] != -1) close(fd[1]);
1200 if (listener != -1) close(listener);
1205 /*******************************************************************
1206 run a program on a local tcp socket, this is used to launch smbd
1207 when regression testing
1208 the return value is a socket which is attached to a subprocess
1209 running "prog". stdin and stdout are attached. stderr is left
1210 attached to the original stderr
1211 ******************************************************************/
1212 int sock_exec(const char *prog)
1215 if (socketpair_tcp(fd) != 0) return -1;