void TestQPrefProxy::test_oldPreferences()
{
auto proxy = qPrefProxy::instance();
proxy->set_proxy_type(2);
proxy->set_proxy_port(80);
proxy->set_proxy_auth(true);
proxy->set_proxy_host("localhost");
proxy->set_proxy_user("unknown");
proxy->set_proxy_pass("secret");
TEST(proxy->proxy_type(), 2);
TEST(proxy->proxy_port(), 80);
TEST(proxy->proxy_auth(), true);
TEST(proxy->proxy_host(), QStringLiteral("localhost"));
TEST(proxy->proxy_user(), QStringLiteral("unknown"));
TEST(proxy->proxy_pass(), QStringLiteral("secret"));
proxy->set_proxy_type(3);
proxy->set_proxy_port(8080);
proxy->set_proxy_auth(false);
proxy->set_proxy_host("127.0.0.1");
proxy->set_proxy_user("unknown_1");
proxy->set_proxy_pass("secret_1");
TEST(proxy->proxy_type(), 3);
TEST(proxy->proxy_port(), 8080);
TEST(proxy->proxy_auth(), false);
TEST(proxy->proxy_host(), QStringLiteral("127.0.0.1"));
TEST(proxy->proxy_user(), QStringLiteral("unknown_1"));
TEST(proxy->proxy_pass(), QStringLiteral("secret_1"));
}
void TestQPrefProxy::test_multiple()
{
// test multiple instances have the same information
prefs.proxy_port= 37;
auto tst_direct = new qPrefProxy;
prefs.proxy_type = 25;
auto tst = qPrefProxy::instance();
QCOMPARE(tst->proxy_port(), tst_direct->proxy_port());
QCOMPARE(tst->proxy_port(), 37);
QCOMPARE(tst->proxy_type(), tst_direct->proxy_type());
QCOMPARE(tst->proxy_type(), 25);
}
void TestQPrefProxy::test_struct_get()
{
// Test struct pref -> get func.
auto tst = qPrefProxy::instance();
prefs.proxy_auth = true;
prefs.proxy_host = copy_qstring("t1 host");
prefs.proxy_pass = copy_qstring("t1 pass");
prefs.proxy_port = 512;
prefs.proxy_type = 3;
prefs.proxy_user = copy_qstring("t1 user");
QCOMPARE(tst->proxy_auth(), true);
QCOMPARE(tst->proxy_host(), QString(prefs.proxy_host));
QCOMPARE(tst->proxy_pass(), QString(prefs.proxy_pass));
QCOMPARE(tst->proxy_port(), 512);
QCOMPARE(tst->proxy_type(), 3);
QCOMPARE(tst->proxy_user(), QString(prefs.proxy_user));
}
int ftp_login(const char *guessed_username, const char *anonpass)
{
int ptype, r;
static url_t *purl = 0;
if(!ftp_connected())
return 1;
if(!ftp->url)
return -1;
#ifdef HAVE_LIBSSH
if (ftp->session)
/* login authentication is performed by the ssh program */
return 0;
#endif
ptype = proxy_type(ftp->url);
if(purl) {
url_destroy(purl);
purl = 0;
}
if(ptype > 0)
purl = url_clone(gvProxyUrl);
r = get_username(ftp->url, guessed_username, false);
if(r != 0)
return r;
if(ptype > 1 && ptype < 7) {
r = get_username(purl, 0, true);
if(r != 0)
return r;
}
#ifdef SECFTP
ftp->sec_complete = false;
ftp->data_prot = prot_clear;
/* don't use secure stuff if anonymous
*/
if(!url_isanon(ftp->url)) {
list *mechlist;
/* request a protection level
*/
if(ftp->url->protlevel) {
if(sec_request_prot(ftp->url->protlevel) != 0)
ftp_err(_("Invalid protection level '%s'\n"),
ftp->url->protlevel);
}
/* get list of mechanisms to try
*/
mechlist = ftp->url->mech ? ftp->url->mech : gvDefaultMechanism;
if(mechlist) {
listitem *li = mechlist->first;
int ret = 0;
for(; li; li=li->next) {
const char *mech_name;
mech_name = secext_name((char *)li->data);
if(mech_name == 0) {
ftp_err(_("unknown mechanism '%s'\n"), (char *)li->data);
continue;
}
if(mech_unsupported(mech_name)) {
ftp_err(_("Yafc was not compiled with support for %s\n"),
mech_name);
continue;
}
ret = sec_login(host_getname(ftp->host), mech_name);
if(ret == -1) {
if(ftp->code == ctError
&& ftp->fullcode != 504 && ftp->fullcode != 534)
url_setmech(ftp->url, "none");
}
if(ret != 1)
break;
}
}
if(ftp->sec_complete)
ftp_err(_("Authentication successful.\n"));
else
ftp_err(_("*** Using plaintext username"
" and password ***\n"));
}
#endif
if(url_isanon(ftp->url))
fprintf(stderr, _("logging in anonymously...\n"));
ftp_set_tmp_verbosity(ftp->url->password ? vbError : vbCommand);
switch(ptype) {
case 0:
default:
ftp_cmd("USER %s", ftp->url->username);
break;
case 1:
ftp_cmd("USER %s@%s", ftp->url->username, ftp->url->hostname);
break;
case 2:
case 3:
case 4:
ftp_cmd("USER %s", purl->username);
if(ftp->code == ctContinue) {
r = get_password(purl, 0, true);
if(r != 0)
return 0;
ftp_cmd("PASS %s", purl->password);
/* FIXME: what reply code do we expect now? */
if(ftp->code < ctTransient) {
if(ptype == 2) {
ftp_cmd("USER %s@%s",
ftp->url->username, ftp->url->hostname);
} else {
if(ptype == 3)
ftp_cmd("SITE %s", purl->hostname);
else
ftp_cmd("OPEN %s", purl->hostname);
if(ftp->code < ctTransient)
ftp_cmd("USER %s", ftp->url->username);
}
}
}
break;
case 5:
ftp_cmd("USER %s@%s@%s",
ftp->url->username, purl->username, ftp->url->hostname);
break;
case 6:
ftp_cmd("USER %s@%s", purl->username, ftp->url->hostname);
if(ftp->code == ctContinue) {
r = get_password(purl, 0, true);
if(r != 0)
return 0;
ftp_cmd("PASS %s", purl->password);
if(ftp->code < ctTransient)
ftp_cmd("USER %s", ftp->url->username);
}
break;
case 7:
ftp_cmd("USER %s@%s:%i", ftp->url->username, ftp->url->hostname, ftp->url->port);
break;
}
if(ftp->code == ctContinue) {
ftp->loggedin = false;
r = get_password(ftp->url, anonpass, false);
if(r != 0)
return r;
if(ptype == 5) {
r = get_password(purl, 0, true);
if(r != 0) {
url_destroy(purl);
purl = 0;
return 0;
}
}
ftp_set_tmp_verbosity(vbCommand);
switch(ptype) {
default:
case 0:
case 1:
case 2:
case 3:
case 4:
case 6:
ftp_cmd("PASS %s", ftp->url->password);
break;
case 5:
ftp_cmd("PASS %s@%s", ftp->url->password, purl->password);
break;
}
}
url_destroy(purl);
purl = 0;
if(ftp->code > ctContinue) {
if(ftp->fullcode == 530 && ftp_loggedin()) {
/* this probable means '530 Already logged in' */
return 2;
}
ftp->loggedin = false;
return 1;
}
if(ftp->code == ctComplete) {
ftp->loggedin = true;
#ifdef SECFTP
/* we are logged in, now set the requested data protection level
* requested from the autologin information in the config file,
* if any, else uses default protection level 'clear', ie
* no protection on the data channel
*/
if(ftp->sec_complete) {
sec_set_protection_level();
fprintf(stderr, _("Data protection is %s\n"),
level_to_name(ftp->data_prot));
}
#endif
ftp->homedir = ftp_getcurdir();
ftp->curdir = xstrdup(ftp->homedir);
ftp->prevdir = xstrdup(ftp->homedir);
if(ftp->url->directory)
ftp_chdir(ftp->url->directory);
ftp_get_feat();
return 0;
}
if(ftp->code == ctTransient)
return 1;
return -1;
}
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;
}
}
