This source file includes following definitions.
- is_a_socket
- set_socket_options
- close_sockets
- write_socket
- read_udp_socket
- read_with_timeout
- send_keepalive
- read_data
- write_data
- read_smb_length_return_keepalive
- read_smb_length
- receive_smb
- client_receive_smb
- send_null_session_msg
- send_smb
- send_one_packet
- open_socket_in
- open_socket_out
- client_name
- client_addr
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 #include "includes.h"
28
29 const char *unix_error_string (int error_num);
30
31 #ifdef WITH_SSL
32 #include <ssl.h>
33 #undef Realloc
34 extern SSL *ssl;
35 extern int sslFd;
36 #endif
37
38 extern int DEBUGLEVEL;
39
40 BOOL passive = False;
41
42
43 int Client = -1;
44
45
46 struct in_addr lastip;
47
48
49 int lastport = 0;
50
51
52 int smb_read_error = 0;
53
54 #if 0
55
56
57
58 BOOL
59 is_a_socket (int fd)
60 {
61 int v;
62 unsigned int l;
63 l = sizeof (int);
64 return (getsockopt (fd, SOL_SOCKET, SO_TYPE, (char *) &v, &l) == 0);
65 }
66 #endif
67
68 enum SOCK_OPT_TYPES
69 { OPT_BOOL, OPT_INT, OPT_ON };
70
71 static const struct
72 {
73 const char *name;
74 int level;
75 int option;
76 int value;
77 int opttype;
78 } socket_options[] =
79 {
80 {
81 "SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
82 {
83 "SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
84 {
85 "SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
86 #ifdef TCP_NODELAY
87 {
88 "TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
89 #endif
90 #ifdef IPTOS_LOWDELAY
91 {
92 "IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
93 #endif
94 #ifdef IPTOS_THROUGHPUT
95 {
96 "IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
97 #endif
98 #ifdef SO_SNDBUF
99 {
100 "SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
101 #endif
102 #ifdef SO_RCVBUF
103 {
104 "SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
105 #endif
106 #ifdef SO_SNDLOWAT
107 {
108 "SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
109 #endif
110 #ifdef SO_RCVLOWAT
111 {
112 "SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
113 #endif
114 #ifdef SO_SNDTIMEO
115 {
116 "SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
117 #endif
118 #ifdef SO_RCVTIMEO
119 {
120 "SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
121 #endif
122 {
123 NULL, 0, 0, 0, 0}};
124
125
126
127
128
129
130 void
131 set_socket_options (int fd, char *options)
132 {
133 fstring tok;
134
135 while (next_token (&options, tok, " \t,", sizeof (tok)))
136 {
137 int ret = 0, i;
138 int value = 1;
139 char *p;
140 BOOL got_value = False;
141
142 if ((p = strchr (tok, '=')))
143 {
144 *p = 0;
145 value = atoi (p + 1);
146 got_value = True;
147 }
148
149 for (i = 0; socket_options[i].name; i++)
150 if (strequal (socket_options[i].name, tok))
151 break;
152
153 if (!socket_options[i].name)
154 {
155 DEBUG (0, ("Unknown socket option %s\n", tok));
156 continue;
157 }
158
159 switch (socket_options[i].opttype)
160 {
161 case OPT_BOOL:
162 case OPT_INT:
163 ret = setsockopt (fd, socket_options[i].level,
164 socket_options[i].option, (char *) &value, sizeof (int));
165 break;
166
167 case OPT_ON:
168 if (got_value)
169 DEBUG (0, ("syntax error - %s does not take a value\n", tok));
170
171 {
172 int on = socket_options[i].value;
173 ret = setsockopt (fd, socket_options[i].level,
174 socket_options[i].option, (char *) &on, sizeof (int));
175 }
176 break;
177 }
178
179 if (ret != 0)
180 DEBUG (0, ("Failed to set socket option %s\n", tok));
181 }
182 }
183
184
185
186
187
188
189 void
190 close_sockets (void)
191 {
192 #ifdef WITH_SSL
193 sslutil_disconnect (Client);
194 #endif
195
196 close (Client);
197 Client = -1;
198 }
199
200
201
202
203
204
205 ssize_t
206 write_socket (int fd, char *buf, size_t len)
207 {
208 ssize_t ret = 0;
209
210 if (passive)
211 return (len);
212 DEBUG (6, ("write_socket(%d,%d)\n", fd, (int) len));
213 ret = write_data (fd, buf, len);
214
215 DEBUG (6, ("write_socket(%d,%d) wrote %d\n", fd, (int) len, (int) ret));
216 if (ret <= 0)
217 DEBUG (1, ("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n",
218 (int) len, fd, unix_error_string (errno)));
219
220 return (ret);
221 }
222
223
224
225
226 ssize_t
227 read_udp_socket (int fd, char *buf, size_t len)
228 {
229 ssize_t ret;
230 struct sockaddr_in sock;
231 unsigned int socklen;
232
233 socklen = sizeof (sock);
234 memset ((char *) &sock, '\0', socklen);
235 memset ((char *) &lastip, '\0', sizeof (lastip));
236 ret = (ssize_t) recvfrom (fd, buf, len, 0, (struct sockaddr *) &sock, &socklen);
237 if (ret <= 0)
238 {
239 DEBUG (2, ("read socket failed. ERRNO=%s\n", unix_error_string (errno)));
240 return (0);
241 }
242
243 lastip = sock.sin_addr;
244 lastport = ntohs (sock.sin_port);
245
246 DEBUG (10, ("read_udp_socket: lastip %s lastport %d read: %d\n",
247 inet_ntoa (lastip), lastport, (int) ret));
248
249 return (ret);
250 }
251
252
253
254
255
256
257
258
259
260 ssize_t
261 read_with_timeout (int fd, char *buf, size_t mincnt, size_t maxcnt, unsigned int time_out)
262 {
263 fd_set fds;
264 int selrtn;
265 ssize_t readret;
266 size_t nread = 0;
267 struct timeval timeout;
268
269
270 if (maxcnt <= 0)
271 return (0);
272
273 smb_read_error = 0;
274
275
276 if (time_out <= 0)
277 {
278 if (mincnt == 0)
279 mincnt = maxcnt;
280
281 while (nread < mincnt)
282 {
283 #ifdef WITH_SSL
284 if (fd == sslFd)
285 {
286 readret = SSL_read (ssl, buf + nread, maxcnt - nread);
287 }
288 else
289 {
290 readret = read (fd, buf + nread, maxcnt - nread);
291 }
292 #else
293 readret = read (fd, buf + nread, maxcnt - nread);
294 #endif
295
296 if (readret == 0)
297 {
298 DEBUG (5, ("read_with_timeout: blocking read. EOF from client.\n"));
299 smb_read_error = READ_EOF;
300 return -1;
301 }
302
303 if (readret == -1)
304 {
305 DEBUG (0, ("read_with_timeout: read error = %s.\n", unix_error_string (errno)));
306 smb_read_error = READ_ERROR;
307 return -1;
308 }
309 nread += readret;
310 }
311 return ((ssize_t) nread);
312 }
313
314
315
316
317
318
319
320
321 timeout.tv_sec = (time_t) (time_out / 1000);
322 timeout.tv_usec = (long) (1000 * (time_out % 1000));
323
324 for (nread = 0; nread < mincnt;)
325 {
326 FD_ZERO (&fds);
327 FD_SET (fd, &fds);
328
329 selrtn = sys_select (fd + 1, &fds, &timeout);
330
331
332 if (selrtn == -1)
333 {
334
335 DEBUG (0,
336 ("read_with_timeout: timeout read. select error = %s.\n",
337 unix_error_string (errno)));
338 smb_read_error = READ_ERROR;
339 return -1;
340 }
341
342
343 if (selrtn == 0)
344 {
345 DEBUG (10, ("read_with_timeout: timeout read. select timed out.\n"));
346 smb_read_error = READ_TIMEOUT;
347 return -1;
348 }
349
350 #ifdef WITH_SSL
351 if (fd == sslFd)
352 {
353 readret = SSL_read (ssl, buf + nread, maxcnt - nread);
354 }
355 else
356 {
357 readret = read (fd, buf + nread, maxcnt - nread);
358 }
359 #else
360 readret = read (fd, buf + nread, maxcnt - nread);
361 #endif
362
363 if (readret == 0)
364 {
365
366 DEBUG (5, ("read_with_timeout: timeout read. EOF from client.\n"));
367 smb_read_error = READ_EOF;
368 return -1;
369 }
370
371 if (readret == -1)
372 {
373
374 DEBUG (0,
375 ("read_with_timeout: timeout read. read error = %s.\n",
376 unix_error_string (errno)));
377 smb_read_error = READ_ERROR;
378 return -1;
379 }
380
381 nread += readret;
382 }
383
384
385 return ((ssize_t) nread);
386 }
387
388 #if 0
389
390
391
392 BOOL
393 send_keepalive (int client)
394 {
395 unsigned char buf[4];
396
397 buf[0] = 0x85;
398 buf[1] = buf[2] = buf[3] = 0;
399
400 return (write_data (client, (char *) buf, 4) == 4);
401 }
402 #endif
403
404
405
406
407
408 ssize_t
409 read_data (int fd, char *buffer, size_t N)
410 {
411 ssize_t ret;
412 size_t total = 0;
413
414 smb_read_error = 0;
415
416 while (total < N)
417 {
418 #ifdef WITH_SSL
419 if (fd == sslFd)
420 {
421 ret = SSL_read (ssl, buffer + total, N - total);
422 }
423 else
424 {
425 ret = read (fd, buffer + total, N - total);
426 }
427 #else
428 ret = read (fd, buffer + total, N - total);
429 #endif
430
431 if (ret == 0)
432 {
433 DEBUG (10,
434 ("read_data: read of %d returned 0. Error = %s\n", (int) (N - total),
435 unix_error_string (errno)));
436 smb_read_error = READ_EOF;
437 return 0;
438 }
439 if (ret == -1)
440 {
441 DEBUG (0,
442 ("read_data: read failure for %d. Error = %s\n", (int) (N - total),
443 unix_error_string (errno)));
444 smb_read_error = READ_ERROR;
445 return -1;
446 }
447 total += ret;
448 }
449 return (ssize_t) total;
450 }
451
452
453
454
455
456 ssize_t
457 write_data (int fd, char *buffer, size_t N)
458 {
459 size_t total = 0;
460 ssize_t ret;
461
462 while (total < N)
463 {
464 #ifdef WITH_SSL
465 if (fd == sslFd)
466 {
467 ret = SSL_write (ssl, buffer + total, N - total);
468 }
469 else
470 {
471 ret = write (fd, buffer + total, N - total);
472 }
473 #else
474 ret = write (fd, buffer + total, N - total);
475 #endif
476
477 if (ret == -1)
478 {
479 DEBUG (1, ("write_data: write failure. Error = %s\n", unix_error_string (errno)));
480 return -1;
481 }
482 if (ret == 0)
483 return total;
484
485 total += ret;
486 }
487 return (ssize_t) total;
488 }
489
490
491
492
493
494
495
496
497
498
499 static ssize_t
500 read_smb_length_return_keepalive (int fd, char *inbuf, unsigned int timeout)
501 {
502 ssize_t len = 0;
503 int msg_type;
504 BOOL ok = False;
505
506 while (!ok)
507 {
508 if (timeout > 0)
509 ok = (read_with_timeout (fd, inbuf, 4, 4, timeout) == 4);
510 else
511 ok = (read_data (fd, inbuf, 4) == 4);
512
513 if (!ok)
514 return (-1);
515
516 len = smb_len (inbuf);
517 msg_type = CVAL (inbuf, 0);
518
519 if (msg_type == 0x85)
520 DEBUG (5, ("Got keepalive packet\n"));
521 }
522
523 DEBUG (10, ("got smb length of %d\n", (int) len));
524
525 return (len);
526 }
527
528 #if 0
529
530
531
532
533
534
535 ssize_t
536 read_smb_length (int fd, char *inbuf, unsigned int timeout)
537 {
538 ssize_t len;
539
540 for (;;)
541 {
542 len = read_smb_length_return_keepalive (fd, inbuf, timeout);
543
544 if (len < 0)
545 return len;
546
547
548 if (CVAL (inbuf, 0) != 0x85)
549 break;
550 }
551
552 DEBUG (10, ("read_smb_length: got smb length of %d\n", len));
553
554 return len;
555 }
556 #endif
557
558
559
560
561
562
563
564 BOOL
565 receive_smb (int fd, char *buffer, unsigned int timeout)
566 {
567 ssize_t len, ret;
568
569 smb_read_error = 0;
570
571 memset (buffer, '\0', smb_size + 100);
572
573 len = read_smb_length_return_keepalive (fd, buffer, timeout);
574 if (len < 0)
575 {
576 DEBUG (10, ("receive_smb: length < 0!\n"));
577 return (False);
578 }
579
580 if (len > BUFFER_SIZE)
581 {
582 DEBUG (0, ("Invalid packet length! (%d bytes).\n", (int) len));
583 if (len > BUFFER_SIZE + (SAFETY_MARGIN / 2))
584 {
585 exit (1);
586 }
587 }
588
589 if (len > 0)
590 {
591 ret = read_data (fd, buffer + 4, len);
592 if (ret != len)
593 {
594 smb_read_error = READ_ERROR;
595 return False;
596 }
597 }
598 return (True);
599 }
600
601
602
603
604
605
606
607
608
609
610
611
612 BOOL
613 client_receive_smb (int fd, char *buffer, unsigned int timeout)
614 {
615 BOOL ret;
616
617 for (;;)
618 {
619 ret = receive_smb (fd, buffer, timeout);
620
621 if (!ret)
622 {
623 DEBUG (10, ("client_receive_smb failed\n"));
624 show_msg (buffer);
625 return ret;
626 }
627
628
629 if (CVAL (buffer, 0) != 0x85)
630 break;
631 }
632 show_msg (buffer);
633 return ret;
634 }
635
636
637
638
639 #if 0
640 BOOL
641 send_null_session_msg (int fd)
642 {
643 ssize_t ret;
644 uint32 blank = 0;
645 size_t len = 4;
646 size_t nwritten = 0;
647 char *buffer = (char *) ␣
648
649 while (nwritten < len)
650 {
651 ret = write_socket (fd, buffer + nwritten, len - nwritten);
652 if (ret <= 0)
653 {
654 DEBUG (0,
655 ("send_null_session_msg: Error writing %d bytes to client. %d. Exiting\n",
656 (int) len, (int) ret));
657 close_sockets ();
658 exit (1);
659 }
660 nwritten += ret;
661 }
662
663 DEBUG (10, ("send_null_session_msg: sent 4 null bytes to client.\n"));
664 return True;
665 }
666
667
668
669
670 BOOL
671 send_smb (int fd, char *buffer)
672 {
673 size_t len;
674 size_t nwritten = 0;
675 ssize_t ret;
676 len = smb_len (buffer) + 4;
677
678 while (nwritten < len)
679 {
680 ret = write_socket (fd, buffer + nwritten, len - nwritten);
681 if (ret <= 0)
682 {
683 DEBUG (0, ("Error writing %d bytes to client. %d. Exiting\n", (int) len, (int) ret));
684 close_sockets ();
685 exit (1);
686 }
687 nwritten += ret;
688 }
689
690 return True;
691 }
692
693
694
695
696
697
698 BOOL
699 send_one_packet (char *buf, int len, struct in_addr ip, int port, int type)
700 {
701 BOOL ret;
702 int out_fd;
703 struct sockaddr_in sock_out;
704
705 if (passive)
706 return (True);
707
708
709 out_fd = socket (AF_INET, type, 0);
710 if (out_fd == -1)
711 {
712 DEBUG (0, ("socket failed"));
713 return False;
714 }
715
716
717 memset ((char *) &sock_out, '\0', sizeof (sock_out));
718 putip ((char *) &sock_out.sin_addr, (char *) &ip);
719 sock_out.sin_port = htons (port);
720 sock_out.sin_family = AF_INET;
721
722 if (DEBUGLEVEL > 0)
723 DEBUG (3, ("sending a packet of len %d to (%s) on port %d of type %s\n",
724 len, inet_ntoa (ip), port, type == SOCK_DGRAM ? "DGRAM" : "STREAM"));
725
726
727 ret = (sendto (out_fd, buf, len, 0, (struct sockaddr *) &sock_out, sizeof (sock_out)) >= 0);
728
729 if (!ret)
730 DEBUG (0, ("Packet send to %s(%d) failed ERRNO=%s\n",
731 inet_ntoa (ip), port, unix_error_string (errno)));
732
733 close (out_fd);
734 return (ret);
735 }
736 #endif
737
738
739
740
741 int
742 open_socket_in (int type, int port, int dlevel, uint32 socket_addr, BOOL rebind)
743 {
744 struct hostent *hp;
745 struct sockaddr_in sock;
746 pstring host_name;
747 int res;
748
749
750 if (gethostname (host_name, MAXHOSTNAMELEN) == -1)
751 {
752 DEBUG (0, ("gethostname failed\n"));
753 return -1;
754 }
755
756
757 if ((hp = Get_Hostbyname (host_name)) == 0)
758 {
759 DEBUG (0, ("Get_Hostbyname: Unknown host %s\n", host_name));
760 return -1;
761 }
762
763 memset ((char *) &sock, '\0', sizeof (sock));
764 memcpy ((char *) &sock.sin_addr, (char *) hp->h_addr, hp->h_length);
765
766 #ifdef HAVE_SOCK_SIN_LEN
767 sock.sin_len = sizeof (sock);
768 #endif
769 sock.sin_port = htons (port);
770 sock.sin_family = hp->h_addrtype;
771 sock.sin_addr.s_addr = socket_addr;
772 res = socket (hp->h_addrtype, type, 0);
773 if (res == -1)
774 {
775 DEBUG (0, ("socket failed\n"));
776 return -1;
777 }
778
779 {
780 int val = 1;
781 if (rebind)
782 val = 1;
783 else
784 val = 0;
785 setsockopt (res, SOL_SOCKET, SO_REUSEADDR, (char *) &val, sizeof (val));
786 }
787
788
789 if (bind (res, (struct sockaddr *) &sock, sizeof (sock)) < 0)
790 {
791 if (port)
792 {
793 if (port == SMB_PORT || port == NMB_PORT)
794 DEBUG (dlevel, ("bind failed on port %d socket_addr=%s (%s)\n",
795 port, inet_ntoa (sock.sin_addr), unix_error_string (errno)));
796 close (res);
797
798 if (dlevel > 0 && port < 1000)
799 port = 7999;
800
801 if (port >= 1000 && port < 9000)
802 return (open_socket_in (type, port + 1, dlevel, socket_addr, rebind));
803 }
804
805 return (-1);
806 }
807 DEBUG (3, ("bind succeeded on port %d\n", port));
808
809 return res;
810 }
811
812
813
814
815
816 int
817 open_socket_out (int type, struct in_addr *addr, int port, int timeout)
818 {
819 struct sockaddr_in sock_out;
820 int res, ret;
821 int connect_loop = 250;
822 int loops = (timeout) / connect_loop;
823
824
825 res = socket (PF_INET, type, 0);
826 if (res == -1)
827 {
828 DEBUG (0, ("socket error\n"));
829 return -1;
830 }
831
832 if (type != SOCK_STREAM)
833 return (res);
834
835 memset ((char *) &sock_out, '\0', sizeof (sock_out));
836 putip ((char *) &sock_out.sin_addr, (char *) addr);
837
838 sock_out.sin_port = htons (port);
839 sock_out.sin_family = PF_INET;
840
841
842 set_blocking (res, False);
843
844 DEBUG (3, ("Connecting to %s at port %d\n", inet_ntoa (*addr), port));
845
846
847 connect_again:
848 ret = connect (res, (struct sockaddr *) &sock_out, sizeof (sock_out));
849
850
851 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY || errno == EAGAIN) && loops--)
852 {
853 msleep (connect_loop);
854 goto connect_again;
855 }
856
857 if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY || errno == EAGAIN))
858 {
859 DEBUG (1, ("timeout connecting to %s:%d\n", inet_ntoa (*addr), port));
860 close (res);
861 return -1;
862 }
863
864 #ifdef EISCONN
865 if (ret < 0 && errno == EISCONN)
866 {
867 errno = 0;
868 ret = 0;
869 }
870 #endif
871
872 if (ret < 0)
873 {
874 DEBUG (1, ("error connecting to %s:%d (%s)\n",
875 inet_ntoa (*addr), port, unix_error_string (errno)));
876 close (res);
877 return -1;
878 }
879
880
881 set_blocking (res, True);
882
883 return res;
884 }
885
886
887
888
889
890
891
892
893 static BOOL global_client_name_done = False;
894 static BOOL global_client_addr_done = False;
895
896
897
898
899 char *
900 client_name (int fd)
901 {
902 struct sockaddr sa;
903 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
904 unsigned int length = sizeof (sa);
905 static pstring name_buf;
906 struct hostent *hp;
907 static int last_fd = -1;
908
909 if (global_client_name_done && last_fd == fd)
910 return name_buf;
911
912 last_fd = fd;
913 global_client_name_done = False;
914
915 pstrcpy (name_buf, "UNKNOWN");
916
917 if (fd == -1)
918 {
919 return name_buf;
920 }
921
922 if (getpeername (fd, &sa, &length) < 0)
923 {
924 DEBUG (0, ("getpeername failed. Error was %s\n", unix_error_string (errno)));
925 return name_buf;
926 }
927
928
929 if ((hp = gethostbyaddr ((char *) &sockin->sin_addr, sizeof (sockin->sin_addr), AF_INET)) == 0)
930 {
931 DEBUG (1, ("Gethostbyaddr failed for %s\n", client_addr (fd)));
932 StrnCpy (name_buf, client_addr (fd), sizeof (name_buf) - 1);
933 }
934 else
935 {
936 StrnCpy (name_buf, (char *) hp->h_name, sizeof (name_buf) - 1);
937 if (!matchname (name_buf, sockin->sin_addr))
938 {
939 DEBUG (0, ("Matchname failed on %s %s\n", name_buf, client_addr (fd)));
940 pstrcpy (name_buf, "UNKNOWN");
941 }
942 }
943 global_client_name_done = True;
944 return name_buf;
945 }
946
947
948
949
950 char *
951 client_addr (int fd)
952 {
953 struct sockaddr sa;
954 struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
955 unsigned int length = sizeof (sa);
956 static fstring addr_buf;
957 static int last_fd = -1;
958
959 if (global_client_addr_done && fd == last_fd)
960 return addr_buf;
961
962 last_fd = fd;
963 global_client_addr_done = False;
964
965 fstrcpy (addr_buf, "0.0.0.0");
966
967 if (fd == -1)
968 {
969 return addr_buf;
970 }
971
972 if (getpeername (fd, &sa, &length) < 0)
973 {
974 DEBUG (0, ("getpeername failed. Error was %s\n", unix_error_string (errno)));
975 return addr_buf;
976 }
977
978 fstrcpy (addr_buf, (char *) inet_ntoa (sockin->sin_addr));
979
980 global_client_addr_done = True;
981 return addr_buf;
982 }