bool ftp_connected(void)
{
#ifdef HAVE_LIBSSH
return (ftp->connected && (sock_connected(ftp->ctrl) || ftp->session));
#else
return (ftp->connected && sock_connected(ftp->ctrl));
#endif
}
sock_t sock_connect_wto(const char *hostname, const int port, const int timeout)
{
int sock;
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock == -1)
return -1;
if (timeout)
{
sock_set_blocking (sock, SOCK_NONBLOCK);
if (sock_try_connection (sock, hostname, port) < 0)
{
int ret = sock_connected (sock, timeout);
if (ret <= 0)
{
sock_close (sock);
return SOCK_ERROR;
}
}
sock_set_blocking(sock, SOCK_BLOCK);
}
else
{
if (sock_try_connection (sock, hostname, port) < 0)
{
sock_close (sock);
sock = SOCK_ERROR;
}
}
return sock;
}
void setup()
{
if(mode == Http)
{
req = initialReq;
initialReq = 0;
QByteArray jsonpCallback = initialJsonpCallback;
initialJsonpCallback.clear();
// don't need these things
initialLastPart.clear();
initialBody.clear();
requests.insert(req, new RequestItem(req, jsonpCallback, RequestItem::Connect));
connect(req, SIGNAL(bytesWritten(int)), SLOT(req_bytesWritten(int)));
connect(req, SIGNAL(error()), SLOT(req_error()));
}
else
{
connect(sock, SIGNAL(connected()), SLOT(sock_connected()));
connect(sock, SIGNAL(readyRead()), SLOT(sock_readyRead()));
connect(sock, SIGNAL(framesWritten(int, int)), SLOT(sock_framesWritten(int, int)));
connect(sock, SIGNAL(closed()), SLOT(sock_closed()));
connect(sock, SIGNAL(peerClosed()), SLOT(sock_peerClosed()));
connect(sock, SIGNAL(error()), SLOT(sock_error()));
}
}
ClientTest(const QString &_host, int _port, const QString &_proto, const QString &_authzid, const QString &_realm, const QString &_user, const QString &_pass, bool _no_authzid, bool _no_realm) :
host(_host),
proto(_proto),
authzid(_authzid),
realm(_realm),
user(_user),
pass(_pass),
port(_port),
no_authzid(_no_authzid),
no_realm(_no_realm),
sock_done(false),
waitCycles(0)
{
sock = new QTcpSocket(this);
connect(sock, SIGNAL(connected()), SLOT(sock_connected()));
connect(sock, SIGNAL(readyRead()), SLOT(sock_readyRead()));
connect(sock, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(sock_error(QAbstractSocket::SocketError)));
sasl = new QCA::SASL(this);
connect(sasl, SIGNAL(clientStarted(bool, const QByteArray &)), SLOT(sasl_clientFirstStep(bool, const QByteArray &)));
connect(sasl, SIGNAL(nextStep(const QByteArray &)), SLOT(sasl_nextStep(const QByteArray &)));
connect(sasl, SIGNAL(needParams(const QCA::SASL::Params &)), SLOT(sasl_needParams(const QCA::SASL::Params &)));
connect(sasl, SIGNAL(authenticated()), SLOT(sasl_authenticated()));
connect(sasl, SIGNAL(readyRead()), SLOT(sasl_readyRead()));
connect(sasl, SIGNAL(readyReadOutgoing()), SLOT(sasl_readyReadOutgoing()));
connect(sasl, SIGNAL(error()), SLOT(sasl_error()));
}
void sock_copy(Socket *tosock, const Socket *fromsock)
{
memcpy(&tosock->remote_addr, &fromsock->remote_addr,
sizeof(tosock->remote_addr));
memcpy(&tosock->local_addr, &fromsock->local_addr,
sizeof(tosock->local_addr));
tosock->connected = sock_connected(fromsock);
}
HttpProxyPost::HttpProxyPost(QObject *parent)
:QObject(parent)
{
d = new Private(this);
connect(&d->sock, SIGNAL(connected()), SLOT(sock_connected()));
connect(&d->sock, SIGNAL(connectionClosed()), SLOT(sock_connectionClosed()));
connect(&d->sock, SIGNAL(readyRead()), SLOT(sock_readyRead()));
connect(&d->sock, SIGNAL(error(int)), SLOT(sock_error(int)));
reset(true);
}
void SocksClient::init()
{
d = new Private(this);
connect(&d->sock, SIGNAL(connected()), SLOT(sock_connected()));
connect(&d->sock, SIGNAL(connectionClosed()), SLOT(sock_connectionClosed()));
connect(&d->sock, SIGNAL(delayedCloseFinished()), SLOT(sock_delayedCloseFinished()));
connect(&d->sock, SIGNAL(readyRead()), SLOT(sock_readyRead()));
connect(&d->sock, SIGNAL(bytesWritten(qint64)), SLOT(sock_bytesWritten(qint64)));
connect(&d->sock, SIGNAL(error(int)), SLOT(sock_error(int)));
resetConnection(true);
}
HttpConnect::HttpConnect(QObject *parent)
:ByteStream(parent)
{
d = new Private(this);
connect(&d->sock, SIGNAL(connected()), SLOT(sock_connected()));
connect(&d->sock, SIGNAL(connectionClosed()), SLOT(sock_connectionClosed()));
connect(&d->sock, SIGNAL(delayedCloseFinished()), SLOT(sock_delayedCloseFinished()));
connect(&d->sock, SIGNAL(readyRead()), SLOT(sock_readyRead()));
connect(&d->sock, SIGNAL(bytesWritten(int)), SLOT(sock_bytesWritten(int)));
connect(&d->sock, SIGNAL(error(int)), SLOT(sock_error(int)));
reset(true);
}
sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, int timeout)
{
sock_t sock;
sock = sock_open (AF_INET, SOCK_STREAM, 0);
if (sock == SOCK_ERROR)
return SOCK_ERROR;
if (bnd)
{
struct sockaddr_in sa;
memset(&sa, 0, sizeof(sa));
sa.sin_family = AF_INET;
if (inet_aton (bnd, &sa.sin_addr) == 0 ||
bind (sock, (struct sockaddr *)&sa, sizeof(sa)) < 0)
{
sock_close (sock);
return SOCK_ERROR;
}
}
if (timeout)
{
sock_set_blocking (sock, 0);
if (sock_try_connection (sock, hostname, port) < 0)
{
int ret = sock_connected (sock, timeout);
if (ret <= 0)
{
sock_close (sock);
return SOCK_ERROR;
}
}
sock_set_blocking(sock, 1);
}
else
{
if (sock_try_connection (sock, hostname, port) < 0)
{
sock_close (sock);
sock = SOCK_ERROR;
}
}
return sock;
}
sock_t sock_connect_wto(const char *hostname, const int port, const int timeout)
{
int sock = SOCK_ERROR;
struct addrinfo *ai, *head, hints;
char service[8];
memset (&hints, 0, sizeof (hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
snprintf (service, sizeof (service), "%u", port);
if (getaddrinfo (hostname, service, &hints, &head))
return SOCK_ERROR;
ai = head;
while (ai)
{
if ((sock = socket (ai->ai_family, ai->ai_socktype, ai->ai_protocol)) > -1)
{
if (timeout)
{
sock_set_blocking (sock, SOCK_NONBLOCK);
if (connect (sock, ai->ai_addr, ai->ai_addrlen) < 0)
{
if (sock_connected (sock, timeout) > 0)
{
sock_set_blocking(sock, SOCK_BLOCK);
break;
}
}
}
else
{
if (connect (sock, ai->ai_addr, ai->ai_addrlen) == 0)
break;
}
sock_close (sock);
}
sock = SOCK_ERROR;
ai = ai->ai_next;
}
if (head) freeaddrinfo (head);
return sock;
}
/* reads reply
* returns 0 on success or -1 on error
*/
int ftp_read_reply(void)
{
char tmp[5]="xxx ";
int r;
ftp_set_signal(SIGALRM, reply_ALRM_handler);
if(ftp->reply_timeout)
alarm(ftp->reply_timeout);
sock_clearerr_in(ftp->ctrl);
r = ftp_gets();
if(!sock_connected(ftp->ctrl)) {
alarm(0);
ftp_set_signal(SIGALRM, SIG_DFL);
ftp_trace("sock is not connected\n");
return -1;
}
if(r == -1) {
alarm(0);
ftp_set_signal(SIGALRM, SIG_DFL);
ftp_trace("ftp_gets returned -1\n");
return -1;
}
ftp_print_reply();
if(ftp->reply[3] == '-') { /* multiline response */
strncpy(tmp, ftp->reply, 3);
do {
if(ftp_gets() == -1)
break;
ftp_print_reply();
} while(strncmp(tmp, ftp->reply, 4) != 0);
}
ftp->tmp_verbosity = vbUnset;
alarm(0);
ftp_set_signal(SIGALRM, SIG_DFL);
return r;
}
/* sends an FTP command on the control channel
* returns reply status code on success or -1 on error
*/
int ftp_cmd(const char *cmd, ...)
{
va_list ap;
int resp;
bool recon = false;
if(!sock_connected(ftp->ctrl)) {
ftp_err(_("No control connection\n"));
ftp->code = ctNone;
ftp->fullcode = -1;
return -1;
}
ftp_set_abort_handler();
ugly:
va_start(ap, cmd);
sock_krb_vprintf(ftp->ctrl, cmd, ap);
sock_printf(ftp->ctrl, "\r\n");
sock_flush(ftp->ctrl);
va_end(ap);
if(ferror(sock_sout(ftp->ctrl))) {
ftp_err(_("error writing command"));
ftp_err(" (");
va_start(ap, cmd);
vfprintf(stderr, cmd, ap);
va_end(ap);
va_start(ap, cmd);
ftp_vtrace(cmd, ap);
va_end(ap);
ftp_err(")\n");
ftp->code = ctNone;
ftp->fullcode = -1;
return -1;
}
va_start(ap, cmd);
ftp_print_cmd(cmd, ap);
va_end(ap);
resp = ftp_read_reply();
ftp_set_close_handler();
if(resp == 421) { /* server is closing control connection! */
ftp_err(_("Server closed control connection\n"));
if(gvAutoReconnect && ftp_loggedin() && strcasecmp(cmd, "QUIT") != 0) {
if(recon) {
ftp_err(_("Reconnect failed\n"));
} else {
ftp_err(_("Automatic reconnect...\n"));
ftp_reopen();
recon = true;
goto ugly;
}
} else {
/* ftp_close();*/
ftp->fullcode = 421;
ftp->code = 4;
return -1;
}
}
return resp;
}
/* reads one line from server into ftp->reply
* returns 0 on success or -1 on failure
*/
static int ftp_gets(void)
{
int c, i=0;
ftp->reply[0] = 0;
if(!sock_connected(ftp->ctrl)) {
ftp_err(_("No control connection\n"));
return -1;
}
while(true) {
c = sock_get(ftp->ctrl);
if(c == EOF) {
ftp_err(_("Server has closed control connection\n"));
ftp_close();
return -1;
}
else if(c == 255/*IAC*/) { /* handle telnet commands */
switch(c = sock_get(ftp->ctrl)) {
case 251/*WILL*/:
case 252/*WONT*/:
c = sock_get(ftp->ctrl);
sock_printf(ftp->ctrl, "%c%c%c", 255/*IAC*/, 254/*DONT*/, c);
sock_flush(ftp->ctrl);
break;
case 253/*DO*/:
case 254/*DONT*/:
c = sock_get(ftp->ctrl);
sock_printf(ftp->ctrl, "%c%c%c", 255/*IAC*/, 252/*WONT*/, c);
sock_flush(ftp->ctrl);
break;
default:
break;
}
continue;
}
else if(c == '\r') {
c = sock_get(ftp->ctrl);
if(c == 0)
c = '\r';
else if(c == '\n') {
ftp->reply[i++] = (char)c;
break;
} else if(c == EOF)
/* do nothing */ ;
else { /* telnet protocol violation, hmpf... */
sock_unget(ftp->ctrl, c);
continue;
}
}
else if(c == '\n')
break;
if(i < MAXREPLY)
ftp->reply[i++] = (char)c;
}
if(i >= MAXREPLY) {
ftp_err(_("Reply too long (truncated)\n"));
i = MAXREPLY;
}
ftp->reply[i] = '\0';
ftp->fullcode = atoi(ftp->reply);
#ifdef SECFTP
{
int r = 0;
switch(ftp->fullcode) { /* handle protected responses 6xx */
case 631:
r = sec_read_msg(ftp->reply, prot_safe);
break;
case 632:
r = sec_read_msg(ftp->reply, prot_private);
break;
case 633:
r = sec_read_msg(ftp->reply, prot_confidential);
break;
}
if(r == -1) {
ftp->fullcode = 0;
ftp->code = vbNone;
return 0;
} else
ftp->fullcode = atoi(ftp->reply);
}
#endif
strip_trailing_chars(ftp->reply, "\n\r");
ftp->code = ftp->fullcode / 100;
return ftp->fullcode;
}
int ftp_open_url(url_t *urlp, bool reset_vars)
{
bool use_proxy;
int i;
if(reset_vars)
ftp_reset_vars();
/* don't assume server is in ascii mode initially even if RFC says so */
ftp->prev_type = '?';
#ifdef HAVE_POSIX_SIGSETJMP
if(sigsetjmp(open_timeout_jmp, 1))
#else
if(setjmp(open_timeout_jmp))
#endif
{
ftp_close();
ftp_err(_("Connection timeout after %u seconds\n"),
ftp->open_timeout);
return 1;
}
ftp_set_signal(SIGALRM, ftp_open_handler);
alarm(ftp->open_timeout);
use_proxy = (proxy_type(urlp) != 0);
ftp_err(_("Looking up %s... "),
use_proxy ? gvProxyUrl->hostname : urlp->hostname);
/* Set the default port (22) for SSH if no port is specified. We
* need to do this here, 'cause host_lookup() sets it to 21
* (default port for vanilla FTP)
*/
if(urlp->protocol) {
if(strcmp(urlp->protocol, "sftp") == 0)
url_setprotocol(urlp, "ssh");
if(strcmp(urlp->protocol, "ssh") == 0 && urlp->port == -1)
urlp->port = 22; /* default SSH port */
}
ftp->host = host_create(use_proxy ? gvProxyUrl : urlp);
if(!host_lookup(ftp->host)) {
herror(host_getname(ftp->host));
alarm(0);
ftp_set_signal(SIGALRM, SIG_IGN);
return -1;
}
/* keep the value in urlp->port
urlp->port = ntohs(ftp->host->port);
and set it to 21 if it is -1 */
if(urlp->port == -1) {
urlp->port = 21;
}
fprintf(stderr, "\r ");
i = strlen(use_proxy ? gvProxyUrl->hostname : urlp->hostname);
while(i--)
fprintf(stderr, " ");
fprintf(stderr, "\r");
ftp_trace("\n");
#ifdef HAVE_LIBSSH
if(urlp->protocol && strcmp(urlp->protocol, "ssh") == 0) {
int ret = ssh_open_url(urlp);
alarm(0);
return ret;
}
#endif
if(urlp->protocol && strcmp(urlp->protocol, "ftp") != 0) {
ftp_err(_("Sorry, don't know how to handle your '%s' protocol\n"
"trying 'ftp' instead...\n"),
urlp->protocol);
url_setprotocol(urlp, 0);
}
if(use_proxy) {
ftp_err(_("Connecting to proxy %s at port %d...\n"),
host_getoname(ftp->host), urlp->port);
} else {
ftp_err(_("Connecting to %s at port %d...\n"),
host_getoname(ftp->host), urlp->port);
}
ftp->ctrl = sock_create();
if (ftp->ctrl == 0) {
ftp_err(_("Unable to create socket.\n"));
alarm(0);
ftp_set_signal(SIGALRM, SIG_IGN);
return -1;
}
if(!sock_connect_host(ftp->ctrl, ftp->host)) {
alarm(0);
ftp_set_signal(SIGALRM, SIG_IGN);
return -1;
}
sock_lowdelay(ftp->ctrl);
char* ip = host_getip(ftp->host);
ftp_err(_("Connected to %s ([%s]:%d).\n"),
host_getoname(ftp->host), ip, urlp->port);
free(ip);
/* read startup message from server */
ftp_set_tmp_verbosity(vbCommand);
ftp_read_reply();
if(ftp->fullcode == 120) {
ftp_set_tmp_verbosity(vbCommand);
ftp_read_reply();
}
alarm(0);
ftp_set_signal(SIGALRM, SIG_IGN);
if(!sock_connected(ftp->ctrl)) {
ftp_close();
return 1;
}
ftp->connected = (ftp->fullcode == 220);
if(ftp->connected) {
void (*tracefunq)(const char *fmt, ...);
url_destroy(ftp->url);
ftp->url = url_clone(urlp);
tracefunq = (ftp->verbosity == vbDebug ? ftp_err : ftp_trace);
char* remote_addr = printable_address(sock_remote_addr(ftp->ctrl)),
*local_addr = printable_address(sock_local_addr(ftp->ctrl));
tracefunq("remote address: %s\n", remote_addr);
tracefunq("local address: %s\n", local_addr);
free(remote_addr);
free(local_addr);
return 0;
} else {
ftp_close();
return 1;
}
}
/* issue a connect, but return after the timeout (seconds) is reached. If
* timeout is 0 or less then we will wait until the OS gives up on the connect
* The socket is returned
*/
sock_t sock_connect_wto_bind (const char *hostname, int port, const char *bnd, int timeout)
{
sock_t sock = SOCK_ERROR;
struct addrinfo *ai, *head, *b_head=NULL, hints;
char service[8];
memset (&hints, 0, sizeof (hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
snprintf (service, sizeof (service), "%u", port);
if (getaddrinfo (hostname, service, &hints, &head))
return SOCK_ERROR;
ai = head;
while (ai)
{
int type = ai->ai_socktype;
if ((sock = sock_open (ai->ai_family, type, ai->ai_protocol)) >= 0)
{
sock_set_cloexec (sock);
if (timeout > 0)
sock_set_blocking (sock, 0);
if (bnd)
{
struct addrinfo b_hints;
memset (&b_hints, 0, sizeof(b_hints));
b_hints.ai_family = ai->ai_family;
b_hints.ai_socktype = ai->ai_socktype;
b_hints.ai_protocol = ai->ai_protocol;
if (getaddrinfo (bnd, NULL, &b_hints, &b_head) ||
bind (sock, b_head->ai_addr, b_head->ai_addrlen) < 0)
{
sock_close (sock);
sock = SOCK_ERROR;
break;
}
}
if (connect (sock, ai->ai_addr, ai->ai_addrlen) == 0)
break;
/* loop as the connect maybe async */
while (sock != SOCK_ERROR)
{
if (sock_recoverable (sock_error()))
{
int connected = sock_connected (sock, timeout);
if (connected == 0) /* try again, interrupted */
continue;
if (connected == 1) /* connected */
{
if (timeout >= 0)
sock_set_blocking(sock, 1);
break;
}
}
sock_close (sock);
sock = SOCK_ERROR;
}
if (sock != SOCK_ERROR)
break;
}
ai = ai->ai_next;
}
if (b_head)
freeaddrinfo (b_head);
freeaddrinfo (head);
return sock;
}
