daab7933daa17ec2f00d570e9882f1db0fec841d
[samba.git] / source3 / lib / util_sock.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Samba utility functions
4    Copyright (C) Andrew Tridgell 1992-1998
5    Copyright (C) Tim Potter      2000-2001
6    
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.
11    
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.
16    
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.
20 */
21
22 #include "includes.h"
23
24 #ifdef WITH_SSL
25 #include <openssl/ssl.h>
26 #undef Realloc  /* SSLeay defines this and samba has a function of this name */
27 extern SSL  *ssl;
28 extern int  sslFd;
29 #endif  /* WITH_SSL */
30
31 /* the last IP received from */
32 struct in_addr lastip;
33
34 /* the last port received from */
35 int lastport=0;
36
37 int smb_read_error = 0;
38
39 /****************************************************************************
40  Determine if a file descriptor is in fact a socket.
41 ****************************************************************************/
42
43 BOOL is_a_socket(int fd)
44 {
45   int v,l;
46   l = sizeof(int);
47   return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
48 }
49
50 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
51
52 typedef struct smb_socket_option
53 {
54   char *name;
55   int level;
56   int option;
57   int value;
58   int opttype;
59 } smb_socket_option;
60
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},
65 #ifdef TCP_NODELAY
66   {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
67 #endif
68 #ifdef IPTOS_LOWDELAY
69   {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
70 #endif
71 #ifdef IPTOS_THROUGHPUT
72   {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
73 #endif
74 #ifdef SO_REUSEPORT
75   {"SO_REUSEPORT",      SOL_SOCKET,    SO_REUSEPORT,    0,                 OPT_BOOL},
76 #endif
77 #ifdef SO_SNDBUF
78   {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
79 #endif
80 #ifdef SO_RCVBUF
81   {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
82 #endif
83 #ifdef SO_SNDLOWAT
84   {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
85 #endif
86 #ifdef SO_RCVLOWAT
87   {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
88 #endif
89 #ifdef SO_SNDTIMEO
90   {"SO_SNDTIMEO",       SOL_SOCKET,    SO_SNDTIMEO,     0,                 OPT_INT},
91 #endif
92 #ifdef SO_RCVTIMEO
93   {"SO_RCVTIMEO",       SOL_SOCKET,    SO_RCVTIMEO,     0,                 OPT_INT},
94 #endif
95   {NULL,0,0,0,0}};
96
97 /****************************************************************************
98  Print socket options.
99 ****************************************************************************/
100 static void print_socket_options(int s)
101 {
102         int value, vlen = 4;
103         smb_socket_option *p = &socket_options[0];
104
105         for (; p->name != NULL; p++) {
106                 if (getsockopt(s, p->level, p->option, (void *)&value, &vlen) == -1) {
107                         DEBUG(5,("Could not test socket option %s.\n", p->name));
108                 } else {
109                         DEBUG(5,("socket option %s = %d\n",p->name,value));
110                 }
111         }
112  }
113
114 /****************************************************************************
115  Set user socket options.
116 ****************************************************************************/
117
118 void set_socket_options(int fd, char *options)
119 {
120         fstring tok;
121
122         while (next_token(&options,tok," \t,", sizeof(tok))) {
123                 int ret=0,i;
124                 int value = 1;
125                 char *p;
126                 BOOL got_value = False;
127
128                 if ((p = strchr_m(tok,'='))) {
129                         *p = 0;
130                         value = atoi(p+1);
131                         got_value = True;
132                 }
133
134                 for (i=0;socket_options[i].name;i++)
135                         if (strequal(socket_options[i].name,tok))
136                                 break;
137
138                 if (!socket_options[i].name) {
139                         DEBUG(0,("Unknown socket option %s\n",tok));
140                         continue;
141                 }
142
143                 switch (socket_options[i].opttype) {
144                 case OPT_BOOL:
145                 case OPT_INT:
146                         ret = setsockopt(fd,socket_options[i].level,
147                                                 socket_options[i].option,(char *)&value,sizeof(int));
148                         break;
149
150                 case OPT_ON:
151                         if (got_value)
152                                 DEBUG(0,("syntax error - %s does not take a value\n",tok));
153
154                         {
155                                 int on = socket_options[i].value;
156                                 ret = setsockopt(fd,socket_options[i].level,
157                                                         socket_options[i].option,(char *)&on,sizeof(int));
158                         }
159                         break;    
160                 }
161       
162                 if (ret != 0)
163                         DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
164         }
165
166         print_socket_options(fd);
167 }
168
169 /****************************************************************************
170  Read from a socket.
171 ****************************************************************************/
172
173 ssize_t read_udp_socket(int fd,char *buf,size_t len)
174 {
175         ssize_t ret;
176         struct sockaddr_in sock;
177         socklen_t socklen = sizeof(sock);
178
179         memset((char *)&sock,'\0',socklen);
180         memset((char *)&lastip,'\0',sizeof(lastip));
181         ret = (ssize_t)recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
182         if (ret <= 0) {
183                 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
184                 return(0);
185         }
186
187         lastip = sock.sin_addr;
188         lastport = ntohs(sock.sin_port);
189
190         DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
191                         inet_ntoa(lastip), lastport, ret));
192
193         return(ret);
194 }
195
196 /*******************************************************************
197  checks if read data is outstanding.
198  ********************************************************************/
199 int read_data_outstanding(int fd, unsigned int time_out)
200 {
201         int selrtn;
202         fd_set fds;
203         struct timeval timeout;
204
205         FD_ZERO(&fds);
206         FD_SET(fd, &fds);
207
208         timeout.tv_sec = (time_t) (time_out / 1000);
209         timeout.tv_usec = (long)(1000 * (time_out % 1000));
210
211         selrtn = sys_select_intr(fd + 1, &fds, NULL, NULL, &timeout);
212
213         if (selrtn <= 0)
214         {
215                 return selrtn;
216         }
217         return FD_ISSET(fd, &fds) ? 1 : 0;
218 }
219
220 /****************************************************************************
221  Read data from a socket with a timout in msec.
222  mincount = if timeout, minimum to read before returning
223  maxcount = number to be read.
224  time_out = timeout in milliseconds
225 ****************************************************************************/
226
227 static ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
228 {
229         fd_set fds;
230         int selrtn;
231         ssize_t readret;
232         size_t nread = 0;
233         struct timeval timeout;
234         
235         /* just checking .... */
236         if (maxcnt <= 0)
237                 return(0);
238         
239         smb_read_error = 0;
240         
241         /* Blocking read */
242         if (time_out <= 0) {
243                 if (mincnt == 0) mincnt = maxcnt;
244                 
245                 while (nread < mincnt) {
246 #ifdef WITH_SSL
247                         if (fd == sslFd) {
248                                 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
249                         } else {
250                                 readret = read(fd, buf + nread, maxcnt - nread);
251                         }
252 #else /* WITH_SSL */
253                         readret = read(fd, buf + nread, maxcnt - nread);
254 #endif /* WITH_SSL */
255                         
256                         if (readret == 0) {
257                                 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
258                                 smb_read_error = READ_EOF;
259                                 return -1;
260                         }
261                         
262                         if (readret == -1) {
263                                 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
264                                 smb_read_error = READ_ERROR;
265                                 return -1;
266                         }
267                         nread += readret;
268                 }
269                 return((ssize_t)nread);
270         }
271         
272         /* Most difficult - timeout read */
273         /* If this is ever called on a disk file and 
274            mincnt is greater then the filesize then
275            system performance will suffer severely as 
276            select always returns true on disk files */
277         
278         /* Set initial timeout */
279         timeout.tv_sec = (time_t)(time_out / 1000);
280         timeout.tv_usec = (long)(1000 * (time_out % 1000));
281         
282         for (nread=0; nread < mincnt; ) {      
283                 FD_ZERO(&fds);
284                 FD_SET(fd,&fds);
285                 
286                 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
287                 
288                 /* Check if error */
289                 if (selrtn == -1) {
290                         /* something is wrong. Maybe the socket is dead? */
291                         DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
292                         smb_read_error = READ_ERROR;
293                         return -1;
294                 }
295                 
296                 /* Did we timeout ? */
297                 if (selrtn == 0) {
298                         DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
299                         smb_read_error = READ_TIMEOUT;
300                         return -1;
301                 }
302                 
303 #ifdef WITH_SSL
304                 if (fd == sslFd) {
305                         readret = SSL_read(ssl, buf + nread, maxcnt - nread);
306                 }else{
307                         readret = read(fd, buf + nread, maxcnt - nread);
308                 }
309 #else /* WITH_SSL */
310                 readret = read(fd, buf+nread, maxcnt-nread);
311 #endif /* WITH_SSL */
312                 
313                 if (readret == 0) {
314                         /* we got EOF on the file descriptor */
315                         DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
316                         smb_read_error = READ_EOF;
317                         return -1;
318                 }
319                 
320                 if (readret == -1) {
321                         /* the descriptor is probably dead */
322                         DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
323                         smb_read_error = READ_ERROR;
324                         return -1;
325                 }
326                 
327                 nread += readret;
328         }
329         
330         /* Return the number we got */
331         return (ssize_t)nread;
332 }
333
334 /****************************************************************************
335  Read data from a fd with a timout in msec.
336  mincount = if timeout, minimum to read before returning
337  maxcount = number to be read.
338  time_out = timeout in milliseconds
339 ****************************************************************************/
340
341 ssize_t read_with_timeout(int fd, char *buf, size_t mincnt, size_t maxcnt,
342                           unsigned int time_out)
343 {
344         ssize_t readret;
345         size_t nread = 0;
346         
347         /* just checking .... */
348         if (maxcnt <= 0)
349                 return(0);
350         
351         /* Blocking read */
352         if (time_out <= 0) {
353                 if (mincnt == 0) mincnt = maxcnt;
354                 
355                 while (nread < mincnt) {
356 #ifdef WITH_SSL
357                         if(fd == sslFd){
358                                 readret = SSL_read(ssl, buf + nread, maxcnt - nread);
359                         }else{
360                                 readret = read(fd, buf + nread, maxcnt - nread);
361                         }
362 #else /* WITH_SSL */
363                         readret = read(fd, buf + nread, maxcnt - nread);
364 #endif /* WITH_SSL */
365                         
366                         if (readret <= 0)
367                                 return readret;
368                         
369                         nread += readret;
370                 }
371                 return((ssize_t)nread);
372         }
373         
374         /* Most difficult - timeout read */
375         /* If this is ever called on a disk file and 
376            mincnt is greater then the filesize then
377            system performance will suffer severely as 
378            select always returns true on disk files */
379         
380         for (nread=0; nread < mincnt; ) {      
381                 int selrtn = read_data_outstanding(fd, time_out);
382                 
383                 if(selrtn <= 0)
384                         return selrtn;
385                 
386 #ifdef WITH_SSL
387                 if(fd == sslFd){
388                         readret = SSL_read(ssl, buf + nread, maxcnt - nread);
389                 }else{
390                         readret = read(fd, buf + nread, maxcnt - nread);
391                 }
392 #else /* WITH_SSL */
393                 readret = read(fd, buf+nread, maxcnt-nread);
394 #endif /* WITH_SSL */
395                 
396                 if (readret <= 0)
397                         return readret;
398                 
399                 nread += readret;
400         }
401         
402         /* Return the number we got */
403         return((ssize_t)nread);
404 }
405
406 /****************************************************************************
407 send a keepalive packet (rfc1002)
408 ****************************************************************************/
409
410 BOOL send_keepalive(int client)
411 {
412   unsigned char buf[4];
413
414   buf[0] = SMBkeepalive;
415   buf[1] = buf[2] = buf[3] = 0;
416
417   return(write_socket_data(client,(char *)buf,4) == 4);
418 }
419
420 /****************************************************************************
421   read data from the client, reading exactly N bytes. 
422 ****************************************************************************/
423
424 ssize_t read_data(int fd,char *buffer,size_t N)
425 {
426   ssize_t  ret;
427   size_t total=0;  
428  
429   smb_read_error = 0;
430
431   while (total < N)
432   {
433 #ifdef WITH_SSL
434     if(fd == sslFd){
435       ret = SSL_read(ssl, buffer + total, N - total);
436     }else{
437       ret = read(fd,buffer + total,N - total);
438     }
439 #else /* WITH_SSL */
440     ret = read(fd,buffer + total,N - total);
441 #endif /* WITH_SSL */
442
443     if (ret == 0)
444     {
445       DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
446       smb_read_error = READ_EOF;
447       return 0;
448     }
449     if (ret == -1)
450     {
451       DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
452       smb_read_error = READ_ERROR;
453       return -1;
454     }
455     total += ret;
456   }
457   return (ssize_t)total;
458 }
459
460 /****************************************************************************
461  Read data from a socket, reading exactly N bytes. 
462 ****************************************************************************/
463
464 static ssize_t read_socket_data(int fd,char *buffer,size_t N)
465 {
466   ssize_t  ret;
467   size_t total=0;  
468  
469   smb_read_error = 0;
470
471   while (total < N)
472   {
473 #ifdef WITH_SSL
474     if(fd == sslFd){
475       ret = SSL_read(ssl, buffer + total, N - total);
476     }else{
477       ret = read(fd,buffer + total,N - total);
478     }
479 #else /* WITH_SSL */
480     ret = read(fd,buffer + total,N - total);
481 #endif /* WITH_SSL */
482
483     if (ret == 0)
484     {
485       DEBUG(10,("read_socket_data: recv of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
486       smb_read_error = READ_EOF;
487       return 0;
488     }
489     if (ret == -1)
490     {
491       DEBUG(0,("read_socket_data: recv failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
492       smb_read_error = READ_ERROR;
493       return -1;
494     }
495     total += ret;
496   }
497   return (ssize_t)total;
498 }
499
500 /****************************************************************************
501  Write data to a fd.
502 ****************************************************************************/
503
504 ssize_t write_data(int fd,char *buffer,size_t N)
505 {
506   size_t total=0;
507   ssize_t ret;
508
509   while (total < N)
510   {
511 #ifdef WITH_SSL
512     if(fd == sslFd){
513       ret = SSL_write(ssl,buffer + total,N - total);
514     }else{
515       ret = write(fd,buffer + total,N - total);
516     }
517 #else /* WITH_SSL */
518     ret = write(fd,buffer + total,N - total);
519 #endif /* WITH_SSL */
520
521     if (ret == -1) {
522       DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
523       return -1;
524     }
525     if (ret == 0) return total;
526
527     total += ret;
528   }
529   return (ssize_t)total;
530 }
531
532 /****************************************************************************
533  Write data to a socket - use send rather than write.
534 ****************************************************************************/
535
536 ssize_t write_socket_data(int fd,char *buffer,size_t N)
537 {
538   size_t total=0;
539   ssize_t ret;
540
541   while (total < N)
542   {
543 #ifdef WITH_SSL
544     if(fd == sslFd){
545       ret = SSL_write(ssl,buffer + total,N - total);
546     }else{
547       ret = send(fd,buffer + total,N - total, 0);
548     }
549 #else /* WITH_SSL */
550     ret = send(fd,buffer + total,N - total,0);
551 #endif /* WITH_SSL */
552
553     if (ret == -1) {
554       DEBUG(0,("write_socket_data: write failure. Error = %s\n", strerror(errno) ));
555       return -1;
556     }
557     if (ret == 0) return total;
558
559     total += ret;
560   }
561   return (ssize_t)total;
562 }
563
564 /****************************************************************************
565 write to a socket
566 ****************************************************************************/
567
568 ssize_t write_socket(int fd,char *buf,size_t len)
569 {
570   ssize_t ret=0;
571
572   DEBUG(6,("write_socket(%d,%d)\n",fd,(int)len));
573   ret = write_socket_data(fd,buf,len);
574       
575   DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,(int)len,(int)ret));
576   if(ret <= 0)
577     DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n", 
578        (int)len, fd, strerror(errno) ));
579
580   return(ret);
581 }
582
583 /****************************************************************************
584 read 4 bytes of a smb packet and return the smb length of the packet
585 store the result in the buffer
586 This version of the function will return a length of zero on receiving
587 a keepalive packet.
588 timeout is in milliseconds.
589 ****************************************************************************/
590
591 static ssize_t read_smb_length_return_keepalive(int fd,char *inbuf,unsigned int timeout)
592 {
593   ssize_t len=0;
594   int msg_type;
595   BOOL ok = False;
596
597   while (!ok)
598   {
599     if (timeout > 0)
600       ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
601     else 
602       ok = (read_socket_data(fd,inbuf,4) == 4);
603
604     if (!ok)
605       return(-1);
606
607     len = smb_len(inbuf);
608     msg_type = CVAL(inbuf,0);
609
610     if (msg_type == SMBkeepalive) 
611       DEBUG(5,("Got keepalive packet\n"));
612   }
613
614   DEBUG(10,("got smb length of %d\n",len));
615
616   return(len);
617 }
618
619 /****************************************************************************
620 read 4 bytes of a smb packet and return the smb length of the packet
621 store the result in the buffer. This version of the function will
622 never return a session keepalive (length of zero).
623 timeout is in milliseconds.
624 ****************************************************************************/
625
626 ssize_t read_smb_length(int fd,char *inbuf,unsigned int timeout)
627 {
628   ssize_t len;
629
630   for(;;)
631   {
632     len = read_smb_length_return_keepalive(fd, inbuf, timeout);
633
634     if(len < 0)
635       return len;
636
637     /* Ignore session keepalives. */
638     if(CVAL(inbuf,0) != SMBkeepalive)
639       break;
640   }
641
642   DEBUG(10,("read_smb_length: got smb length of %d\n",len));
643
644   return len;
645 }
646
647 /****************************************************************************
648   read an smb from a fd. Note that the buffer *MUST* be of size
649   BUFFER_SIZE+SAFETY_MARGIN.
650   The timeout is in milliseconds. 
651   This function will return on a
652   receipt of a session keepalive packet.
653 ****************************************************************************/
654
655 BOOL receive_smb(int fd,char *buffer, unsigned int timeout)
656 {
657         ssize_t len,ret;
658
659         smb_read_error = 0;
660
661         memset(buffer,'\0',smb_size + 100);
662
663         len = read_smb_length_return_keepalive(fd,buffer,timeout);
664         if (len < 0) {
665                 DEBUG(10,("receive_smb: length < 0!\n"));
666                 return(False);
667         }
668
669         /*
670          * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
671      * of header. Don't print the error if this fits.... JRA.
672          */
673
674         if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
675                 DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
676                 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
677                         smb_read_error = READ_ERROR;
678                         return False;
679                 }
680         }
681
682         if(len > 0) {
683                 ret = read_socket_data(fd,buffer+4,len);
684                 if (ret != len) {
685                         smb_read_error = READ_ERROR;
686                         return False;
687                 }
688         }
689
690         return(True);
691 }
692
693 /****************************************************************************
694   read an smb from a fd ignoring all keepalive packets. Note that the buffer 
695   *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
696   The timeout is in milliseconds
697
698   This is exactly the same as receive_smb except that it never returns
699   a session keepalive packet (just as receive_smb used to do).
700   receive_smb was changed to return keepalives as the oplock processing means this call
701   should never go into a blocking read.
702 ****************************************************************************/
703
704 BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout)
705 {
706   BOOL ret;
707
708   for(;;)
709   {
710     ret = receive_smb(fd, buffer, timeout);
711
712     if (!ret)
713     {
714       DEBUG(10,("client_receive_smb failed\n"));
715       show_msg(buffer);
716       return ret;
717     }
718
719     /* Ignore session keepalive packets. */
720     if(CVAL(buffer,0) != SMBkeepalive)
721       break;
722   }
723   show_msg(buffer);
724   return ret;
725 }
726
727 /****************************************************************************
728   send an smb to a fd 
729 ****************************************************************************/
730
731 BOOL send_smb(int fd,char *buffer)
732 {
733         size_t len;
734         size_t nwritten=0;
735         ssize_t ret;
736         len = smb_len(buffer) + 4;
737
738         while (nwritten < len) {
739                 ret = write_socket(fd,buffer+nwritten,len - nwritten);
740                 if (ret <= 0) {
741                         DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
742                                 (int)len,(int)ret, strerror(errno) ));
743                         return False;
744                 }
745                 nwritten += ret;
746         }
747
748         return True;
749 }
750
751 /****************************************************************************
752 send a single packet to a port on another machine
753 ****************************************************************************/
754
755 BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
756 {
757   BOOL ret;
758   int out_fd;
759   struct sockaddr_in sock_out;
760
761   /* create a socket to write to */
762   out_fd = socket(AF_INET, type, 0);
763   if (out_fd == -1) 
764     {
765       DEBUG(0,("socket failed"));
766       return False;
767     }
768
769   /* set the address and port */
770   memset((char *)&sock_out,'\0',sizeof(sock_out));
771   putip((char *)&sock_out.sin_addr,(char *)&ip);
772   sock_out.sin_port = htons( port );
773   sock_out.sin_family = AF_INET;
774   
775   if (DEBUGLEVEL > 0)
776     DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
777              len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
778         
779   /* send it */
780   ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
781
782   if (!ret)
783     DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
784              inet_ntoa(ip),port,strerror(errno)));
785
786   close(out_fd);
787   return(ret);
788 }
789
790 /****************************************************************************
791  Open a socket of the specified type, port, and address for incoming data.
792 ****************************************************************************/
793
794 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
795 {
796         struct sockaddr_in sock;
797         int res;
798
799         memset( (char *)&sock, '\0', sizeof(sock) );
800
801 #ifdef HAVE_SOCK_SIN_LEN
802         sock.sin_len         = sizeof(sock);
803 #endif
804         sock.sin_port        = htons( port );
805         sock.sin_family      = AF_INET;
806         sock.sin_addr.s_addr = socket_addr;
807
808         res = socket( AF_INET, type, 0 );
809         if( res == -1 ) {
810                 if( DEBUGLVL(0) ) {
811                         dbgtext( "open_socket_in(): socket() call failed: " );
812                         dbgtext( "%s\n", strerror( errno ) );
813                 }
814                 return -1;
815         }
816
817         /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
818         {
819                 int val = rebind ? 1 : 0;
820                 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
821                         if( DEBUGLVL( dlevel ) ) {
822                                 dbgtext( "open_socket_in(): setsockopt: " );
823                                 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
824                                 dbgtext( "on port %d failed ", port );
825                                 dbgtext( "with error = %s\n", strerror(errno) );
826                         }
827                 }
828 #ifdef SO_REUSEPORT
829                 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
830                         if( DEBUGLVL( dlevel ) ) {
831                                 dbgtext( "open_socket_in(): setsockopt: ");
832                                 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
833                                 dbgtext( "on port %d failed ", port );
834                                 dbgtext( "with error = %s\n", strerror(errno) );
835                         }
836                 }
837 #endif /* SO_REUSEPORT */
838         }
839
840         /* now we've got a socket - we need to bind it */
841         if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
842                 if( DEBUGLVL(dlevel) && (port == SMB_PORT || port == NMB_PORT) ) {
843                         dbgtext( "bind failed on port %d ", port );
844                         dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
845                         dbgtext( "Error = %s\n", strerror(errno) );
846                 }
847                 close( res ); 
848                 return( -1 ); 
849         }
850
851         DEBUG( 3, ( "bind succeeded on port %d\n", port ) );
852
853         return( res );
854  }
855
856 /****************************************************************************
857   create an outgoing socket. timeout is in milliseconds.
858   **************************************************************************/
859
860 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
861 {
862   struct sockaddr_in sock_out;
863   int res,ret;
864   int connect_loop = 250; /* 250 milliseconds */
865   int loops = (timeout) / connect_loop;
866
867   /* create a socket to write to */
868   res = socket(PF_INET, type, 0);
869   if (res == -1) 
870     { DEBUG(0,("socket error\n")); return -1; }
871
872   if (type != SOCK_STREAM) return(res);
873   
874   memset((char *)&sock_out,'\0',sizeof(sock_out));
875   putip((char *)&sock_out.sin_addr,(char *)addr);
876   
877   sock_out.sin_port = htons( port );
878   sock_out.sin_family = PF_INET;
879
880   /* set it non-blocking */
881   set_blocking(res,False);
882
883   DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
884   
885   /* and connect it to the destination */
886 connect_again:
887   ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
888
889   /* Some systems return EAGAIN when they mean EINPROGRESS */
890   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
891         errno == EAGAIN) && loops--) {
892     msleep(connect_loop);
893     goto connect_again;
894   }
895
896   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
897          errno == EAGAIN)) {
898       DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
899       close(res);
900       return -1;
901   }
902
903 #ifdef EISCONN
904   if (ret < 0 && errno == EISCONN) {
905     errno = 0;
906     ret = 0;
907   }
908 #endif
909
910   if (ret < 0) {
911     DEBUG(2,("error connecting to %s:%d (%s)\n",
912              inet_ntoa(*addr),port,strerror(errno)));
913     close(res);
914     return -1;
915   }
916
917   /* set it blocking again */
918   set_blocking(res,True);
919
920   return res;
921 }
922
923 /*
924   open a connected UDP socket to host on port
925 */
926 int open_udp_socket(const char *host, int port)
927 {
928         int type = SOCK_DGRAM;
929         struct sockaddr_in sock_out;
930         int res;
931         struct in_addr *addr;
932
933         addr = interpret_addr2(host);
934
935         res = socket(PF_INET, type, 0);
936         if (res == -1) {
937                 return -1;
938         }
939
940         memset((char *)&sock_out,'\0',sizeof(sock_out));
941         putip((char *)&sock_out.sin_addr,(char *)addr);
942         sock_out.sin_port = htons(port);
943         sock_out.sin_family = PF_INET;
944
945         if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
946                 close(res);
947                 return -1;
948         }
949
950         return res;
951 }
952
953
954 /* the following 3 client_*() functions are nasty ways of allowing
955    some generic functions to get info that really should be hidden in
956    particular modules */
957 static int client_fd = -1;
958
959 void client_setfd(int fd)
960 {
961         client_fd = fd;
962 }
963
964 char *client_name(void)
965 {
966         return get_socket_name(client_fd);
967 }
968
969 char *client_addr(void)
970 {
971         return get_socket_addr(client_fd);
972 }
973
974 /*******************************************************************
975  matchname - determine if host name matches IP address. Used to
976  confirm a hostname lookup to prevent spoof attacks
977  ******************************************************************/
978 static BOOL matchname(char *remotehost,struct in_addr  addr)
979 {
980         struct hostent *hp;
981         int     i;
982         
983         if ((hp = sys_gethostbyname(remotehost)) == 0) {
984                 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
985                 return False;
986         } 
987
988         /*
989          * Make sure that gethostbyname() returns the "correct" host name.
990          * Unfortunately, gethostbyname("localhost") sometimes yields
991          * "localhost.domain". Since the latter host name comes from the
992          * local DNS, we just have to trust it (all bets are off if the local
993          * DNS is perverted). We always check the address list, though.
994          */
995         
996         if (strcasecmp(remotehost, hp->h_name)
997             && strcasecmp(remotehost, "localhost")) {
998                 DEBUG(0,("host name/name mismatch: %s != %s\n",
999                          remotehost, hp->h_name));
1000                 return False;
1001         }
1002         
1003         /* Look up the host address in the address list we just got. */
1004         for (i = 0; hp->h_addr_list[i]; i++) {
1005                 if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
1006                         return True;
1007         }
1008         
1009         /*
1010          * The host name does not map to the original host address. Perhaps
1011          * someone has compromised a name server. More likely someone botched
1012          * it, but that could be dangerous, too.
1013          */
1014         
1015         DEBUG(0,("host name/address mismatch: %s != %s\n",
1016                  inet_ntoa(addr), hp->h_name));
1017         return False;
1018 }
1019
1020  
1021 /*******************************************************************
1022  return the DNS name of the remote end of a socket
1023  ******************************************************************/
1024 char *get_socket_name(int fd)
1025 {
1026         static pstring name_buf;
1027         static fstring addr_buf;
1028         struct hostent *hp;
1029         struct in_addr addr;
1030         char *p;
1031
1032         /* reverse lookups can be *very* expensive, and in many
1033            situations won't work because many networks don't link dhcp
1034            with dns. To avoid the delay we avoid the lookup if
1035            possible */
1036         if (!lp_hostname_lookups()) {
1037                 return get_socket_addr(fd);
1038         }
1039         
1040         p = get_socket_addr(fd);
1041
1042         /* it might be the same as the last one - save some DNS work */
1043         if (strcmp(p, addr_buf) == 0) return name_buf;
1044
1045         pstrcpy(name_buf,"UNKNOWN");
1046         if (fd == -1) return name_buf;
1047
1048         fstrcpy(addr_buf, p);
1049
1050         addr = *interpret_addr2(p);
1051         
1052         /* Look up the remote host name. */
1053         if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1054                 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1055                 pstrcpy(name_buf, p);
1056         } else {
1057                 pstrcpy(name_buf,(char *)hp->h_name);
1058                 if (!matchname(name_buf, addr)) {
1059                         DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1060                         pstrcpy(name_buf,"UNKNOWN");
1061                 }
1062         }
1063
1064         alpha_strcpy(name_buf, name_buf, "_-.", sizeof(name_buf));
1065         if (strstr(name_buf,"..")) {
1066                 pstrcpy(name_buf, "UNKNOWN");
1067         }
1068
1069         return name_buf;
1070 }
1071
1072 /*******************************************************************
1073  return the IP addr of the remote end of a socket as a string 
1074  ******************************************************************/
1075 char *get_socket_addr(int fd)
1076 {
1077         struct sockaddr sa;
1078         struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1079         int     length = sizeof(sa);
1080         static fstring addr_buf;
1081
1082         fstrcpy(addr_buf,"0.0.0.0");
1083
1084         if (fd == -1) {
1085                 return addr_buf;
1086         }
1087         
1088         if (getpeername(fd, &sa, &length) < 0) {
1089                 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1090                 return addr_buf;
1091         }
1092         
1093         fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1094         
1095         return addr_buf;
1096 }
1097
1098 /*******************************************************************
1099  opens and connects to a unix pipe socket
1100  ******************************************************************/
1101 int open_pipe_sock(char *path)
1102 {
1103         int sock;
1104         struct sockaddr_un sa;
1105
1106         sock = socket(AF_UNIX, SOCK_STREAM, 0);
1107
1108         if (sock < 0)
1109         {
1110                 DEBUG(0, ("unix socket open failed\n"));
1111                 return sock;
1112         }
1113
1114         ZERO_STRUCT(sa);
1115         sa.sun_family = AF_UNIX;
1116         safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1117
1118         DEBUG(10, ("socket open succeeded.  file name: %s\n", sa.sun_path));
1119
1120         if (connect(sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1121         {
1122                 DEBUG(0,("socket connect to %s failed\n", sa.sun_path));
1123                 close(sock);
1124                 return -1;
1125         }
1126
1127         return sock;
1128 }
1129
1130 /*******************************************************************
1131  Create protected unix domain socket.
1132
1133  some unixen cannot set permissions on a ux-dom-sock, so we
1134  have to make sure that the directory contains the protection
1135  permissions, instead.
1136  ******************************************************************/
1137 int create_pipe_sock(const char *socket_dir,
1138                                         const char *socket_name,
1139                                         mode_t dir_perms)
1140 {
1141         struct sockaddr_un sunaddr;
1142         struct stat st;
1143         int sock;
1144         mode_t old_umask;
1145         pstring path;
1146         
1147         /* Create the socket directory or reuse the existing one */
1148         
1149         if (lstat(socket_dir, &st) == -1) {
1150                 
1151                 if (errno == ENOENT) {
1152                         
1153                         /* Create directory */
1154                         
1155                         if (mkdir(socket_dir, dir_perms) == -1) {
1156                                 DEBUG(0, ("error creating socket directory "
1157                                           "%s: %s\n", socket_dir, 
1158                                           strerror(errno)));
1159                                 return -1;
1160                         }
1161                         
1162                 } else {
1163                         
1164                         DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1165                                   socket_dir, strerror(errno)));
1166                         return -1;
1167                 }
1168                 
1169         } else {
1170                 
1171                 /* Check ownership and permission on existing directory */
1172                 
1173                 if (!S_ISDIR(st.st_mode)) {
1174                         DEBUG(0, ("socket directory %s isn't a directory\n",
1175                                   socket_dir));
1176                         return -1;
1177                 }
1178                 
1179                 if ((st.st_uid != sec_initial_uid()) || 
1180                     ((st.st_mode & 0777) != dir_perms)) {
1181                         DEBUG(0, ("invalid permissions on socket directory "
1182                                   "%s\n", socket_dir));
1183                         return -1;
1184                 }
1185         }
1186         
1187         /* Create the socket file */
1188         
1189         old_umask = umask(0);
1190         
1191         sock = socket(AF_UNIX, SOCK_STREAM, 0);
1192         
1193         if (sock == -1) {
1194                 perror("socket");
1195                 umask(old_umask);
1196                 return -1;
1197         }
1198         
1199         snprintf(path, sizeof(path), "%s/%s", socket_dir, socket_name);
1200         
1201         unlink(path);
1202         memset(&sunaddr, 0, sizeof(sunaddr));
1203         sunaddr.sun_family = AF_UNIX;
1204         safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1205         
1206         if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1207                 DEBUG(0, ("bind failed on pipe socket %s: %s\n",
1208                           path,
1209                           strerror(errno)));
1210                 close(sock);
1211                 umask(old_umask);
1212                 return -1;
1213         }
1214         
1215         if (listen(sock, 5) == -1) {
1216                 DEBUG(0, ("listen failed on pipe socket %s: %s\n",
1217                           path,
1218                           strerror(errno)));
1219                 close(sock);
1220                 umask(old_umask);
1221                 return -1;
1222         }
1223         
1224         umask(old_umask);
1225         
1226         /* Success! */
1227         
1228         return sock;
1229 }
1230
1231 /*******************************************************************
1232 this is like socketpair but uses tcp. It is used by the Samba
1233 regression test code
1234 The function guarantees that nobody else can attach to the socket,
1235 or if they do that this function fails and the socket gets closed
1236 returns 0 on success, -1 on failure
1237 the resulting file descriptors are symmetrical
1238  ******************************************************************/
1239 static int socketpair_tcp(int fd[2])
1240 {
1241         int listener;
1242         struct sockaddr_in sock;
1243         struct sockaddr_in sock2;
1244         socklen_t socklen = sizeof(sock);
1245         int connect_done = 0;
1246         
1247         fd[0] = fd[1] = listener = -1;
1248
1249         memset(&sock, 0, sizeof(sock));
1250         
1251         if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1252
1253         memset(&sock2, 0, sizeof(sock2));
1254 #ifdef HAVE_SOCK_SIN_LEN
1255         sock2.sin_len = sizeof(sock2);
1256 #endif
1257         sock2.sin_family = PF_INET;
1258
1259         bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
1260
1261         if (listen(listener, 1) != 0) goto failed;
1262
1263         if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
1264
1265         if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1266
1267         set_blocking(fd[1], 0);
1268
1269         sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1270
1271         if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
1272                 if (errno != EINPROGRESS) goto failed;
1273         } else {
1274                 connect_done = 1;
1275         }
1276
1277         if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
1278
1279         close(listener);
1280         if (connect_done == 0) {
1281                 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
1282                     && errno != EISCONN) goto failed;
1283         }
1284
1285         set_blocking(fd[1], 1);
1286
1287         /* all OK! */
1288         return 0;
1289
1290  failed:
1291         if (fd[0] != -1) close(fd[0]);
1292         if (fd[1] != -1) close(fd[1]);
1293         if (listener != -1) close(listener);
1294         return -1;
1295 }
1296
1297
1298 /*******************************************************************
1299 run a program on a local tcp socket, this is used to launch smbd
1300 when regression testing
1301 the return value is a socket which is attached to a subprocess
1302 running "prog". stdin and stdout are attached. stderr is left
1303 attached to the original stderr
1304  ******************************************************************/
1305 int sock_exec(const char *prog)
1306 {
1307         int fd[2];
1308         if (socketpair_tcp(fd) != 0) {
1309                 DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno)));
1310                 return -1;
1311         }
1312         if (fork() == 0) {
1313                 close(fd[0]);
1314                 close(0);
1315                 close(1);
1316                 dup(fd[1]);
1317                 dup(fd[1]);
1318                 exit(system(prog));
1319         }
1320         close(fd[1]);
1321         return fd[0];
1322 }