Attachment #220543 for bug #157005

Lines 1-2 Link Here

(-)oftpd-0.3.7.orig/src/Makefile.am (-1 / +1 lines)
1	bin_PROGRAMS = oftpd	1	bin_PROGRAMS = oftpd
2	oftpd_SOURCES = file_list.c file_list.h ftp_command.c ftp_command.h ftp_listener.c ftp_listener.h ftp_session.c ftp_session.h oftpd.c oftpd.h telnet_session.c telnet_session.h watchdog.c watchdog.h error.c error.h af_portability.h daemon_assert.c daemon_assert.h	2	oftpd_SOURCES = file_list.c file_list.h ftp_command.c ftp_command.h ftp_listener.c ftp_listener.h ftp_session.c ftp_session.h oftpd.c oftpd.h telnet_session.c telnet_session.h watchdog.c watchdog.h error.c error.h af_portability.h af_portability.c daemon_assert.c daemon_assert.h




#include <stdlib.h>
#include <netdb.h>
#include <netinet/in.h>

unsigned short int sockaddr_port(const struct sockaddr *sa, socklen_t salen)
{
#ifdef INET6
	char sbuf[NI_MAXSERV];
#endif
	unsigned short int port = 0; 

#ifdef INET6
	if (getnameinfo(sa, salen, NULL, 0, sbuf, sizeof(sbuf),
			NI_NUMERICSERV) == 0)
		port = atoi(sbuf);
	else
#endif
	        switch (sa->sa_family) {
		case AF_INET:
			port = ntohs(((struct sockaddr_in *)sa)->sin_port);
			break;
#ifdef INET6
		case AF_INET6:
			port = ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
			break;
#endif
		default: 
			/* everything went wrong :-P */
			exit(1);
		}
	return port;
}                                                                                                             

Lines 2-11 Link Here

(-)oftpd-0.3.7.orig/src/af_portability.h (-2 / +5 lines)
2	#define AF_PORTABILITY_H	2	#define AF_PORTABILITY_H
3		3
4	#include <netinet/in.h>	4	#include <netinet/in.h>
5	#include <sys/socket.h>
6		5
7	/* _x_ must be a pointer to a sockaddr structure */	6	/* _x_ must be a pointer to a sockaddr structure */
8		7	/*
9	#define SAFAM(_x_) (((struct sockaddr *)(_x_))->sa_family)	8	#define SAFAM(_x_) (((struct sockaddr *)(_x_))->sa_family)
10		9
11	#ifdef HAVE_NEW_SS_FAMILY	10	#ifdef HAVE_NEW_SS_FAMILY
Lines 26-31 Link Here
26	#define SINADDR(_x_) SIN4ADDR(_x_)	25	#define SINADDR(_x_) SIN4ADDR(_x_)
27	#define SINPORT(_x_) SIN4PORT(_x_)	26	#define SINPORT(_x_) SIN4PORT(_x_)
28	#endif	27	#endif
		28	*/
29		29
30	#ifndef INET_ADDRSTRLEN	30	#ifndef INET_ADDRSTRLEN
31	#define INET_ADDRSTRLEN 16	31	#define INET_ADDRSTRLEN 16
Lines 43-52 Link Here
43	#define IP_ADDRSTRLEN INET_ADDRSTRLEN	43	#define IP_ADDRSTRLEN INET_ADDRSTRLEN
44	#endif	44	#endif
45		45
		46	unsigned short int sockaddr_port(const struct sockaddr *sa, socklen_t salen);
		47	/*
46	#ifdef INET6	48	#ifdef INET6
47	typedef struct sockaddr_storage sockaddr_storage_t;	49	typedef struct sockaddr_storage sockaddr_storage_t;
48	#else	50	#else
49	typedef struct sockaddr_in sockaddr_storage_t;	51	typedef struct sockaddr_in sockaddr_storage_t;
50	#endif	52	#endif
		53	*/
51		54
52	#endif /* AF_PORTABILITY_H */	55	#endif /* AF_PORTABILITY_H */




/* Define if you have the <limits.h> header file.  */
#undef HAVE_LIMITS_H

/* Define if you have the <syslog.h> header file.  */
#undef HAVE_SYSLOG_H

/* Define if you have the <sys/time.h> header file.  */
#undef HAVE_SYS_TIME_H

/* Define if you have the <sys/types.h> header file.  */
#undef HAVE_SYS_TYPES_H

/* Define if you have the <syslog.h> header file.  */
#undef HAVE_SYSLOG_H

/* Define if you have the <unistd.h> header file.  */
#undef HAVE_UNISTD_H


Lines 23-28 Link Here

