[rtems-libbsd commit] ftpfs: Add to services
Joel Sherrill
joel at rtems.org
Fri Aug 3 13:36:48 UTC 2012
Module: rtems-libbsd
Branch: master
Commit: 116c6cf409e7a6d366f824018a84fd27d2a306c3
Changeset: http://git.rtems.org/rtems-libbsd/commit/?id=116c6cf409e7a6d366f824018a84fd27d2a306c3
Author: Joel Sherrill <joel.sherrill at oarcorp.com>
Date: Fri Aug 3 08:40:27 2012 -0500
ftpfs: Add to services
---
freebsd-userspace/{ => rtems}/include/netdb.h | 0
services/ftpfs/Makefile | 38 +
services/ftpfs/ftpfs.c | 1317 +++++++++++++++++++++++++
services/ftpfs/include/rtems/ftpfs.h | 160 +++
4 files changed, 1515 insertions(+), 0 deletions(-)
diff --git a/freebsd-userspace/include/netdb.h b/freebsd-userspace/rtems/include/netdb.h
similarity index 100%
rename from freebsd-userspace/include/netdb.h
rename to freebsd-userspace/rtems/include/netdb.h
diff --git a/services/ftpfs/Makefile b/services/ftpfs/Makefile
new file mode 100644
index 0000000..bad8803
--- /dev/null
+++ b/services/ftpfs/Makefile
@@ -0,0 +1,38 @@
+include ../../config.inc
+
+include $(RTEMS_MAKEFILE_PATH)/Makefile.inc
+include $(RTEMS_CUSTOM)
+include $(PROJECT_ROOT)/make/leaf.cfg
+
+CFLAGS += -I $(INSTALL_BASE)/include
+
+CFLAGS += -w
+CFLAGS += -I include
+CFLAGS += -std=gnu99
+CFLAGS += -MT $@ -MD -MP -MF $(basename $@).d
+
+C_FILES =
+C_FILES += ftpfs.c
+
+C_O_FILES = $(C_FILES:%.c=%.o)
+C_D_FILES = $(C_FILES:%.c=%.d)
+
+LIB = libftpfs.a
+
+all: $(LIB)
+
+$(LIB): $(C_O_FILES)
+ $(AR) rcu $@ $^
+
+install: $(LIB)
+ install -d $(INSTALL_BASE)/include/rtems
+ install -c -m 644 include/rtems/ftpfs.h $(INSTALL_BASE)/
+ install -c -m 644 $(LIB) $(INSTALL_BASE)
+
+clean:
+ rm -f $(LIB) $(C_O_FILES) $(C_D_FILES) $(GEN_FILES)
+
+-include $(C_D_FILES)
+
+doc:
+
diff --git a/services/ftpfs/ftpfs.c b/services/ftpfs/ftpfs.c
new file mode 100644
index 0000000..3fd0ffa
--- /dev/null
+++ b/services/ftpfs/ftpfs.c
@@ -0,0 +1,1317 @@
+/**
+ * @file
+ *
+ * File Transfer Protocol file system (FTP client).
+ */
+
+/*
+ * Copyright (c) 2009-2012
+ * embedded brains GmbH
+ * Obere Lagerstr. 30
+ * D-82178 Puchheim
+ * Germany
+ * <rtems at embedded-brains.de>
+ *
+ * (c) Copyright 2002
+ * Thomas Doerfler
+ * IMD Ingenieurbuero fuer Microcomputertechnik
+ * Herbststr. 8
+ * 82178 Puchheim, Germany
+ * <Thomas.Doerfler at imd-systems.de>
+ *
+ * Modified by Sebastian Huber <sebastian.huber at embedded-brains.de>.
+ *
+ * This code has been created after closly inspecting "tftpdriver.c" from Eric
+ * Norum.
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.com/license/LICENSE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <malloc.h>
+#include <netdb.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/select.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include <rtems.h>
+#include <rtems/ftpfs.h>
+#include <rtems/libio_.h>
+#include <rtems/rtems_bsdnet.h>
+#include <rtems/seterr.h>
+
+#ifdef DEBUG
+ #define DEBUG_PRINTF(...) printf(__VA_ARGS__)
+#else
+ #define DEBUG_PRINTF(...)
+#endif
+
+/**
+ * Connection entry for each open file stream.
+ */
+typedef struct {
+ /**
+ * Control connection socket.
+ */
+ int ctrl_socket;
+
+ /**
+ * Data transfer socket.
+ */
+ int data_socket;
+
+ /**
+ * Current index into the reply buffer.
+ */
+ size_t reply_current;
+
+ /**
+ * End index of the reply buffer.
+ */
+ size_t reply_end;
+
+ /**
+ * Buffer for relpy data.
+ */
+ char reply_buffer [128];
+
+ /**
+ * End of file flag.
+ */
+ bool eof;
+} rtems_ftpfs_entry;
+
+/**
+ * Mount entry for each file system instance.
+ */
+typedef struct {
+ /**
+ * Verbose mode enabled or disabled.
+ */
+ bool verbose;
+
+ /**
+ * Timeout value
+ */
+ struct timeval timeout;
+} rtems_ftpfs_mount_entry;
+
+static const rtems_filesystem_operations_table rtems_ftpfs_ops;
+
+static const rtems_filesystem_file_handlers_r rtems_ftpfs_handlers;
+
+static const rtems_filesystem_file_handlers_r rtems_ftpfs_root_handlers;
+
+static bool rtems_ftpfs_use_timeout(const struct timeval *to)
+{
+ return to->tv_sec != 0 || to->tv_usec != 0;
+}
+
+static int rtems_ftpfs_set_connection_timeout(
+ int socket,
+ const struct timeval *to
+)
+{
+ if (rtems_ftpfs_use_timeout(to)) {
+ int rv = 0;
+
+ rv = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, to, sizeof(*to));
+ if (rv != 0) {
+ return EIO;
+ }
+
+ rv = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, to, sizeof(*to));
+ if (rv != 0) {
+ return EIO;
+ }
+ }
+
+ return 0;
+}
+
+static rtems_status_code rtems_ftpfs_do_ioctl(
+ const char *mount_point,
+ ioctl_command_t req,
+ ...
+)
+{
+ rtems_status_code sc = RTEMS_SUCCESSFUL;
+ int rv = 0;
+ int fd = 0;
+ va_list ap;
+
+ if (mount_point == NULL) {
+ mount_point = RTEMS_FTPFS_MOUNT_POINT_DEFAULT;
+ }
+
+ fd = open(mount_point, O_RDWR);
+ if (fd < 0) {
+ return RTEMS_INVALID_NAME;
+ }
+
+ va_start(ap, req);
+ rv = ioctl(fd, req, va_arg(ap, void *));
+ va_end(ap);
+ if (rv != 0) {
+ sc = RTEMS_INVALID_NUMBER;
+ }
+
+ rv = close(fd);
+ if (rv != 0 && sc == RTEMS_SUCCESSFUL) {
+ sc = RTEMS_IO_ERROR;
+ }
+
+ return sc;
+}
+
+rtems_status_code rtems_ftpfs_get_verbose(const char *mount_point, bool *verbose)
+{
+ return rtems_ftpfs_do_ioctl(
+ mount_point,
+ RTEMS_FTPFS_IOCTL_GET_VERBOSE,
+ verbose
+ );
+}
+
+rtems_status_code rtems_ftpfs_set_verbose(const char *mount_point, bool verbose)
+{
+ return rtems_ftpfs_do_ioctl(
+ mount_point,
+ RTEMS_FTPFS_IOCTL_SET_VERBOSE,
+ &verbose
+ );
+}
+
+rtems_status_code rtems_ftpfs_get_timeout(
+ const char *mount_point,
+ struct timeval *timeout
+)
+{
+ return rtems_ftpfs_do_ioctl(
+ mount_point,
+ RTEMS_FTPFS_IOCTL_GET_TIMEOUT,
+ timeout
+ );
+}
+
+rtems_status_code rtems_ftpfs_set_timeout(
+ const char *mount_point,
+ const struct timeval *timeout
+)
+{
+ return rtems_ftpfs_do_ioctl(
+ mount_point,
+ RTEMS_FTPFS_IOCTL_SET_TIMEOUT,
+ timeout
+ );
+}
+
+typedef void (*rtems_ftpfs_reply_parser)(
+ const char * /* reply fragment */,
+ size_t /* reply fragment length */,
+ void * /* parser argument */
+);
+
+typedef enum {
+ RTEMS_FTPFS_REPLY_START,
+ RTEMS_FTPFS_REPLY_SINGLE_LINE,
+ RTEMS_FTPFS_REPLY_DONE,
+ RTEMS_FTPFS_REPLY_MULTI_LINE,
+ RTEMS_FTPFS_REPLY_MULTI_LINE_START
+} rtems_ftpfs_reply_state;
+
+typedef enum {
+ RTEMS_FTPFS_REPLY_ERROR = 0,
+ RTEMS_FTPFS_REPLY_1 = '1',
+ RTEMS_FTPFS_REPLY_2 = '2',
+ RTEMS_FTPFS_REPLY_3 = '3',
+ RTEMS_FTPFS_REPLY_4 = '4',
+ RTEMS_FTPFS_REPLY_5 = '5'
+} rtems_ftpfs_reply;
+
+#define RTEMS_FTPFS_REPLY_SIZE 3
+
+static bool rtems_ftpfs_is_reply_code_valid(unsigned char *reply)
+{
+ return isdigit(reply [0]) && isdigit(reply [1]) && isdigit(reply [2]);
+}
+
+static rtems_ftpfs_reply rtems_ftpfs_get_reply(
+ rtems_ftpfs_entry *e,
+ rtems_ftpfs_reply_parser parser,
+ void *parser_arg,
+ bool verbose
+)
+{
+ rtems_ftpfs_reply_state state = RTEMS_FTPFS_REPLY_START;
+ unsigned char reply_code [RTEMS_FTPFS_REPLY_SIZE] = { 'a', 'a', 'a' };
+ size_t reply_code_index = 0;
+
+ while (state != RTEMS_FTPFS_REPLY_DONE) {
+ char *buf = NULL;
+ size_t i = 0;
+ size_t n = 0;
+
+ /* Receive reply fragment from socket */
+ if (e->reply_current == e->reply_end) {
+ ssize_t rv = 0;
+
+ e->reply_current = 0;
+ e->reply_end = 0;
+
+ rv = recv(
+ e->ctrl_socket,
+ &e->reply_buffer [0],
+ sizeof(e->reply_buffer),
+ 0
+ );
+
+ if (rv > 0) {
+ e->reply_end = (size_t) rv;
+ } else {
+ return RTEMS_FTPFS_REPLY_ERROR;
+ }
+ }
+
+ buf = &e->reply_buffer [e->reply_current];
+ n = e->reply_end - e->reply_current;
+
+ /* Invoke parser if necessary */
+ if (parser != NULL) {
+ parser(buf, n, parser_arg);
+ }
+
+ /* Parse reply fragment */
+ for (i = 0; i < n && state != RTEMS_FTPFS_REPLY_DONE; ++i) {
+ char c = buf [i];
+
+ switch (state) {
+ case RTEMS_FTPFS_REPLY_START:
+ if (reply_code_index < RTEMS_FTPFS_REPLY_SIZE) {
+ reply_code [reply_code_index] = c;
+ ++reply_code_index;
+ } else if (rtems_ftpfs_is_reply_code_valid(reply_code)) {
+ if (c == '-') {
+ state = RTEMS_FTPFS_REPLY_MULTI_LINE;
+ } else {
+ state = RTEMS_FTPFS_REPLY_SINGLE_LINE;
+ }
+ } else {
+ return RTEMS_FTPFS_REPLY_ERROR;
+ }
+ break;
+ case RTEMS_FTPFS_REPLY_SINGLE_LINE:
+ if (c == '\n') {
+ state = RTEMS_FTPFS_REPLY_DONE;
+ }
+ break;
+ case RTEMS_FTPFS_REPLY_MULTI_LINE:
+ if (c == '\n') {
+ state = RTEMS_FTPFS_REPLY_MULTI_LINE_START;
+ reply_code_index = 0;
+ }
+ break;
+ case RTEMS_FTPFS_REPLY_MULTI_LINE_START:
+ if (reply_code_index < RTEMS_FTPFS_REPLY_SIZE) {
+ if (reply_code [reply_code_index] == c) {
+ ++reply_code_index;
+ } else {
+ state = RTEMS_FTPFS_REPLY_MULTI_LINE;
+ }
+ } else {
+ if (c == ' ') {
+ state = RTEMS_FTPFS_REPLY_SINGLE_LINE;
+ } else {
+ state = RTEMS_FTPFS_REPLY_MULTI_LINE;
+ }
+ }
+ break;
+ default:
+ return RTEMS_FTPFS_REPLY_ERROR;
+ }
+ }
+
+ /* Be verbose if necessary */
+ if (verbose) {
+ write(STDERR_FILENO, buf, i);
+ }
+
+ /* Update reply index */
+ e->reply_current += i;
+ }
+
+ return reply_code [0];
+}
+
+static rtems_ftpfs_reply rtems_ftpfs_send_command_with_parser(
+ rtems_ftpfs_entry *e,
+ const char *cmd,
+ const char *arg,
+ rtems_ftpfs_reply_parser parser,
+ void *parser_arg,
+ bool verbose
+)
+{
+ rtems_ftpfs_reply reply = RTEMS_FTPFS_REPLY_ERROR;
+ size_t cmd_len = strlen(cmd);
+ size_t arg_len = arg != NULL ? strlen(arg) : 0;
+ size_t len = cmd_len + arg_len + 2;
+ char *buf = malloc(len);
+
+ if (buf != NULL) {
+ ssize_t n = 0;
+ char *buf_arg = buf + cmd_len;
+ char *buf_eol = buf_arg + arg_len;
+
+ memcpy(buf, cmd, cmd_len);
+ memcpy(buf_arg, arg, arg_len);
+ buf_eol [0] = '\r';
+ buf_eol [1] = '\n';
+
+ /* Send */
+ n = send(e->ctrl_socket, buf, len, 0);
+ if (n == (ssize_t) len) {
+ if (verbose) {
+ write(STDERR_FILENO, buf, len);
+ }
+
+ /* Reply */
+ reply = rtems_ftpfs_get_reply(e, parser, parser_arg, verbose);
+ }
+
+ free(buf);
+ }
+
+ return reply;
+}
+
+static rtems_ftpfs_reply rtems_ftpfs_send_command(
+ rtems_ftpfs_entry *e,
+ const char *cmd,
+ const char *arg,
+ bool verbose
+)
+{
+ return rtems_ftpfs_send_command_with_parser(
+ e,
+ cmd,
+ arg,
+ NULL,
+ NULL,
+ verbose
+ );
+}
+
+typedef enum {
+ STATE_USER_NAME,
+ STATE_START_PASSWORD,
+ STATE_START_HOST_NAME,
+ STATE_START_HOST_NAME_OR_PATH,
+ STATE_START_PATH,
+ STATE_PASSWORD,
+ STATE_HOST_NAME,
+ STATE_DONE,
+ STATE_INVALID
+} split_state;
+
+static bool rtems_ftpfs_split_names (
+ char *s,
+ const char **user,
+ const char **password,
+ const char **hostname,
+ const char **path
+)
+{
+ split_state state = STATE_USER_NAME;
+ size_t len = strlen(s);
+ size_t i = 0;
+
+ *user = s;
+ *password = NULL;
+ *hostname = NULL;
+ *path = NULL;
+
+ for (i = 0; i < len; ++i) {
+ char c = s [i];
+
+ switch (state) {
+ case STATE_USER_NAME:
+ if (c == ':') {
+ state = STATE_START_PASSWORD;
+ s [i] = '\0';
+ } else if (c == '@') {
+ state = STATE_START_HOST_NAME;
+ s [i] = '\0';
+ } else if (c == '/') {
+ state = STATE_START_HOST_NAME_OR_PATH;
+ s [i] = '\0';
+ }
+ break;
+ case STATE_START_PASSWORD:
+ state = STATE_PASSWORD;
+ *password = &s [i];
+ --i;
+ break;
+ case STATE_START_HOST_NAME:
+ state = STATE_HOST_NAME;
+ *hostname = &s [i];
+ --i;
+ break;
+ case STATE_START_HOST_NAME_OR_PATH:
+ if (c == '@') {
+ state = STATE_START_HOST_NAME;
+ } else {
+ state = STATE_DONE;
+ *path = &s [i];
+ goto done;
+ }
+ break;
+ case STATE_START_PATH:
+ state = STATE_DONE;
+ *path = &s [i];
+ goto done;
+ case STATE_PASSWORD:
+ if (c == '@') {
+ state = STATE_START_HOST_NAME;
+ s [i] = '\0';
+ } else if (c == '/') {
+ state = STATE_START_HOST_NAME_OR_PATH;
+ s [i] = '\0';
+ }
+ break;
+ case STATE_HOST_NAME:
+ if (c == '/') {
+ state = STATE_START_PATH;
+ s [i] = '\0';
+ }
+ break;
+ default:
+ state = STATE_INVALID;
+ goto done;
+ }
+ }
+
+done:
+
+ /* This is a special case with no username and password */
+ if (*hostname == NULL) {
+ *hostname = &s [0];
+ *user = "anonymous";
+ *password = *user;
+ }
+
+ /* If we have no password use the user name */
+ if (*password == NULL) {
+ *password = *user;
+ }
+
+ return state == STATE_DONE;
+}
+
+static socklen_t rtems_ftpfs_create_address(
+ struct sockaddr_in *sa,
+ unsigned long address,
+ unsigned short port
+)
+{
+ memset(sa, sizeof(*sa), 0);
+
+ sa->sin_family = AF_INET;
+ sa->sin_addr.s_addr = address;
+ sa->sin_port = port;
+ sa->sin_len = sizeof(*sa);
+
+ return sizeof(*sa);
+}
+
+static int rtems_ftpfs_terminate(rtems_libio_t *iop, bool error)
+{
+ int eno = 0;
+ int rv = 0;
+ rtems_ftpfs_entry *e = iop->data1;
+ rtems_ftpfs_mount_entry *me = iop->pathinfo.mt_entry->fs_info;
+ bool verbose = me->verbose;
+ rtems_ftpfs_reply reply = RTEMS_FTPFS_REPLY_ERROR;
+
+ if (e != NULL) {
+ /* Close data connection if necessary */
+ if (e->data_socket >= 0) {
+ rv = close(e->data_socket);
+ if (rv != 0) {
+ eno = EIO;
+ }
+
+ /* For write connections we have to obtain the transfer reply */
+ if (
+ e->ctrl_socket >= 0
+ && (iop->flags & LIBIO_FLAGS_WRITE) != 0
+ && !error
+ ) {
+ reply = rtems_ftpfs_get_reply(e, NULL, NULL, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_2) {
+ eno = EIO;
+ }
+ }
+ }
+
+ /* Close control connection if necessary */
+ if (e->ctrl_socket >= 0) {
+ reply = rtems_ftpfs_send_command(e, "QUIT", NULL, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_2) {
+ eno = EIO;
+ }
+
+ rv = close(e->ctrl_socket);
+ if (rv != 0) {
+ eno = EIO;
+ }
+ }
+
+ /* Free connection entry */
+ free(e);
+ }
+
+ /* Invalidate IO entry */
+ iop->data1 = NULL;
+
+ return eno;
+}
+
+static int rtems_ftpfs_open_ctrl_connection(
+ rtems_ftpfs_entry *e,
+ const char *user,
+ const char *password,
+ const char *hostname,
+ uint32_t *client_address,
+ bool verbose,
+ const struct timeval *timeout
+)
+{
+ int rv = 0;
+ int eno = 0;
+ rtems_ftpfs_reply reply = RTEMS_FTPFS_REPLY_ERROR;
+ struct in_addr address = { .s_addr = 0 };
+ struct sockaddr_in sa;
+ socklen_t size = 0;
+
+ /* Create the socket for the control connection */
+ e->ctrl_socket = socket(AF_INET, SOCK_STREAM, 0);
+ if (e->ctrl_socket < 0) {
+ return ENOMEM;
+ }
+
+ /* Set up the server address from the hostname */
+ if (inet_aton(hostname, &address) == 0) {
+ /* Try to get the address by name */
+ struct hostent *he = gethostbyname(hostname);
+
+ if (he != NULL) {
+ memcpy(&address, he->h_addr, sizeof(address));
+ } else {
+ return ENOENT;
+ }
+ }
+ rtems_ftpfs_create_address(&sa, address.s_addr, htons(RTEMS_FTPFS_CTRL_PORT));
+ DEBUG_PRINTF("server = %s\n", inet_ntoa(sa.sin_addr));
+
+ /* Open control connection */
+ rv = connect(
+ e->ctrl_socket,
+ (struct sockaddr *) &sa,
+ sizeof(sa)
+ );
+ if (rv != 0) {
+ return ENOENT;
+ }
+
+ /* Set control connection timeout */
+ eno = rtems_ftpfs_set_connection_timeout(e->ctrl_socket, timeout);
+ if (eno != 0) {
+ return eno;
+ }
+
+ /* Get client address */
+ size = rtems_ftpfs_create_address(&sa, INADDR_ANY, 0);
+ rv = getsockname(
+ e->ctrl_socket,
+ (struct sockaddr *) &sa,
+ &size
+ );
+ if (rv != 0) {
+ return ENOMEM;
+ }
+ *client_address = ntohl(sa.sin_addr.s_addr);
+ DEBUG_PRINTF("client = %s\n", inet_ntoa(sa.sin_addr));
+
+ /* Now we should get a welcome message from the server */
+ reply = rtems_ftpfs_get_reply(e, NULL, NULL, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_2) {
+ return ENOENT;
+ }
+
+ /* Send USER command */
+ reply = rtems_ftpfs_send_command(e, "USER ", user, verbose);
+ if (reply == RTEMS_FTPFS_REPLY_3) {
+ /* Send PASS command */
+ reply = rtems_ftpfs_send_command(e, "PASS ", password, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_2) {
+ return EACCES;
+ }
+
+ /* TODO: Some server may require an account */
+ } else if (reply != RTEMS_FTPFS_REPLY_2) {
+ return EACCES;
+ }
+
+ /* Send TYPE command to set binary mode for all data transfers */
+ reply = rtems_ftpfs_send_command(e, "TYPE I", NULL, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_2) {
+ return EIO;
+ }
+
+ return 0;
+}
+
+static int rtems_ftpfs_open_data_connection_active(
+ rtems_ftpfs_entry *e,
+ uint32_t client_address,
+ const char *file_command,
+ const char *filename,
+ bool verbose,
+ const struct timeval *timeout
+)
+{
+ int rv = 0;
+ int eno = 0;
+ rtems_ftpfs_reply reply = RTEMS_FTPFS_REPLY_ERROR;
+ struct sockaddr_in sa;
+ socklen_t size = 0;
+ int port_socket = -1;
+ char port_command [] = "PORT 000,000,000,000,000,000";
+ uint16_t data_port = 0;
+
+ /* Create port socket to establish a data data connection */
+ port_socket = socket(AF_INET, SOCK_STREAM, 0);
+ if (port_socket < 0) {
+ eno = ENOMEM;
+ goto cleanup;
+ }
+
+ /* Bind port socket */
+ rtems_ftpfs_create_address(&sa, INADDR_ANY, 0);
+ rv = bind(
+ port_socket,
+ (struct sockaddr *) &sa,
+ sizeof(sa)
+ );
+ if (rv != 0) {
+ eno = EBUSY;
+ goto cleanup;
+ }
+
+ /* Get port number for data socket */
+ size = rtems_ftpfs_create_address(&sa, INADDR_ANY, 0);
+ rv = getsockname(
+ port_socket,
+ (struct sockaddr *) &sa,
+ &size
+ );
+ if (rv != 0) {
+ eno = ENOMEM;
+ goto cleanup;
+ }
+ data_port = ntohs(sa.sin_port);
+
+ /* Send PORT command to set data connection port for server */
+ snprintf(
+ port_command,
+ sizeof(port_command),
+ "PORT %lu,%lu,%lu,%lu,%lu,%lu",
+ (client_address >> 24) & 0xffUL,
+ (client_address >> 16) & 0xffUL,
+ (client_address >> 8) & 0xffUL,
+ (client_address >> 0) & 0xffUL,
+ (data_port >> 8) & 0xffUL,
+ (data_port >> 0) & 0xffUL
+ );
+ reply = rtems_ftpfs_send_command(e, port_command, NULL, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_2) {
+ eno = ENOTSUP;
+ goto cleanup;
+ }
+
+ /* Listen on port socket for incoming data connections */
+ rv = listen(port_socket, 1);
+ if (rv != 0) {
+ eno = EBUSY;
+ goto cleanup;
+ }
+
+ /* Send RETR or STOR command with filename */
+ reply = rtems_ftpfs_send_command(e, file_command, filename, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_1) {
+ eno = EIO;
+ goto cleanup;
+ }
+
+ /* Wait for connect on data connection if necessary */
+ if (rtems_ftpfs_use_timeout(timeout)) {
+ struct timeval to = *timeout;
+ fd_set fds;
+
+ FD_ZERO(&fds);
+ FD_SET(port_socket, &fds);
+
+ rv = select(port_socket + 1, &fds, NULL, NULL, &to);
+ if (rv <= 0) {
+ eno = EIO;
+ goto cleanup;
+ }
+ }
+
+ /* Accept data connection */
+ size = sizeof(sa);
+ e->data_socket = accept(
+ port_socket,
+ (struct sockaddr *) &sa,
+ &size
+ );
+ if (e->data_socket < 0) {
+ eno = EIO;
+ goto cleanup;
+ }
+
+cleanup:
+
+ /* Close port socket if necessary */
+ if (port_socket >= 0) {
+ rv = close(port_socket);
+ if (rv != 0) {
+ eno = EIO;
+ }
+ }
+
+ return eno;
+}
+
+typedef enum {
+ RTEMS_FTPFS_PASV_START = 0,
+ RTEMS_FTPFS_PASV_JUNK,
+ RTEMS_FTPFS_PASV_DATA,
+ RTEMS_FTPFS_PASV_DONE
+} rtems_ftpfs_pasv_state;
+
+typedef struct {
+ rtems_ftpfs_pasv_state state;
+ uint8_t data [6];
+ size_t index;
+} rtems_ftpfs_pasv_entry;
+
+static void rtems_ftpfs_pasv_parser(
+ const char* buf,
+ size_t len,
+ void *arg
+)
+{
+ rtems_ftpfs_pasv_entry *e = arg;
+ size_t i = 0;
+
+ for (i = 0; i < len; ++i) {
+ int c = buf [i];
+
+ switch (e->state) {
+ case RTEMS_FTPFS_PASV_START:
+ if (!isdigit(c)) {
+ e->state = RTEMS_FTPFS_PASV_JUNK;
+ e->index = 0;
+ }
+ break;
+ case RTEMS_FTPFS_PASV_JUNK:
+ if (isdigit(c)) {
+ e->state = RTEMS_FTPFS_PASV_DATA;
+ e->data [e->index] = (uint8_t) (c - '0');
+ }
+ break;
+ case RTEMS_FTPFS_PASV_DATA:
+ if (isdigit(c)) {
+ e->data [e->index] = (uint8_t) (e->data [e->index] * 10 + c - '0');
+ } else if (c == ',') {
+ ++e->index;
+ if (e->index < sizeof(e->data)) {
+ e->data [e->index] = 0;
+ } else {
+ e->state = RTEMS_FTPFS_PASV_DONE;
+ }
+ } else {
+ e->state = RTEMS_FTPFS_PASV_DONE;
+ }
+ break;
+ default:
+ return;
+ }
+ }
+}
+
+static int rtems_ftpfs_open_data_connection_passive(
+ rtems_ftpfs_entry *e,
+ uint32_t client_address,
+ const char *file_command,
+ const char *filename,
+ bool verbose,
+ const struct timeval *timeout
+)
+{
+ int rv = 0;
+ rtems_ftpfs_reply reply = RTEMS_FTPFS_REPLY_ERROR;
+ struct sockaddr_in sa;
+ uint32_t data_address = 0;
+ uint16_t data_port = 0;
+
+ rtems_ftpfs_pasv_entry pe = {
+ .state = RTEMS_FTPFS_PASV_START
+ };
+
+ /* Send PASV command */
+ reply = rtems_ftpfs_send_command_with_parser(
+ e,
+ "PASV",
+ NULL,
+ rtems_ftpfs_pasv_parser,
+ &pe,
+ verbose
+ );
+ if (reply != RTEMS_FTPFS_REPLY_2) {
+ return ENOTSUP;
+ }
+ data_address = ((uint32_t)(pe.data [0]) << 24) + ((uint32_t)(pe.data [1]) << 16)
+ + ((uint32_t)(pe.data [2]) << 8) + ((uint32_t)(pe.data [3]));
+ data_port = (uint16_t) ((pe.data [4] << 8) + pe.data [5]);
+ rtems_ftpfs_create_address(&sa, htonl(data_address), htons(data_port));
+ DEBUG_PRINTF(
+ "server data = %s:%u\n",
+ inet_ntoa(sa.sin_addr),
+ (unsigned) ntohs(sa.sin_port)
+ );
+
+ /* Create data socket */
+ e->data_socket = socket(AF_INET, SOCK_STREAM, 0);
+ if (e->data_socket < 0) {
+ return ENOMEM;
+ }
+
+ /* Open data connection */
+ rv = connect(
+ e->data_socket,
+ (struct sockaddr *) &sa,
+ sizeof(sa)
+ );
+ if (rv != 0) {
+ return EIO;
+ }
+
+ /* Send RETR or STOR command with filename */
+ reply = rtems_ftpfs_send_command(e, file_command, filename, verbose);
+ if (reply != RTEMS_FTPFS_REPLY_1) {
+ return EIO;
+ }
+
+ return 0;
+}
+
+static int rtems_ftpfs_open(
+ rtems_libio_t *iop,
+ const char *path,
+ int oflag,
+ mode_t mode
+)
+{
+ int eno = 0;
+ bool ok = false;
+ rtems_ftpfs_entry *e = NULL;
+ rtems_ftpfs_mount_entry *me = iop->pathinfo.mt_entry->fs_info;
+ bool verbose = me->verbose;
+ const struct timeval *timeout = &me->timeout;
+ const char *user = NULL;
+ const char *password = NULL;
+ const char *hostname = NULL;
+ const char *filename = NULL;
+ const char *file_command = (iop->flags & LIBIO_FLAGS_WRITE) != 0
+ ? "STOR "
+ : "RETR ";
+ uint32_t client_address = 0;
+ char *location = iop->pathinfo.node_access;
+
+ /* Invalidate data handle */
+ iop->data1 = NULL;
+
+ /* Split location into parts */
+ ok = rtems_ftpfs_split_names(
+ location,
+ &user,
+ &password,
+ &hostname,
+ &filename
+ );
+ if (!ok) {
+ rtems_set_errno_and_return_minus_one(ENOENT);
+ }
+ DEBUG_PRINTF(
+ "user = '%s', password = '%s', filename = '%s'\n",
+ user,
+ password,
+ filename
+ );
+
+ /* Check for either read-only or write-only flags */
+ if (
+ (iop->flags & LIBIO_FLAGS_WRITE) != 0
+ && (iop->flags & LIBIO_FLAGS_READ) != 0
+ ) {
+ rtems_set_errno_and_return_minus_one(ENOTSUP);
+ }
+
+ /* Allocate connection entry */
+ e = calloc(1, sizeof(*e));
+ if (e == NULL) {
+ rtems_set_errno_and_return_minus_one(ENOMEM);
+ }
+
+ /* Initialize connection entry */
+ e->ctrl_socket = -1;
+ e->data_socket = -1;
+
+ /* Save connection state */
+ iop->data1 = e;
+
+ /* Open control connection */
+ eno = rtems_ftpfs_open_ctrl_connection(
+ e,
+ user,
+ password,
+ hostname,
+ &client_address,
+ verbose,
+ timeout
+ );
+ if (eno != 0) {
+ goto cleanup;
+ }
+
+ /* Open passive data connection */
+ eno = rtems_ftpfs_open_data_connection_passive(
+ e,
+ client_address,
+ file_command,
+ filename,
+ verbose,
+ timeout
+ );
+ if (eno == ENOTSUP) {
+ /* Open active data connection */
+ eno = rtems_ftpfs_open_data_connection_active(
+ e,
+ client_address,
+ file_command,
+ filename,
+ verbose,
+ timeout
+ );
+ }
+ if (eno != 0) {
+ goto cleanup;
+ }
+
+ /* Set data connection timeout */
+ eno = rtems_ftpfs_set_connection_timeout(e->data_socket, timeout);
+
+cleanup:
+
+ if (eno == 0) {
+ return 0;
+ } else {
+ /* Free all resources if an error occured */
+ rtems_ftpfs_terminate(iop, true);
+
+ rtems_set_errno_and_return_minus_one(eno);
+ }
+}
+
+static ssize_t rtems_ftpfs_read(
+ rtems_libio_t *iop,
+ void *buffer,
+ size_t count
+)
+{
+ rtems_ftpfs_entry *e = iop->data1;
+ rtems_ftpfs_mount_entry *me = iop->pathinfo.mt_entry->fs_info;
+ bool verbose = me->verbose;
+ char *in = buffer;
+ size_t todo = count;
+
+ if (e->eof) {
+ return 0;
+ }
+
+ while (todo > 0) {
+ ssize_t rv = recv(e->data_socket, in, todo, 0);
+
+ if (rv <= 0) {
+ if (rv == 0) {
+ rtems_ftpfs_reply reply =
+ rtems_ftpfs_get_reply(e, NULL, NULL, verbose);
+
+ if (reply == RTEMS_FTPFS_REPLY_2) {
+ e->eof = true;
+ break;
+ }
+ }
+
+ rtems_set_errno_and_return_minus_one(EIO);
+ }
+
+ in += rv;
+ todo -= (size_t) rv;
+ }
+
+ return (ssize_t) (count - todo);
+}
+
+static ssize_t rtems_ftpfs_write(
+ rtems_libio_t *iop,
+ const void *buffer,
+ size_t count
+)
+{
+ rtems_ftpfs_entry *e = iop->data1;
+ const char *out = buffer;
+ size_t todo = count;
+
+ while (todo > 0) {
+ ssize_t rv = send(e->data_socket, out, todo, 0);
+
+ if (rv <= 0) {
+ if (rv == 0) {
+ break;
+ } else {
+ rtems_set_errno_and_return_minus_one(EIO);
+ }
+ }
+
+ out += rv;
+ todo -= (size_t) rv;
+ }
+
+ return (ssize_t) (count - todo);
+}
+
+static int rtems_ftpfs_close(rtems_libio_t *iop)
+{
+ int eno = rtems_ftpfs_terminate(iop, false);
+
+ if (eno == 0) {
+ return 0;
+ } else {
+ rtems_set_errno_and_return_minus_one(eno);
+ }
+}
+
+/* Dummy version to let fopen(*,"w") work properly */
+static int rtems_ftpfs_ftruncate(rtems_libio_t *iop, off_t count)
+{
+ return 0;
+}
+
+static void rtems_ftpfs_eval_path(
+ rtems_filesystem_eval_path_context_t *self
+)
+{
+ rtems_filesystem_eval_path_eat_delimiter(self);
+
+ if (rtems_filesystem_eval_path_has_path(self)) {
+ const char *path = rtems_filesystem_eval_path_get_path(self);
+ size_t pathlen = rtems_filesystem_eval_path_get_pathlen(self);
+ char *pathdup = malloc(pathlen + 1);
+
+ rtems_filesystem_eval_path_clear_path(self);
+
+ if (pathdup != NULL) {
+ rtems_filesystem_location_info_t *currentloc =
+ rtems_filesystem_eval_path_get_currentloc(self);
+
+ memcpy(pathdup, path, pathlen);
+ pathdup [pathlen] = '\0';
+ currentloc->node_access = pathdup;
+ currentloc->handlers = &rtems_ftpfs_handlers;
+ } else {
+ rtems_filesystem_eval_path_error(self, ENOMEM);
+ }
+ }
+}
+
+static void rtems_ftpfs_free_node(const rtems_filesystem_location_info_t *loc)
+{
+ free(loc->node_access);
+}
+
+static rtems_filesystem_node_types_t rtems_ftpfs_node_type(
+ const rtems_filesystem_location_info_t *loc
+)
+{
+ return RTEMS_FILESYSTEM_MEMORY_FILE;
+}
+
+int rtems_ftpfs_initialize(
+ rtems_filesystem_mount_table_entry_t *e,
+ const void *d
+)
+{
+ rtems_ftpfs_mount_entry *me = malloc(sizeof(rtems_ftpfs_mount_entry));
+
+ /* Mount entry for FTP file system instance */
+ e->fs_info = me;
+ if (e->fs_info == NULL) {
+ rtems_set_errno_and_return_minus_one(ENOMEM);
+ }
+ me->verbose = false;
+ me->timeout.tv_sec = 0;
+ me->timeout.tv_usec = 0;
+
+ /* Set handler and oparations table */
+ e->mt_fs_root->location.handlers = &rtems_ftpfs_root_handlers;
+ e->ops = &rtems_ftpfs_ops;
+
+ /* We maintain no real file system nodes, so there is no real root */
+ e->mt_fs_root->location.node_access = NULL;
+
+ return 0;
+}
+
+static void rtems_ftpfs_unmount_me(
+ rtems_filesystem_mount_table_entry_t *e
+)
+{
+ free(e->fs_info);
+}
+
+static int rtems_ftpfs_ioctl(
+ rtems_libio_t *iop,
+ uint32_t command,
+ void *arg
+)
+{
+ rtems_ftpfs_mount_entry *me = iop->pathinfo.mt_entry->fs_info;
+ bool *verbose = arg;
+ struct timeval *timeout = arg;
+
+ if (arg == NULL) {
+ rtems_set_errno_and_return_minus_one(EINVAL);
+ }
+
+ switch (command) {
+ case RTEMS_FTPFS_IOCTL_GET_VERBOSE:
+ *verbose = me->verbose;
+ break;
+ case RTEMS_FTPFS_IOCTL_SET_VERBOSE:
+ me->verbose = *verbose;
+ break;
+ case RTEMS_FTPFS_IOCTL_GET_TIMEOUT:
+ *timeout = me->timeout;
+ break;
+ case RTEMS_FTPFS_IOCTL_SET_TIMEOUT:
+ me->timeout = *timeout;
+ break;
+ default:
+ rtems_set_errno_and_return_minus_one(EINVAL);
+ }
+
+ return 0;
+}
+
+/*
+ * The stat() support is intended only for the cp shell command. Each request
+ * will return that we have a regular file with read, write and execute
+ * permissions for every one. The node index uses a global counter to support
+ * a remote to remote copy. This is not a very sophisticated method.
+ */
+static int rtems_ftpfs_fstat(
+ const rtems_filesystem_location_info_t *loc,
+ struct stat *st
+)
+{
+ static unsigned ino = 0;
+
+ /* FIXME */
+ st->st_ino = ++ino;
+ st->st_dev = rtems_filesystem_make_dev_t(0xcc494cd6U, 0x1d970b4dU);
+
+ st->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
+
+ return 0;
+}
+
+static const rtems_filesystem_operations_table rtems_ftpfs_ops = {
+ .lock_h = rtems_filesystem_default_lock,
+ .unlock_h = rtems_filesystem_default_unlock,
+ .eval_path_h = rtems_ftpfs_eval_path,
+ .link_h = rtems_filesystem_default_link,
+ .are_nodes_equal_h = rtems_filesystem_default_are_nodes_equal,
+ .node_type_h = rtems_ftpfs_node_type,
+ .mknod_h = rtems_filesystem_default_mknod,
+ .rmnod_h = rtems_filesystem_default_rmnod,
+ .fchmod_h = rtems_filesystem_default_fchmod,
+ .chown_h = rtems_filesystem_default_chown,
+ .clonenod_h = rtems_filesystem_default_clonenode,
+ .freenod_h = rtems_ftpfs_free_node,
+ .mount_h = rtems_filesystem_default_mount,
+ .fsmount_me_h = rtems_ftpfs_initialize,
+ .unmount_h = rtems_filesystem_default_unmount,
+ .fsunmount_me_h = rtems_ftpfs_unmount_me,
+ .utime_h = rtems_filesystem_default_utime,
+ .symlink_h = rtems_filesystem_default_symlink,
+ .readlink_h = rtems_filesystem_default_readlink,
+ .rename_h = rtems_filesystem_default_rename,
+ .statvfs_h = rtems_filesystem_default_statvfs
+};
+
+static const rtems_filesystem_file_handlers_r rtems_ftpfs_handlers = {
+ .open_h = rtems_ftpfs_open,
+ .close_h = rtems_ftpfs_close,
+ .read_h = rtems_ftpfs_read,
+ .write_h = rtems_ftpfs_write,
+ .ioctl_h = rtems_filesystem_default_ioctl,
+ .lseek_h = rtems_filesystem_default_lseek,
+ .fstat_h = rtems_ftpfs_fstat,
+ .ftruncate_h = rtems_ftpfs_ftruncate,
+ .fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
+ .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync,
+ .fcntl_h = rtems_filesystem_default_fcntl
+};
+
+static const rtems_filesystem_file_handlers_r rtems_ftpfs_root_handlers = {
+ .open_h = rtems_filesystem_default_open,
+ .close_h = rtems_filesystem_default_close,
+ .read_h = rtems_filesystem_default_read,
+ .write_h = rtems_filesystem_default_write,
+ .ioctl_h = rtems_ftpfs_ioctl,
+ .lseek_h = rtems_filesystem_default_lseek,
+ .fstat_h = rtems_filesystem_default_fstat,
+ .ftruncate_h = rtems_filesystem_default_ftruncate,
+ .fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
+ .fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync,
+ .fcntl_h = rtems_filesystem_default_fcntl
+};
diff --git a/services/ftpfs/include/rtems/ftpfs.h b/services/ftpfs/include/rtems/ftpfs.h
new file mode 100644
index 0000000..8b1de3c
--- /dev/null
+++ b/services/ftpfs/include/rtems/ftpfs.h
@@ -0,0 +1,160 @@
+/**
+ * @file
+ *
+ * @brief File Transfer Protocol file system (FTP client).
+ */
+
+/*
+ * Copyright (c) 2009
+ * embedded brains GmbH
+ * Obere Lagerstr. 30
+ * D-82178 Puchheim
+ * Germany
+ * <rtems at embedded-brains.de>
+ *
+ * (c) Copyright 2002
+ * Thomas Doerfler
+ * IMD Ingenieurbuero fuer Microcomputertechnik
+ * Herbststr. 8
+ * 82178 Puchheim, Germany
+ * <Thomas.Doerfler at imd-systems.de>
+ *
+ * Modified by Sebastian Huber <sebastian.huber at embedded-brains.de>.
+ *
+ * This code has been created after closly inspecting "tftpdriver.c" from Eric
+ * Norum.
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rtems.com/license/LICENSE.
+ */
+
+#ifndef _RTEMS_FTPFS_H
+#define _RTEMS_FTPFS_H
+
+#include <sys/time.h>
+#include <sys/ioctl.h>
+
+#include <rtems/libio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup rtems_ftpfs File Transfer Protocol File System
+ *
+ * @brief The FTP file system (FTP client) can be used to transfer files from
+ * or to remote hosts.
+ *
+ * You can mount the FTP file system with a call to mount() or
+ * mount_and_make_target_path() with the @ref RTEMS_FILESYSTEM_TYPE_FTPFS file
+ * system type.
+ *
+ * You have to add @ref CONFIGURE_FILESYSTEM_FTPFS to your application
+ * configuration.
+ *
+ * You can open files either read-only or write-only. A seek is not allowed.
+ * A close terminates the control and data connections.
+ *
+ * To open a file @c file.txt in the directory @c dir (relative to home
+ * directory of the server) on a server named @c host using the user name
+ * @c user and the password @c pw you must specify the following path:
+ * <tt>/FTP/user:pw@@host/dir/file.txt</tt>.
+ *
+ * If the server is the default server specified in BOOTP, it can be ommitted:
+ * <tt>/FTP/user:pw/dir/file.txt</tt>.
+ *
+ * The user name will be used for the password if it is ommitted:
+ * <tt>/FTP/user@@host/dir/file.txt</tt>.
+ *
+ * For the data transfer passive (= default) and active (= fallback) mode are
+ * supported.
+ *
+ * @{
+ */
+
+/**
+ * @brief Well-known port number for FTP control connection.
+ */
+#define RTEMS_FTPFS_CTRL_PORT 21
+
+/**
+ * @brief Default mount point for FTP file system.
+ */
+#define RTEMS_FTPFS_MOUNT_POINT_DEFAULT "/FTP"
+
+/**
+ * @brief FTP file system IO control requests.
+ */
+typedef enum {
+ RTEMS_FTPFS_IOCTL_GET_VERBOSE = _IOR( 'd', 1, bool *),
+ RTEMS_FTPFS_IOCTL_SET_VERBOSE = _IOW( 'd', 1, bool *),
+ RTEMS_FTPFS_IOCTL_GET_TIMEOUT = _IOR( 'd', 2, struct timeval *),
+ RTEMS_FTPFS_IOCTL_SET_TIMEOUT = _IOW( 'd', 2, struct timeval *)
+} rtems_ftpfs_ioctl_numbers;
+
+/**
+ * @brief Returns in @a verbose if the verbose mode is enabled or disabled for
+ * the file system at @a mount_point.
+ *
+ * If @a mount_point is @c NULL the default mount point
+ * @ref RTEMS_FTPFS_MOUNT_POINT_DEFAULT will be used.
+ */
+rtems_status_code rtems_ftpfs_get_verbose( const char *mount_point, bool *verbose);
+
+/**
+ * @brief Enables or disables the verbose mode if @a verbose is @c true or
+ * @c false respectively for the file system at @a mount_point.
+ *
+ * In the enabled verbose mode the commands and replies of the FTP control
+ * connections will be printed to standard error.
+ *
+ * If @a mount_point is @c NULL the default mount point
+ * @ref RTEMS_FTPFS_MOUNT_POINT_DEFAULT will be used.
+ */
+rtems_status_code rtems_ftpfs_set_verbose( const char *mount_point, bool verbose);
+
+/**
+ * @brief Returns the current timeout value in @a timeout for the file system
+ * at @a mount_point.
+ *
+ * If @a mount_point is @c NULL the default mount point
+ * @ref RTEMS_FTPFS_MOUNT_POINT_DEFAULT will be used.
+ */
+rtems_status_code rtems_ftpfs_get_timeout(
+ const char *mount_point,
+ struct timeval *timeout
+);
+
+/**
+ * @brief Sets the timeout value to @a timeout for the file system at
+ * @a mount_point.
+ *
+ * The timeout value will be used during connection establishment of active
+ * data connections. It will be also used for send and receive operations on
+ * data and control connections.
+ *
+ * If @a mount_point is @c NULL the default mount point
+ * @ref RTEMS_FTPFS_MOUNT_POINT_DEFAULT will be used.
+ */
+rtems_status_code rtems_ftpfs_set_timeout(
+ const char *mount_point,
+ const struct timeval *timeout
+);
+
+/** @} */
+
+/**
+ * @brief Do not call directly, use mount().
+ */
+int rtems_ftpfs_initialize(
+ rtems_filesystem_mount_table_entry_t *mt_entry,
+ const void *data
+);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
More information about the vc
mailing list