?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r25055: Add file_id_string_tos
[Samba.git] / source / lib / util_sock.c
blob9dcbdd9f02552753f69fc98146308594573d215c
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 Copyright (C) Jeremy Allison 1992-2005
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23
24 /* the following 3 client_*() functions are nasty ways of allowing
25 some generic functions to get info that really should be hidden in
26 particular modules */
27 static int client_fd = -1;
28 /* What to print out on a client disconnect error. */
29 static char client_ip_string[16];
30
31 void client_setfd(int fd)
32 {
33 client_fd = fd;
34 safe_strcpy(client_ip_string, get_peer_addr(client_fd), sizeof(client_ip_string)-1);
35 }
36
37 static char *get_socket_addr(int fd)
38 {
39 struct sockaddr sa;
40 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
41 socklen_t length = sizeof(sa);
42 static fstring addr_buf;
43
44 fstrcpy(addr_buf,"0.0.0.0");
45
46 if (fd == -1) {
47 return addr_buf;
48 }
49
50 if (getsockname(fd, &sa, &length) < 0) {
51 DEBUG(0,("getsockname failed. Error was %s\n", strerror(errno) ));
52 return addr_buf;
53 }
54
55 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
56
57 return addr_buf;
58 }
59
60 static int get_socket_port(int fd)
61 {
62 struct sockaddr sa;
63 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
64 socklen_t length = sizeof(sa);
65
66 if (fd == -1)
67 return -1;
68
69 if (getsockname(fd, &sa, &length) < 0) {
70 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
71 return -1;
72 }
73
74 return ntohs(sockin->sin_port);
75 }
76
77 char *client_name(void)
78 {
79 return get_peer_name(client_fd,False);
80 }
81
82 char *client_addr(void)
83 {
84 return get_peer_addr(client_fd);
85 }
86
87 char *client_socket_addr(void)
88 {
89 return get_socket_addr(client_fd);
90 }
91
92 int client_socket_port(void)
93 {
94 return get_socket_port(client_fd);
95 }
96
97 struct in_addr *client_inaddr(struct sockaddr *sa)
98 {
99 struct sockaddr_in *sockin = (struct sockaddr_in *) (sa);
100 socklen_t length = sizeof(*sa);
101
102 if (getpeername(client_fd, sa, &length) < 0) {
103 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
104 return NULL;
105 }
106
107 return &sockin->sin_addr;
108 }
109
110 /* the last IP received from */
111 struct in_addr lastip;
112
113 /* the last port received from */
114 int lastport=0;
115
116 int smb_read_error = 0;
117
118 /****************************************************************************
119 Determine if a file descriptor is in fact a socket.
120 ****************************************************************************/
121
122 BOOL is_a_socket(int fd)
123 {
124 int v;
125 socklen_t l;
126 l = sizeof(int);
127 return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
128 }
129
130 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
131
132 typedef struct smb_socket_option {
133 const char *name;
134 int level;
135 int option;
136 int value;
137 int opttype;
138 } smb_socket_option;
139
140 static const smb_socket_option socket_options[] = {
141 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
142 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
143 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
144 #ifdef TCP_NODELAY
145 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
146 #endif
147 #ifdef TCP_KEEPCNT
148 {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
149 #endif
150 #ifdef TCP_KEEPIDLE
151 {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
152 #endif
153 #ifdef TCP_KEEPINTVL
154 {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
155 #endif
156 #ifdef IPTOS_LOWDELAY
157 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
158 #endif
159 #ifdef IPTOS_THROUGHPUT
160 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
161 #endif
162 #ifdef SO_REUSEPORT
163 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
164 #endif
165 #ifdef SO_SNDBUF
166 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
167 #endif
168 #ifdef SO_RCVBUF
169 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
170 #endif
171 #ifdef SO_SNDLOWAT
172 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
173 #endif
174 #ifdef SO_RCVLOWAT
175 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
176 #endif
177 #ifdef SO_SNDTIMEO
178 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
179 #endif
180 #ifdef SO_RCVTIMEO
181 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
182 #endif
183 #ifdef TCP_FASTACK
184 {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
185 #endif
186 {NULL,0,0,0,0}};
187
188 /****************************************************************************
189 Print socket options.
190 ****************************************************************************/
191
192 static void print_socket_options(int s)
193 {
194 int value;
195 socklen_t vlen = 4;
196 const smb_socket_option *p = &socket_options[0];
197
198 /* wrapped in if statement to prevent streams leak in SCO Openserver 5.0 */
199 /* reported on samba-technical --jerry */
200 if ( DEBUGLEVEL >= 5 ) {
201 for (; p->name != NULL; p++) {
202 if (getsockopt(s, p->level, p->option, (void *)&value, &vlen) == -1) {
203 DEBUG(5,("Could not test socket option %s.\n", p->name));
204 } else {
205 DEBUG(5,("socket option %s = %d\n",p->name,value));
206 }
207 }
208 }
209 }
210
211 /****************************************************************************
212 Set user socket options.
213 ****************************************************************************/
214
215 void set_socket_options(int fd, const char *options)
216 {
217 fstring tok;
218
219 while (next_token(&options,tok," \t,", sizeof(tok))) {
220 int ret=0,i;
221 int value = 1;
222 char *p;
223 BOOL got_value = False;
224
225 if ((p = strchr_m(tok,'='))) {
226 *p = 0;
227 value = atoi(p+1);
228 got_value = True;
229 }
230
231 for (i=0;socket_options[i].name;i++)
232 if (strequal(socket_options[i].name,tok))
233 break;
234
235 if (!socket_options[i].name) {
236 DEBUG(0,("Unknown socket option %s\n",tok));
237 continue;
238 }
239
240 switch (socket_options[i].opttype) {
241 case OPT_BOOL:
242 case OPT_INT:
243 ret = setsockopt(fd,socket_options[i].level,
244 socket_options[i].option,(char *)&value,sizeof(int));
245 break;
246
247 case OPT_ON:
248 if (got_value)
249 DEBUG(0,("syntax error - %s does not take a value\n",tok));
250
251 {
252 int on = socket_options[i].value;
253 ret = setsockopt(fd,socket_options[i].level,
254 socket_options[i].option,(char *)&on,sizeof(int));
255 }
256 break;
257 }
258
259 if (ret != 0)
260 DEBUG(0,("Failed to set socket option %s (Error %s)\n",tok, strerror(errno) ));
261 }
262
263 print_socket_options(fd);
264 }
265
266 /****************************************************************************
267 Read from a socket.
268 ****************************************************************************/
269
270 ssize_t read_udp_socket(int fd,char *buf,size_t len)
271 {
272 ssize_t ret;
273 struct sockaddr_in sock;
274 socklen_t socklen = sizeof(sock);
275
276 memset((char *)&sock,'\0',socklen);
277 memset((char *)&lastip,'\0',sizeof(lastip));
278 ret = (ssize_t)sys_recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
279 if (ret <= 0) {
280 /* Don't print a low debug error for a non-blocking socket. */
281 if (errno == EAGAIN) {
282 DEBUG(10,("read socket returned EAGAIN. ERRNO=%s\n",strerror(errno)));
283 } else {
284 DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
285 }
286 return(0);
287 }
288
289 lastip = sock.sin_addr;
290 lastport = ntohs(sock.sin_port);
291
292 DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %lu\n",
293 inet_ntoa(lastip), lastport, (unsigned long)ret));
294
295 return(ret);
296 }
297
298 #if 0
299
300 Socket routines from HEAD - maybe re-enable in future. JRA.
301
302 /****************************************************************************
303 Work out if we've timed out.
304 ****************************************************************************/
305
306 static BOOL timeout_until(struct timeval *timeout, const struct timeval *endtime)
307 {
308 struct timeval now;
309 SMB_BIG_INT t_dif;
310
311 GetTimeOfDay(&now);
312
313 t_dif = usec_time_diff(endtime, &now);
314 if (t_dif <= 0) {
315 return False;
316 }
317
318 timeout->tv_sec = (t_dif / (SMB_BIG_INT)1000000);
319 timeout->tv_usec = (t_dif % (SMB_BIG_INT)1000000);
320 return True;
321 }
322
323 /****************************************************************************
324 Read data from the client, reading exactly N bytes, or until endtime timeout.
325 Use with a non-blocking socket if endtime != NULL.
326 ****************************************************************************/
327
328 ssize_t read_data_until(int fd,char *buffer,size_t N, const struct timeval *endtime)
329 {
330 ssize_t ret;
331 size_t total=0;
332
333 smb_read_error = 0;
334
335 while (total < N) {
336
337 if (endtime != NULL) {
338 fd_set r_fds;
339 struct timeval timeout;
340 int selrtn;
341
342 if (!timeout_until(&timeout, endtime)) {
343 DEBUG(10,("read_data_until: read timed out\n"));
344 smb_read_error = READ_TIMEOUT;
345 return -1;
346 }
347
348 FD_ZERO(&r_fds);
349 FD_SET(fd, &r_fds);
350
351 /* Select but ignore EINTR. */
352 selrtn = sys_select_intr(fd+1, &r_fds, NULL, NULL, &timeout);
353 if (selrtn == -1) {
354 /* something is wrong. Maybe the socket is dead? */
355 DEBUG(0,("read_data_until: select error = %s.\n", strerror(errno) ));
356 smb_read_error = READ_ERROR;
357 return -1;
358 }
359
360 /* Did we timeout ? */
361 if (selrtn == 0) {
362 DEBUG(10,("read_data_until: select timed out.\n"));
363 smb_read_error = READ_TIMEOUT;
364 return -1;
365 }
366 }
367
368 ret = sys_read(fd,buffer + total,N - total);
369
370 if (ret == 0) {
371 DEBUG(10,("read_data_until: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
372 smb_read_error = READ_EOF;
373 return 0;
374 }
375
376 if (ret == -1) {
377 if (errno == EAGAIN) {
378 /* Non-blocking socket with no data available. Try select again. */
379 continue;
380 }
381 DEBUG(0,("read_data_until: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
382 smb_read_error = READ_ERROR;
383 return -1;
384 }
385 total += ret;
386 }
387 return (ssize_t)total;
388 }
389 #endif
390
391 /****************************************************************************
392 Read data from a socket with a timout in msec.
393 mincount = if timeout, minimum to read before returning
394 maxcount = number to be read.
395 time_out = timeout in milliseconds
396 ****************************************************************************/
397
398 ssize_t read_socket_with_timeout(int fd,char *buf,size_t mincnt,size_t maxcnt,unsigned int time_out)
399 {
400 fd_set fds;
401 int selrtn;
402 ssize_t readret;
403 size_t nread = 0;
404 struct timeval timeout;
405
406 /* just checking .... */
407 if (maxcnt <= 0)
408 return(0);
409
410 smb_read_error = 0;
411
412 /* Blocking read */
413 if (time_out == 0) {
414 if (mincnt == 0) {
415 mincnt = maxcnt;
416 }
417
418 while (nread < mincnt) {
419 readret = sys_read(fd, buf + nread, maxcnt - nread);
420
421 if (readret == 0) {
422 DEBUG(5,("read_socket_with_timeout: blocking read. EOF from client.\n"));
423 smb_read_error = READ_EOF;
424 return -1;
425 }
426
427 if (readret == -1) {
428 if (fd == client_fd) {
429 /* Try and give an error message saying what client failed. */
430 DEBUG(0,("read_socket_with_timeout: client %s read error = %s.\n",
431 client_ip_string, strerror(errno) ));
432 } else {
433 DEBUG(0,("read_socket_with_timeout: read error = %s.\n", strerror(errno) ));
434 }
435 smb_read_error = READ_ERROR;
436 return -1;
437 }
438 nread += readret;
439 }
440 return((ssize_t)nread);
441 }
442
443 /* Most difficult - timeout read */
444 /* If this is ever called on a disk file and
445 mincnt is greater then the filesize then
446 system performance will suffer severely as
447 select always returns true on disk files */
448
449 /* Set initial timeout */
450 timeout.tv_sec = (time_t)(time_out / 1000);
451 timeout.tv_usec = (long)(1000 * (time_out % 1000));
452
453 for (nread=0; nread < mincnt; ) {
454 FD_ZERO(&fds);
455 FD_SET(fd,&fds);
456
457 selrtn = sys_select_intr(fd+1,&fds,NULL,NULL,&timeout);
458
459 /* Check if error */
460 if (selrtn == -1) {
461 /* something is wrong. Maybe the socket is dead? */
462 if (fd == client_fd) {
463 /* Try and give an error message saying what client failed. */
464 DEBUG(0,("read_socket_with_timeout: timeout read for client %s. select error = %s.\n",
465 client_ip_string, strerror(errno) ));
466 } else {
467 DEBUG(0,("read_socket_with_timeout: timeout read. select error = %s.\n", strerror(errno) ));
468 }
469 smb_read_error = READ_ERROR;
470 return -1;
471 }
472
473 /* Did we timeout ? */
474 if (selrtn == 0) {
475 DEBUG(10,("read_socket_with_timeout: timeout read. select timed out.\n"));
476 smb_read_error = READ_TIMEOUT;
477 return -1;
478 }
479
480 readret = sys_read(fd, buf+nread, maxcnt-nread);
481
482 if (readret == 0) {
483 /* we got EOF on the file descriptor */
484 DEBUG(5,("read_socket_with_timeout: timeout read. EOF from client.\n"));
485 smb_read_error = READ_EOF;
486 return -1;
487 }
488
489 if (readret == -1) {
490 /* the descriptor is probably dead */
491 if (fd == client_fd) {
492 /* Try and give an error message saying what client failed. */
493 DEBUG(0,("read_socket_with_timeout: timeout read to client %s. read error = %s.\n",
494 client_ip_string, strerror(errno) ));
495 } else {
496 DEBUG(0,("read_socket_with_timeout: timeout read. read error = %s.\n", strerror(errno) ));
497 }
498 smb_read_error = READ_ERROR;
499 return -1;
500 }
501
502 nread += readret;
503 }
504
505 /* Return the number we got */
506 return (ssize_t)nread;
507 }
508
509 /****************************************************************************
510 Read data from the client, reading exactly N bytes.
511 ****************************************************************************/
512
513 ssize_t read_data(int fd,char *buffer,size_t N)
514 {
515 ssize_t ret;
516 size_t total=0;
517
518 smb_read_error = 0;
519
520 while (total < N) {
521 ret = sys_read(fd,buffer + total,N - total);
522
523 if (ret == 0) {
524 DEBUG(10,("read_data: read of %d returned 0. Error = %s\n", (int)(N - total), strerror(errno) ));
525 smb_read_error = READ_EOF;
526 return 0;
527 }
528
529 if (ret == -1) {
530 if (fd == client_fd) {
531 /* Try and give an error message saying what client failed. */
532 DEBUG(0,("read_data: read failure for %d bytes to client %s. Error = %s\n",
533 (int)(N - total), client_ip_string, strerror(errno) ));
534 } else {
535 DEBUG(0,("read_data: read failure for %d. Error = %s\n", (int)(N - total), strerror(errno) ));
536 }
537 smb_read_error = READ_ERROR;
538 return -1;
539 }
540 total += ret;
541 }
542 return (ssize_t)total;
543 }
544
545 /****************************************************************************
546 Write data to a fd.
547 ****************************************************************************/
548
549 ssize_t write_data(int fd, const char *buffer, size_t N)
550 {
551 size_t total=0;
552 ssize_t ret;
553
554 while (total < N) {
555 ret = sys_write(fd,buffer + total,N - total);
556
557 if (ret == -1) {
558 if (fd == client_fd) {
559 /* Try and give an error message saying what client failed. */
560 DEBUG(0,("write_data: write failure in writing to client %s. Error %s\n",
561 client_ip_string, strerror(errno) ));
562 } else {
563 DEBUG(0,("write_data: write failure. Error = %s\n", strerror(errno) ));
564 }
565 return -1;
566 }
567
568 if (ret == 0) {
569 return total;
570 }
571
572 total += ret;
573 }
574 return (ssize_t)total;
575 }
576
577 /****************************************************************************
578 Send a keepalive packet (rfc1002).
579 ****************************************************************************/
580
581 BOOL send_keepalive(int client)
582 {
583 unsigned char buf[4];
584
585 buf[0] = SMBkeepalive;
586 buf[1] = buf[2] = buf[3] = 0;
587
588 return(write_data(client,(char *)buf,4) == 4);
589 }
590
591
592 /****************************************************************************
593 Read 4 bytes of a smb packet and return the smb length of the packet.
594 Store the result in the buffer.
595 This version of the function will return a length of zero on receiving
596 a keepalive packet.
597 Timeout is in milliseconds.
598 ****************************************************************************/
599
600 static ssize_t read_smb_length_return_keepalive(int fd, char *inbuf, unsigned int timeout)
601 {
602 ssize_t len=0;
603 int msg_type;
604 BOOL ok = False;
605
606 while (!ok) {
607 if (timeout > 0)
608 ok = (read_socket_with_timeout(fd,inbuf,4,4,timeout) == 4);
609 else
610 ok = (read_data(fd,inbuf,4) == 4);
611
612 if (!ok)
613 return(-1);
614
615 len = smb_len(inbuf);
616 msg_type = CVAL(inbuf,0);
617
618 if (msg_type == SMBkeepalive)
619 DEBUG(5,("Got keepalive packet\n"));
620 }
621
622 DEBUG(10,("got smb length of %lu\n",(unsigned long)len));
623
624 return(len);
625 }
626
627 /****************************************************************************
628 Read 4 bytes of a smb packet and return the smb length of the packet.
629 Store the result in the buffer. This version of the function will
630 never return a session keepalive (length of zero).
631 Timeout is in milliseconds.
632 ****************************************************************************/
633
634 ssize_t read_smb_length(int fd, char *inbuf, unsigned int timeout)
635 {
636 ssize_t len;
637
638 for(;;) {
639 len = read_smb_length_return_keepalive(fd, inbuf, timeout);
640
641 if(len < 0)
642 return len;
643
644 /* Ignore session keepalives. */
645 if(CVAL(inbuf,0) != SMBkeepalive)
646 break;
647 }
648
649 DEBUG(10,("read_smb_length: got smb length of %lu\n",
650 (unsigned long)len));
651
652 return len;
653 }
654
655 /****************************************************************************
656 Read an smb from a fd. Note that the buffer *MUST* be of size
657 BUFFER_SIZE+SAFETY_MARGIN.
658 The timeout is in milliseconds.
659 This function will return on receipt of a session keepalive packet.
660 maxlen is the max number of bytes to return, not including the 4 byte
661 length. If zero it means BUFFER_SIZE+SAFETY_MARGIN limit.
662 Doesn't check the MAC on signed packets.
663 ****************************************************************************/
664
665 ssize_t receive_smb_raw(int fd, char *buffer, unsigned int timeout, size_t maxlen)
666 {
667 ssize_t len,ret;
668
669 smb_read_error = 0;
670
671 len = read_smb_length_return_keepalive(fd,buffer,timeout);
672 if (len < 0) {
673 DEBUG(10,("receive_smb_raw: length < 0!\n"));
674
675 /*
676 * Correct fix. smb_read_error may have already been
677 * set. Only set it here if not already set. Global
678 * variables still suck :-). JRA.
679 */
680
681 if (smb_read_error == 0)
682 smb_read_error = READ_ERROR;
683 return -1;
684 }
685
686 /*
687 * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
688 * of header. Don't print the error if this fits.... JRA.
689 */
690
691 if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
692 DEBUG(0,("Invalid packet length! (%lu bytes).\n",(unsigned long)len));
693 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
694
695 /*
696 * Correct fix. smb_read_error may have already been
697 * set. Only set it here if not already set. Global
698 * variables still suck :-). JRA.
699 */
700
701 if (smb_read_error == 0)
702 smb_read_error = READ_ERROR;
703 return -1;
704 }
705 }
706
707 if(len > 0) {
708 if (maxlen) {
709 len = MIN(len,maxlen);
710 }
711
712 if (timeout > 0) {
713 ret = read_socket_with_timeout(fd,buffer+4,len,len,timeout);
714 } else {
715 ret = read_data(fd,buffer+4,len);
716 }
717
718 if (ret != len) {
719 if (smb_read_error == 0) {
720 smb_read_error = READ_ERROR;
721 }
722 return -1;
723 }
724
725 /* not all of samba3 properly checks for packet-termination of strings. This
726 ensures that we don't run off into empty space. */
727 SSVAL(buffer+4,len, 0);
728 }
729
730 return len;
731 }
732
733 static ssize_t receive_smb_raw_talloc(TALLOC_CTX *mem_ctx, int fd,
734 char **buffer, unsigned int timeout)
735 {
736 char lenbuf[4];
737 ssize_t len,ret;
738
739 smb_read_error = 0;
740
741 len = read_smb_length_return_keepalive(fd, lenbuf, timeout);
742 if (len < 0) {
743 DEBUG(10,("receive_smb_raw: length < 0!\n"));
744
745 /*
746 * Correct fix. smb_read_error may have already been
747 * set. Only set it here if not already set. Global
748 * variables still suck :-). JRA.
749 */
750
751 if (smb_read_error == 0)
752 smb_read_error = READ_ERROR;
753 return -1;
754 }
755
756 /*
757 * A WRITEX with CAP_LARGE_WRITEX can be 64k worth of data plus 65 bytes
758 * of header. Don't print the error if this fits.... JRA.
759 */
760
761 if (len > (BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE)) {
762 DEBUG(0,("Invalid packet length! (%lu bytes).\n",(unsigned long)len));
763 if (len > BUFFER_SIZE + (SAFETY_MARGIN/2)) {
764
765 /*
766 * Correct fix. smb_read_error may have already been
767 * set. Only set it here if not already set. Global
768 * variables still suck :-). JRA.
769 */
770
771 if (smb_read_error == 0)
772 smb_read_error = READ_ERROR;
773 return -1;
774 }
775 }
776
777 /*
778 * The +4 here can't wrap, we've checked the length above already.
779 */
780
781 *buffer = TALLOC_ARRAY(mem_ctx, char, len+4);
782
783 if (*buffer == NULL) {
784 DEBUG(0, ("Could not allocate inbuf of length %d\n",
785 (int)len+4));
786 if (smb_read_error == 0)
787 smb_read_error = READ_ERROR;
788 return -1;
789 }
790
791 memcpy(*buffer, lenbuf, sizeof(lenbuf));
792
793 if(len > 0) {
794 if (timeout > 0) {
795 ret = read_socket_with_timeout(fd,(*buffer)+4, len,
796 len, timeout);
797 } else {
798 ret = read_data(fd, (*buffer)+4, len);
799 }
800
801 if (ret != len) {
802 if (smb_read_error == 0) {
803 smb_read_error = READ_ERROR;
804 }
805 return -1;
806 }
807 }
808
809 return len + 4;
810 }
811
812 /****************************************************************************
813 Wrapper for receive_smb_raw().
814 Checks the MAC on signed packets.
815 ****************************************************************************/
816
817 BOOL receive_smb(int fd, char *buffer, unsigned int timeout)
818 {
819 if (receive_smb_raw(fd, buffer, timeout, 0) < 0) {
820 return False;
821 }
822
823 if (srv_encryption_on()) {
824 NTSTATUS status = srv_decrypt_buffer(buffer);
825 if (!NT_STATUS_IS_OK(status)) {
826 DEBUG(0, ("receive_smb: SMB decryption failed on incoming packet! Error %s\n",
827 nt_errstr(status) ));
828 if (smb_read_error == 0) {
829 smb_read_error = READ_BAD_DECRYPT;
830 }
831 return False;
832 }
833 }
834
835 /* Check the incoming SMB signature. */
836 if (!srv_check_sign_mac(buffer, True)) {
837 DEBUG(0, ("receive_smb: SMB Signature verification failed on incoming packet!\n"));
838 if (smb_read_error == 0) {
839 smb_read_error = READ_BAD_SIG;
840 }
841 return False;
842 }
843
844 return True;
845 }
846
847 ssize_t receive_smb_talloc(TALLOC_CTX *mem_ctx, int fd, char **buffer,
848 unsigned int timeout)
849 {
850 ssize_t len;
851
852 len = receive_smb_raw_talloc(mem_ctx, fd, buffer, timeout);
853
854 if (len < 0) {
855 return -1;
856 }
857
858 if (srv_encryption_on()) {
859 NTSTATUS status = srv_decrypt_buffer(*buffer);
860 if (!NT_STATUS_IS_OK(status)) {
861 DEBUG(0, ("receive_smb: SMB decryption failed on "
862 "incoming packet! Error %s\n",
863 nt_errstr(status) ));
864 if (smb_read_error == 0) {
865 smb_read_error = READ_BAD_DECRYPT;
866 }
867 return -1;
868 }
869 }
870
871 /* Check the incoming SMB signature. */
872 if (!srv_check_sign_mac(*buffer, True)) {
873 DEBUG(0, ("receive_smb: SMB Signature verification failed on "
874 "incoming packet!\n"));
875 if (smb_read_error == 0) {
876 smb_read_error = READ_BAD_SIG;
877 }
878 return -1;
879 }
880
881 return len;
882 }
883
884 /****************************************************************************
885 Send an smb to a fd.
886 ****************************************************************************/
887
888 BOOL send_smb(int fd, char *buffer)
889 {
890 size_t len;
891 size_t nwritten=0;
892 ssize_t ret;
893 char *buf_out = buffer;
894
895 /* Sign the outgoing packet if required. */
896 srv_calculate_sign_mac(buf_out);
897
898 if (srv_encryption_on()) {
899 NTSTATUS status = srv_encrypt_buffer(buffer, &buf_out);
900 if (!NT_STATUS_IS_OK(status)) {
901 DEBUG(0, ("send_smb: SMB encryption failed on outgoing packet! Error %s\n",
902 nt_errstr(status) ));
903 return False;
904 }
905 }
906
907 len = smb_len(buf_out) + 4;
908
909 while (nwritten < len) {
910 ret = write_data(fd,buf_out+nwritten,len - nwritten);
911 if (ret <= 0) {
912 DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
913 (int)len,(int)ret, strerror(errno) ));
914 srv_free_enc_buffer(buf_out);
915 return False;
916 }
917 nwritten += ret;
918 }
919
920 srv_free_enc_buffer(buf_out);
921 return True;
922 }
923
924 /****************************************************************************
925 Open a socket of the specified type, port, and address for incoming data.
926 ****************************************************************************/
927
928 int open_socket_in( int type, int port, int dlevel, uint32 socket_addr, BOOL rebind )
929 {
930 struct sockaddr_in sock;
931 int res;
932
933 memset( (char *)&sock, '\0', sizeof(sock) );
934
935 #ifdef HAVE_SOCK_SIN_LEN
936 sock.sin_len = sizeof(sock);
937 #endif
938 sock.sin_port = htons( port );
939 sock.sin_family = AF_INET;
940 sock.sin_addr.s_addr = socket_addr;
941
942 res = socket( AF_INET, type, 0 );
943 if( res == -1 ) {
944 if( DEBUGLVL(0) ) {
945 dbgtext( "open_socket_in(): socket() call failed: " );
946 dbgtext( "%s\n", strerror( errno ) );
947 }
948 return -1;
949 }
950
951 /* This block sets/clears the SO_REUSEADDR and possibly SO_REUSEPORT. */
952 {
953 int val = rebind ? 1 : 0;
954 if( setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&val,sizeof(val)) == -1 ) {
955 if( DEBUGLVL( dlevel ) ) {
956 dbgtext( "open_socket_in(): setsockopt: " );
957 dbgtext( "SO_REUSEADDR = %s ", val?"True":"False" );
958 dbgtext( "on port %d failed ", port );
959 dbgtext( "with error = %s\n", strerror(errno) );
960 }
961 }
962 #ifdef SO_REUSEPORT
963 if( setsockopt(res,SOL_SOCKET,SO_REUSEPORT,(char *)&val,sizeof(val)) == -1 ) {
964 if( DEBUGLVL( dlevel ) ) {
965 dbgtext( "open_socket_in(): setsockopt: ");
966 dbgtext( "SO_REUSEPORT = %s ", val?"True":"False" );
967 dbgtext( "on port %d failed ", port );
968 dbgtext( "with error = %s\n", strerror(errno) );
969 }
970 }
971 #endif /* SO_REUSEPORT */
972 }
973
974 /* now we've got a socket - we need to bind it */
975 if( bind( res, (struct sockaddr *)&sock, sizeof(sock) ) == -1 ) {
976 if( DEBUGLVL(dlevel) && (port == SMB_PORT1 || port == SMB_PORT2 || port == NMB_PORT) ) {
977 dbgtext( "bind failed on port %d ", port );
978 dbgtext( "socket_addr = %s.\n", inet_ntoa( sock.sin_addr ) );
979 dbgtext( "Error = %s\n", strerror(errno) );
980 }
981 close( res );
982 return( -1 );
983 }
984
985 DEBUG( 10, ( "bind succeeded on port %d\n", port ) );
986
987 return( res );
988 }
989
990 /****************************************************************************
991 Create an outgoing socket. timeout is in milliseconds.
992 **************************************************************************/
993
994 int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
995 {
996 struct sockaddr_in sock_out;
997 int res,ret;
998 int connect_loop = 10;
999 int increment = 10;
1000
1001 /* create a socket to write to */
1002 res = socket(PF_INET, type, 0);
1003 if (res == -1) {
1004 DEBUG(0,("socket error (%s)\n", strerror(errno)));
1005 return -1;
1006 }
1007
1008 if (type != SOCK_STREAM)
1009 return(res);
1010
1011 memset((char *)&sock_out,'\0',sizeof(sock_out));
1012 putip((char *)&sock_out.sin_addr,(char *)addr);
1013
1014 sock_out.sin_port = htons( port );
1015 sock_out.sin_family = PF_INET;
1016
1017 /* set it non-blocking */
1018 set_blocking(res,False);
1019
1020 DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
1021
1022 /* and connect it to the destination */
1023 connect_again:
1024
1025 ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
1026
1027 /* Some systems return EAGAIN when they mean EINPROGRESS */
1028 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
1029 errno == EAGAIN) && (connect_loop < timeout) ) {
1030 smb_msleep(connect_loop);
1031 timeout -= connect_loop;
1032 connect_loop += increment;
1033 if (increment < 250) {
1034 /* After 8 rounds we end up at a max of 255 msec */
1035 increment *= 1.5;
1036 }
1037 goto connect_again;
1038 }
1039
1040 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
1041 errno == EAGAIN)) {
1042 DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
1043 close(res);
1044 return -1;
1045 }
1046
1047 #ifdef EISCONN
1048
1049 if (ret < 0 && errno == EISCONN) {
1050 errno = 0;
1051 ret = 0;
1052 }
1053 #endif
1054
1055 if (ret < 0) {
1056 DEBUG(2,("error connecting to %s:%d (%s)\n",
1057 inet_ntoa(*addr),port,strerror(errno)));
1058 close(res);
1059 return -1;
1060 }
1061
1062 /* set it blocking again */
1063 set_blocking(res,True);
1064
1065 return res;
1066 }
1067
1068 /****************************************************************************
1069 Create an outgoing TCP socket to any of the addrs. This is for
1070 simultaneous connects to port 445 and 139 of a host or even a variety
1071 of DC's all of which are equivalent for our purposes.
1072 **************************************************************************/
1073
1074 BOOL open_any_socket_out(struct sockaddr_in *addrs, int num_addrs,
1075 int timeout, int *fd_index, int *fd)
1076 {
1077 int i, resulting_index, res;
1078 int *sockets;
1079 BOOL good_connect;
1080
1081 fd_set r_fds, wr_fds;
1082 struct timeval tv;
1083 int maxfd;
1084
1085 int connect_loop = 10000; /* 10 milliseconds */
1086
1087 timeout *= 1000; /* convert to microseconds */
1088
1089 sockets = SMB_MALLOC_ARRAY(int, num_addrs);
1090
1091 if (sockets == NULL)
1092 return False;
1093
1094 resulting_index = -1;
1095
1096 for (i=0; i<num_addrs; i++)
1097 sockets[i] = -1;
1098
1099 for (i=0; i<num_addrs; i++) {
1100 sockets[i] = socket(PF_INET, SOCK_STREAM, 0);
1101 if (sockets[i] < 0)
1102 goto done;
1103 set_blocking(sockets[i], False);
1104 }
1105
1106 connect_again:
1107 good_connect = False;
1108
1109 for (i=0; i<num_addrs; i++) {
1110
1111 if (sockets[i] == -1)
1112 continue;
1113
1114 if (connect(sockets[i], (struct sockaddr *)&(addrs[i]),
1115 sizeof(*addrs)) == 0) {
1116 /* Rather unlikely as we are non-blocking, but it
1117 * might actually happen. */
1118 resulting_index = i;
1119 goto done;
1120 }
1121
1122 if (errno == EINPROGRESS || errno == EALREADY ||
1123 #ifdef EISCONN
1124 errno == EISCONN ||
1125 #endif
1126 errno == EAGAIN || errno == EINTR) {
1127 /* These are the error messages that something is
1128 progressing. */
1129 good_connect = True;
1130 } else if (errno != 0) {
1131 /* There was a direct error */
1132 close(sockets[i]);
1133 sockets[i] = -1;
1134 }
1135 }
1136
1137 if (!good_connect) {
1138 /* All of the connect's resulted in real error conditions */
1139 goto done;
1140 }
1141
1142 /* Lets see if any of the connect attempts succeeded */
1143
1144 maxfd = 0;
1145 FD_ZERO(&wr_fds);
1146 FD_ZERO(&r_fds);
1147
1148 for (i=0; i<num_addrs; i++) {
1149 if (sockets[i] == -1)
1150 continue;
1151 FD_SET(sockets[i], &wr_fds);
1152 FD_SET(sockets[i], &r_fds);
1153 if (sockets[i]>maxfd)
1154 maxfd = sockets[i];
1155 }
1156
1157 tv.tv_sec = 0;
1158 tv.tv_usec = connect_loop;
1159
1160 res = sys_select_intr(maxfd+1, &r_fds, &wr_fds, NULL, &tv);
1161
1162 if (res < 0)
1163 goto done;
1164
1165 if (res == 0)
1166 goto next_round;
1167
1168 for (i=0; i<num_addrs; i++) {
1169
1170 if (sockets[i] == -1)
1171 continue;
1172
1173 /* Stevens, Network Programming says that if there's a
1174 * successful connect, the socket is only writable. Upon an
1175 * error, it's both readable and writable. */
1176
1177 if (FD_ISSET(sockets[i], &r_fds) &&
1178 FD_ISSET(sockets[i], &wr_fds)) {
1179 /* readable and writable, so it's an error */
1180 close(sockets[i]);
1181 sockets[i] = -1;
1182 continue;
1183 }
1184
1185 if (!FD_ISSET(sockets[i], &r_fds) &&
1186 FD_ISSET(sockets[i], &wr_fds)) {
1187 /* Only writable, so it's connected */
1188 resulting_index = i;
1189 goto done;
1190 }
1191 }
1192
1193 next_round:
1194
1195 timeout -= connect_loop;
1196 if (timeout <= 0)
1197 goto done;
1198 connect_loop *= 1.5;
1199 if (connect_loop > timeout)
1200 connect_loop = timeout;
1201 goto connect_again;
1202
1203 done:
1204 for (i=0; i<num_addrs; i++) {
1205 if (i == resulting_index)
1206 continue;
1207 if (sockets[i] >= 0)
1208 close(sockets[i]);
1209 }
1210
1211 if (resulting_index >= 0) {
1212 *fd_index = resulting_index;
1213 *fd = sockets[*fd_index];
1214 set_blocking(*fd, True);
1215 }
1216
1217 free(sockets);
1218
1219 return (resulting_index >= 0);
1220 }
1221 /****************************************************************************
1222 Open a connected UDP socket to host on port
1223 **************************************************************************/
1224
1225 int open_udp_socket(const char *host, int port)
1226 {
1227 int type = SOCK_DGRAM;
1228 struct sockaddr_in sock_out;
1229 int res;
1230 struct in_addr *addr;
1231
1232 addr = interpret_addr2(host);
1233
1234 res = socket(PF_INET, type, 0);
1235 if (res == -1) {
1236 return -1;
1237 }
1238
1239 memset((char *)&sock_out,'\0',sizeof(sock_out));
1240 putip((char *)&sock_out.sin_addr,(char *)addr);
1241 sock_out.sin_port = htons(port);
1242 sock_out.sin_family = PF_INET;
1243
1244 if (connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out))) {
1245 close(res);
1246 return -1;
1247 }
1248
1249 return res;
1250 }
1251
1252
1253 /*******************************************************************
1254 Matchname - determine if host name matches IP address. Used to
1255 confirm a hostname lookup to prevent spoof attacks.
1256 ******************************************************************/
1257
1258 static BOOL matchname(char *remotehost,struct in_addr addr)
1259 {
1260 struct hostent *hp;
1261 int i;
1262
1263 if ((hp = sys_gethostbyname(remotehost)) == 0) {
1264 DEBUG(0,("sys_gethostbyname(%s): lookup failure.\n", remotehost));
1265 return False;
1266 }
1267
1268 /*
1269 * Make sure that gethostbyname() returns the "correct" host name.
1270 * Unfortunately, gethostbyname("localhost") sometimes yields
1271 * "localhost.domain". Since the latter host name comes from the
1272 * local DNS, we just have to trust it (all bets are off if the local
1273 * DNS is perverted). We always check the address list, though.
1274 */
1275
1276 if (!strequal(remotehost, hp->h_name)
1277 && !strequal(remotehost, "localhost")) {
1278 DEBUG(0,("host name/name mismatch: %s != %s\n",
1279 remotehost, hp->h_name));
1280 return False;
1281 }
1282
1283 /* Look up the host address in the address list we just got. */
1284 for (i = 0; hp->h_addr_list[i]; i++) {
1285 if (memcmp(hp->h_addr_list[i], (char *) & addr, sizeof(addr)) == 0)
1286 return True;
1287 }
1288
1289 /*
1290 * The host name does not map to the original host address. Perhaps
1291 * someone has compromised a name server. More likely someone botched
1292 * it, but that could be dangerous, too.
1293 */
1294
1295 DEBUG(0,("host name/address mismatch: %s != %s\n",
1296 inet_ntoa(addr), hp->h_name));
1297 return False;
1298 }
1299
1300 /*******************************************************************
1301 Return the DNS name of the remote end of a socket.
1302 ******************************************************************/
1303
1304 char *get_peer_name(int fd, BOOL force_lookup)
1305 {
1306 static pstring name_buf;
1307 pstring tmp_name;
1308 static fstring addr_buf;
1309 struct hostent *hp;
1310 struct in_addr addr;
1311 char *p;
1312
1313 /* reverse lookups can be *very* expensive, and in many
1314 situations won't work because many networks don't link dhcp
1315 with dns. To avoid the delay we avoid the lookup if
1316 possible */
1317 if (!lp_hostname_lookups() && (force_lookup == False)) {
1318 return get_peer_addr(fd);
1319 }
1320
1321 p = get_peer_addr(fd);
1322
1323 /* it might be the same as the last one - save some DNS work */
1324 if (strcmp(p, addr_buf) == 0)
1325 return name_buf;
1326
1327 pstrcpy(name_buf,"UNKNOWN");
1328 if (fd == -1)
1329 return name_buf;
1330
1331 fstrcpy(addr_buf, p);
1332
1333 addr = *interpret_addr2(p);
1334
1335 /* Look up the remote host name. */
1336 if ((hp = gethostbyaddr((char *)&addr.s_addr, sizeof(addr.s_addr), AF_INET)) == 0) {
1337 DEBUG(1,("Gethostbyaddr failed for %s\n",p));
1338 pstrcpy(name_buf, p);
1339 } else {
1340 pstrcpy(name_buf,(char *)hp->h_name);
1341 if (!matchname(name_buf, addr)) {
1342 DEBUG(0,("Matchname failed on %s %s\n",name_buf,p));
1343 pstrcpy(name_buf,"UNKNOWN");
1344 }
1345 }
1346
1347 /* can't pass the same source and dest strings in when you
1348 use --enable-developer or the clobber_region() call will
1349 get you */
1350
1351 pstrcpy( tmp_name, name_buf );
1352 alpha_strcpy(name_buf, tmp_name, "_-.", sizeof(name_buf));
1353 if (strstr(name_buf,"..")) {
1354 pstrcpy(name_buf, "UNKNOWN");
1355 }
1356
1357 return name_buf;
1358 }
1359
1360 /*******************************************************************
1361 Return the IP addr of the remote end of a socket as a string.
1362 ******************************************************************/
1363
1364 char *get_peer_addr(int fd)
1365 {
1366 struct sockaddr sa;
1367 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
1368 socklen_t length = sizeof(sa);
1369 static fstring addr_buf;
1370
1371 fstrcpy(addr_buf,"0.0.0.0");
1372
1373 if (fd == -1) {
1374 return addr_buf;
1375 }
1376
1377 if (getpeername(fd, &sa, &length) < 0) {
1378 DEBUG(0,("getpeername failed. Error was %s\n", strerror(errno) ));
1379 return addr_buf;
1380 }
1381
1382 fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
1383
1384 return addr_buf;
1385 }
1386
1387 /*******************************************************************
1388 Create protected unix domain socket.
1389
1390 Some unixes cannot set permissions on a ux-dom-sock, so we
1391 have to make sure that the directory contains the protection
1392 permissions instead.
1393 ******************************************************************/
1394
1395 int create_pipe_sock(const char *socket_dir,
1396 const char *socket_name,
1397 mode_t dir_perms)
1398 {
1399 #ifdef HAVE_UNIXSOCKET
1400 struct sockaddr_un sunaddr;
1401 struct stat st;
1402 int sock;
1403 mode_t old_umask;
1404 pstring path;
1405
1406 old_umask = umask(0);
1407
1408 /* Create the socket directory or reuse the existing one */
1409
1410 if (lstat(socket_dir, &st) == -1) {
1411 if (errno == ENOENT) {
1412 /* Create directory */
1413 if (mkdir(socket_dir, dir_perms) == -1) {
1414 DEBUG(0, ("error creating socket directory "
1415 "%s: %s\n", socket_dir,
1416 strerror(errno)));
1417 goto out_umask;
1418 }
1419 } else {
1420 DEBUG(0, ("lstat failed on socket directory %s: %s\n",
1421 socket_dir, strerror(errno)));
1422 goto out_umask;
1423 }
1424 } else {
1425 /* Check ownership and permission on existing directory */
1426 if (!S_ISDIR(st.st_mode)) {
1427 DEBUG(0, ("socket directory %s isn't a directory\n",
1428 socket_dir));
1429 goto out_umask;
1430 }
1431 if ((st.st_uid != sec_initial_uid()) ||
1432 ((st.st_mode & 0777) != dir_perms)) {
1433 DEBUG(0, ("invalid permissions on socket directory "
1434 "%s\n", socket_dir));
1435 goto out_umask;
1436 }
1437 }
1438
1439 /* Create the socket file */
1440
1441 sock = socket(AF_UNIX, SOCK_STREAM, 0);
1442
1443 if (sock == -1) {
1444 perror("socket");
1445 goto out_umask;
1446 }
1447
1448 pstr_sprintf(path, "%s/%s", socket_dir, socket_name);
1449
1450 unlink(path);
1451 memset(&sunaddr, 0, sizeof(sunaddr));
1452 sunaddr.sun_family = AF_UNIX;
1453 safe_strcpy(sunaddr.sun_path, path, sizeof(sunaddr.sun_path)-1);
1454
1455 if (bind(sock, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1) {
1456 DEBUG(0, ("bind failed on pipe socket %s: %s\n", path,
1457 strerror(errno)));
1458 goto out_close;
1459 }
1460
1461 if (listen(sock, 5) == -1) {
1462 DEBUG(0, ("listen failed on pipe socket %s: %s\n", path,
1463 strerror(errno)));
1464 goto out_close;
1465 }
1466
1467 umask(old_umask);
1468 return sock;
1469
1470 out_close:
1471 close(sock);
1472
1473 out_umask:
1474 umask(old_umask);
1475 return -1;
1476
1477 #else
1478 DEBUG(0, ("create_pipe_sock: No Unix sockets on this system\n"));
1479 return -1;
1480 #endif /* HAVE_UNIXSOCKET */
1481 }
Samba GIT mirror