(-)oftpd-0.3.7.orig/src/error.c (+1 lines)
23	{	23	{
24	va_list args;	24	va_list args;
25		25
		26	fprintf(stderr, "error_init: %d %s", error_code, desc_fmt);
26	daemon_assert(err != NULL);	27	daemon_assert(err != NULL);
27	daemon_assert(error_code >= 0);	28	daemon_assert(error_code >= 0);
28	daemon_assert(desc_fmt != NULL);	29	daemon_assert(desc_fmt != NULL);




#include <arpa/inet.h>
#include <netdb.h>
#include "ftp_command.h"
#include "af_portability.h"
#include "daemon_assert.h"

/* argument types */

static const char *parse_host_port(struct sockaddr_in *addr, const char *s);
static const char *parse_number(int *num, const char *s, int max_num);
static const char *parse_offset(off_t *ofs, const char *s);
static const char *parse_host_port_long(struct sockaddr *sa, const char *s);
static const char *parse_host_port_ext(struct sockaddr *sa, const char *s); 

int ftp_command_parse(const char *input, ftp_command_t *cmd)
{

	    input++;

            /* parse the host & port information (if any) */
	    input = parse_host_port((struct sockaddr_in *)&tmp.arg[0].host_port, input);
	    if (input == NULL) {
	        return 0;
	    }

            input++;
 
            /* parse the host & port information (if any) */
            input = parse_host_port_long((struct sockaddr *)&tmp.arg[0].host_port, input);
            if (input == NULL) {
                return 0;
            }

            input++;
 
            /* parse the host & port information (if any) */
            input = parse_host_port_ext((struct sockaddr *)&tmp.arg[0].host_port, input);
            if (input == NULL) {
                return 0;
            }


/* note: returns success even for unknown address families */
/*       this is okay, as long as subsequent uses VERIFY THE FAMILY first */
static const char *parse_host_port_long(struct sockaddr *sa, const char *s)
{   
    int i;
    int family;


    /* okay, everything parses, load the address if possible */
    if (family == 4) {
        ((struct sockaddr_in *)sa)->sin_family = AF_INET;
	if (addr_len != sizeof(struct in_addr)) {
	    return NULL;
	}
	if (port_len != 2) {
	    return NULL;
	}	
	memcpy(&((struct sockaddr_in *)sa)->sin_addr, addr, addr_len);
	((struct sockaddr_in *)sa)->sin_port = htons((port[0] << 8) + port[1]);
    }
#ifdef INET6
    else if (family == 6) {
        ((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
	if (addr_len != sizeof(struct in6_addr)) {
	    return NULL;
	}
	if (port_len != 2) {
	    return NULL;
	}
	memcpy(&((struct sockaddr_in6 *)sa)->sin6_addr, addr, addr_len);
	((struct sockaddr_in6 *)sa)->sin6_port = htons((port[0] << 8) + port[1]);
    }
#endif
    else {
        sa->sa_family = -1;
    }

    /* return new pointer */
    return s;
}

static const char *parse_host_port_ext(struct sockaddr *sa, const char *s)
{ 
    int delimeter;
    int family;

        }
#endif /* HAVE_INET_ATON */

        ((struct sockaddr_in *)sa)->sin_addr = in_addr;
    }
#else
    {
        struct addrinfo hints, *res;
	struct *res;

	memset(&hints, 0, sizeof(hints));
	hints.ai_flags = AI_NUMERICHOST;

    }
#endif /* INET6 */

    sa->sa_family = family;
    if (family == AF_INET) {
    	((struct sockaddr_in *)sa)->sin_port = htons(port);
#ifdef INET6    
    } else if (family == AF_INET6) {
    	((struct sockaddr_in6 *)sa)->sin6_port = htons(port);
#endif /* INET6 */
    } else {
	/* we have an error! */
	return NULL;
    }

    /* return new pointer */
    return s;




#include <netinet/in.h>
#include <limits.h>
#include <sys/types.h>
#include "af_portability.h"

/* special macro for handling EPSV ALL requests */
#define EPSV_ALL (-1)

    int num_arg;
    union {
        char string[MAX_STRING_LEN+1];
#ifdef INET6
        struct sockaddr_storage host_port;
#else
	struct sockaddr_in host_port;
#endif
        int num;
	off_t offset;
    } arg[MAX_ARG];




#include "af_portability.h"



/* maximum number of consecutive errors in accept()
   before we terminate listener                     */
#define MAX_ACCEPT_ERROR 10

/* prototypes */
static int invariant(const ftp_listener_t *f);
static void *connection_acceptor(ftp_listener_t *f);
static void addr_to_string(const struct sockaddr *s, char *addr);
static void *connection_handler(connection_info_t *info);
static void connection_handler_cleanup(connection_info_t *info);


                      int inactivity_timeout,
                      error_t *err)
{
#ifdef INET6
    struct sockaddr_storage sock_addr;
    int gai_err;
    struct addrinfo hints;
    struct addrinfo *res;
    char buf[ADDR_BUF_LEN+1];
    int ret;
#else 
    struct sockaddr_in sock_addr;
    char *addr_str;
#endif
    int fd;
    int flags;
    int pipefds[2];
    int reuseaddr;
    char dir[PATH_MAX+1];
    char buf[ADDR_BUF_LEN+1];
    const char *inet_ntop_ret;

    daemon_assert(f != NULL);
    daemon_assert(port >= 0);

    }

    /* set up our socket address */
    memset(&sock_addr, 0, sizeof(sock_addr));

    if (address == NULL) {
#ifdef INET6
    memset(&hints, 0, sizeof(hints));
	 
    /* with AF_UNSPEC we can handle even hostnames */
    hints.ai_family    = (address == NULL ? AF_INET6 : AF_UNSPEC);
    hints.ai_flags     = AI_PASSIVE;
    hints.ai_socktype  = SOCK_STREAM;

    gai_err = getaddrinfo(address, "21", &hints, &res);							        
    if (gai_err != 0) {
	if (gai_err < 0) gai_err = -gai_err;
        error_init(err, gai_err, "error parsing server socket address; %s",
		gai_strerror(gai_err));
	return 0;
    }
	
    memcpy(&sock_addr, res->ai_addr, res->ai_addrlen);
    freeaddrinfo(res);
#else
    if (address == NULL) {
        sock_addr.sin_family = AF_INET;
        sock_addr.sin_addr.s_addr = INADDR_ANY;
#endif
    } else {
	struct hostent *hp;
		
	hp = gethostbyname(address);
	if(hp == NULL) {
		error_init(err, h_errno, "error with gethostbyname");
		return 0;
	}
		
	assert(hp->h_length <= sizeof(sock_addr));
	memcpy(&sock_addr, hp->h_addr, hp->h_length);
    }
#endif
 * says it uses) but no corresponding function in libc.
 * -- Matthew Danish [3/20/2001]
 */

    /* setup non-default port */
    if (port != 0) {			        
	sa_family_t family = ((struct sockaddr *)&sock_addr)->sa_family;
	switch (family) {
#ifdef INET6
	case AF_INET6:
		((struct sockaddr_in6*)&sock_addr)->sin6_port = port;
		break;
#endif
	case AF_INET:
		((struct sockaddr_in*)&sock_addr)->sin_port = port;
		break;
	default:
		/* handle error */
		error_init(err, 1, "unknown adderess family");
		return 0;
	}
        }

        memcpy(&sock_addr, res->ai_addr, res->ai_addrlen);
        freeaddrinfo(res);
    } 

    if (port == 0) {
        SINPORT(&sock_addr) = htons(DEFAULT_FTP_PORT);
    } else {
        SINPORT(&sock_addr) = htons(port);
    }
	
#ifdef INET6
    ret = getnameinfo((struct sockaddr *)(&sock_addr), sizeof(sock_addr), buf, sizeof(buf), 
					NULL, 0, NI_NUMERICHOST);
    if (ret != 0) {
                              sizeof(buf));
    if (inet_ntop_ret == NULL) {
        error_init(err, errno, "error converting server address to ASCII; %s", 
                   strerror(errno));
        return 0;

    
    /* Put some information in syslog */
    syslog(LOG_INFO, "Binding interface '%s', port %d, max clients %d\n", buf, 
	sockaddr_port((struct sockaddr *)&sock_addr, sizeof(sock_addr)), max_connections);    
#else 
    /* this should be thread-safe, as glibc texinfo documentation states: 
     * 
     *     In multi-threaded programs each thread has an own
     *     statically-allocated buffer (for inet_ntoa).  But still 
     *     subsequent calls of `inet_ntoa' in the same thread will 
     *     overwrite the result of the last call.
     */
    addr_str = inet_ntoa(sock_addr.sin_addr);

    /* Put some information in syslog */
    syslog(LOG_INFO, "Binding interface '%s', port %d, max clients %d\n", 
        addr_str,sockaddr_port((struct sockaddr*)&sock_addr,sizeof(sock_addr)),
	max_connections);
#endif
    

    /* okay, finally do some socket manipulation */
    fd = socket(((struct sockaddr *)&sock_addr)->sa_family, SOCK_STREAM, 0);
    if (fd == -1) {
        error_init(err, errno, "error creating socket; %s", strerror(errno));
        return 0;

        return 0;
    }

    if (bind(fd, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0) 
             sizeof(struct sockaddr_in)) != 0) 
    {
        close(fd);
        error_init(err, errno, "error binding address; %s", strerror(errno));

    daemon_assert(invariant(f));
    daemon_assert(err != NULL);

    syslog(LOG_WARNING, "in ftp_listener_start\n");

    error_code = pthread_create(&thread_id, 
                                NULL, 
                                (void *(*)())connection_acceptor, 


    int fd;
    int tcp_nodelay;
#ifdef INET6
    struct sockaddr_storage client_addr;
    struct sockaddr_storage server_addr;
#else 
    struct sockaddr_in client_addr;
    struct sockaddr_in server_addr;
#endif
    unsigned addr_len;
    
    connection_info_t *info;


    daemon_assert(invariant(f));

    syslog(LOG_WARNING, "in connection_acceptor\n");
    
    if (!watchdog_init(&f->watchdog, f->inactivity_timeout, &err)) {
        syslog(LOG_ERR, "Error initializing watchdog thread; %s", 
            error_get_desc(&err));

         }

         /* otherwise accept our pending connection (if any) */
         addr_len = sizeof(client_addr);
         fd = accept(f->fd, (struct sockaddr *)&client_addr, &addr_len);
         if (fd >= 0) {
             
    	     syslog(LOG_WARNING, "in connection_acceptor loop\n");

             tcp_nodelay = 1;
             if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&tcp_nodelay,
                 sizeof(int)) != 0)

                 continue;
             }

             addr_len = sizeof(server_addr);
             if (getsockname(fd, (struct sockaddr *)&server_addr, 
                 &addr_len) == -1) 
             {


             telnet_session_init(&info->telnet_session, fd, fd);

             syslog(LOG_WARNING, "about to call ftp_session_init\n");

             if (!ftp_session_init(&info->ftp_session, 
                                   (struct sockaddr *)&client_addr, 
                                   (struct sockaddr *)&server_addr, 
                                   &info->telnet_session,  
                                   f->dir, 
                                   &err)) 


/* convert an address to a printable string */
/* NOT THREADSAFE - wrap with a mutex before calling! */
static char *addr2string(const struct sockaddr *s)
{
    static char addr[IP_ADDRSTRLEN+1];
    int error;


#ifdef INET6
    error = getnameinfo((struct sockaddr *)s, 
                         sizeof(struct sockaddr_storage),
                         addr, 
                         sizeof(addr), 
                         NULL,
                         0, 
                         NI_NUMERICHOST);
    if (error != 0) {
        syslog(LOG_WARNING, "getnameinfo error; %s", gai_strerror(error));
        ret_val = "Unknown IP";
    } else {
        ret_val = addr;

    int num_connections;
    char drop_reason[80];

    syslog(LOG_WARNING, "in connection_handler\n");
    /* for ease of use only */
    f = info->ftp_listener;


    pthread_mutex_lock(&f->mutex);
    num_connections = ++f->num_connections;
    syslog(LOG_INFO, "%s port %d connection", 
        addr2string((struct sockaddr *)&info->ftp_session.client_addr), 
        sockaddr_port((struct sockaddr *)&info->ftp_session.client_addr, 
	    sizeof(info->ftp_session.client_addr)));
    pthread_mutex_unlock(&f->mutex);

    /* handle the session */
    if (num_connections <= f->max_connections) {

        syslog(LOG_WARNING, "about to call ftp_session_run\n");
        ftp_session_run(&info->ftp_session, &info->watched);

    } else {

        pthread_mutex_lock(&f->mutex);
        syslog(LOG_WARNING, 
          "%s port %d exceeds max users (%d), dropping connection",
          addr2string((struct sockaddr *)&info->ftp_session.client_addr), 
          sockaddr_port((struct sockaddr *)&info->ftp_session.client_addr, 
	      sizeof(info->ftp_session.client_addr)),
          num_connections);
        pthread_mutex_unlock(&f->mutex);



    syslog(LOG_INFO, 
      "%s port %d disconnected", 
      addr2string((struct sockaddr *)&info->ftp_session.client_addr),
      sockaddr_port((struct sockaddr *)&info->ftp_session.client_addr, 
          sizeof(info->ftp_session.client_addr)));

    pthread_mutex_unlock(&f->mutex);





static void init_passive_port();
static int get_passive_port();
static int convert_newlines(char *dst, const char *src, int srclen);
static void get_addr_str(const struct sockaddr *s, char *buf, int bufsiz);
static void send_readme(const ftp_session_t *f, int code);
static void netscape_hack(int fd);
static void set_port(ftp_session_t *f, const struct sockaddr *host_port);
static int set_pasv(ftp_session_t *f, struct sockaddr *host_port);
static int ip_equal(const struct sockaddr *a, const struct sockaddr *b);
static void get_absolute_fname(char *fname, 
                               int fname_len,
                               const char *dir,



int ftp_session_init(ftp_session_t *f, 
                     const struct sockaddr *client_addr, 
                     const struct sockaddr *server_addr, 
                     telnet_session_t *t, 
                     const char *dir,
  	             error_t *err)

    daemon_assert(err != NULL);

#ifdef INET6
    /* if the control connection is on IPv6, we need to get an IPv4 address 
     * to bind the socket to */
    if (server_addr->sa_family == AF_INET6) {
	struct addrinfo hints;
	struct addrinfo *res;
	int errcode;

        memset(&hints, 0, sizeof(struct addrinfo));
        hints.ai_family = AF_INET;
	hints.ai_flags = AI_PASSIVE;
	hints.ai_socktype = SOCK_STREAM;
	
	if ((errcode = getaddrinfo(NULL, "21", &hints, &res)) != 0) {
	    error_init(err, 0, "unable to determine IPv4 address; %s",
	        gai_strerror(errcode));
	    return 0;
	}

        /* let's sanity check */
	daemon_assert(res != NULL);
	daemon_assert(sizeof(f->server_ipv4_addr) >= res->ai_addrlen);
        daemon_assert(res->ai_addr->sa_family == AF_INET);

        /* copy the result and free memory as necessary */
	memcpy(&f->server_ipv4_addr, res->ai_addr, res->ai_addrlen);
        freeaddrinfo(res);
    } else {
        f->server_ipv4_addr = *((struct sockaddr_in *)server_addr);
        f->server_ipv4_addr = *server_addr;
    }
#else
    f->server_ipv4_addr = *server_addr;
#endif

    f->session_active = 1;


    f->epsv_all_set = 0;

#ifdef INET6
    memcpy(&f->client_addr, client_addr, sizeof(struct sockaddr_in6));
    memcpy(&f->server_addr, server_addr, sizeof(struct sockaddr_in6));
    memcpy(&f->data_port,   client_addr, sizeof(struct sockaddr_in6));
#else
    memcpy(&f->client_addr, client_addr, sizeof(struct sockaddr_in));
    memcpy(&f->server_addr, server_addr, sizeof(struct sockaddr_in));
    memcpy(&f->data_port,   client_addr, sizeof(struct sockaddr_in));
#endif
    get_addr_str(client_addr, f->client_addr_str, sizeof(f->client_addr_str));

    f->server_addr = *server_addr;

    f->telnet_session = t;
    daemon_assert(strlen(dir) < sizeof(f->dir));
    strcpy(f->dir, dir);

    f->data_channel = DATA_PORT;
    f->data_port = *client_addr;
    f->server_fd = -1;

    daemon_assert(invariant(f));

            /* If the client specifies a port, verify that it is from the   */
	    /* host the client connected from.  This prevents a client from */
	    /* using the server to open connections to arbritrary hosts.    */
	    if (!ip_equal((struct sockaddr *)&f->client_addr, 
		    (struct sockaddr *)&f->data_port)) {
	        return 0;
	    }
	    if (f->server_fd != -1) {

}

#ifdef INET6
static void get_addr_str(const struct sockaddr *s, char *buf, int bufsiz)
{
    int port;
    int error;

     * number (which is 5 chars max), plus the '\0' character. */ 
    daemon_assert(bufsiz >= (INET_ADDRSTRLEN + 12));

    error = getnameinfo(s, sizeof(struct sockaddr_storage), buf, 
                bufsiz, NULL, 0, NI_NUMERICHOST);
    /* getnameinfo() should never fail when called with NI_NUMERICHOST */
    daemon_assert(error == 0);

    len = strlen(buf);
    daemon_assert(bufsiz >= len+12);
    snprintf(buf+len, bufsiz-len, " port %d", sockaddr_port((struct sockaddr *)s, sizeof(s)));
}
#else
static void get_addr_str(const struct sockaddr *s, char *buf, int bufsiz)
{
    unsigned int addr;
    int port;

     * number (which is 5 chars max), plus the '\0' character. */ 
    daemon_assert(bufsiz >= (INET_ADDRSTRLEN + 12));

    addr = ntohl(((struct sockaddr_in *)s)->sin_addr.s_addr);
    port = ntohs(((struct sockaddr_in *)s)->sin_port);
    snprintf(buf, bufsiz, "%d.%d.%d.%d port %d", 
        (addr >> 24) & 0xff, 
	(addr >> 16) & 0xff,

}

/* support for the various port setting functions */
static void set_port(ftp_session_t *f, const struct sockaddr *host_port)
{	
    daemon_assert(invariant(f));
    daemon_assert(host_port != NULL);

    if (f->epsv_all_set) {
        reply(f, 500, "After EPSV ALL, only EPSV allowed.");
    } else if (!ip_equal((struct sockaddr *)&f->client_addr, host_port)) {
        reply(f, 500, "Port must be on command channel IP.");
#ifdef INET6
    } else if (sockaddr_port(host_port, sizeof(struct sockaddr_storage))
	       < IPPORT_RESERVED) {
#else
    } else if (sockaddr_port(host_port, sizeof(struct sockaddr_in))
	       < IPPORT_RESERVED) {
#endif
        reply(f, 500, "Port may not be less than 1024, which is reserved.");
    } else {
        /* close any outstanding PASSIVE port */

        }

        f->data_channel = DATA_PORT;
#ifdef INET6
	memcpy(&f->data_port, host_port, sizeof(struct sockaddr_in6));
#else
	memcpy(&f->data_port, host_port, sizeof(struct sockaddr_in));
#endif
	reply(f, 200, "Command okay.");
    }


/* set IP and port for client to receive data on */
static void do_port(ftp_session_t *f, const ftp_command_t *cmd) 
{
#ifdef INET6
    const struct sockaddr_storage *host_port;
#else
    const struct sockaddr_in *host_port;
#endif

    daemon_assert(invariant(f));
    daemon_assert(cmd != NULL);
    daemon_assert(cmd->num_arg == 1);

    host_port = &cmd->arg[0].host_port;
    daemon_assert(((struct sockaddr *)host_port)->sa_family == AF_INET);

    set_port(f, (struct sockaddr *)host_port);

    daemon_assert(invariant(f));
}

/* set IP and port for client to receive data on, transport independent */
static void do_lprt(ftp_session_t *f, const ftp_command_t *cmd)  
{
#ifdef INET6
    const struct sockaddr_storage *host_port;
#else
    const struct sockaddr_in *host_port;
#endif
    struct sockaddr_in6 *tmp = (struct sockaddr_in6 *)host_port;

    daemon_assert(invariant(f));
    daemon_assert(cmd != NULL);

    host_port = &cmd->arg[0].host_port;

#ifdef INET6
    if ((((struct sockaddr *)host_port)->sa_family != AF_INET) && 
        (((struct sockaddr *)host_port)->sa_family != AF_INET6)) {
        reply(f, 521, "Only IPv4 and IPv6 supported, address families (4,6)");
    }
#else
    if (((struct sockaddr *)host_port)->sa_family != AF_INET) {
        reply(f, 521, "Only IPv4 supported, address family (4)");
    }
#endif

    /*
    syslog(LOG_WARNING, "host is %d:%d:%d:%d:%d:%d:%d:%d %d", 
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[0]),
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[1]),
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[2]),
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[3]),
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[4]),
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[5]),
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[6]),
	ntohs(((struct sockaddr_in6 *)host_port)->sin6_addr.s6_addr16[7]),
	sockaddr_port(host_port, sizeof(struct sockaddr_storage)));
    */

    set_port(f, (struct sockaddr *)host_port);

    daemon_assert(invariant(f));
}

/* requests.                                                         */
static void do_eprt(ftp_session_t *f, const ftp_command_t *cmd)  
{
#ifdef INET6
    const struct sockaddr_storage *host_port;
#else
    const struct sockaddr_in *host_port;
#endif

    daemon_assert(invariant(f));
    daemon_assert(cmd != NULL);

/* support for the various pasv setting functions */
/* returns the file descriptor of the bound port, or -1 on error */
/* note: the "host_port" parameter will be modified, having its port set */
static int set_pasv(ftp_session_t *f, struct sockaddr *bind_addr)
{
    int socket_fd;
    int port;
    sa_family_t family;

    daemon_assert(invariant(f));
    daemon_assert(bind_addr != NULL);

    family = ((struct sockaddr *)bind_addr)->sa_family;
    socket_fd = socket(family, SOCK_STREAM, 0);
    if (socket_fd == -1) {
        reply(f, 500, "Error creating server socket; %s.", strerror(errno));
	return -1;


    for (;;) {
        port = get_passive_port();
#ifdef INET6
	if (((struct sockaddr *)bind_addr)->sa_family == AF_INET6) {
	    ((struct sockaddr_in6 *)bind_addr)->sin6_port = htons(port);
	} else 
#endif
	    ((struct sockaddr_in *)bind_addr)->sin_port = htons(port);
	
	if (bind(socket_fd, (struct sockaddr *)bind_addr, 
#ifdef INET6
	    sizeof(struct sockaddr_storage)) == 0) 
#else 
	    sizeof(struct sockaddr_in)) == 0) 
#endif
	{
	    break;
	}

        goto exit_pasv;
    }

#ifdef INET6
    socket_fd = set_pasv(f, (struct sockaddr *)&f->server_ipv4_addr);
#else
    socket_fd = set_pasv(f, (struct sockaddr *)&f->server_addr);
#endif
    if (socket_fd == -1) {
        goto exit_pasv;
    }

    /* report port to client */
#ifdef INET6
    addr = ntohl(f->server_ipv4_addr.sin_addr.s_addr);
    port = ntohs(f->server_ipv4_addr.sin_port);
#else
    addr = ntohl(f->server_addr.sin_addr.s_addr);
    port = ntohs(f->server_addr.sin_port);
#endif
    reply(f, 227, "Entering Passive Mode (%d,%d,%d,%d,%d,%d).",
        addr >> 24, 
	(addr >> 16) & 0xff,

        goto exit_lpsv;
    }

    socket_fd = set_pasv(f, (struct sockaddr *)&f->server_addr);
    if (socket_fd == -1) {
        goto exit_lpsv;
    }

    /* report address and port to server */
#ifdef INET6
    if (((struct sockaddr *)&f->server_addr)->sa_family == AF_INET6) {
        a = (uint8_t *)&(((struct sockaddr_in6 *)&f->server_addr)->sin6_addr);
        p = (uint8_t *)&(((struct sockaddr_in6 *)&f->server_addr)->sin6_port);
	snprintf(addr, sizeof(addr),
	    "(6,16,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,2,%d,%d)",
	    a[0],  a[1],  a[2],  a[3],  a[4],  a[5],  a[6],  a[7],  a[8],

    } else 
#endif
    {
        a = (uint8_t *)&(((struct sockaddr_in *)&f->server_addr)->sin_addr);
        p = (uint8_t *)&(((struct sockaddr_in *)&f->server_addr)->sin_port);
	snprintf(addr, sizeof(addr), "(4,4,%d,%d,%d,%d,2,%d,%d)",
	    a[0], a[1], a[2], a[3], p[0], p[1]);    
    }

static void do_epsv(ftp_session_t *f, const ftp_command_t *cmd) 
{
    int socket_fd;
    struct sockaddr *addr;

    daemon_assert(invariant(f));
    daemon_assert(cmd != NULL);


    /* check our argument, if any,  and use the appropriate address */
    if (cmd->num_arg == 0) {
        addr = (struct sockaddr *)&f->server_addr;
    } else {
        switch (cmd->arg[0].num) {
	    /* EPSV_ALL is a special number indicating the server sent */
	    /* the command "EPSV ALL" - this is not a request to assign */
	    /* a new passive port, but rather to deny all future port */
	    /* assignment requests other than EPSV */

                f->epsv_all_set = 1;
		reply(f, 200, "EPSV ALL command successful.");
		goto exit_epsv;
#ifdef INET6
	    case 1:
	        addr = (struct sockaddr *)&f->server_ipv4_addr;
		break;
#ifdef INET6
	    case 2:
	        addr = (struct sockaddr *)&f->server_addr;
		break;
	    default:
	        reply(f, 522, "Only IPv4 and IPv6 supported, use (1,2)");
	        goto exit_epsv;
#else
	    case 1:
	        addr = (struct sockaddr *)&f->server_addr;
		break;
	    default:
	        reply(f, 522, "Only IPv4 supported, use (1)");
	        goto exit_epsv;


    /* report port to client */
    reply(f, 229, "Entering Extended Passive Mode (|||%d|)", 
        sockaddr_port((struct sockaddr *)&f->server_addr, 
		sizeof(f->server_addr)));

    /* close any outstanding PASSIVE port */
    if (f->data_channel == DATA_PASSIVE) {

static int open_connection(ftp_session_t *f)
{
    int socket_fd;
#ifdef INET6
    struct sockaddr_storage addr;
#else
    struct sockaddr_in addr;
#endif
    unsigned addr_len;
    sa_family_t family;

    daemon_assert((f->data_channel == DATA_PORT) || 
                  (f->data_channel == DATA_PASSIVE));

    if (f->data_channel == DATA_PORT) {
    	family = ((struct sockaddr *)&f->data_port)->sa_family;
        socket_fd = socket(family, SOCK_STREAM, 0);
	if (socket_fd == -1) {
	    reply(f, 425, "Error creating socket; %s.", strerror(errno));
	    return -1;
	}
	if (connect(socket_fd, (struct sockaddr *)&f->data_port, 
	    sizeof(f->data_port)) != 0)
	{
	    reply(f, 425, "Error connecting; %s.", strerror(errno));
	    close(socket_fd);
	    return -1;
	}
    } else {
	sa_family_t a, b;
        daemon_assert(f->data_channel == DATA_PASSIVE);

        addr_len = sizeof(addr);
        socket_fd = accept(f->server_fd, (struct sockaddr *)&addr, &addr_len);
	if (socket_fd == -1) {
	    reply(f, 425, "Error accepting connection; %s.", strerror(errno));

        /* in IPv6, the client can connect to a channel using a different */
	/* protocol - in that case, we'll just blindly let the connection */
	/* through, otherwise verify addresses match */
        a = ((struct sockaddr *)&addr)->sa_family;
	b = ((struct sockaddr *)&f->client_addr)->sa_family;

	if (a == b) {
	    if (a == AF_INET6) {
	        if (memcmp(&(((struct sockaddr_in6 *)&addr)->sin6_addr), 
		       &(((struct sockaddr_in6 *)&f->client_addr)->sin6_addr),
	               sizeof(struct in6_addr)))
	        {
	            reply(f, 425, 
	             "Error accepting connection; connection from invalid IP.");
	            close(socket_fd);
	            return -1;
                }
	    } else {
	        if (memcmp(&(((struct sockaddr_in *)&addr)->sin_addr), 
		       &(((struct sockaddr_in *)&f->client_addr)->sin_addr),
	               sizeof(struct in_addr)))
	        {
	            reply(f, 425, 
	             "Error accepting connection; connection from invalid IP.");
	            close(socket_fd);
	            return -1;
                }
	    }
	}
#else
	if (memcmp(&f->client_addr.sin_addr, 

    }
}

#ifdef INET6

/* compare two addresses to see if they contain the same IP address */
static int ip_equal(const struct sockaddr *a, const struct sockaddr *b)
{
    struct sockaddr *aa, *bb;
    
    daemon_assert(a != NULL);
    daemon_assert(b != NULL);
    daemon_assert((a->sa_family == AF_INET) || (a->sa_family == AF_INET6));
    daemon_assert((b->sa_family == AF_INET) || (b->sa_family == AF_INET6));
    
    aa = (struct sockaddr *)a;
    bb = (struct sockaddr *)b;
    
    /* we have to handle those --damned-- IPV4MAPPED addresses */
    if (aa->sa_family != bb->sa_family) {	    
    	if (a->sa_family == AF_INET6 && 
            IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)a)->sin6_addr)) {
	        aa = (struct sockaddr *)alloca(sizeof(struct sockaddr_in));
	        memset(aa, 0, sizeof(struct sockaddr_in));
	        ((struct sockaddr_in *)aa)->sin_addr.s_addr = 
	    	    ((struct sockaddr_in6 *)a)->sin6_addr.s6_addr32[3];
	        ((struct sockaddr_in *)aa)->sin_port = 
		    ((struct sockaddr_in6 *)a)->sin6_port;
        } else if (b->sa_family == AF_INET6 && 
            IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)b)->sin6_addr)) {
	        bb = (struct sockaddr *)alloca(sizeof(struct sockaddr_in));
	        memset(bb, 0, sizeof(struct sockaddr_in));
	        ((struct sockaddr_in *)bb)->sin_addr.s_addr = 
	    	    ((struct sockaddr_in6 *)b)->sin6_addr.s6_addr32[3];
	        ((struct sockaddr_in *)bb)->sin_port = 
		    ((struct sockaddr_in6 *)b)->sin6_port;
        } else {
            return 0;
	}
    }

    if (aa->sa_family == AF_INET6) {
    	if (memcmp(&((struct sockaddr_in6 *)aa)->sin6_addr, 
		   &((struct sockaddr_in6 *)bb)->sin6_addr, 
		   sizeof(struct sockaddr_in6)) != 0) return 0;
    } else { 
    	if (((struct sockaddr_in *)aa)->sin_addr.s_addr != 
	    ((struct sockaddr_in *)bb)->sin_addr.s_addr) return 0;
    }
    
    return 1;
}

#else 

static int ip_equal(const struct sockaddr *a, const struct sockaddr *b)
{
    daemon_assert(a != NULL);
    daemon_assert(b != NULL);
    daemon_assert(a->sa_family == AF_INET);
    daemon_assert(b->sa_family == AF_INET);

    if (((struct sockaddr_in *)aa)->sin_addr.s_addr != 
	((struct sockaddr_in *)bb)->sin_addr.s_addr) return 0;
    
    return 1;
}

#endif

Lines 12-18 Link Here

(-)oftpd-0.3.7.orig/src/ftp_session.h (-6 / +17 lines)
12	#include <netinet/in.h>	12	#include <netinet/in.h>
13	#include <sys/types.h>	13	#include <sys/types.h>
14	#include <limits.h>	14	#include <limits.h>
15	#include "af_portability.h"
16	#include "watchdog.h"	15	#include "watchdog.h"
17	#include "error.h"	16	#include "error.h"
18		17
Lines 54-65 Link Here
54	int epsv_all_set;	53	int epsv_all_set;
55		54
56	/* address of client */	55	/* address of client */
57	sockaddr_storage_t client_addr;	56	#ifdef INET6
		57	struct sockaddr_storage client_addr;
		58	#else
		59	struct sockaddr_in client_addr;
		60	#endif
58	char client_addr_str[ADDRPORT_STRLEN];	61	char client_addr_str[ADDRPORT_STRLEN];
59		62
60	/* address of server (including IPv4 version) */	63	/* address of server (including IPv4 version) */
61	sockaddr_storage_t server_addr;	64	#ifdef INET6
		65	struct sockaddr_storage server_addr;
62	struct sockaddr_in server_ipv4_addr;	66	struct sockaddr_in server_ipv4_addr;
		67	#else
		68	struct sockaddr_in server_addr;
		69	#endif
63		70
64	/* telnet session to encapsulate control channel logic */	71	/* telnet session to encapsulate control channel logic */
65	telnet_session_t *telnet_session;	72	telnet_session_t *telnet_session;
Lines 70-76 Link Here
70	/* data channel information, including type,	77	/* data channel information, including type,
71	and client address or server port depending on type */	78	and client address or server port depending on type */
72	int data_channel;	79	int data_channel;
73	sockaddr_storage_t data_port;	80	#ifdef INET6
		81	struct sockaddr_storage data_port;
		82	#else
		83	struct sockaddr_in data_port;
		84	#endif
74	int server_fd;	85	int server_fd;
75		86
76	/* watchdog to handle timeout */	87	/* watchdog to handle timeout */
Lines 78-85 Link Here
78	} ftp_session_t;	89	} ftp_session_t;
79		90
80	int ftp_session_init(ftp_session_t *f,	91	int ftp_session_init(ftp_session_t *f,
81	const sockaddr_storage_t *client_addr,	92	const struct sockaddr *client_addr,
82	const sockaddr_storage_t *server_addr,	93	const struct sockaddr *server_addr,
83	telnet_session_t *t,	94	telnet_session_t *t,
84	const char *dir,	95	const char *dir,
85	error_t *err);	96	error_t *err);

Lines 300-306 Link Here

(-)oftpd-0.3.7.orig/src/oftpd.c (-2 / +2 lines)
300		300
301		301
302	fork_ret = fork();	302	fork_ret = fork();
303	if (fork_ret == -1) {	303	if (fork_ret < 0) {
304	fprintf(stderr, "%s: error forking; %s\n", exe_name, strerror(errno));	304	fprintf(stderr, "%s: error forking; %s\n", exe_name, strerror(errno));
305	exit(1);	305	exit(1);
306	}	306	}
Lines 313-319 Link Here
313	exit(1);	313	exit(1);
314	}	314	}
315	fork_ret = fork();	315	fork_ret = fork();
316	if (fork_ret == -1) {	316	if (fork_ret < 0) {
317	fprintf(stderr, "%s: error forking; %s\n", exe_name, strerror(errno));	317	fprintf(stderr, "%s: error forking; %s\n", exe_name, strerror(errno));
318	exit(1);	318	exit(1);
319	}	319	}

Return to bug 157005

Lines 97-111 Link Here

(-)oftpd-0.3.7.orig/src/config.h.in (-3 / +3 lines)
97	/* Define if you have the <limits.h> header file. */	97	/* Define if you have the <limits.h> header file. */
98	#undef HAVE_LIMITS_H	98	#undef HAVE_LIMITS_H
99		99
		100	/* Define if you have the <syslog.h> header file. */
		101	#undef HAVE_SYSLOG_H
		102
100	/* Define if you have the <sys/time.h> header file. */	103	/* Define if you have the <sys/time.h> header file. */
101	#undef HAVE_SYS_TIME_H	104	#undef HAVE_SYS_TIME_H
102		105
103	/* Define if you have the <sys/types.h> header file. */	106	/* Define if you have the <sys/types.h> header file. */
104	#undef HAVE_SYS_TYPES_H	107	#undef HAVE_SYS_TYPES_H
105		108
106	/* Define if you have the <syslog.h> header file. */
107	#undef HAVE_SYSLOG_H
108
109	/* Define if you have the <unistd.h> header file. */	109	/* Define if you have the <unistd.h> header file. */
110	#undef HAVE_UNISTD_H	110	#undef HAVE_UNISTD_H
111		111

Lines 12-18 Link Here

(-)oftpd-0.3.7.orig/src/ftp_command.c (-21 / +28 lines)
12	#include <arpa/inet.h>	12	#include <arpa/inet.h>
13	#include <netdb.h>	13	#include <netdb.h>
14	#include "ftp_command.h"	14	#include "ftp_command.h"
15	#include "af_portability.h"
16	#include "daemon_assert.h"	15	#include "daemon_assert.h"
17		16
18	/* argument types */	17	/* argument types */
Lines 67-74 Link Here
67	static const char parse_host_port(struct sockaddr_in addr, const char *s);	66	static const char parse_host_port(struct sockaddr_in addr, const char *s);
68	static const char parse_number(int num, const char *s, int max_num);	67	static const char parse_number(int num, const char *s, int max_num);
69	static const char parse_offset(off_t ofs, const char *s);	68	static const char parse_offset(off_t ofs, const char *s);
70	static const char parse_host_port_long(sockaddr_storage_t sa, const char *s);	69	static const char parse_host_port_long(struct sockaddr sa, const char *s);
71	static const char parse_host_port_ext(sockaddr_storage_t sa, const char *s);	70	static const char parse_host_port_ext(struct sockaddr sa, const char *s);
72		71
73	int ftp_command_parse(const char input, ftp_command_t cmd)	72	int ftp_command_parse(const char input, ftp_command_t cmd)
74	{	73	{
Lines 137-143 Link Here
137	input++;	136	input++;
138		137
139	/* parse the host & port information (if any) */	138	/* parse the host & port information (if any) */
140	input = parse_host_port(&tmp.arg[0].host_port, input);	139	input = parse_host_port((struct sockaddr_in *)&tmp.arg[0].host_port, input);
141	if (input == NULL) {	140	if (input == NULL) {
142	return 0;	141	return 0;
143	}	142	}
Lines 151-157 Link Here
151	input++;	150	input++;
152		151
153	/* parse the host & port information (if any) */	152	/* parse the host & port information (if any) */
154	input = parse_host_port_long(&tmp.arg[0].host_port, input);	153	input = parse_host_port_long((struct sockaddr *)&tmp.arg[0].host_port, input);
155	if (input == NULL) {	154	if (input == NULL) {
156	return 0;	155	return 0;
157	}	156	}
Lines 165-171 Link Here
165	input++;	164	input++;
166		165
167	/* parse the host & port information (if any) */	166	/* parse the host & port information (if any) */
168	input = parse_host_port_ext(&tmp.arg[0].host_port, input);	167	input = parse_host_port_ext((struct sockaddr *)&tmp.arg[0].host_port, input);
169	if (input == NULL) {	168	if (input == NULL) {
170	return 0;	169	return 0;
171	}	170	}
Lines 378-384 Link Here
378		377
379	/* note: returns success even for unknown address families */	378	/* note: returns success even for unknown address families */
380	/* this is okay, as long as subsequent uses VERIFY THE FAMILY first */	379	/* this is okay, as long as subsequent uses VERIFY THE FAMILY first */
381	static const char parse_host_port_long(sockaddr_storage_t sa, const char *s)	380	static const char parse_host_port_long(struct sockaddr sa, const char *s)
382	{	381	{
383	int i;	382	int i;
384	int family;	383	int family;
Lines 441-478 Link Here
441		440
442	/* okay, everything parses, load the address if possible */	441	/* okay, everything parses, load the address if possible */
443	if (family == 4) {	442	if (family == 4) {
444	SAFAM(sa) = AF_INET;	443	((struct sockaddr_in *)sa)->sin_family = AF_INET;
445	if (addr_len != sizeof(struct in_addr)) {	444	if (addr_len != sizeof(struct in_addr)) {
446	return NULL;	445	return NULL;
447	}	446	}
448	if (port_len != 2) {	447	if (port_len != 2) {
449	return NULL;	448	return NULL;
450	}	449	}
451	memcpy(&SINADDR(sa), addr, addr_len);	450	memcpy(&((struct sockaddr_in *)sa)->sin_addr, addr, addr_len);
452	SINPORT(sa) = htons((port[0] << 8) + port[1]);	451	((struct sockaddr_in *)sa)->sin_port = htons((port[0] << 8) + port[1]);
453	}	452	}
454	#ifdef INET6	453	#ifdef INET6
455	else if (family == 6) {	454	else if (family == 6) {
456	SAFAM(sa) = AF_INET6;	455	((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
457	if (addr_len != sizeof(struct in6_addr)) {	456	if (addr_len != sizeof(struct in6_addr)) {
458	return NULL;	457	return NULL;
459	}	458	}
460	if (port_len != 2) {	459	if (port_len != 2) {
461	return NULL;	460	return NULL;
462	}	461	}
463	memcpy(&SIN6ADDR(sa), addr, addr_len);	462	memcpy(&((struct sockaddr_in6 *)sa)->sin6_addr, addr, addr_len);
464	SINPORT(sa) = htons((port[0] << 8) + port[1]);	463	((struct sockaddr_in6 *)sa)->sin6_port = htons((port[0] << 8) + port[1]);
465	}	464	}
466	#endif	465	#endif
467	else {	466	else {
468	SAFAM(sa) = -1;	467	sa->sa_family = -1;
469	}	468	}
470		469
471	/* return new pointer */	470	/* return new pointer */
472	return s;	471	return s;
473	}	472	}
474		473
475	static const char parse_host_port_ext(sockaddr_storage_t sa, const char *s)	474	static const char parse_host_port_ext(struct sockaddr sa, const char *s)
476	{	475	{
477	int delimeter;	476	int delimeter;
478	int family;	477	int family;
Lines 545-556 Link Here
545	}	544	}
546	#endif /* HAVE_INET_ATON */	545	#endif /* HAVE_INET_ATON */
547		546
548	SIN4ADDR(sa) = in_addr;	547	((struct sockaddr_in *)sa)->sin_addr = in_addr;
549	}	548	}
550	#else	549	#else
551	{	550	{
552	struct addrinfo hints;	551	struct addrinfo hints, *res;
553	struct *res;
554		552
555	memset(&hints, 0, sizeof(hints));	553	memset(&hints, 0, sizeof(hints));
556	hints.ai_flags = AI_NUMERICHOST;	554	hints.ai_flags = AI_NUMERICHOST;
Lines 566-573 Link Here
566	}	564	}
567	#endif /* INET6 */	565	#endif /* INET6 */
568		566
569	SAFAM(sa) = family;	567	sa->sa_family = family;
570	SINPORT(sa) = htons(port);	568	if (family == AF_INET) {
		569	((struct sockaddr_in *)sa)->sin_port = htons(port);
		570	#ifdef INET6
		571	} else if (family == AF_INET6) {
		572	((struct sockaddr_in6 *)sa)->sin6_port = htons(port);
		573	#endif /* INET6 */
		574	} else {
		575	/* we have an error! */
		576	return NULL;
		577	}
571		578
572	/* return new pointer */	579	/* return new pointer */
573	return s;	580	return s;

Line 0 Link Here

(-)oftpd-0.3.7.orig/src/af_portability.c (+32 lines)
	1	#include <stdlib.h>
	2	#include <netdb.h>
	3	#include <netinet/in.h>
	4
	5	unsigned short int sockaddr_port(const struct sockaddr *sa, socklen_t salen)
	6	{
	7	#ifdef INET6
	8	char sbuf[NI_MAXSERV];
	9	#endif
	10	unsigned short int port = 0;
	11
	12	#ifdef INET6
	13	if (getnameinfo(sa, salen, NULL, 0, sbuf, sizeof(sbuf),
	14	NI_NUMERICSERV) == 0)
	15	port = atoi(sbuf);
	16	else
	17	#endif
	18	switch (sa->sa_family) {
	19	case AF_INET:
	20	port = ntohs(((struct sockaddr_in *)sa)->sin_port);
	21	break;
	22	#ifdef INET6
	23	case AF_INET6:
	24	port = ntohs(((struct sockaddr_in6 *)sa)->sin6_port);
	25	break;
	26	#endif
	27	default:
	28	/* everything went wrong :-P */
	29	exit(1);
	30	}
	31	return port;
	32	}

Lines 34-40 Link Here

(-)oftpd-0.3.7.orig/src/ftp_command.h (-2 / +5 lines)
34	#include <netinet/in.h>	34	#include <netinet/in.h>
35	#include <limits.h>	35	#include <limits.h>
36	#include <sys/types.h>	36	#include <sys/types.h>
37	#include "af_portability.h"
38		37
39	/* special macro for handling EPSV ALL requests */	38	/* special macro for handling EPSV ALL requests */
40	#define EPSV_ALL (-1)	39	#define EPSV_ALL (-1)
Lines 50-56 Link Here
50	int num_arg;	49	int num_arg;
51	union {	50	union {
52	char string[MAX_STRING_LEN+1];	51	char string[MAX_STRING_LEN+1];
53	sockaddr_storage_t host_port;	52	#ifdef INET6
		53	struct sockaddr_storage host_port;
		54	#else
		55	struct sockaddr_in host_port;
		56	#endif
54	int num;	57	int num;
55	off_t offset;	58	off_t offset;
56	} arg[MAX_ARG];	59	} arg[MAX_ARG];

Lines 52-58 Link Here

(-)oftpd-0.3.7.orig/src/ftp_listener.c (-73 / +115 lines)
52	#include "af_portability.h"	52	#include "af_portability.h"
53		53
54		54
55
56	/* maximum number of consecutive errors in accept()	55	/* maximum number of consecutive errors in accept()
57	before we terminate listener */	56	before we terminate listener */
58	#define MAX_ACCEPT_ERROR 10	57	#define MAX_ACCEPT_ERROR 10
Lines 73-79 Link Here
73	/* prototypes */	72	/* prototypes */
74	static int invariant(const ftp_listener_t *f);	73	static int invariant(const ftp_listener_t *f);
75	static void connection_acceptor(ftp_listener_t f);	74	static void connection_acceptor(ftp_listener_t f);
76	static void addr_to_string(const sockaddr_storage_t s, char addr);	75	static void addr_to_string(const struct sockaddr s, char addr);
77	static void connection_handler(connection_info_t info);	76	static void connection_handler(connection_info_t info);
78	static void connection_handler_cleanup(connection_info_t *info);	77	static void connection_handler_cleanup(connection_info_t *info);
79		78
Lines 85-98 Link Here
85	int inactivity_timeout,	84	int inactivity_timeout,
86	error_t *err)	85	error_t *err)
87	{	86	{
88	sockaddr_storage_t sock_addr;	87	#ifdef INET6
		88	struct sockaddr_storage sock_addr;
		89	int gai_err;
		90	struct addrinfo hints;
		91	struct addrinfo *res;
		92	char buf[ADDR_BUF_LEN+1];
		93	int ret;
		94	#else
		95	struct sockaddr_in sock_addr;
		96	char *addr_str;
		97	#endif
89	int fd;	98	int fd;
90	int flags;	99	int flags;
91	int pipefds[2];	100	int pipefds[2];
92	int reuseaddr;	101	int reuseaddr;
93	char dir[PATH_MAX+1];	102	char dir[PATH_MAX+1];
94	char buf[ADDR_BUF_LEN+1];
95	const char *inet_ntop_ret;
96		103
97	daemon_assert(f != NULL);	104	daemon_assert(f != NULL);
98	daemon_assert(port >= 0);	105	daemon_assert(port >= 0);
Lines 108-171 Link Here
108	}	115	}
109		116
110	/* set up our socket address */	117	/* set up our socket address */
111	memset(&sock_addr, 0, sizeof(sockaddr_storage_t));	118	memset(&sock_addr, 0, sizeof(sock_addr));
112		119
113	if (address == NULL) {
114	#ifdef INET6	120	#ifdef INET6
115	SAFAM(&sock_addr) = AF_INET6;	121	memset(&hints, 0, sizeof(hints));
116	memcpy(&SIN6ADDR(&sock_addr), &in6addr_any, sizeof(struct in6_addr));	122
		123	/* with AF_UNSPEC we can handle even hostnames */
		124	hints.ai_family = (address == NULL ? AF_INET6 : AF_UNSPEC);
		125	hints.ai_flags = AI_PASSIVE;
		126	hints.ai_socktype = SOCK_STREAM;
		127
		128	gai_err = getaddrinfo(address, "21", &hints, &res);
		129	if (gai_err != 0) {
		130	if (gai_err < 0) gai_err = -gai_err;
		131	error_init(err, gai_err, "error parsing server socket address; %s",
		132	gai_strerror(gai_err));
		133	return 0;
		134	}
		135
		136	memcpy(&sock_addr, res->ai_addr, res->ai_addrlen);
		137	freeaddrinfo(res);
117	#else	138	#else
118	SAFAM(&sock_addr) = AF_INET;	139	if (address == NULL) {
		140	sock_addr.sin_family = AF_INET;
119	sock_addr.sin_addr.s_addr = INADDR_ANY;	141	sock_addr.sin_addr.s_addr = INADDR_ANY;
120	#endif
121	} else {	142	} else {
122	int gai_err;	143	struct hostent *hp;
123	struct addrinfo hints;	144
124	struct addrinfo *res;	145	hp = gethostbyname(address);
125		146	if(hp == NULL) {
126	memset(&hints, 0, sizeof(hints));	147	error_init(err, h_errno, "error with gethostbyname");
127		148	return 0;
128	/* - This code should be able to parse both IPv4 and IPv6 internet	149	}
129	* addresses and put them in the sock_addr variable.	150
130	* - Much neater now.	151	assert(hp->h_length <= sizeof(sock_addr));
131	* - Bug: Can't handle hostnames, only IP addresses. Not sure	152	memcpy(&sock_addr, hp->h_addr, hp->h_length);
132	* exactly why. But then again, I'm not sure exactly why	153	}
133	* there is a man page for getipnodebyname (which getaddrinfo	154	#endif
134	* says it uses) but no corresponding function in libc.
135	* -- Matthew Danish [3/20/2001]
136	*/
137		155
		156	/* setup non-default port */
		157	if (port != 0) {
		158	sa_family_t family = ((struct sockaddr *)&sock_addr)->sa_family;
		159	switch (family) {
138	#ifdef INET6	160	#ifdef INET6
139	hints.ai_family = AF_INET6;	161	case AF_INET6:
140	#else	162	((struct sockaddr_in6*)&sock_addr)->sin6_port = port;
141	hints.ai_family = AF_INET;	163	break;
142	#endif	164	#endif
143		165	case AF_INET:
144	hints.ai_flags = AI_PASSIVE;	166	((struct sockaddr_in*)&sock_addr)->sin_port = port;
145		167	break;
146	gai_err = getaddrinfo(address, NULL, &hints, &res);	168	default:
147	if (gai_err != 0) {	169	/* handle error */
148	error_init(err, gai_err, "error parsing server socket address; %s",	170	error_init(err, 1, "unknown adderess family");
149	gai_strerror(gai_err));	171	return 0;
150	return 0;	172	}
151	}
152
153	memcpy(&sock_addr, res->ai_addr, res->ai_addrlen);
154	freeaddrinfo(res);
155	}
156
157	if (port == 0) {
158	SINPORT(&sock_addr) = htons(DEFAULT_FTP_PORT);
159	} else {
160	SINPORT(&sock_addr) = htons(port);
161	}	173	}
162		174
163		175	#ifdef INET6
164	inet_ntop_ret = inet_ntop(SAFAM(&sock_addr),	176	ret = getnameinfo((struct sockaddr *)(&sock_addr), sizeof(sock_addr), buf, sizeof(buf),
165	(void *)&SINADDR(&sock_addr),	177	NULL, 0, NI_NUMERICHOST);
166	buf,	178	if (ret != 0) {
167	sizeof(buf));
168	if (inet_ntop_ret == NULL) {
169	error_init(err, errno, "error converting server address to ASCII; %s",	179	error_init(err, errno, "error converting server address to ASCII; %s",
170	strerror(errno));	180	strerror(errno));
171	return 0;	181	return 0;
Lines 173-183 Link Here
173		183
174	/* Put some information in syslog */	184	/* Put some information in syslog */
175	syslog(LOG_INFO, "Binding interface '%s', port %d, max clients %d\n", buf,	185	syslog(LOG_INFO, "Binding interface '%s', port %d, max clients %d\n", buf,
176	ntohs(SINPORT(&sock_addr)), max_connections);	186	sockaddr_port((struct sockaddr *)&sock_addr, sizeof(sock_addr)), max_connections);
		187	#else
		188	/* this should be thread-safe, as glibc texinfo documentation states:
		189	*
		190	* In multi-threaded programs each thread has an own
		191	* statically-allocated buffer (for inet_ntoa). But still
		192	* subsequent calls of `inet_ntoa' in the same thread will
		193	* overwrite the result of the last call.
		194	*/
		195	addr_str = inet_ntoa(sock_addr.sin_addr);
		196
		197	/* Put some information in syslog */
		198	syslog(LOG_INFO, "Binding interface '%s', port %d, max clients %d\n",
		199	addr_str,sockaddr_port((struct sockaddr*)&sock_addr,sizeof(sock_addr)),
		200	max_connections);
		201	#endif
177		202
178		203
179	/* okay, finally do some socket manipulation */	204	/* okay, finally do some socket manipulation */
180	fd = socket(AF_INET, SOCK_STREAM, 0);	205	fd = socket(((struct sockaddr *)&sock_addr)->sa_family, SOCK_STREAM, 0);
181	if (fd == -1) {	206	if (fd == -1) {
182	error_init(err, errno, "error creating socket; %s", strerror(errno));	207	error_init(err, errno, "error creating socket; %s", strerror(errno));
183	return 0;	208	return 0;
Lines 193-200 Link Here
193	return 0;	218	return 0;
194	}	219	}
195		220
196	if (bind(fd, (struct sockaddr *)&sock_addr,	221	if (bind(fd, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) != 0)
197	sizeof(struct sockaddr_in)) != 0)
198	{	222	{
199	close(fd);	223	close(fd);
200	error_init(err, errno, "error binding address; %s", strerror(errno));	224	error_init(err, errno, "error binding address; %s", strerror(errno));
Lines 261-266 Link Here
261	daemon_assert(invariant(f));	285	daemon_assert(invariant(f));
262	daemon_assert(err != NULL);	286	daemon_assert(err != NULL);
263		287
		288	syslog(LOG_WARNING, "in ftp_listener_start\n");
		289
264	error_code = pthread_create(&thread_id,	290	error_code = pthread_create(&thread_id,
265	NULL,	291	NULL,
266	(void ()())connection_acceptor,	292	(void ()())connection_acceptor,
Lines 320-327 Link Here
320		346
321	int fd;	347	int fd;
322	int tcp_nodelay;	348	int tcp_nodelay;
323	sockaddr_storage_t client_addr;	349	#ifdef INET6
324	sockaddr_storage_t server_addr;	350	struct sockaddr_storage client_addr;
		351	struct sockaddr_storage server_addr;
		352	#else
		353	struct sockaddr_in client_addr;
		354	struct sockaddr_in server_addr;
		355	#endif
325	unsigned addr_len;	356	unsigned addr_len;
326		357
327	connection_info_t *info;	358	connection_info_t *info;
Lines 332-337 Link Here
332		363
333	daemon_assert(invariant(f));	364	daemon_assert(invariant(f));
334		365
		366	syslog(LOG_WARNING, "in connection_acceptor\n");
		367
335	if (!watchdog_init(&f->watchdog, f->inactivity_timeout, &err)) {	368	if (!watchdog_init(&f->watchdog, f->inactivity_timeout, &err)) {
336	syslog(LOG_ERR, "Error initializing watchdog thread; %s",	369	syslog(LOG_ERR, "Error initializing watchdog thread; %s",
337	error_get_desc(&err));	370	error_get_desc(&err));
Lines 355-364 Link Here
355	}	388	}
356		389
357	/* otherwise accept our pending connection (if any) */	390	/* otherwise accept our pending connection (if any) */
358	addr_len = sizeof(sockaddr_storage_t);	391	addr_len = sizeof(client_addr);
359	fd = accept(f->fd, (struct sockaddr *)&client_addr, &addr_len);	392	fd = accept(f->fd, (struct sockaddr *)&client_addr, &addr_len);
360	if (fd >= 0) {	393	if (fd >= 0) {
361		394
		395	syslog(LOG_WARNING, "in connection_acceptor loop\n");
		396
362	tcp_nodelay = 1;	397	tcp_nodelay = 1;
363	if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&tcp_nodelay,	398	if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (void *)&tcp_nodelay,
364	sizeof(int)) != 0)	399	sizeof(int)) != 0)
Lines 370-376 Link Here
370	continue;	405	continue;
371	}	406	}
372		407
373	addr_len = sizeof(sockaddr_storage_t);	408	addr_len = sizeof(server_addr);
374	if (getsockname(fd, (struct sockaddr *)&server_addr,	409	if (getsockname(fd, (struct sockaddr *)&server_addr,
375	&addr_len) == -1)	410	&addr_len) == -1)
376	{	411	{
Lines 392-400 Link Here
392		427
393	telnet_session_init(&info->telnet_session, fd, fd);	428	telnet_session_init(&info->telnet_session, fd, fd);
394		429
		430	syslog(LOG_WARNING, "about to call ftp_session_init\n");
		431
395	if (!ftp_session_init(&info->ftp_session,	432	if (!ftp_session_init(&info->ftp_session,
396	&client_addr,	433	(struct sockaddr *)&client_addr,
397	&server_addr,	434	(struct sockaddr *)&server_addr,
398	&info->telnet_session,	435	&info->telnet_session,
399	f->dir,	436	f->dir,
400	&err))	437	&err))
Lines 444-450 Link Here
444		481
445	/* convert an address to a printable string */	482	/* convert an address to a printable string */
446	/* NOT THREADSAFE - wrap with a mutex before calling! */	483	/* NOT THREADSAFE - wrap with a mutex before calling! */
447	static char addr2string(const sockaddr_storage_t s)	484	static char addr2string(const struct sockaddr s)
448	{	485	{
449	static char addr[IP_ADDRSTRLEN+1];	486	static char addr[IP_ADDRSTRLEN+1];
450	int error;	487	int error;
Lines 454-467 Link Here
454		491
455	#ifdef INET6	492	#ifdef INET6
456	error = getnameinfo((struct sockaddr *)s,	493	error = getnameinfo((struct sockaddr *)s,
457	sizeof(sockaddr_storage_t),	494	sizeof(struct sockaddr_storage),
458	addr,	495	addr,
459	sizeof(addr),	496	sizeof(addr),
460	NULL,	497	NULL,
461	0,	498	0,
462	NI_NUMERICHOST);	499	NI_NUMERICHOST);
463	if (error != 0) {	500	if (error != 0) {
464	syslog(LOG_WARN, "getnameinfo error; %s", gai_strerror(error));	501	syslog(LOG_WARNING, "getnameinfo error; %s", gai_strerror(error));
465	ret_val = "Unknown IP";	502	ret_val = "Unknown IP";
466	} else {	503	} else {
467	ret_val = addr;	504	ret_val = addr;
Lines 480-485 Link Here
480	int num_connections;	517	int num_connections;
481	char drop_reason[80];	518	char drop_reason[80];
482		519
		520	syslog(LOG_WARNING, "in connection_handler\n");
483	/* for ease of use only */	521	/* for ease of use only */
484	f = info->ftp_listener;	522	f = info->ftp_listener;
485		523
Lines 497-509 Link Here
497	pthread_mutex_lock(&f->mutex);	535	pthread_mutex_lock(&f->mutex);
498	num_connections = ++f->num_connections;	536	num_connections = ++f->num_connections;
499	syslog(LOG_INFO, "%s port %d connection",	537	syslog(LOG_INFO, "%s port %d connection",
500	addr2string(&info->ftp_session.client_addr),	538	addr2string((struct sockaddr *)&info->ftp_session.client_addr),
501	ntohs(SINPORT(&info->ftp_session.client_addr)));	539	sockaddr_port((struct sockaddr *)&info->ftp_session.client_addr,
		540	sizeof(info->ftp_session.client_addr)));
502	pthread_mutex_unlock(&f->mutex);	541	pthread_mutex_unlock(&f->mutex);
503		542
504	/* handle the session */	543	/* handle the session */
505	if (num_connections <= f->max_connections) {	544	if (num_connections <= f->max_connections) {
506		545
		546	syslog(LOG_WARNING, "about to call ftp_session_run\n");
507	ftp_session_run(&info->ftp_session, &info->watched);	547	ftp_session_run(&info->ftp_session, &info->watched);
508		548
509	} else {	549	} else {
Lines 518-525 Link Here
518	pthread_mutex_lock(&f->mutex);	558	pthread_mutex_lock(&f->mutex);
519	syslog(LOG_WARNING,	559	syslog(LOG_WARNING,
520	"%s port %d exceeds max users (%d), dropping connection",	560	"%s port %d exceeds max users (%d), dropping connection",
521	addr2string(&info->ftp_session.client_addr),	561	addr2string((struct sockaddr *)&info->ftp_session.client_addr),
522	ntohs(SINPORT(&info->ftp_session.client_addr)),	562	sockaddr_port((struct sockaddr *)&info->ftp_session.client_addr,
		563	sizeof(info->ftp_session.client_addr)),
523	num_connections);	564	num_connections);
524	pthread_mutex_unlock(&f->mutex);	565	pthread_mutex_unlock(&f->mutex);
525		566
Lines 548-555 Link Here
548		589
549	syslog(LOG_INFO,	590	syslog(LOG_INFO,
550	"%s port %d disconnected",	591	"%s port %d disconnected",
551	addr2string(&info->ftp_session.client_addr),	592	addr2string((struct sockaddr *)&info->ftp_session.client_addr),
552	ntohs(SINPORT(&info->ftp_session.client_addr)));	593	sockaddr_port((struct sockaddr *)&info->ftp_session.client_addr,
		594	sizeof(info->ftp_session.client_addr)));
553		595
554	pthread_mutex_unlock(&f->mutex);	596	pthread_mutex_unlock(&f->mutex);
555		597