void ftp_destroy(Ftp *ftp)
{
if(!ftp)
return;
list_free(ftp->dirs_to_flush);
list_free(ftp->cache);
ftp->cache = ftp->dirs_to_flush = 0;
host_destroy(ftp->host);
sock_destroy(ftp->data);
sock_destroy(ftp->ctrl);
ftp->host = NULL;
ftp->data = ftp->ctrl = NULL;
url_destroy(ftp->url);
ftp->url = NULL;
free(ftp->homedir);
free(ftp->curdir);
free(ftp->prevdir);
list_free(ftp->taglist);
#ifdef SECFTP
sec_end();
#endif
free(ftp);
}
static void create_bookmark(const char *guessed_alias)
{
char *default_alias = 0;
char *prompt;
url_t *url;
listitem *li;
int a;
char *alias;
alias = xstrdup(guessed_alias);
while(true) {
if(!alias) {
default_alias = guess_alias(ftp->url);
if(default_alias)
asprintf(&prompt, "alias (%s): ", default_alias);
else
prompt = xstrdup("alias: ");
force_completion_type = cpBookmark;
alias = input_read_string(prompt);
free(prompt);
if(!alias || !*alias)
alias = default_alias;
else
free(default_alias);
}
url = url_clone(ftp->url);
url_setalias(url, alias);
free(alias);
alias = 0;
li = list_search(gvBookmarks, (listsearchfunc)urlcmp, url);
if(li) {
a = ask(ASKYES|ASKNO|ASKCANCEL, ASKYES,
_("a bookmark named '%s' already exists, overwrite?"),
url->alias ? url->alias : url->hostname);
if(a == ASKCANCEL) {
url_destroy(url);
return;
}
if(a == ASKYES)
break;
} else
break;
}
/* password is automatically saved if anonymous login */
if(!url_isanon(url) && url->password) {
a = ask(ASKYES|ASKNO, ASKNO, _("Save password?"));
if(a == ASKNO)
url_setpassword(url, 0);
}
create_the_bookmark(url);
printf(_("created bookmark %s\n"), url->alias);
}
void
url_resource_destroy(UrlResource *rsrc)
{
if( !rsrc )
return;
if(rsrc->url)
url_destroy(rsrc->url);
safe_free(rsrc->outfile);
free(rsrc);
}
int ftp_reopen(void)
{
if(ftp && ftp->url) {
url_t *u = url_clone(ftp->url);
int r;
url_setdirectory(u, ftp->curdir);
r = ftp_open_url(u, false);
if(r == 0) {
r = ftp_login(u->username, gvAnonPasswd);
} else
ftp_close();
url_destroy(u);
return r;
}
return -1;
}
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;
}
}
void ftp_reset_vars(void)
{
sock_destroy(ftp->data);
ftp->data = NULL;
sock_destroy(ftp->ctrl);
ftp->ctrl = NULL;
host_destroy(ftp->host);
ftp->host = NULL;
#ifdef HAVE_LIBSSH
if (ftp->session)
{
sftp_free(ftp->sftp_session);
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->sftp_session = NULL;
ftp->session = NULL;
}
#endif
url_destroy(ftp->url);
ftp->url = NULL;
ftp->connected = false;
ftp->loggedin = false;
ftp->has_mdtm_command = true;
ftp->has_size_command = true;
ftp->has_pasv_command = true;
ftp->has_stou_command = true;
ftp->has_site_chmod_command = true;
ftp->has_site_idle_command = true;
ftp->has_mlsd_command = true;
list_free(ftp->dirs_to_flush);
ftp->dirs_to_flush = list_new((listfunc)free);
list_free(ftp->cache);
ftp->cache = list_new((listfunc)rdir_destroy);
/* don't assume server is in ascii mode initially even if RFC says so */
ftp->prev_type = '?';
ftp->code = ctNone;
ftp->fullcode = 0;
ftp->reply_timeout = gvCommandTimeout;
free(ftp->last_mkpath);
ftp->last_mkpath = 0;
#ifdef SECFTP
sec_end();
ftp->request_data_prot = 0;
ftp->buffer_size = 0;
#endif
ftp->LIST_type = ltUnknown;
list_free(ftp->taglist);
ftp->taglist = list_new((listfunc)rfile_destroy);
}
int main(int argc, char* argv[])
{
if (argc != 2)
{
print_usage(argv[0]);
return EXIT_FAILURE;
}
URL url;
url_init(&url);
int error = url_from_string(&url, argv[1]);
if (error)
{
fprintf(stderr, "Could not sucessfully parse FTP url (error code: %d)\n", error);
url_destroy(&url);
return EXIT_FAILURE;
}
error = url_host_to_ip(&url);
if (error)
{
fprintf(stderr, "Could not get an IPv4 IP address from hostname %s (error code: %d)\n", url.host, error);
return EXIT_FAILURE;
}
FTP ftp;
error = ftp_connect(&ftp, url.ip, url.port ? url.port : 21);
if (error)
{
fprintf(stderr, "Could not connect to ftp at IP %s, port %d\n", url.ip, url.port ? url.port : 21);
return EXIT_FAILURE;
}
const char* user = strlen(url.user) ? url.user : "******";
const char* pass = strlen(url.password) ? url.password : "******";
error = ftp_login(&ftp, user, pass);
if (error)
{
fprintf(stderr, "Could not login with user %s and pass %s\n", user, pass);
return EXIT_FAILURE;
}
char path[1024] = "";
for (int i = 0; i < url.num_parts - 1; ++i) {
strcat(path, url.parts[i]);
strcat(path, "/");
}
if (path[0] != 0) {
error = ftp_cwd(&ftp, path);
if (error) {
perror("ftp_cwd");
return error;
}
}
error = ftp_pasv(&ftp);
if (error) {
perror("ftp_pasv");
return error;
}
const char* file_name = url.num_parts ? url.parts[url.num_parts - 1] : "";
error = ftp_retr(&ftp, file_name);
if (error) {
perror("ftp_retr");
return error;
}
error = ftp_download(&ftp, file_name);
if (error) {
perror("ftp_download");
return error;
}
error = ftp_disconnect(&ftp);
if (error) {
perror("ftp_disconnect");
return error;
}
url_destroy(&url);
return EXIT_SUCCESS;
}
int http_transfer(UrlResource *rsrc, libnet_callback notify)
{
FILE *out = NULL;
Url *u = NULL;
Url *proxy_url = NULL;
Url *redir_u = NULL;
char *request = NULL;
//char *raw_header = NULL;
HttpHeader *header = NULL;
//char *len_string = NULL;
//char *new_location = NULL;
char *tmp_string = NULL;
//char buf[BUFSIZE];
int sock = -1;
ssize_t bytes_read = 0;
int msg_code = 0;
int retval = 0;
int i;
char *buf = MALLOC(BUFSIZE);
if (!buf)
{
LIBNET_DEBUG("No enough memory!\n");
return 0;
}
/* make sure we haven't recursed too much */
if ( redirect_count > REDIRECT_MAX )
{
LIBNET_DEBUG("redirection max count exceeded (looping redirect?)");
redirect_count = 0;
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
/* make sure everything's initialized to something useful */
u = rsrc->url;
if ( !u->host )
{
LIBNET_DEBUG("no host specified");
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
/* fill in proxyness */
if ( !rsrc->proxy )
{
rsrc->proxy = get_proxy("HTTP_PROXY");
}
if (( NULL == rsrc->outfile ) && (NULL == rsrc->buffer))
{
if ( u->file )
rsrc->outfile = strdup(u->file);
else
rsrc->outfile = strdup("index.html");
}
if ( !u->path )
u->path = strdup("/");
if ( !u->file )
u->file = strdup(""); /* funny looking */
if ( !u->port )
u->port = 80;
rsrc->options |= default_opts;
/* send the request to either the proxy or the remote host */
if ( rsrc->proxy )
{
proxy_url = url_new();
url_init(proxy_url, rsrc->proxy);
if ( !proxy_url->port )
proxy_url->port = 80;
if ( !proxy_url->host )
{
LIBNET_DEBUG( "bad proxy `%s'", rsrc->proxy);
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
if ( proxy_url->username )
rsrc->proxy_username = strdup(proxy_url->username);
if ( proxy_url->password )
rsrc->proxy_password = strdup(proxy_url->password);
#ifdef LIB_W5300
sock = w5300_tcp_connect(proxy_url->host, proxy_url->port, rsrc->srcip, rsrc->srcport);
#else
sock = util_tcp_connect(proxy_url->host, proxy_url->port);
#endif
if (sock < 0)
{
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
safe_free(u->path);
safe_free(u->file);
u->path = strdup("");
u->file = strdup(u->full_url);
request = get_request(rsrc);
LIBNET_DEBUG("sending request:\n%s", request);
S_WRITE(sock, request, STRLEN(request));
FREE(request);
}
else /* no proxy */
{
#ifdef LIB_W5300
sock = w5300_tcp_connect(u->host, u->port, rsrc->srcip, rsrc->srcport);
#else
sock = util_tcp_connect(u->host, u->port);
#endif
if (sock < 0)
{
msg_code = -NET_ERR_CONNECT_FAILED;
goto cleanup;
}
request = get_request(rsrc);
LIBNET_DEBUG("sending request:\n%s", request);
S_WRITE(sock, request, STRLEN(request));
FREE(request);
}
if (rsrc->outfile)
{
if ((get_file_size(rsrc->outfile) > 0) && (rsrc->options & OPT_RESUME))
out = fopen(rsrc->outfile, "rb+");
else
out = fopen(rsrc->outfile, "wb");
if ( !out )
{
LIBNET_DEBUG( "opening %s: %s", rsrc->outfile, "");
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
/* check to see if it returned a HTTP 1.x response */
MEMSET(buf, '\0', 5);
#ifdef LIB_W5300
bytes_read = S_READ(sock, buf, BUFSIZE);
buf[bytes_read] = '\0';
LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf);
#else
bytes_read = S_READ(sock, buf, 8);
#endif
if ( bytes_read <= 0 )
{
msg_code = -NET_ERR_HTTP_SERVER_ERROR;
goto cleanup;
}
if ( ! (buf[0] == 'H' && buf[1] == 'T'
&& buf[2] == 'T' && buf[3] == 'P') )
{
if((rsrc->options & OPT_RESUME) && rsrc->outfile_offset)
{
LIBNET_DEBUG("server does not support resume!");
msg_code = -NET_ERR_OPERATION_NOT_PERMIT;
goto cleanup;
}
//fwrite(buf, bytes_read, 1,out);
}
else
{
/* skip the header */
#ifdef LIB_W5300
buf[bytes_read] = '\0';
#else
char *raw_header1 = NULL;
buf[bytes_read] = '\0';
raw_header1 = get_raw_header(sock);
strconcat2(buf, raw_header1, NULL);
FREE(raw_header1);
LIBNET_DEBUG("receive respond:(%d)\n%s", bytes_read, buf);
#endif
header = make_http_header(buf);
/* check for redirects */
tmp_string = get_header_value("location", header);
if (buf[9] == '3' && tmp_string )
{
#if 1 //diable redirec function
redir_u = url_new();
/* make sure we still send user/password along */
redir_u->username = safe_strdup(u->username);
redir_u->password = safe_strdup(u->password);
url_init(redir_u, tmp_string);
rsrc->url = redir_u;
redirect_count++;
//retval = transfer(rsrc, notify);
transfer((UINT32)rsrc, (UINT32)notify);
rsrc->url =u;
redirect_count--;
if(redirect_count<0) redirect_count=0;
if (redir_u)
{
url_destroy(redir_u);
FREE(redir_u);
}
#endif
FREE(tmp_string);
tmp_string = NULL;
//msg_code = -NET_ERR_OPERATION_NOT_PERMIT;//we can support redirect now, remove this line.
goto cleanup;
}
if (tmp_string)
{
FREE(tmp_string);
tmp_string = NULL;
}
if (buf[9] == '4' || buf[9] == '5')
{
for (i = 0; buf[i] && buf[i] != '\n'; i++);
buf[i] = '\0';
LIBNET_DEBUG("HTTP error from server: %s\n", buf);
if( buf[9] == '4' && buf[10] == '0' && buf[11] == '4')
msg_code = -NET_ERR_FILE_NOT_FOUND;
else
msg_code = -NET_ERR_HTTP_SERVER_ERROR;
goto cleanup;
}
tmp_string = get_header_value("content-length", header);
if (tmp_string)
{
rsrc->outfile_size = (off_t )ATOI(tmp_string);
FREE(tmp_string);
tmp_string = NULL;
if(rsrc->use_pecache ==0)
{
if ((rsrc->buffer) && (rsrc->buffer_len < rsrc->outfile_size))
{
LIBNET_DEBUG("the buffer length less than the file fize (%d < %d)\n", rsrc->buffer, (int)rsrc->outfile_size);
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
}
tmp_string = get_header_value("content-range", header);
if (tmp_string)
{
FREE(tmp_string);
tmp_string = NULL;
rsrc->outfile_size += rsrc->outfile_offset;
}
if ((!rsrc->outfile_size) &&
(rsrc->options & OPT_RESUME) &&
!(rsrc->options & OPT_NORESUME)
&& rsrc->outfile_offset )
{
LIBNET_DEBUG("unable to determine remote file size");
msg_code = -NET_ERR_FILE_SAVE_ERROR;
goto cleanup;
}
}
if(rsrc->use_pecache ==0)
retval = dump_data(rsrc, sock, out, notify);
else
retval = dump_data_to_pecache(rsrc, sock, out, notify);
cleanup:
free_http_header(header);
//if (raw_header)
// FREE(raw_header);
if (proxy_url)
{
url_destroy(proxy_url);
FREE(proxy_url);
}
if (sock >= 0)
{
S_CLOSE(sock);
}
if (out)
fclose(out);
if (buf)
{
FREE(buf);
}
#ifndef WIN32
if (rsrc->outfile)
fs_sync(rsrc->outfile);
#endif
if (msg_code < 0 && rsrc->running)
{
notify(NET_MSG_DOWNLOAD_FINISH, (UINT32)msg_code);
libnet_abort_url_read(TRUE);//to break url_open while loop //retval!=1 means transfer fail
}
return retval;
}
void auto_create_bookmark(void)
{
listitem *li;
int a;
bool auto_create, had_passwd = false;
bool update = false;
if(gvAutoBookmark == 0 && gvAutoBookmarkUpdate == 0)
return;
if(!ftp_loggedin() || gvSighupReceived)
return;
auto_create = (gvAutoBookmark == 1);
/* check if bookmark already exists */
li = list_search(gvBookmarks, (listsearchfunc)urlcmp, ftp->url);
if(li) {
if(!should_update_bookmark((url_t *)li->data))
return;
/* bookmark already exist, update it */
if(gvAutoBookmarkUpdate == 2) {
a = ask(ASKYES|ASKNO, ASKYES,
_("Do you want to update the bookmark for this site?"));
if(a == ASKNO)
return;
}
update = true;
auto_create = true;
had_passwd = (((url_t *)li->data)->password != 0);
}
if(gvAutoBookmark == 2 && !auto_create) {
a = ask(ASKYES|ASKNO, ASKYES,
_("Do you want to create a bookmark for this site?"));
if(a == ASKNO)
return;
create_bookmark(0);
} else { /* auto autobookmark... */
url_t* url = url_clone(ftp->url);
char* a = guess_alias(ftp->url);
url_setalias(url, a);
free(a);
li = list_search(gvBookmarks, (listsearchfunc)urlcmp, url);
if(li) {
/* bookmark already exist, overwrite it */
while(true) {
url_t *xurl = (url_t *)li->data;
if(xurl->alias && (strcmp(xurl->alias, url->alias) == 0)
&& (strcmp(xurl->hostname, url->hostname) != 0))
{
/* create a new version of the alias, since guessed alias
* already exists but for another host
*/
update = false;
char* par = strrchr(url->alias, '(');
int ver = 1;
if (par)
{
*par = 0;
ver = atoi(par + 1);
}
if (asprintf(&a, "%s(%d)", url->alias, ver + 1) == -1)
{
fprintf(stderr, _("Failed to allocate memory.\n"));
url_destroy(url);
return;
}
url_setalias(url, a);
free(a);
} else {
update = true;
had_passwd = (xurl->password != 0);
break;
}
li = list_search(gvBookmarks, (listsearchfunc)urlcmp, url);
if(li == 0)
break;
}
if(li) /* overwrite bookmark (ie, delete old and create a new) */
list_delitem(gvBookmarks, li);
if(!url_isanon(url) && gvAutoBookmarkSavePasswd == false
&& !had_passwd)
url_setpassword(url, 0);
} else {
if(!url_isanon(url) && gvAutoBookmarkSavePasswd == false)
url_setpassword(url, 0);
}
create_the_bookmark(url);
if(!gvAutoBookmarkSilent) {
if(update)
printf(_("updated bookmark %s\n"), url->alias);
else
printf(_("created bookmark %s\n"), url->alias);
}
}
}
int ssh_open_url(url_t* urlp)
{
ftp->session = ssh_new();
if (!ftp->session)
return -1;
/* set log level */
if (ftp_get_verbosity() == vbDebug)
{
int verbosity = SSH_LOG_PROTOCOL;
ssh_options_set(ftp->session, SSH_OPTIONS_LOG_VERBOSITY, &verbosity);
}
/* If we have ssh options from yafcrc, load them */
if (gvSSHOptions) {
args_t *args = args_create();
args_init(args, 0, NULL);
args_push_back(args, gvSSHOptions);
int argc = 0;
if (ssh_options_getopt(ftp->session, &argc, args->argv) != SSH_OK) {
ftp_err(_("Failed to load SSH options from yafcrc config (ssh_options = '%s')\n"), gvSSHOptions);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
args->argc = argc;
args_destroy(args);
}
/* set host name */
ssh_options_set(ftp->session, SSH_OPTIONS_HOST, urlp->hostname);
/* if we have port use that one */
if (urlp->port > 0)
ssh_options_set(ftp->session, SSH_OPTIONS_PORT, &urlp->port);
/* parse .ssh/config */
int r = ssh_options_parse_config(ftp->session, NULL);
if (r != SSH_OK)
{
ftp_err(_("Failed to parse ssh config: %s\n"), ssh_get_error(ftp->session));
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
/* if we have username use that one */
if (urlp->username)
ssh_options_set(ftp->session, SSH_OPTIONS_USER, urlp->username);
/* connect to server */
r = ssh_connect(ftp->session);
if (r != SSH_OK)
{
ftp_err(_("Couldn't initialise connection to server: %s\n"), ssh_get_error(ftp->session));
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
/* verify server */
if (verify_knownhost(ftp->session))
{
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
/* authenticate user */
r = test_several_auth_methods(ftp->session, urlp);
if (r != SSH_OK)
{
ftp_err(_("Authentication failed: %s\n"), ssh_get_error(ftp->session));
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
ftp->ssh_version = ssh_get_version(ftp->session);
if (!ftp->ssh_version) {
ftp_err(_("Couldn't initialise connection to server\n"));
return -1;
}
ftp->sftp_session = sftp_new(ftp->session);
if (!ftp->sftp_session)
{
ftp_err(_("Couldn't initialise ftp subsystem: %s\n"), ssh_get_error(ftp->session));
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return -1;
}
r = sftp_init(ftp->sftp_session);
if (r != SSH_OK)
{
ftp_err(_("Couldn't initialise ftp subsystem: %s\n"), ssh_get_error(ftp->sftp_session));
sftp_free(ftp->sftp_session);
ftp->sftp_session = NULL;
ssh_disconnect(ftp->session);
ssh_free(ftp->session);
ftp->session = NULL;
return r;
}
ftp->connected = true;
ftp->loggedin = true;
free(ftp->homedir);
ftp->homedir = ftp_getcurdir();
url_destroy(ftp->url);
ftp->url = url_clone(urlp);
free(ftp->curdir);
ftp->curdir = xstrdup(ftp->homedir);
free(ftp->prevdir);
ftp->prevdir = xstrdup(ftp->homedir);
if (ftp->url->directory)
ftp_chdir(ftp->url->directory);
ftp_get_feat();
return 0;
}
int ssh_open_url(url_t *urlp)
{
char *sftp = gvSFTPServerProgram;
char *s;
int r;
args_clear(ftp->ssh_args);
if(urlp->sftp_server)
sftp = urlp->sftp_server;
args_push_back(ftp->ssh_args, gvSSHProgram);
if(gvSSHOptions && strlen(gvSSHOptions))
args_push_back(ftp->ssh_args, gvSSHOptions);
args_push_back(ftp->ssh_args, urlp->hostname);
r = get_username(urlp, gvUsername, false);
if(r != 0)
return r;
if(urlp->username) {
args_push_back(ftp->ssh_args, "-l");
args_push_back(ftp->ssh_args, urlp->username);
} else {
/* we need a username, otherwise other functions will fail
*/
urlp->username = xstrdup(gvUsername);
}
if(urlp->port) {
char *p;
asprintf(&p, "%d", urlp->port);
args_push_back(ftp->ssh_args, "-p");
args_push_back(ftp->ssh_args, p);
free(p);
}
if(ftp_get_verbosity() == vbDebug)
args_push_back(ftp->ssh_args, "-v");
/* no subsystem if the server-spec contains a '/' */
if(sftp == 0 || strchr(sftp, '/') == 0)
args_push_back(ftp->ssh_args, "-s");
/* Otherwise finish up and return the arg array */
if(sftp != 0)
args_push_back(ftp->ssh_args, sftp);
else
args_push_back(ftp->ssh_args, "sftp");
s = args_cat2(ftp->ssh_args, 0);
ftp_trace("SSH args: %s\n", s);
if(ftp_get_verbosity() == vbDebug)
fprintf(stderr, "SSH args: %s\n", s);
free(s);
args_add_null(ftp->ssh_args);
if(ssh_connect(ftp->ssh_args->argv, &ftp->ssh_in, &ftp->ssh_out,
&ftp->ssh_pid) == -1)
{
return -1;
}
ftp->ssh_version = ssh_init();
if(ftp->ssh_version == -1) {
ftp_err("Couldn't initialise connection to server\n");
return -1;
}
ftp->connected = true;
ftp->loggedin = true;
ftp->homedir = ftp_getcurdir();
url_destroy(ftp->url);
ftp->url = url_clone(urlp);
ftp->curdir = xstrdup(ftp->homedir);
ftp->prevdir = xstrdup(ftp->homedir);
if(ftp->url->directory)
ftp_chdir(ftp->url->directory);
ftp_get_feat();
return 0;
}
