45beb38ac9e2560bb17e065b711ae833209ddfcf
[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                 /* XXX: You might think that we ought to set
667                  * smb_read_error here, but apparently that breaks the
668                  * recursive main loop in oplock.c.  Global variables
669                  * suck. */
670                 return False;
671         }
672
673         /*
674          * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
675      * of header. Don't print the error if this fits.... JRA.
676          */
677
678         if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
679                 DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
680                 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
681                         smb_read_error = READ_ERROR;
682                         return False;
683                 }
684         }
685
686         if(len > 0) {
687                 ret = read_socket_data(fd,buffer+4,len);
688                 if (ret != len) {
689                         smb_read_error = READ_ERROR;
690                         return False;
691                 }
692         }
693
694         return(True);
695 }
696
697 /****************************************************************************
698   read an smb from a fd ignoring all keepalive packets. Note that the buffer 
699   *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
700   The timeout is in milliseconds
701
702   This is exactly the same as receive_smb except that it never returns
703   a session keepalive packet (just as receive_smb used to do).
704   receive_smb was changed to return keepalives as the oplock processing means this call
705   should never go into a blocking read.
706 ****************************************************************************/
707
708 BOOL client_receive_smb(int fd,char *buffer, unsigned int timeout)
709 {
710   BOOL ret;
711
712   for(;;)
713   {
714     ret = receive_smb(fd, buffer, timeout);
715
716     if (!ret)
717     {
718       DEBUG(10,("client_receive_smb failed\n"));
719       show_msg(buffer);
720       return ret;
721     }
722
723     /* Ignore session keepalive packets. */
724     if(CVAL(buffer,0) != SMBkeepalive)
725       break;
726   }
727   show_msg(buffer);
728   return ret;
729 }
730
731 /****************************************************************************
732   send an smb to a fd 
733 ****************************************************************************/
734
735 BOOL send_smb(int fd,char *buffer)
736 {
737         size_t len;
738         size_t nwritten=0;
739         ssize_t ret;
740         len = smb_len(buffer) + 4;
741
742         while (nwritten < len) {
743                 ret = write_socket(fd,buffer+nwritten,len - nwritten);
744                 if (ret <= 0) {
745                         DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
746                                 (int)len,(int)ret, strerror(errno) ));
747                         return False;
748                 }
749                 nwritten += ret;
750         }
751
752         return True;
753 }
754
755 /****************************************************************************
756 send a single packet to a port on another machine
757 ****************************************************************************/
758
759 BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
760 {
761   BOOL ret;
762   int out_fd;
763   struct sockaddr_in sock_out;
764
765   /* create a socket to write to */
766   out_fd = socket(AF_INET, type, 0);
767   if (out_fd == -1) 
768     {
769       DEBUG(0,("socket failed"));
770       return False;
771     }
772
773   /* set the address and port */
774   memset((char *)&sock_out,'\0',sizeof(sock_out));
775   putip((char *)&sock_out.sin_addr,(char *)&ip);
776   sock_out.sin_port = htons( port );
777   sock_out.sin_family = AF_INET;
778   
779   if (DEBUGLEVEL > 0)
780     DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
781              len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
782         
783   /* send it */
784   ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
785
786   if (!ret)
787     DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
788              inet_ntoa(ip),port,strerror(errno)));
789
790   close(out_fd);
791   return(ret);
792 }
793
794 /****************************************************************************
795  Open a socket of the specified type, port, and address for incoming data.
796 ****************************************************************************/
797
798 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
799 {
800         struct sockaddr_in sock;
801         int res;
802
803         memset( (char *)&sock, '\0', sizeof(sock) );
804
805 #ifdef HAVE_SOCK_SIN_LEN
806         sock.sin_len         = sizeof(sock);
807 #endif
808         sock.sin_port        = htons( port );
809         sock.sin_family      = AF_INET;
810         sock.sin_addr.s_addr = socket_addr;
811
812         res = socket( AF_INET, type, 0 );
813         if( res == -1 ) {
814                 if( DEBUGLVL(0) ) {
815                         dbgtext( "open_socket_in(): socket() call failed: " );
816                         dbgtext( "%s\n", strerror( errno ) );
817                 }
818                 return -1;
819         }
820
821         /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
822         {
823                 int val = rebind ? 1 : 0;
824                 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
825                         if( DEBUGLVL( dlevel ) ) {
826                                 dbgtext( "open_socket_in(): setsockopt: " );
827                                 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
828                                 dbgtext( "on port %d failed ", port );
829                                 dbgtext( "with error = %s\n", strerror(errno) );
830                         }
831                 }
832 #ifdef SO_REUSEPORT
833                 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
834                         if( DEBUGLVL( dlevel ) ) {
835                                 dbgtext( "open_socket_in(): setsockopt: ");
836                                 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
837                                 dbgtext( "on port %d failed ", port );
838                                 dbgtext( "with error = %s\n", strerror(errno) );
839                         }
840                 }
841 #endif /* SO_REUSEPORT */
842         }
843
844         /* now we've got a socket - we need to bind it */
845         if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
846                 if( DEBUGLVL(dlevel) && (port == SMB_PORT || port == NMB_PORT) ) {
847                         dbgtext( "bind failed on port %d ", port );
848                         dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
849                         dbgtext( "Error = %s\n", strerror(errno) );
850                 }
851                 close( res ); 
852                 return( -1 ); 
853         }
854
855         DEBUG( 3, ( "bind succeeded on port %d\n", port ) );
856
857         return( res );
858  }
859
860 /****************************************************************************
861   create an outgoing socket. timeout is in milliseconds.
862   **************************************************************************/
863
864 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
865 {
866   struct sockaddr_in sock_out;
867   int res,ret;
868   int connect_loop = 250; /* 250 milliseconds */
869   int loops = (timeout) / connect_loop;
870
871   /* create a socket to write to */
872   res = socket(PF_INET, type, 0);
873   if (res == -1) 
874     { DEBUG(0,("socket error\n")); return -1; }
875
876   if (type != SOCK_STREAM) return(res);
877   
878   memset((char *)&sock_out,'\0',sizeof(sock_out));
879   putip((char *)&sock_out.sin_addr,(char *)addr);
880   
881   sock_out.sin_port = htons( port );
882   sock_out.sin_family = PF_INET;
883
884   /* set it non-blocking */
885   set_blocking(res,False);
886
887   DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
888   
889   /* and connect it to the destination */
890 connect_again:
891   ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
892
893   /* Some systems return EAGAIN when they mean EINPROGRESS */
894   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
895         errno == EAGAIN) && loops--) {
896     msleep(connect_loop);
897     goto connect_again;
898   }
899
900   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
901          errno == EAGAIN)) {
902       DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
903       close(res);
904       return -1;
905   }
906
907 #ifdef EISCONN
908   if (ret < 0 && errno == EISCONN) {
909     errno = 0;
910     ret = 0;
911   }
912 #endif
913
914   if (ret < 0) {
915     DEBUG(2,("error connecting to %s:%d (%s)\n",
916              inet_ntoa(*addr),port,strerror(errno)));
917     close(res);
918     return -1;
919   }
920
921   /* set it blocking again */
922   set_blocking(res,True);
923
924   return res;
925 }
926
927 /*
928   open a connected UDP socket to host on port
929 */
930 int open_udp_socket(const char *host, int port)
931 {
932         int type = SOCK_DGRAM;
933         struct sockaddr_in sock_out;
934         int res;
935         struct in_addr *addr;
936
937         addr = interpret_addr2(host);
938
939         res = socket(PF_INET, type, 0);
940         if (res == -1) {
941                 return -1;
942         }
943
944         memset((char *)&sock_out,'\0',sizeof(sock_out));
945         putip((char *)&sock_out.sin_addr,(char *)addr);
946         sock_out.sin_port = htons(port);
947         sock_out.sin_family = PF_INET;
948
949         if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
950                 close(res);
951                 return -1;
952         }
953
954         return res;
955 }
956
957
958 /* the following 3 client_*() functions are nasty ways of allowing
959    some generic functions to get info that really should be hidden in
960    particular modules */
961 static int client_fd = -1;
962
963 void client_setfd(int fd)
964 {
965         client_fd = fd;
966 }
967
968 char *client_name(void)
969 {
970         return get_socket_name(client_fd);
971 }
972
973 char *client_addr(void)
974 {
975         return get_socket_addr(client_fd);
976 }
977
978 /*******************************************************************
979  matchname - determine if host name matches IP address. Used to
980  confirm a hostname lookup to prevent spoof attacks
981  ******************************************************************/
982 static BOOL matchname(char *remotehost,struct in_addr  addr)
983 {
984         struct hostent *hp;
985         int     i;
986         
987         if ((hp = sys_gethostbyname(remotehost)) == 0) {
988                 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
989                 return False;
990         } 
991
992         /*
993          * Make sure that gethostbyname() returns the "correct" host name.
994          * Unfortunately, gethostbyname("localhost") sometimes yields
995          * "localhost.domain". Since the latter host name comes from the
996          * local DNS, we just have to trust it (all bets are off if the local
997          * DNS is perverted). We always check the address list, though.
998          */
999         
1000         if (strcasecmp(remotehost, hp->h_name)
1001             && strcasecmp(remotehost, "localhost")) {
1002                 DEBUG(0,("host name/name mismatch: %s != %s\n",
1003                          remotehost, hp->h_name));
1004                 return False;
1005         }
1006         
1007         /* Look up the host address in the address list we just got. */
1008         for (i = 0; hp->h_addr_list[i]; i++) {
1009                 if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
1010                         return True;
1011         }
1012         
1013         /*
1014          * The host name does not map to the original host address. Perhaps
1015          * someone has compromised a name server. More likely someone botched
1016          * it, but that could be dangerous, too.
1017          */
1018         
1019         DEBUG(0,("host name/address mismatch: %s != %s\n",
1020                  inet_ntoa(addr), hp->h_name));
1021         return False;
1022 }
1023
1024  
1025 /*******************************************************************
1026  return the DNS name of the remote end of a socket
1027  ******************************************************************/
1028 char *get_socket_name(int fd)
1029 {
1030         static pstring name_buf;
1031         static fstring addr_buf;
1032         struct hostent *hp;
1033         struct in_addr addr;
1034         char *p;
1035
1036         /* reverse lookups can be *very* expensive, and in many
1037            situations won't work because many networks don't link dhcp
1038            with dns. To avoid the delay we avoid the lookup if
1039            possible */
1040         if (!lp_hostname_lookups()) {
1041                 return get_socket_addr(fd);
1042         }
1043         
1044         p = get_socket_addr(fd);
1045
1046         /* it might be the same as the last one - save some DNS work */
1047         if (strcmp(p, addr_buf) == 0) return name_buf;
1048
1049         pstrcpy(name_buf,"UNKNOWN");
1050         if (fd == -1) return name_buf;
1051
1052         fstrcpy(addr_buf, p);
1053
1054         addr = *interpret_addr2(p);
1055         
1056         /* Look up the remote host name. */
1057         if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1058                 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1059                 pstrcpy(name_buf, p);
1060         } else {
1061                 pstrcpy(name_buf,(char *)hp->h_name);
1062                 if (!matchname(name_buf, addr)) {
1063                         DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1064                         pstrcpy(name_buf,"UNKNOWN");
1065                 }
1066         }
1067
1068         alpha_strcpy(name_buf, name_buf, "_-.", sizeof(name_buf));
1069         if (strstr(name_buf,"..")) {
1070                 pstrcpy(name_buf, "UNKNOWN");
1071         }
1072
1073         return name_buf;
1074 }
1075
1076 /*******************************************************************
1077  return the IP addr of the remote end of a socket as a string 
1078  ******************************************************************/
1079 char *get_socket_addr(int fd)
1080 {
1081         struct sockaddr sa;
1082         struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1083         int     length = sizeof(sa);
1084         static fstring addr_buf;
1085
1086         fstrcpy(addr_buf,"0.0.0.0");
1087
1088         if (fd == -1) {
1089                 return addr_buf;
1090         }
1091         
1092         if (getpeername(fd, &sa, &length) < 0) {
1093                 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1094                 return addr_buf;
1095         }
1096         
1097         fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1098         
1099         return addr_buf;
1100 }
1101
1102 /*******************************************************************
1103  opens and connects to a unix pipe socket
1104  ******************************************************************/
1105 int open_pipe_sock(char *path)
1106 {
1107         int sock;
1108         struct sockaddr_un sa;
1109
1110         sock = socket(AF_UNIX, SOCK_STREAM, 0);
1111
1112         if (sock < 0)
1113         {
1114                 DEBUG(0, ("unix socket open failed\n"));
1115                 return sock;
1116         }
1117
1118         ZERO_STRUCT(sa);
1119         sa.sun_family = AF_UNIX;
1120         safe_strcpy(sa.sun_path, path, sizeof(sa.sun_path)-1);
1121
1122         DEBUG(10, ("socket open succeeded.  file name: %s\n", sa.sun_path));
1123
1124         if (connect(sock, (struct sockaddr*) &sa, sizeof(sa)) < 0)
1125         {
1126                 DEBUG(0,("socket connect to %s failed\n", sa.sun_path));
1127                 close(sock);
1128                 return -1;
1129         }
1130
1131         return sock;
1132 }
1133
1134 /*******************************************************************
1135  Create protected unix domain socket.
1136
1137  some unixen cannot set permissions on a ux-dom-sock, so we
1138  have to make sure that the directory contains the protection
1139  permissions, instead.
1140  ******************************************************************/
1141 int create_pipe_sock(const char *socket_dir,
1142                                         const char *socket_name,
1143                                         mode_t dir_perms)
1144 {
1145         struct sockaddr_un sunaddr;
1146         struct stat st;
1147         int sock;
1148         mode_t old_umask;
1149         pstring path;
1150         
1151         /* Create the socket directory or reuse the existing one */
1152         
1153         if (lstat(socket_dir, &st) == -1) {
1154                 
1155                 if (errno == ENOENT) {
1156                         
1157                         /* Create directory */
1158                         
1159                         if (mkdir(socket_dir, dir_perms) == -1) {
1160                                 DEBUG(0, ("error creating socket directory "
1161                                           "%s: %s\n", socket_dir, 
1162                                           strerror(errno)));
1163                                 return -1;
1164                         }
1165                         
1166                 } else {
1167                         
1168                         DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1169                                   socket_dir, strerror(errno)));
1170                         return -1;
1171                 }
1172                 
1173         } else {
1174                 
1175                 /* Check ownership and permission on existing directory */
1176                 
1177                 if (!S_ISDIR(st.st_mode)) {
1178                         DEBUG(0, ("socket directory %s isn't a directory\n",
1179                                   socket_dir));
1180                         return -1;
1181                 }
1182                 
1183                 if ((st.st_uid != sec_initial_uid()) || 
1184                     ((st.st_mode & 0777) != dir_perms)) {
1185                         DEBUG(0, ("invalid permissions on socket directory "
1186                                   "%s\n", socket_dir));
1187                         return -1;
1188                 }
1189         }
1190         
1191         /* Create the socket file */
1192         
1193         old_umask = umask(0);
1194         
1195         sock = socket(AF_UNIX, SOCK_STREAM, 0);
1196         
1197         if (sock == -1) {
1198                 perror("socket");
1199                 umask(old_umask);
1200                 return -1;
1201         }
1202         
1203         snprintf(path, sizeof(path), "%s/%s", socket_dir, socket_name);
1204         
1205         unlink(path);
1206         memset(&sunaddr, 0, sizeof(sunaddr));
1207         sunaddr.sun_family = AF_UNIX;
1208         safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1209         
1210         if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1211                 DEBUG(0, ("bind failed on pipe socket %s: %s\n",
1212                           path,
1213                           strerror(errno)));
1214                 close(sock);
1215                 umask(old_umask);
1216                 return -1;
1217         }
1218         
1219         if (listen(sock, 5) == -1) {
1220                 DEBUG(0, ("listen failed on pipe socket %s: %s\n",
1221                           path,
1222                           strerror(errno)));
1223                 close(sock);
1224                 umask(old_umask);
1225                 return -1;
1226         }
1227         
1228         umask(old_umask);
1229         
1230         /* Success! */
1231         
1232         return sock;
1233 }
1234
1235 /*******************************************************************
1236 this is like socketpair but uses tcp. It is used by the Samba
1237 regression test code
1238 The function guarantees that nobody else can attach to the socket,
1239 or if they do that this function fails and the socket gets closed
1240 returns 0 on success, -1 on failure
1241 the resulting file descriptors are symmetrical
1242  ******************************************************************/
1243 static int socketpair_tcp(int fd[2])
1244 {
1245         int listener;
1246         struct sockaddr_in sock;
1247         struct sockaddr_in sock2;
1248         socklen_t socklen = sizeof(sock);
1249         int connect_done = 0;
1250         
1251         fd[0] = fd[1] = listener = -1;
1252
1253         memset(&sock, 0, sizeof(sock));
1254         
1255         if ((listener = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1256
1257         memset(&sock2, 0, sizeof(sock2));
1258 #ifdef HAVE_SOCK_SIN_LEN
1259         sock2.sin_len = sizeof(sock2);
1260 #endif
1261         sock2.sin_family = PF_INET;
1262
1263         bind(listener, (struct sockaddr *)&sock2, sizeof(sock2));
1264
1265         if (listen(listener, 1) != 0) goto failed;
1266
1267         if (getsockname(listener, (struct sockaddr *)&sock, &socklen) != 0) goto failed;
1268
1269         if ((fd[1] = socket(PF_INET, SOCK_STREAM, 0)) == -1) goto failed;
1270
1271         set_blocking(fd[1], 0);
1272
1273         sock.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
1274
1275         if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) == -1) {
1276                 if (errno != EINPROGRESS) goto failed;
1277         } else {
1278                 connect_done = 1;
1279         }
1280
1281         if ((fd[0] = accept(listener, (struct sockaddr *)&sock, &socklen)) == -1) goto failed;
1282
1283         close(listener);
1284         if (connect_done == 0) {
1285                 if (connect(fd[1],(struct sockaddr *)&sock,sizeof(sock)) != 0
1286                     && errno != EISCONN) goto failed;
1287         }
1288
1289         set_blocking(fd[1], 1);
1290
1291         /* all OK! */
1292         return 0;
1293
1294  failed:
1295         if (fd[0] != -1) close(fd[0]);
1296         if (fd[1] != -1) close(fd[1]);
1297         if (listener != -1) close(listener);
1298         return -1;
1299 }
1300
1301
1302 /*******************************************************************
1303 run a program on a local tcp socket, this is used to launch smbd
1304 when regression testing
1305 the return value is a socket which is attached to a subprocess
1306 running "prog". stdin and stdout are attached. stderr is left
1307 attached to the original stderr
1308  ******************************************************************/
1309 int sock_exec(const char *prog)
1310 {
1311         int fd[2];
1312         if (socketpair_tcp(fd) != 0) {
1313                 DEBUG(0,("socketpair_tcp failed (%s)\n", strerror(errno)));
1314                 return -1;
1315         }
1316         if (fork() == 0) {
1317                 close(fd[0]);
1318                 close(0);
1319                 close(1);
1320                 dup(fd[1]);
1321                 dup(fd[1]);
1322                 exit(system(prog));
1323         }
1324         close(fd[1]);
1325         return fd[0];
1326 }