1 /* ftpd.c: BetaFTPD main
2 Copyright (C) 1999-2000 Steinar H. Gunderson
4 This program is is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License, version 2 of the
6 License as published by the Free Software Foundation.
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
13 You should have received a copy of the GNU General Public License
14 along with this program; if not, write to the Free Software
15 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19 * Special note: this file has been overwritten by another (0-byte) file, been
20 * through the dead, and restored (with the help of dd, grep, gpm, vi and less)
21 * with a sucess rate of 99.9%. Show it a little respect -- don't add junk
40 #include <sys/types.h>
79 #if HAVE_NETINET_IN_SYSTM_H
80 #include <netinet/in_systm.h>
84 #include <netinet/in.h>
88 #include <netinet/ip.h>
91 #if HAVE_NETINET_TCP_H
92 #include <netinet/tcp.h>
96 #include <arpa/inet.h>
100 #include <sys/stat.h>
104 #include <sys/ioctl.h>
107 #if HAVE_LINUX_SOCKET_H
108 #include <linux/socket.h>
112 #include <linux/tcp.h>
116 #include <sys/mman.h>
124 #include <sys/time.h>
128 #include <sys/time.h>
132 #include <sys/filio.h>
147 #if HAVE_SYS_SIGNAL_H
148 #include <sys/signal.h>
152 #include <sys/poll.h>
155 #if HAVE_SYS_SENDFILE_H
156 #include <sys/sendfile.h>
160 * <linux/socket.h> does not export this to glibc2 systems, and it isn't
161 * always defined anywhere else.
163 #if !defined(TCP_CORK) && defined(__linux__)
179 #define MAP_FAILED -1
182 struct conn *first_conn = NULL;
183 struct ftran *first_ftran = NULL;
185 struct dcache *first_dcache = NULL;
187 char message_buf[512];
190 unsigned int highest_fds = 0;
194 struct pollfd fds[FD_MAX];
196 #define MAXCLIENTS FD_MAX
198 fd_set master_fds, master_send_fds;
199 #define MAXCLIENTS FD_SETSIZE
203 FILE *xferlog = NULL;
206 #if HAVE_LINUX_SENDFILE || HAVE_BSD_SENDFILE
207 int sendfile_supported = 1;
211 * This variable specifies if it's soon time to check for timed out
212 * clients, and timed out directory listing cache entries. It is
213 * set to 1 by a signal handler every minute, and set to 0 when the
214 * checking has been performed.
216 int time_to_check = 1;
220 * snprintf(): snprintf() replacement for systems that miss it. Note
221 * that this implementation does _not_ necessarily protect
222 * against all buffer overflows. Get a real snprintf() in
223 * your C library. That being said, the 8k limit is
224 * substantially larger than any other string in BetaFTPD,
225 * which should make such an attack harder.
227 int snprintf(char *str, size_t n, const char *format, ...)
233 va_start(args, format);
234 err = vsprintf(buf, format, args);
244 #ifndef HAVE_VSNPRINTF
246 * vsnprintf: vsnprintf() replacement for systems that miss it. Please
247 * see snprintf (above) for more information.
249 int vsnprintf(char *str, size_t n, const char *format, va_list ap)
254 err = vsprintf(buf, format, ap);
262 * add_fd(): Add an fd to the set we monitor. Return 0 on success.
263 * This code is shared between poll() and select() versions.
265 int add_fd(const int fd, const int events)
269 printf("add_fd(%d, %x): failed\n", fd, events);
274 fds[fd].events = events;
275 if (highest_fds < fd)
278 if (fd >= FD_SETSIZE)
281 FD_SET(fd, &master_fds);
282 if (events & POLLOUT)
283 FD_SET(fd, &master_send_fds);
289 * del_fd(): Close and remove an fd from the set(s) we monitor. (See also add_fd().)
291 void del_fd(const int fd)
300 /* Reduce poll()'s workload by not making it watch past end of array */
301 while ((highest_fds > 0) && (fds[highest_fds].fd == -1))
304 if (fd >= FD_SETSIZE)
306 FD_CLR(fd, &master_fds);
307 FD_CLR(fd, &master_send_fds);
316 struct conn *c = first_conn;
317 printf("list_clients:\n");
318 while (c && c->next_conn) {
320 printf("list_clients: fd %d\n", c->sock);
326 * add_to_linked_list():
327 * Inserts an element (conn, ftran or dcache) into its linked list.
328 * The list is placed at the beginning, right after the (bogus)
329 * first element of the list.
331 void add_to_linked_list(struct list_element * const first,
332 struct list_element * const elem)
337 elem->next = first->next;
338 if (elem->next) elem->next->prev = elem;
341 /* this is the bogus head of the list */
347 * remove_from_linked_list():
348 * Removes an element (conn, ftran or dcache) from its linked list,
351 void remove_from_linked_list(struct list_element * const elem)
353 if (elem->prev != NULL) elem->prev->next = elem->next;
354 if (elem->next != NULL) elem->next->prev = elem->prev;
360 * Allocates a new control connection (type `struct conn'),
361 * initializes it, and adds it to the linked list. The connection
362 * operates on the socket SOCK.
364 struct conn *alloc_new_conn(const int sock)
366 const unsigned int one = 1;
367 struct conn *c = (struct conn *)(malloc(sizeof(struct conn)));
369 if (c == NULL) return NULL;
372 ioctl(sock, FIONBIO, &one);
373 if (add_fd(sock, POLLIN) != 0) {
375 send(sock, "230 Server too busy, please try again later.\r\n", 46, 0);
380 add_to_linked_list((struct list_element *)first_conn,
381 (struct list_element *)c);
383 /* this is the bogus head of the list */
390 c->buf_len = c->auth = c->rest_pos = 0;
398 * strcpy(c->curr_dir, "/");
399 * strcpy(c->last_cmd, "");
400 * strcpy(c->rename_from, "")
402 c->curr_dir[0] = '/';
404 c->curr_dir[1] = c->last_cmd[0] = c->rename_from[0] = '\0';
406 c->curr_dir[1] = c->rename_from[0] = '\0';
409 time(&(c->last_transfer));
411 /* list_clients(); */
418 * Allocates a new data connection (type `struct ftran'), and
419 * adds it to the linked list. The connection operates on the
420 * socket SOCK, and has the control connection C as its parent.
422 struct ftran *alloc_new_ftran(const int sock, const struct conn * const c)
424 struct ftran *f = (struct ftran *)(malloc(sizeof(struct ftran)));
426 if (f == NULL) return f;
428 /* this is the bogus head of the list */
429 f->next_ftran = NULL;
430 f->prev_ftran = NULL;
432 add_to_linked_list((struct list_element *)first_ftran,
433 (struct list_element *)f);
439 f->owner = (struct conn * const)c;
455 * Destroy a control connection, remove it from the linked
456 * list, and clean up after it.
458 void destroy_conn(struct conn * const c)
460 if (c == NULL) return;
463 destroy_ftran(c->transfer);
464 remove_from_linked_list((struct list_element *)c);
469 * Destroy a data connection, remove it from the linked list,
470 * and clean up after it.
472 * For some reason, TCP_CORK (Linux 2.2.x-only) doesn't flush
473 * even _after_ the socket is closed, so we zero it just before
474 * closing. We also zero just before sending the last packet,
475 * as it seems to be needed on some systems.
477 * If you wonder why I check for `defined(SOL_TCP)' and don't
478 * provide an alternative, see the comments on init_file_transfer().
480 void destroy_ftran(struct ftran * const f)
482 const unsigned int zero = 0;
484 if (f == NULL) return;
485 #if defined(TCP_CORK) && defined(SOL_TCP)
486 setsockopt(f->sock, SOL_TCP, TCP_CORK, (void *)&zero, sizeof(zero));
492 time(&(f->dir_cache->last_used));
493 f->dir_cache->use_count--;
499 if (f->dir_listing) {
503 munmap(f->file_data, f->size);
509 if (f->local_file != -1) close(f->local_file);
512 if (f->dir_listing) unlink(f->filename);
515 f->owner->transfer = NULL;
518 if (f->dir_cache != NULL) f->dir_cache->use_count--;
521 remove_from_linked_list((struct list_element *)f);
525 * process_all_clients():
526 * Processes all the _control_ connections in active_clients
527 * (normally returned from a select(), there are at max
528 * NUM_AC active connections in the set), sending them
529 * through to the command parser if a command has been
533 int process_all_clients(const int num_ac)
535 int process_all_clients(const fd_set * const active_clients, const int num_ac)
538 struct conn *c = NULL, *next = first_conn->next_conn;
539 int checked_through = 0;
541 /* run through the linked list */
542 while (next != NULL && checked_through < num_ac) {
548 if ((fds[c->sock].revents & (POLLIN|POLLERR|POLLHUP|POLLNVAL)) == 0) {
552 if (!FD_ISSET(c->sock, active_clients)) {
559 bytes_avail = recv(c->sock, c->recv_buf + c->buf_len,
560 255 - c->buf_len, 0);
561 if (bytes_avail <= 0) {
563 * select() has already told us there's something about
564 * this socket, so if we get a return value of zero, the
565 * client has closed the socket. If we get a return value
566 * of -1 (error), we close the socket ourselves.
568 * We do the same for poll(), even though we actually have
569 * bits that tell us what is happening (in case of new
570 * input AND error/hangup at the same time, we do an
571 * explicit check at the bottom of the loop as well).
577 /* overrun = disconnect */
578 if (c->buf_len + bytes_avail > 254) {
579 numeric(c, 503, "Buffer overrun; disconnecting.");
584 c->buf_len += bytes_avail;
587 if (c->free_me || (fds[c->sock].revents & (POLLERR|POLLHUP|POLLNVAL))) {
591 return checked_through;
596 * Send a message that the transfer is completed, write xferlog
597 * entry (optional), and update the last_transfer record in the
598 * file transfer object. Goes for both uploads and downloads.
600 void finish_transfer(struct ftran * const f)
602 char finished[] = "226 Transfer complete.\r\n";
603 if (send(f->owner->sock, finished, strlen(finished), 0) == -1 && errno == EPIPE) {
604 destroy_conn(f->owner);
608 time(&(f->owner->last_transfer));
611 if (!f->dir_listing) {
618 update_display(first_conn);
623 * process_all_sendfiles():
624 * Sends data to all clients that are ready to receive it.
625 * Also checks for data connections that are newly-connected,
626 * and handler xferlog entries for the files that are finished.
629 int process_all_sendfiles(const int num_ac)
631 int process_all_sendfiles(fd_set * const active_clients, const int num_ac)
634 struct ftran *f = NULL, *next = first_ftran->next_ftran;
635 int checked_through = 0;
636 int tempaddr_len = sizeof(struct sockaddr_in);
638 while (next != NULL && checked_through < num_ac) {
640 next = f->next_ftran;
643 if ((f->upload == 1) && (fds[f->sock].revents & POLLHUP)) {
650 if (fds[f->sock].revents & (POLLERR|POLLNVAL|POLLHUP)) {
656 /* state = 2: incoming PASV, state >3: send file */
658 if ((f->state < 2) || (f->state == 3) || (fds[f->sock].revents & (POLLIN|POLLOUT)) == 0) {
660 if ((f->state < 2) || (f->state == 3) || !FD_ISSET(f->sock, active_clients)) {
668 /* Nothing is needed for the poll() version? */
670 FD_CLR(f->sock, active_clients);
673 if (f->state == 2) { /* incoming PASV */
674 const unsigned int one = 1;
675 const int tempsock = accept(f->sock, &(f->sin), &tempaddr_len);
679 if (tempsock == -1) {
685 ioctl(f->sock, FIONBIO, &one);
686 init_file_transfer(f);
688 flush_numeric(f->owner);
689 if (f->owner->free_me) {
690 destroy_conn(f->owner);
695 if (f->upload) continue;
699 init_file_transfer(f);
701 flush_numeric(f->owner);
702 if (f->owner->free_me) {
703 destroy_conn(f->owner);
707 if (f->upload) continue;
711 /* for download, we send the first packets right away */
714 if (do_upload(f)) continue;
717 if (do_download(f)) continue;
719 /* do_{upload,download} returned 0, the transfer is complete */
722 update_display(first_conn);
726 return checked_through;
730 int do_upload(struct ftran *f)
732 char upload_buf[16384];
735 /* keep buffer size small in ascii transfers
736 to prevent process stalling while filtering
737 data on slower computers */
740 * This isn't a big problem, since we won't get
741 * packets this big anyway, the biggest I've seen
742 * was 12kB on 100mbit (but that was from a Windows
743 * machine), so I've reduced the buffer from 64 kB
744 * to 16 kB :-) --Steinar
746 const int maxlen = (f->ascii_mode == 1) ? 4096 : 16384;
748 const int maxlen = 16384;
752 size = recv(f->sock, upload_buf, maxlen, 0);
757 if (size > 0 && f->ascii_mode == 1) {
758 size = ascii_uploadfilter(upload_buf, size);
761 if (size > 0 && (write(f->local_file, upload_buf, size) == size)) {
763 } else if (size == -1 && errno != EAGAIN) {
764 /* don't write xferlog... or? */
765 numeric(f->owner, 426, strerror(errno));
773 int do_download(struct ftran *f)
775 #if defined(TCP_CORK) && defined(SOL_TCP)
776 unsigned int zero = 0;
780 int more_to_send = 0;
783 char buf[MAX_BLOCK_SIZE];
786 char buf2[MAX_BLOCK_SIZE * 2];
790 #if HAVE_LINUX_SENDFILE || HAVE_BSD_SENDFILE
792 * We handle the optimal case first, which is sendfile().
793 * Here we use a rather simplified sending `algorithm',
794 * leaving most of the quirks to the system calls.
796 if (sendfile_supported == 1 && f->dir_listing == 0) {
798 size = f->size - f->pos;
800 if (size > f->block_size) size = f->block_size;
801 if (size < 0) size = 0;
804 if (size != f->block_size) {
805 setsockopt(f->sock, SOL_TCP, TCP_CORK, (void *)&zero, sizeof(zero));
809 err = mysendfile(f->sock, f->local_file, &f->pos, size);
810 return (f->pos < f->size) && (err > -1);
815 size = f->size - f->pos;
817 if (size > f->block_size) size = f->block_size;
818 if (size < 0) size = 0;
820 bytes_to_send = size;
821 sendfrom_buf = f->file_data + f->pos;
823 bytes_to_send = read(f->local_file, buf, f->block_size);
827 if (bytes_to_send == f->block_size) more_to_send = 1;
830 if (f->ascii_mode == 1) {
831 bytes_to_send = ascii_downloadfilter(sendfrom_buf,
832 buf2, bytes_to_send);
835 #endif /* WANT_ASCII */
837 #if defined(TCP_CORK) && defined(SOL_TCP)
838 /* if we believe this is the last packet, unset TCP_CORK */
839 if (more_to_send == 0) {
840 setsockopt(f->sock, SOL_TCP, TCP_CORK, (void *)&zero, sizeof(zero));
844 size = send(f->sock, sendfrom_buf, bytes_to_send, 0);
845 if (size < bytes_to_send) more_to_send = 1;
848 if (f->ascii_mode == 1 && size < bytes_to_send && size > 0) {
849 size = ascii_findlength(sendfrom_buf, size);
854 if (size > 0) f->pos += size;
861 void write_xferlog(struct ftran *f)
864 time_t now = time(NULL);
865 struct tm *t = localtime(&now);
867 if (xferlog == NULL) return;
869 strftime(temp, 256, "%a %b %d %H:%M:%S %Y", t);
871 fprintf(xferlog, "%s %u %s %lu %s b _ %c %c %s ftp 0 *\n",
873 fprintf(xferlog, "%s %u %s %lu %s b _ o %c %s ftp 0 *\n",
875 temp, (int)(difftime(now, f->tran_start)),
876 inet_ntoa(f->sin.sin_addr), f->size,
879 (f->upload) ? 'i' : 'o',
881 (f->owner->auth == 4) ? 'r' : 'a', f->owner->username);
885 /* vim needs this to work properly :-( */
892 /* Reallocate the buggers constantly */
895 struct conn *c = first_conn;
896 int maxloops = MAXCLIENTS;
898 while (c && c->next_conn) {
899 struct conn *temp = malloc(sizeof(*temp));
901 *temp = *(c->next_conn);
902 if (temp->transfer) temp->transfer->owner = temp;
903 memset(c->next_conn, 0, sizeof(struct conn));
909 assert(maxloops > 0);
915 * main(): Main function. Does the initialization, and contains
916 * the main server loop. Takes no command-line arguments
917 * (see README for justification).
924 /* the sets are declared globally if we use poll() */
926 fd_set fds, fds_send;
929 /*setlinebuf(stdout);*/
930 setvbuf(stdout, (char *)NULL, _IOLBF, 0);
932 signal(SIGPIPE, SIG_IGN);
934 printf("BetaFTPD version %s, Copyright (C) 1999-2000 Steinar H. Gunderson\n", VERSION);
935 puts("BetaFTPD comes with ABSOLUTELY NO WARRANTY; for details see the file");
936 puts("COPYING. This is free software, and you are welcome to redistribute it");
937 puts("under certain conditions; again see the file COPYING for details.");
940 /* we don't need stdin */
946 for (i = 0; i < FD_MAX; i++) {
952 FD_ZERO(&master_fds);
953 FD_ZERO(&master_send_fds);
956 server_sock = create_server_socket();
959 printf("%cc", (char)27); /* reset and clear the screen */
962 /* init dummy first connection */
963 first_conn = alloc_new_conn(-1);
964 first_ftran = alloc_new_ftran(0, NULL);
966 first_dcache = alloc_new_dcache();
971 #warning No xferlog support for nonroot yet
974 xferlog = fopen("/var/log/xferlog", "a");
975 if (xferlog == NULL) xferlog = fopen("/usr/adm/xferlog", "a");
977 if (xferlog != NULL) {
978 fseek(xferlog, 0L, SEEK_END);
987 puts("fork() failed, exiting");
992 puts("BetaFTPD forked into the background");
996 puts("BetaFTPD active");
999 /* set timeout alarm here (after the fork) */
1001 signal(SIGALRM, handle_alarm);
1003 #if HAVE_LINUX_SENDFILE || HAVE_BSD_SENDFILE
1004 /* check that sendfile() is really implemented (same check as configure does) */
1006 int out_fd = 1, in_fd = 0;
1011 mysendfile(out_fd, in_fd, &offset, size);
1012 if (errno == ENOSYS) sendfile_supported = 0;
1019 struct timeval timeout;
1022 /*screw_clients(); //look for memory errors */
1025 update_display(first_conn);
1029 i = poll(fds, highest_fds + 1, 60000);
1033 for (j=0; j<=highest_fds; j++) {
1034 if (fds[j].revents) printf("fds[%d].fd %d, .revents %x\n", j, fds[j].fd, fds[j].revents);
1039 /* reset fds (gets changed by select()) */
1041 fds_send = master_send_fds;
1044 * wait up to 60 secs for any activity
1046 timeout.tv_sec = 60;
1047 timeout.tv_usec = 0;
1049 i = select(FD_SETSIZE, &fds, &fds_send, NULL, &timeout);
1053 if (errno == EBADF) {
1055 /* don't like this, but we have to */
1056 clear_bad_fds(&server_sock);
1058 } else if (errno != EINTR) {
1069 /* fix an invalid server socket */
1070 if (fds[server_sock].revents & POLLERR) {
1071 del_fd(server_sock);
1072 server_sock = create_server_socket();
1076 /* remove any timed out sockets */
1077 if (time_to_check) {
1085 if (i <= 0) continue;
1088 i -= process_all_sendfiles(i);
1089 process_all_clients(i);
1091 /* sends are given highest `priority' */
1092 i -= process_all_sendfiles(&fds_send, i);
1094 /* incoming PASV connections and uploads */
1095 i -= process_all_sendfiles(&fds, i);
1098 * check the incoming PASV connections first, so
1099 * process_all_clients() won't be confused.
1101 process_all_clients(&fds, i);
1105 if (fds[server_sock].revents & POLLIN) {
1107 if (FD_ISSET(server_sock, &fds)) {
1109 accept_new_client(&server_sock);
1116 * accept_new_client():
1117 * Open a socket for the new client, say hello and put it in
1120 void accept_new_client(int * const server_sock)
1122 struct sockaddr_in tempaddr;
1123 int tempaddr_len = sizeof(tempaddr);
1124 const int tempsock = accept(*server_sock, (struct sockaddr *)&tempaddr, &tempaddr_len);
1126 static int num_err = 0;
1133 if ((errno == EBADF || errno == EPIPE) && ++num_err >= 3) {
1134 del_fd(*server_sock);
1135 *server_sock = create_server_socket();
1138 struct conn * const c = alloc_new_conn(tempsock);
1141 char hello[] = "220 BetaFTPD " VERSION " ready.\r\n";
1144 memcpy(&(c->addr), &tempaddr, sizeof(struct sockaddr));
1147 if (send(tempsock, hello, strlen(hello), 0) == -1 && errno == EPIPE)
1154 * time_out_sockets():
1155 * Times out any socket that has not had any transfer
1156 * in the last 15 minutes (delay not customizable by FTP
1157 * user -- you must change it in ftpd.h).
1159 * Note that RFC959 explicitly states that there are no
1160 * `spontaneous' error replies, yet we have to do it to
1161 * get the message through at all.
1163 * If we check this list for every accept() call, it's
1164 * actually eating a lot of CPU time, so we only check
1165 * it every minute. We used to do a time() call here,
1166 * but we've changed to do use an alarm() call and set
1167 * the time_to_check_flag in the SIGALRM handler.
1169 RETSIGTYPE handle_alarm(int signum)
1175 signal(SIGALRM, handle_alarm);
1178 void time_out_sockets()
1180 struct conn *c = NULL, *next = first_conn->next_conn;
1181 time_t now = time(NULL);
1183 /* run through the linked list */
1184 while (next != NULL) {
1186 next = c->next_conn;
1188 if ((c->transfer == NULL || c->transfer->state != 5) &&
1189 (now - c->last_transfer > TIMEOUT_SECS)) {
1190 /* RFC violation? */
1191 numeric(c, 421, "Timeout (%u minutes): Closing control connection.", TIMEOUT_SECS/60);
1199 * Remove some bytes from the incoming buffer. This gives
1200 * room for new data on the control connection, and should
1201 * be called when the code has finished using the data.
1202 * (This is done automatically for all commands, so you
1203 * normally need not worry about it.)
1205 void remove_bytes(struct conn * const c, const int num)
1207 if (c->buf_len <= num) {
1211 memmove(c->recv_buf, c->recv_buf + num, c->buf_len);
1216 * numeric(): Sends a numeric FTP reply to the client. Note that
1217 * you can use this command much the same way as you
1218 * would use a printf() (with all the normal %s, %d,
1219 * etc.), since it actually uses printf() internally.
1221 * This command doesn't actually SEND the data -- it
1222 * just puts it in a buffer which is sent after the
1223 * command handler has completed. The reasons for this
1224 * are simple -- it makes error checking and cleanup
1225 * MUCH cleaner, so we won't have to check for errors
1226 * in every single little branch of the code.
1228 void numeric(struct conn * const c, const int numeric, const char * const format, ...)
1233 int in_buf = strlen(message_buf);
1235 snprintf(fmt, 256, "%03u %s\r\n", numeric, format);
1237 va_start(args, format);
1238 i = vsnprintf(message_buf + in_buf, 512 - in_buf, fmt, args);
1243 * Actually flushes the buffer written by numeric() -- but does
1244 * NOT erase it. If an error, sets the "free_me" flag in the socket.
1246 void flush_numeric(struct conn * const c)
1248 if (send(c->sock, message_buf, strlen(message_buf), 0) == -1 && errno == EPIPE)
1253 * init_file_transfer():
1254 * Initiate a data connection for sending. This does not open
1255 * any files etc., just does whatever is needed for the socket,
1256 * if needed. It does, however, send the 150 reply to the client,
1257 * and mmap()s if needed.
1259 * Linux systems (others?) define SOL_TCP right away, which saves us
1260 * some grief and code size. Perhaps using getprotoent() is the `right'
1261 * way, but it's bigger :-) (Optionally, we could figure it out at
1262 * configure time, of course...)
1264 * For optimal speed, we use the Linux 2.2.x-only TCP_CORK flag if
1265 * possible. Note that this is only defined in the first `arm' --
1266 * we silently assume that Linux is the only OS supporting this
1267 * flag. This might be an over-generalization, but I it looks like
1268 * we'll have to depend on it other places as well, so we might
1269 * just as well be evil here.
1271 void init_file_transfer(struct ftran * const f)
1274 struct conn * const c = f->owner;
1275 const int mode = IPTOS_THROUGHPUT, zero = 0, one = 1;
1280 /* we want max throughput */
1281 setsockopt(f->sock, SOL_IP, IP_TOS, (void *)&mode, sizeof(mode));
1282 setsockopt(f->sock, SOL_TCP, TCP_NODELAY, (void *)&zero, sizeof(zero));
1284 setsockopt(f->sock, SOL_TCP, TCP_CORK, (void *)&one, sizeof(one));
1287 /* should these pointers be freed afterwards? */
1289 getprotoent(); /* legal? */
1291 const struct protoent * const pe_ip = getprotobyname("ip");
1292 const struct protoent * const pe_tcp = getprotobyname("tcp");
1293 setsockopt(f->sock, pe_ip->p_proto, IP_TOS, (void *)&mode, sizeof(mode));
1294 setsockopt(f->sock, pe_tcp->p_proto, TCP_NODELAY, (void *)&zero, sizeof(zero));
1300 if (f->dir_listing) {
1301 f->block_size = MAX_BLOCK_SIZE;
1304 f->ascii_mode = f->owner->ascii_mode;
1307 /* find the preferred block size */
1308 f->block_size = MAX_BLOCK_SIZE;
1309 if (fstat(f->local_file, &buf) != -1 &&
1310 buf.st_blksize < MAX_BLOCK_SIZE) {
1311 f->block_size = buf.st_blksize;
1322 #endif /* WANT_UPLOAD */
1324 TRAP_ERROR(add_fd(f->sock, events), 500, return);
1328 setsockopt(f->sock, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));
1330 #if !HAVE_POLL && WANT_UPLOAD
1332 * if we let an upload socket stay in master_send_fds, we would
1333 * get data that would fool us into closing the socket... (sigh)
1336 FD_CLR(f->sock, &master_send_fds);
1337 FD_SET(f->sock, &master_fds);
1341 time(&(f->owner->last_transfer));
1343 if (f->dir_listing) {
1345 numeric(f->owner, 150, "Opening ASCII mode data connection for directory listing.");
1348 * slightly kludged -- perhaps we should kill the second arm,
1349 * at the expense of code size? Or perhaps we could collapse
1350 * the two possible replies into one?
1356 #endif /* WANT_UPLOAD */
1358 numeric(f->owner, 150, "Opening %s mode data connection for '%s'",
1359 (f->ascii_mode) ? "ASCII" : "BINARY", f->filename);
1361 numeric(f->owner, 150, "Opening %s mode data connection for '%s' (%u bytes)",
1362 (f->ascii_mode) ? "ASCII" : "BINARY", f->filename,
1365 #else /* !WANT_ASCII */
1368 numeric(f->owner, 150, "Opening BINARY mode data connection for '%s'", f->filename);
1370 #endif /* WANT_UPLOAD */
1371 numeric(f->owner, 150, "Opening BINARY mode data connection for '%s' (%u bytes)", f->filename, f->size);
1372 #endif /* !WANT_ASCII */
1376 * This section _could_ in theory be more optimized, but it's
1377 * much easier this way, and hopefully, the compiler will be
1378 * intelligent enough to optimize most of this away. The idea
1379 * is, some modes _require_ use of mmap (or not). The preferred
1380 * thing is using mmap() when we don't have sendfile(), and not
1381 * using mmap() when we have sendfile().
1384 if (f->dir_listing == 0) {
1385 #if HAVE_LINUX_SENDFILE || HAVE_BSD_SENDFILE
1386 int do_mmap = (sendfile_supported) ? 0 : 1;
1391 if (f->ascii_mode == 1) do_mmap = 1;
1394 if (f->upload == 1) do_mmap = 0;
1398 f->file_data = mmap(NULL, f->size, PROT_READ, MAP_SHARED, f->local_file, 0);
1399 if (f->file_data == MAP_FAILED) f->file_data = NULL;
1401 f->file_data = NULL;
1403 f->pos = f->owner->rest_pos;
1405 #else /* !HAVE_MMAP */
1406 lseek(f->local_file, f->owner->rest_pos, SEEK_SET);
1411 * create_server_socket():
1412 * Create and bind a server socket, that we can use to
1413 * listen to new clients on.
1415 int create_server_socket()
1417 int server_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
1418 const unsigned int one = 1;
1419 struct sockaddr_in addr;
1423 * In the `perfect' world, if an address was in use, we could
1424 * just wait for the kernel to clear everything up, and everybody
1425 * would be happy. But when you just found out your server socket
1426 * was invalid, it has to be `re-made', and 3000 users are trying
1427 * to access your fileserver, I think it's nice that it comes
1428 * up right away... hence this option.
1430 setsockopt(server_sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
1431 ioctl(server_sock, FIONBIO, &one); /* just in case */
1433 addr.sin_family = AF_INET;
1434 addr.sin_addr.s_addr = INADDR_ANY;
1435 addr.sin_port = htons(FTP_PORT);
1438 err = bind(server_sock, (struct sockaddr *)&addr, sizeof(struct sockaddr));
1443 /* try to recover from recoverable errors... */
1444 if (errno == ENOMEM || errno == EADDRINUSE) {
1445 puts("Waiting 1 sec before trying again...");
1452 } while (err == -1);
1454 listen(server_sock, 20);
1456 err = add_fd(server_sock, POLLIN);
1468 * Try to find invalid socket descriptors, and clean them.
1469 * The methods used are rather UGLY, but I can't think of
1470 * any good way of checking e.g. server_sock without
1471 * doing anything to it :-(
1473 * poll() is able to do this in a much cleaner way, which
1474 * we use if we use poll(). That checking isn't done here,
1477 void clear_bad_fds(int * const server_sock)
1481 struct timeval tv = { 0, 0 };
1484 FD_SET(*server_sock, &fds);
1485 if (select(*server_sock, &fds, NULL, NULL, &tv) == -1) {
1486 FD_CLR(*server_sock, &master_fds);
1487 close(*server_sock);
1488 *server_sock = create_server_socket();
1492 /* could do this (conn, ftran) in any order */
1494 struct conn *c = NULL, *next = first_conn->next_conn;
1496 /* run through the linked list */
1497 while (next != NULL) {
1501 next = c->next_conn;
1503 if (read(c->sock, &buf, 0) == -1 &&
1511 struct ftran *f = NULL, *next = first_ftran->next_ftran;
1513 while (next != NULL) {
1517 next = f->next_ftran;
1519 if (read(f->sock, &buf, 0) == -1 &&
1528 #if HAVE_BSD_SENDFILE || HAVE_LINUX_SENDFILE
1529 int mysendfile(int sock, int fd, off_t *offset, size_t count)
1531 #if HAVE_BSD_SENDFILE
1535 err = sendfile(fd, sock, *offset, count, NULL, &ssize, 0);
1536 if (ssize > 0) *offset += ssize;
1537 #else /* !HAVE_BSD_SENDFILE */
1538 #if HAVE_LINUX_SENDFILE
1539 return sendfile(sock, fd, offset, count);
1540 #endif /* HAVE_LINUX_SENDFILE */
1541 #endif /* !HAVE_BSD_SENDFILE */
1543 #endif /* HAVE_BSD_SENDFILE || HAVE_LINUX_SENDFILE */
1548 * dump_file(): Dumps a file on the control connection. Used for
1549 * welcome messages and the likes. Note that outbuf
1550 * is so big, to prevent any crashing from users creating
1551 * weird .message files (like 1024 LFs)... The size of
1552 * the file is limited to 1024 bytes (by truncation).
1554 void dump_file(struct conn * const c, const int num, const char * const filename)
1556 char buf[1024], outbuf[5121];
1557 char *ptr = outbuf + 4;
1560 const int dumpfile = open(filename, O_RDONLY);
1561 if (dumpfile == -1) return;
1563 i = read(dumpfile, buf, 1024);
1569 sprintf(outbuf, "%03u-", num);
1572 if (buf[j] == '\n') {
1573 sprintf(ptr, "%03u-", num);
1579 send(c->sock, outbuf, ptr - outbuf, 0);
1586 * Lists all README file in the current (ie. OS current)
1587 * directory, in a 250- message.
1589 void list_readmes(struct conn * const c)
1592 const time_t now = time(NULL);
1595 if (glob("README*", 0, NULL, &pglob) != 0) return;
1597 for (i = 0; i < pglob.gl_pathc; i++) {
1602 if (stat(pglob.gl_pathv[i], &buf) == -1) continue;
1604 /* remove trailing LF */
1605 tm = ctime(&buf.st_mtime);
1606 tm[strlen(tm) - 1] = 0;
1608 snprintf(str, 256, "250-Please read the file %s\r\n"
1609 "250-\tIt was last modified %s - %ld days ago\r\n",
1610 pglob.gl_pathv[i], tm,
1611 (now - buf.st_mtime) / 86400);
1612 send(c->sock, str, strlen(str), 0);