Ma/mscp
1
0
Fork 0
mirror of https://github.com/upa/mscp.git synced 2026-02-14 00:54:43 +08:00
Code Issues Packages Projects Releases 1 Wiki Activity

change indent from space to tab

Browse Source
This commit is contained in:
Ryo Nakamura
2022-10-29 23:48:50 +09:00
parent ff697aa514
commit c76fa3141d
9 changed files with 1200 additions and 1200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/atomic.h
View File

@@ -9,12 +9,12 @@ typedef int refcnt;
static inline void refcnt_inc(refcnt *cnt)
{
__sync_add_and_fetch(cnt, 1);
__sync_add_and_fetch(cnt, 1);
}
static inline refcnt refcnt_dec(refcnt *cnt)
{
return __sync_sub_and_fetch(cnt, 1);
return __sync_sub_and_fetch(cnt, 1);
}
@@ -22,37 +22,37 @@ typedef pthread_mutex_t lock;
static inline void lock_init(lock *l)
{
pthread_mutex_init(l, NULL);
pthread_mutex_init(l, NULL);
}
static inline void lock_acquire(lock *l)
{
int ret = pthread_mutex_lock(l);
if (ret < 0) {
switch (ret) {
case EINVAL:
pr_err("invalid mutex\n");
exit(1);
case EDEADLK:
pr_err("a deadlock would occur\n");
exit(1);
}
}
int ret = pthread_mutex_lock(l);
if (ret < 0) {
switch (ret) {
case EINVAL:
pr_err("invalid mutex\n");
exit(1);
case EDEADLK:
pr_err("a deadlock would occur\n");
exit(1);
}
}
}
static inline void lock_release(lock *l)
{
int ret = pthread_mutex_unlock(l);
if (ret < 0) {
switch (ret) {
case EINVAL:
pr_err("invalid mutex\n");
exit(1);
case EPERM:
pr_err("this thread does not hold this mutex\n");
exit(1);
}
}
int ret = pthread_mutex_unlock(l);
if (ret < 0) {
switch (ret) {
case EINVAL:
pr_err("invalid mutex\n");
exit(1);
case EPERM:
pr_err("this thread does not hold this mutex\n");
exit(1);
}
}
}
#endif /* _ATOMIC_H_ */

1088
src/file.c
View File

File diff suppressed because it is too large Load Diff

34
src/file.h
View File

@@ -10,18 +10,18 @@
#include <atomic.h>
struct file {
struct list_head list; /* sscp->file_list */
struct list_head list; /* sscp->file_list */
char path[PATH_MAX]; /* copy source path */
bool remote; /* source is remote */
size_t size; /* size of this file */
char path[PATH_MAX]; /* copy source path */
bool remote; /* source is remote */
size_t size; /* size of this file */
char dst_path[PATH_MAX]; /* copy destination path */
bool dst_remote; /* destination is remote */
char dst_path[PATH_MAX]; /* copy destination path */
bool dst_remote; /* destination is remote */
int state; /* destination file state */
lock lock; /* mutex to protect state */
refcnt refcnt; /* chunks referencing this file */
int state; /* destination file state */
lock lock; /* mutex to protect state */
refcnt refcnt; /* chunks referencing this file */
};
#define FILE_STATE_INIT 0
#define FILE_STATE_OPENED 1
@@ -51,26 +51,26 @@ struct file {
*/
struct chunk {
struct list_head list; /* sscp->chunk_list */
struct file *f;
size_t off; /* offset of this chunk on the file f */
size_t len; /* length of this chunk */
size_t done; /* copied bytes for this chunk by a thread */
struct list_head list; /* sscp->chunk_list */
struct file *f;
size_t off; /* offset of this chunk on the file f */
size_t len; /* length of this chunk */
size_t done; /* copied bytes for this chunk by a thread */
};
char *file_find_hostname(char *path);
bool file_has_hostname(char *path);
int file_fill(sftp_session sftp, struct list_head *file_list, char **src_array, int cnt,
char *dst);
char *dst);
int chunk_fill(struct list_head *file_list, struct list_head *chunk_list,
int nr_conn, int min_chunk_sz, int max_chunk_sz);
int nr_conn, int min_chunk_sz, int max_chunk_sz);
struct chunk *chunk_acquire(struct list_head *chunk_list);
int chunk_prepare(struct chunk *c, sftp_session sftp);
int chunk_copy(struct chunk *c, sftp_session sftp,
size_t sftp_buf_sz, size_t io_buf_sz, size_t *counter);
size_t sftp_buf_sz, size_t io_buf_sz, size_t *counter);
#ifdef DEBUG
void file_dump(struct list_head *file_list);

760
src/main.c
View File

@@ -22,28 +22,28 @@
/* XXX: need to investigate max buf size for sftp_read/sftp_write */
struct sscp {
char *host; /* remote host (and username) */
struct ssh_opts *opts; /* ssh parameters */
sftp_session ctrl; /* control sftp session */
char *host; /* remote host (and username) */
struct ssh_opts *opts; /* ssh parameters */
sftp_session ctrl; /* control sftp session */
struct list_head file_list;
struct list_head chunk_list; /* stack of chunks */
lock chunk_lock; /* lock for chunk list */
struct list_head file_list;
struct list_head chunk_list; /* stack of chunks */
lock chunk_lock; /* lock for chunk list */
char *target;
char *target;
int sftp_buf_sz, io_buf_sz;
int sftp_buf_sz, io_buf_sz;
struct timeval start; /* timestamp of starting copy */
struct timeval start; /* timestamp of starting copy */
};
struct sscp_thread {
struct sscp *sscp;
sftp_session sftp;
struct sscp *sscp;
sftp_session sftp;
pthread_t tid;
size_t done; /* copied bytes */
bool finished;
pthread_t tid;
size_t done; /* copied bytes */
bool finished;
};
void *sscp_copy_thread(void *arg);
@@ -55,175 +55,175 @@ int nr_threads;
void stop_copy_threads(int sig)
{
int n;
int n;
pr("stopping...\n");
for (n = 0; n < nr_threads; n++) {
pthread_cancel(threads[n].tid);
}
pr("stopping...\n");
for (n = 0; n < nr_threads; n++) {
pthread_cancel(threads[n].tid);
}
}
void usage(bool print_help) {
printf("sscp: super scp, copy files over multiple ssh connections\n"
"\n"
"Usage: sscp [CvqDdh] [-n nr_conns] [-s min_chunk_sz] [-S max_chunk_sz]\n"
" [-b sftp_buf_sz] [-B io_buf_sz]\n"
" [-l login_name] [-p port] [-i identity_file]\n"
" [-c cipher_spec] source ... target\n"
"\n");
if (!print_help)
return;
printf("sscp: super scp, copy files over multiple ssh connections\n"
"\n"
"Usage: sscp [CvqDdh] [-n nr_conns] [-s min_chunk_sz] [-S max_chunk_sz]\n"
" [-b sftp_buf_sz] [-B io_buf_sz]\n"
" [-l login_name] [-p port] [-i identity_file]\n"
" [-c cipher_spec] source ... target\n"
"\n");
printf(" -n NR_CONNECTIONS number of connections (default: half of # of cpu cores)\n"
" -s MIN_CHUNK_SIZE min chunk size (default: 64MB)\n"
" -S MAX_CHUNK_SIZE max chunk size (default: filesize / nr_conn)\n"
" -b SFTP_BUF_SIZE buf size for sftp_read/write (default 131072B)\n"
" -B IO_BUF_SIZE buf size for read/write (default 131072B)\n"
" Note that this value is derived from\n"
" qemu/block/ssh.c. need investigation...\n"
" -v increment verbose output level\n"
" -q disable output\n"
" -D dry run\n"
"\n"
" -l LOGIN_NAME login name\n"
" -p PORT port number\n"
" -i IDENTITY identity file for publickey authentication\n"
" -c CIPHER cipher spec, see `ssh -Q cipher`\n"
" -C enable compression on libssh\n"
" -d increment ssh debug output level\n"
" -h print this help\n"
"\n");
if (!print_help)
return;
printf(" -n NR_CONNECTIONS number of connections (default: half of # of cpu cores)\n"
" -s MIN_CHUNK_SIZE min chunk size (default: 64MB)\n"
" -S MAX_CHUNK_SIZE max chunk size (default: filesize / nr_conn)\n"
" -b SFTP_BUF_SIZE buf size for sftp_read/write (default 131072B)\n"
" -B IO_BUF_SIZE buf size for read/write (default 131072B)\n"
" Note that this value is derived from\n"
" qemu/block/ssh.c. need investigation...\n"
" -v increment verbose output level\n"
" -q disable output\n"
" -D dry run\n"
"\n"
" -l LOGIN_NAME login name\n"
" -p PORT port number\n"
" -i IDENTITY identity file for publickey authentication\n"
" -c CIPHER cipher spec, see `ssh -Q cipher`\n"
" -C enable compression on libssh\n"
" -d increment ssh debug output level\n"
" -h print this help\n"
"\n");
}
char *find_hostname(int ind, int argc, char **argv)
{
char *h, *hostnames[argc];
int n, cnt = 0;
char *h, *hostnames[argc];
int n, cnt = 0;
for (n = ind; n < argc; n++) {
h = file_find_hostname(argv[n]);
if (h)
hostnames[cnt++] = h;
}
for (n = ind; n < argc; n++) {
h = file_find_hostname(argv[n]);
if (h)
hostnames[cnt++] = h;
}
if (cnt == 0)
return NULL;
if (cnt == 0)
return NULL;
/* check all hostnames are identical */
for (n = 1; n < cnt; n++) {
int s1 = strlen(hostnames[n - 1]);
int s2 = strlen(hostnames[n]);
if (s1 != s2) {
pr_err("different hostnames: %s and %s\n",
hostnames[n - 1], hostnames[n]);
goto err_out;
}
if (strncmp(hostnames[n - 1], hostnames[n], s1) != 0) {
pr_err("different hostnames: %s and %s\n",
hostnames[n - 1], hostnames[n]);
goto err_out;
}
}
/* check all hostnames are identical */
for (n = 1; n < cnt; n++) {
int s1 = strlen(hostnames[n - 1]);
int s2 = strlen(hostnames[n]);
if (s1 != s2) {
pr_err("different hostnames: %s and %s\n",
hostnames[n - 1], hostnames[n]);
goto err_out;
}
if (strncmp(hostnames[n - 1], hostnames[n], s1) != 0) {
pr_err("different hostnames: %s and %s\n",
hostnames[n - 1], hostnames[n]);
goto err_out;
}
}
for (n = 1; n < cnt; n++) {
free(hostnames[n]);
}
for (n = 1; n < cnt; n++) {
free(hostnames[n]);
}
return hostnames[0];
return hostnames[0];
err_out:
for (n = 0; n < cnt; n++) {
free(hostnames[n]);
}
return NULL;
for (n = 0; n < cnt; n++) {
free(hostnames[n]);
}
return NULL;
}
int main(int argc, char **argv)
{
struct sscp sscp;
struct sscp sscp;
struct ssh_opts opts;
int min_chunk_sz = DEFAULT_MIN_CHUNK_SZ;
int max_chunk_sz = 0;
int verbose = 1;
bool dryrun = false;
int ret = 0, n;
char ch;
int min_chunk_sz = DEFAULT_MIN_CHUNK_SZ;
int max_chunk_sz = 0;
int verbose = 1;
bool dryrun = false;
int ret = 0, n;
char ch;
memset(&opts, 0, sizeof(opts));
memset(&sscp, 0, sizeof(sscp));
INIT_LIST_HEAD(&sscp.file_list);
INIT_LIST_HEAD(&sscp.chunk_list);
lock_init(&sscp.chunk_lock);
sscp.sftp_buf_sz = DEFAULT_SFTP_BUF_SZ;
sscp.io_buf_sz = DEFAULT_IO_BUF_SZ;
memset(&opts, 0, sizeof(opts));
memset(&sscp, 0, sizeof(sscp));
INIT_LIST_HEAD(&sscp.file_list);
INIT_LIST_HEAD(&sscp.chunk_list);
lock_init(&sscp.chunk_lock);
sscp.sftp_buf_sz = DEFAULT_SFTP_BUF_SZ;
sscp.io_buf_sz = DEFAULT_IO_BUF_SZ;
nr_threads = (int)(nr_cpus() / 2);
nr_threads = nr_threads == 0 ? 1 : nr_threads;
nr_threads = (int)(nr_cpus() / 2);
nr_threads = nr_threads == 0 ? 1 : nr_threads;
while ((ch = getopt(argc, argv, "n:s:S:b:B:vqDl:p:i:c:Cdh")) != -1) {
switch (ch) {
case 'n':
nr_threads = atoi(optarg);
if (nr_threads < 1) {
pr_err("invalid number of connections: %s\n", optarg);
return 1;
}
break;
case 's':
min_chunk_sz = atoi(optarg);
if (min_chunk_sz < getpagesize()) {
pr_err("min chunk size must be "
"larger than or equal to %d: %s\n",
getpagesize(), optarg);
return 1;
}
if (min_chunk_sz % getpagesize() != 0) {
pr_err("min chunk size must be "
"multiple of page size %d: %s\n",
getpagesize(), optarg);
return -1;
}
break;
case 'S':
max_chunk_sz = atoi(optarg);
if (max_chunk_sz < getpagesize()) {
pr_err("max chunk size must be "
"larger than or equal to %d: %s\n",
getpagesize(), optarg);
return 1;
}
if (max_chunk_sz % getpagesize() != 0) {
pr_err("max chunk size must be "
"multiple of page size %d: %s\n",
getpagesize(), optarg);
return -1;
}
break;
case 'b':
sscp.sftp_buf_sz = atoi(optarg);
if (sscp.sftp_buf_sz < 1) {
pr_err("invalid buffer size: %s\n", optarg);
return -1;
}
break;
case 'B':
sscp.io_buf_sz = atoi(optarg);
if (sscp.io_buf_sz < 1) {
pr_err("invalid buffer size: %s\n", optarg);
return -1;
}
break;
case 'v':
verbose++;
break;
case 'q':
verbose = -1;
break;
case 'D':
dryrun = true;
break;
case 'n':
nr_threads = atoi(optarg);
if (nr_threads < 1) {
pr_err("invalid number of connections: %s\n", optarg);
return 1;
}
break;
case 's':
min_chunk_sz = atoi(optarg);
if (min_chunk_sz < getpagesize()) {
pr_err("min chunk size must be "
"larger than or equal to %d: %s\n",
getpagesize(), optarg);
return 1;
}
if (min_chunk_sz % getpagesize() != 0) {
pr_err("min chunk size must be "
"multiple of page size %d: %s\n",
getpagesize(), optarg);
return -1;
}
break;
case 'S':
max_chunk_sz = atoi(optarg);
if (max_chunk_sz < getpagesize()) {
pr_err("max chunk size must be "
"larger than or equal to %d: %s\n",
getpagesize(), optarg);
return 1;
}
if (max_chunk_sz % getpagesize() != 0) {
pr_err("max chunk size must be "
"multiple of page size %d: %s\n",
getpagesize(), optarg);
return -1;
}
break;
case 'b':
sscp.sftp_buf_sz = atoi(optarg);
if (sscp.sftp_buf_sz < 1) {
pr_err("invalid buffer size: %s\n", optarg);
return -1;
}
break;
case 'B':
sscp.io_buf_sz = atoi(optarg);
if (sscp.io_buf_sz < 1) {
pr_err("invalid buffer size: %s\n", optarg);
return -1;
}
break;
case 'v':
verbose++;
break;
case 'q':
verbose = -1;
break;
case 'D':
dryrun = true;
break;
case 'l':
opts.login_name = optarg;
break;
@@ -242,322 +242,322 @@ int main(int argc, char **argv)
case 'd':
opts.debuglevel++;
break;
case 'h':
usage(true);
return 1;
default:
usage(false);
return 1;
case 'h':
usage(true);
return 1;
default:
usage(false);
return 1;
}
}
}
pprint_set_level(verbose);
pprint_set_level(verbose);
if (max_chunk_sz > 0 && min_chunk_sz > max_chunk_sz) {
pr_err("smaller max chunk size than min chunk size: %d < %d\n",
max_chunk_sz, min_chunk_sz);
return 1;
}
if (max_chunk_sz > 0 && min_chunk_sz > max_chunk_sz) {
pr_err("smaller max chunk size than min chunk size: %d < %d\n",
max_chunk_sz, min_chunk_sz);
return 1;
}
if (argc - optind < 2) {
/* sscp needs at lease 2 (src and target) argument */
usage(false);
return 1;
}
if (argc - optind < 2) {
/* sscp needs at lease 2 (src and target) argument */
usage(false);
return 1;
}
sscp.target = argv[argc - 1];
sscp.target = argv[argc - 1];
/* create control session */
sscp.host = find_hostname(optind, argc, argv);
if (!sscp.host) {
pr_err("no remote host given\n");
return 1;
}
pprint3("connecting to %s for checking destinations...\n", sscp.host);
sscp.ctrl = ssh_make_sftp_session(sscp.host, &opts);
if (!sscp.ctrl)
return 1;
sscp.opts = &opts; /* save ssh-able ssh_opts */
/* create control session */
sscp.host = find_hostname(optind, argc, argv);
if (!sscp.host) {
pr_err("no remote host given\n");
return 1;
}
pprint3("connecting to %s for checking destinations...\n", sscp.host);
sscp.ctrl = ssh_make_sftp_session(sscp.host, &opts);
if (!sscp.ctrl)
return 1;
sscp.opts = &opts; /* save ssh-able ssh_opts */
/* fill file list */
ret = file_fill(sscp.ctrl, &sscp.file_list, &argv[optind], argc - optind - 1,
sscp.target);
if (ret < 0)
goto out;
/* fill file list */
ret = file_fill(sscp.ctrl, &sscp.file_list, &argv[optind], argc - optind - 1,
sscp.target);
if (ret < 0)
goto out;
#ifdef DEBUG
file_dump(&sscp.file_list);
file_dump(&sscp.file_list);
#endif
/* fill chunk list */
ret = chunk_fill(&sscp.file_list, &sscp.chunk_list,
nr_threads, min_chunk_sz, max_chunk_sz);
if (ret < 0)
goto out;
/* fill chunk list */
ret = chunk_fill(&sscp.file_list, &sscp.chunk_list,
nr_threads, min_chunk_sz, max_chunk_sz);
if (ret < 0)
goto out;
#ifdef DEBUG
chunk_dump(&sscp.chunk_list);
chunk_dump(&sscp.chunk_list);
#endif
if (dryrun)
return 0;
if (dryrun)
return 0;
/* register SIGINT to stop thrads */
if (signal(SIGINT, stop_copy_threads) == SIG_ERR) {
pr_err("cannot set signal: %s\n", strerrno());
ret = 1;
goto out;
}
/* register SIGINT to stop thrads */
if (signal(SIGINT, stop_copy_threads) == SIG_ERR) {
pr_err("cannot set signal: %s\n", strerrno());
ret = 1;
goto out;
}
/* prepare thread instances */
threads = calloc(nr_threads, sizeof(struct sscp_thread));
memset(threads, 0, nr_threads * sizeof(struct sscp_thread));
for (n = 0; n < nr_threads; n++) {
struct sscp_thread *t = &threads[n];
t->sscp = &sscp;
t->finished = false;
pprint3("connecting to %s for a copy thread...\n", sscp.host);
t->sftp = ssh_make_sftp_session(sscp.host, sscp.opts);
if (!t->sftp)
goto join_out;
}
/* prepare thread instances */
threads = calloc(nr_threads, sizeof(struct sscp_thread));
memset(threads, 0, nr_threads * sizeof(struct sscp_thread));
for (n = 0; n < nr_threads; n++) {
struct sscp_thread *t = &threads[n];
t->sscp = &sscp;
t->finished = false;
pprint3("connecting to %s for a copy thread...\n", sscp.host);
t->sftp = ssh_make_sftp_session(sscp.host, sscp.opts);
if (!t->sftp)
goto join_out;
}
/* spawn count thread */
ret = pthread_create(&mtid, NULL, sscp_monitor_thread, &sscp);
if (ret < 0) {
pr_err("pthread_create error: %d\n", ret);
stop_copy_threads(0);
goto join_out;
}
/* spawn count thread */
ret = pthread_create(&mtid, NULL, sscp_monitor_thread, &sscp);
if (ret < 0) {
pr_err("pthread_create error: %d\n", ret);
stop_copy_threads(0);
goto join_out;
}
/* save start time */
gettimeofday(&sscp.start, NULL);
/* save start time */
gettimeofday(&sscp.start, NULL);
/* spawn threads */
for (n = 0; n < nr_threads; n++) {
struct sscp_thread *t = &threads[n];
ret = pthread_create(&t->tid, NULL, sscp_copy_thread, t);
if (ret < 0) {
pr_err("pthread_create error: %d\n", ret);
stop_copy_threads(0);
goto join_out;
}
}
/* spawn threads */
for (n = 0; n < nr_threads; n++) {
struct sscp_thread *t = &threads[n];
ret = pthread_create(&t->tid, NULL, sscp_copy_thread, t);
if (ret < 0) {
pr_err("pthread_create error: %d\n", ret);
stop_copy_threads(0);
goto join_out;
}
}
join_out:
/* waiting for threads join... */
for (n = 0; n < nr_threads; n++)
if (threads[n].tid)
pthread_join(threads[n].tid, NULL);
/* waiting for threads join... */
for (n = 0; n < nr_threads; n++)
if (threads[n].tid)
pthread_join(threads[n].tid, NULL);
if (mtid != 0) {
pthread_cancel(mtid);
pthread_join(mtid, NULL);
}
if (mtid != 0) {
pthread_cancel(mtid);
pthread_join(mtid, NULL);
}
out:
if (sscp.ctrl)
ssh_sftp_close(sscp.ctrl);
if (sscp.ctrl)
ssh_sftp_close(sscp.ctrl);
return ret;
}
void sscp_copy_thread_cleanup(void *arg)
{
struct sscp_thread *t = arg;
if (t->sftp)
ssh_sftp_close(t->sftp);
t->finished = true;
struct sscp_thread *t = arg;
if (t->sftp)
ssh_sftp_close(t->sftp);
t->finished = true;
}
void *sscp_copy_thread(void *arg)
{
struct sscp_thread *t = arg;
struct sscp *sscp = t->sscp;
sftp_session sftp = t->sftp;
struct chunk *c;
struct sscp_thread *t = arg;
struct sscp *sscp = t->sscp;
sftp_session sftp = t->sftp;
struct chunk *c;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
pthread_cleanup_push(sscp_copy_thread_cleanup, t);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
pthread_cleanup_push(sscp_copy_thread_cleanup, t);
while (1) {
lock_acquire(&sscp->chunk_lock);
c = chunk_acquire(&sscp->chunk_list);
lock_release(&sscp->chunk_lock);
while (1) {
lock_acquire(&sscp->chunk_lock);
c = chunk_acquire(&sscp->chunk_list);
lock_release(&sscp->chunk_lock);
if (!c)
break; /* no more chunks */
if (!c)
break; /* no more chunks */
if (chunk_prepare(c, sftp) < 0)
break;
if (chunk_prepare(c, sftp) < 0)
break;
if (chunk_copy(c, sftp,
sscp->sftp_buf_sz, sscp->io_buf_sz, &t->done) < 0)
break;
}
if (chunk_copy(c, sftp,
sscp->sftp_buf_sz, sscp->io_buf_sz, &t->done) < 0)
break;
}
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
return NULL;
return NULL;
}
static double calculate_bps(size_t diff, struct timeval *b, struct timeval *a)
{
double sec, usec;
double sec, usec;
if (a->tv_usec < b->tv_usec) {
a->tv_usec += 1000000;
a->tv_sec--;
}
if (a->tv_usec < b->tv_usec) {
a->tv_usec += 1000000;
a->tv_sec--;
}
sec = a->tv_sec - b->tv_sec;
usec = a->tv_usec - b->tv_usec;
sec += usec / 1000000;
sec = a->tv_sec - b->tv_sec;
usec = a->tv_usec - b->tv_usec;
sec += usec / 1000000;
return (double)diff / sec;
return (double)diff / sec;
}
static void print_progress_bar(double percent, char *suffix)
{
int n, thresh, bar_width;
struct winsize ws;
char buf[128];
int n, thresh, bar_width;
struct winsize ws;
char buf[128];
/*
* [=======> ] XX.X% SUFFIX
*/
/*
* [=======> ] XX.X% SUFFIX
*/
buf[0] = '\0';
buf[0] = '\0';
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) < 0)
return; /* XXX */
bar_width = min(sizeof(buf), ws.ws_col) - strlen(suffix) - 8;
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) < 0)
return; /* XXX */
bar_width = min(sizeof(buf), ws.ws_col) - strlen(suffix) - 8;
if (bar_width > 8) {
memset(buf, 0, sizeof(buf));
thresh = floor(bar_width * (percent / 100)) - 1;
if (bar_width > 8) {
memset(buf, 0, sizeof(buf));
thresh = floor(bar_width * (percent / 100)) - 1;
for (n = 1; n < bar_width - 1; n++) {
if (n <= thresh)
buf[n] = '=';
else
buf[n] = ' ';
}
buf[thresh] = '>';
buf[0] = '[';
buf[bar_width - 1] = ']';
snprintf(buf + bar_width, sizeof(buf) - bar_width,
" %3d%% ", (int)floor(percent));
}
for (n = 1; n < bar_width - 1; n++) {
if (n <= thresh)
buf[n] = '=';
else
buf[n] = ' ';
}
buf[thresh] = '>';
buf[0] = '[';
buf[bar_width - 1] = ']';
snprintf(buf + bar_width, sizeof(buf) - bar_width,
" %3d%% ", (int)floor(percent));
}
pprint1("%s%s", buf, suffix);
pprint1("%s%s", buf, suffix);
}
static void print_progress(struct timeval *start, struct timeval *end,
size_t total, size_t last, size_t done)
size_t total, size_t last, size_t done)
{
char *bps_units[] = { "B/s", "KB/s", "MB/s", "GB/s" };
char *byte_units[] = { "B", "KB", "MB", "GB", "TB", "PB" };
char suffix[128];
int bps_u, byte_tu, byte_du;
size_t total_round;
int percent;
double bps;
char *bps_units[] = { "B/s", "KB/s", "MB/s", "GB/s" };
char *byte_units[] = { "B", "KB", "MB", "GB", "TB", "PB" };
char suffix[128];
int bps_u, byte_tu, byte_du;
size_t total_round;
int percent;
double bps;
#define array_size(a) (sizeof(a) / sizeof(a[0]))
total_round = total;
for (byte_tu = 0; total_round > 1000 && byte_tu < array_size(byte_units) - 1;
byte_tu++)
total_round /= 1024;
total_round = total;
for (byte_tu = 0; total_round > 1000 && byte_tu < array_size(byte_units) - 1;
byte_tu++)
total_round /= 1024;
bps = calculate_bps(done - last, start, end);
for (bps_u = 0; bps > 1000 && bps_u < array_size(bps_units); bps_u++)
bps /= 1000;
bps = calculate_bps(done - last, start, end);
for (bps_u = 0; bps > 1000 && bps_u < array_size(bps_units); bps_u++)
bps /= 1000;
percent = floor(((double)(done) / (double)total) * 100);
for (byte_du = 0; done > 1000 && byte_du < array_size(byte_units) - 1; byte_du++)
done /= 1024;
percent = floor(((double)(done) / (double)total) * 100);
for (byte_du = 0; done > 1000 && byte_du < array_size(byte_units) - 1; byte_du++)
done /= 1024;
snprintf(suffix, sizeof(suffix), "%lu%s/%lu%s %.2f%s ",
done, byte_units[byte_du], total_round, byte_units[byte_tu],
bps, bps_units[bps_u]);
snprintf(suffix, sizeof(suffix), "%lu%s/%lu%s %.2f%s ",
done, byte_units[byte_du], total_round, byte_units[byte_tu],
bps, bps_units[bps_u]);
print_progress_bar(percent, suffix);
print_progress_bar(percent, suffix);
}
void sscp_monitor_thread_cleanup(void *arg)
{
struct sscp *sscp = arg;
struct timeval end;
struct file *f;
size_t total, done;
int n;
struct sscp *sscp = arg;
struct timeval end;
struct file *f;
size_t total, done;
int n;
total = done = 0;
total = done = 0;
gettimeofday(&end, NULL);
gettimeofday(&end, NULL);
/* get total byte to be transferred */
list_for_each_entry(f, &sscp->file_list, list) {
total += f->size;
}
/* get total byte to be transferred */
list_for_each_entry(f, &sscp->file_list, list) {
total += f->size;
}
/* get total byte transferred */
for (n = 0; n < nr_threads; n++) {
done += threads[n].done;
}
/* get total byte transferred */
for (n = 0; n < nr_threads; n++) {
done += threads[n].done;
}
print_progress(&sscp->start, &end, total, 0, done);
fputs("\n", stdout); /* the final ouput. we need \n */
print_progress(&sscp->start, &end, total, 0, done);
fputs("\n", stdout); /* the final ouput. we need \n */
}
void *sscp_monitor_thread(void *arg)
{
struct sscp *sscp = arg;
struct timeval a, b;
struct file *f;
bool all_done;
size_t total, done, last;
int n;
struct sscp *sscp = arg;
struct timeval a, b;
struct file *f;
bool all_done;
size_t total, done, last;
int n;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
pthread_cleanup_push(sscp_monitor_thread_cleanup, sscp);
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
pthread_cleanup_push(sscp_monitor_thread_cleanup, sscp);
/* get total byte to be transferred */
total = 0;
list_for_each_entry(f, &sscp->file_list, list) {
total += f->size;
}
/* get total byte to be transferred */
total = 0;
list_for_each_entry(f, &sscp->file_list, list) {
total += f->size;
}
while (1) {
all_done = true;
last = done = 0;
while (1) {
all_done = true;
last = done = 0;
for (n = 0; n < nr_threads; n++) {
last += threads[n].done;
}
gettimeofday(&b, NULL);
for (n = 0; n < nr_threads; n++) {
last += threads[n].done;
}
gettimeofday(&b, NULL);
usleep(500000);
usleep(500000);
for (n = 0; n < nr_threads; n++) {
done += threads[n].done;;
if (!threads[n].finished)
all_done = false;
}
gettimeofday(&a, NULL);
for (n = 0; n < nr_threads; n++) {
done += threads[n].done;;
if (!threads[n].finished)
all_done = false;
}
gettimeofday(&a, NULL);
print_progress(&b, &a, total, last, done);
print_progress(&b, &a, total, last, done);
if (all_done || total == done)
break;
}
if (all_done || total == done)
break;
}
pthread_cleanup_pop(1);
pthread_cleanup_pop(1);
return NULL;
return NULL;
}

22
src/platform.c
View File

@@ -14,25 +14,25 @@
#ifdef __APPLE__
int nr_cpus()
{
int n;
size_t size = sizeof(n);
int n;
size_t size = sizeof(n);
if (sysctlbyname("machdep.cpu.core_count", &n, &size, NULL, 0) != 0) {
pr_err("failed to get number of cpu cores: %s\n", strerrno());
return -1;
}
if (sysctlbyname("machdep.cpu.core_count", &n, &size, NULL, 0) != 0) {
pr_err("failed to get number of cpu cores: %s\n", strerrno());
return -1;
}
return n;
return n;
}
#endif
#ifdef linux
int nr_cpus()
{
cpu_set_t cpu_set;
if (sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set) == 0)
return CPU_COUNT(&cpu_set);
return -1;
cpu_set_t cpu_set;
if (sched_getaffinity(0, sizeof(cpu_set_t), &cpu_set) == 0)
return CPU_COUNT(&cpu_set);
return -1;
}
#endif

20
src/pprint.c
View File

@@ -13,20 +13,20 @@ static pthread_mutex_t pprint_lock = PTHREAD_MUTEX_INITIALIZER;
void pprint_set_level(int level)
{
pprint_level = level;
pprint_level = level;
}
void pprint(int level, const char *fmt, ...)
{
va_list va;
va_list va;
if (level <= pprint_level) {
pthread_mutex_lock(&pprint_lock);
va_start(va, fmt);
vfprintf(stdout, fmt, va);
fflush(stdout);
va_end(va);
pthread_mutex_unlock(&pprint_lock);
}
if (level <= pprint_level) {
pthread_mutex_lock(&pprint_lock);
va_start(va, fmt);
vfprintf(stdout, fmt, va);
fflush(stdout);
va_end(va);
pthread_mutex_unlock(&pprint_lock);
}
}

406
src/ssh.c
View File

@@ -10,265 +10,265 @@ static int ssh_verify_known_hosts(ssh_session session);
static int ssh_set_opts(ssh_session ssh, struct ssh_opts *opts)
{
ssh_set_log_level(opts->debuglevel);
ssh_set_log_level(opts->debuglevel);
if (opts->login_name &&
ssh_options_set(ssh, SSH_OPTIONS_USER, opts->login_name) < 0) {
pr_err("failed to set login name\n");
return -1;
}
if (opts->login_name &&
ssh_options_set(ssh, SSH_OPTIONS_USER, opts->login_name) < 0) {
pr_err("failed to set login name\n");
return -1;
}
if (opts->port &&
ssh_options_set(ssh, SSH_OPTIONS_PORT_STR, opts->port) < 0) {
pr_err("failed to set port number\n");
return -1;
}
if (opts->port &&
ssh_options_set(ssh, SSH_OPTIONS_PORT_STR, opts->port) < 0) {
pr_err("failed to set port number\n");
return -1;
}
if (opts->identity &&
ssh_options_set(ssh, SSH_OPTIONS_IDENTITY, opts->identity) < 0) {
pr_err("failed to set identity\n");
return -1;
}
if (opts->identity &&
ssh_options_set(ssh, SSH_OPTIONS_IDENTITY, opts->identity) < 0) {
pr_err("failed to set identity\n");
return -1;
}
if (opts->cipher) {
if (ssh_options_set(ssh, SSH_OPTIONS_CIPHERS_C_S, opts->cipher) < 0) {
pr_err("failed to set cipher client to server\n");
return -1;
}
if (ssh_options_set(ssh, SSH_OPTIONS_CIPHERS_S_C, opts->cipher) < 0) {
pr_err("failed to set cipher client to server\n");
return -1;
}
}
if (opts->cipher) {
if (ssh_options_set(ssh, SSH_OPTIONS_CIPHERS_C_S, opts->cipher) < 0) {
pr_err("failed to set cipher client to server\n");
return -1;
}
if (ssh_options_set(ssh, SSH_OPTIONS_CIPHERS_S_C, opts->cipher) < 0) {
pr_err("failed to set cipher client to server\n");
return -1;
}
}
if (opts->compress &&
ssh_options_set(ssh, SSH_OPTIONS_COMPRESSION, "yes") < 0) {
pr_err("failed to enable ssh compression\n");
return -1;
}
if (opts->compress &&
ssh_options_set(ssh, SSH_OPTIONS_COMPRESSION, "yes") < 0) {
pr_err("failed to enable ssh compression\n");
return -1;
}
return 0;
return 0;
}
static int ssh_authenticate(ssh_session ssh, struct ssh_opts *opts)
{
int auth_bit_mask;
int ret;
/* none method */
ret = ssh_userauth_none(ssh, NULL);
if (ret == SSH_AUTH_SUCCESS)
return 0;
int auth_bit_mask;
int ret;
auth_bit_mask = ssh_userauth_list(ssh, NULL);
/* none method */
ret = ssh_userauth_none(ssh, NULL);
if (ret == SSH_AUTH_SUCCESS)
return 0;
if (auth_bit_mask & SSH_AUTH_METHOD_NONE &&
ssh_userauth_none(ssh, NULL) == SSH_AUTH_SUCCESS) {
return 0;
}
auth_bit_mask = ssh_userauth_list(ssh, NULL);
if (auth_bit_mask & SSH_AUTH_METHOD_PUBLICKEY &&
ssh_userauth_publickey_auto(ssh, NULL, NULL) == SSH_AUTH_SUCCESS) {
return 0;
}
if (auth_bit_mask & SSH_AUTH_METHOD_NONE &&
ssh_userauth_none(ssh, NULL) == SSH_AUTH_SUCCESS) {
return 0;
}
if (auth_bit_mask & SSH_AUTH_METHOD_PASSWORD) {
if (!opts->password) {
opts->password = getpass("Password: ");
}
if (ssh_userauth_password(ssh, NULL, opts->password) == SSH_AUTH_SUCCESS)
return 0;
}
if (auth_bit_mask & SSH_AUTH_METHOD_PUBLICKEY &&
ssh_userauth_publickey_auto(ssh, NULL, NULL) == SSH_AUTH_SUCCESS) {
return 0;
}
pr_err("authentication failure: %s\n", ssh_get_error(ssh));
return -1;
if (auth_bit_mask & SSH_AUTH_METHOD_PASSWORD) {
if (!opts->password) {
opts->password = getpass("Password: ");
}
if (ssh_userauth_password(ssh, NULL, opts->password) == SSH_AUTH_SUCCESS)
return 0;
}
pr_err("authentication failure: %s\n", ssh_get_error(ssh));
return -1;
}
static ssh_session ssh_make_ssh_session(char *sshdst, struct ssh_opts *opts)
{
ssh_session ssh = ssh_new();
ssh_session ssh = ssh_new();
if (ssh_set_opts(ssh, opts) != 0)
goto free_out;
if (ssh_set_opts(ssh, opts) != 0)
goto free_out;
if (ssh_options_set(ssh, SSH_OPTIONS_HOST, sshdst) != SSH_OK) {
pr_err("failed to set destination host\n");
goto free_out;
}
if (ssh_options_set(ssh, SSH_OPTIONS_HOST, sshdst) != SSH_OK) {
pr_err("failed to set destination host\n");
goto free_out;
}
if (ssh_connect(ssh) != SSH_OK) {
pr_err("failed to connect ssh server: %s\n", ssh_get_error(ssh));
goto free_out;
}
if (ssh_connect(ssh) != SSH_OK) {
pr_err("failed to connect ssh server: %s\n", ssh_get_error(ssh));
goto free_out;
}
if (ssh_authenticate(ssh, opts) != 0) {
pr_err("authentication failed: %s\n", ssh_get_error(ssh));
goto disconnect_out;
}
if (ssh_authenticate(ssh, opts) != 0) {
pr_err("authentication failed: %s\n", ssh_get_error(ssh));
goto disconnect_out;
}
if (ssh_verify_known_hosts(ssh) != 0) {
goto disconnect_out;
}
if (ssh_verify_known_hosts(ssh) != 0) {
goto disconnect_out;
}
return ssh;
return ssh;
disconnect_out:
ssh_disconnect(ssh);
ssh_disconnect(ssh);
free_out:
ssh_free(ssh);
return NULL;
ssh_free(ssh);
return NULL;
}
sftp_session ssh_make_sftp_session(char *sshdst, struct ssh_opts *opts)
{
sftp_session sftp;
ssh_session ssh = ssh_make_ssh_session(sshdst, opts);
sftp_session sftp;
ssh_session ssh = ssh_make_ssh_session(sshdst, opts);
if (!ssh) {
return NULL;
}
if (!ssh) {
return NULL;
}
sftp = sftp_new(ssh);
if (!sftp) {
pr_err("failed to allocate sftp session: %s\n", ssh_get_error(ssh));
goto err_out;
}
sftp = sftp_new(ssh);
if (!sftp) {
pr_err("failed to allocate sftp session: %s\n", ssh_get_error(ssh));
goto err_out;
}
if (sftp_init(sftp) != SSH_OK) {
pr_err("failed to initialize sftp session: err code %d\n",
sftp_get_error(sftp));
goto err_out;
}
if (sftp_init(sftp) != SSH_OK) {
pr_err("failed to initialize sftp session: err code %d\n",
sftp_get_error(sftp));
goto err_out;
}
return sftp;
return sftp;
err_out:
ssh_disconnect(ssh);
ssh_free(ssh);
return NULL;
ssh_disconnect(ssh);
ssh_free(ssh);
return NULL;
}
/* copied from https://api.libssh.org/stable/libssh_tutor_guided_tour.html*/
static int ssh_verify_known_hosts(ssh_session session)
{
enum ssh_known_hosts_e state;
unsigned char *hash = NULL;
ssh_key srv_pubkey = NULL;
size_t hlen;
char buf[10];
char *hexa;
char *p;
int cmp;
int rc;
rc = ssh_get_server_publickey(session, &srv_pubkey);
if (rc < 0) {
return -1;
}
rc = ssh_get_publickey_hash(srv_pubkey,
SSH_PUBLICKEY_HASH_SHA1,
&hash,
&hlen);
ssh_key_free(srv_pubkey);
if (rc < 0) {
return -1;
}
state = ssh_session_is_known_server(session);
switch (state) {
case SSH_KNOWN_HOSTS_OK:
/* OK */
break;
case SSH_KNOWN_HOSTS_CHANGED:
fprintf(stderr, "Host key for server changed: it is now:\n");
//ssh_print_hexa("Public key hash", hash, hlen);
fprintf(stderr, "For security reasons, connection will be stopped\n");
ssh_clean_pubkey_hash(&hash);
return -1;
case SSH_KNOWN_HOSTS_OTHER:
fprintf(stderr, "The host key for this server was not found but an other"
"type of key exists.\n");
fprintf(stderr, "An attacker might change the default server key to"
"confuse your client into thinking the key does not exist\n");
ssh_clean_pubkey_hash(&hash);
return -1;
case SSH_KNOWN_HOSTS_NOT_FOUND:
fprintf(stderr, "Could not find known host file.\n");
fprintf(stderr, "If you accept the host key here, the file will be"
"automatically created.\n");
/* FALL THROUGH to SSH_SERVER_NOT_KNOWN behavior */
case SSH_KNOWN_HOSTS_UNKNOWN:
hexa = ssh_get_hexa(hash, hlen);
fprintf(stderr,"The server is unknown. Do you trust the host key?\n");
fprintf(stderr, "Public key hash: %s\n", hexa);
ssh_string_free_char(hexa);
ssh_clean_pubkey_hash(&hash);
p = fgets(buf, sizeof(buf), stdin);
if (p == NULL) {
return -1;
}
cmp = strncasecmp(buf, "yes", 3);
if (cmp != 0) {
return -1;
}
rc = ssh_session_update_known_hosts(session);
if (rc < 0) {
fprintf(stderr, "Error %s\n", strerror(errno));
return -1;
}
break;
case SSH_KNOWN_HOSTS_ERROR:
fprintf(stderr, "Error %s", ssh_get_error(session));
ssh_clean_pubkey_hash(&hash);
return -1;
}
ssh_clean_pubkey_hash(&hash);
return 0;
enum ssh_known_hosts_e state;
unsigned char *hash = NULL;
ssh_key srv_pubkey = NULL;
size_t hlen;
char buf[10];
char *hexa;
char *p;
int cmp;
int rc;
rc = ssh_get_server_publickey(session, &srv_pubkey);
if (rc < 0) {
return -1;
}
rc = ssh_get_publickey_hash(srv_pubkey,
SSH_PUBLICKEY_HASH_SHA1,
&hash,
&hlen);
ssh_key_free(srv_pubkey);
if (rc < 0) {
return -1;
}
state = ssh_session_is_known_server(session);
switch (state) {
case SSH_KNOWN_HOSTS_OK:
/* OK */
break;
case SSH_KNOWN_HOSTS_CHANGED:
fprintf(stderr, "Host key for server changed: it is now:\n");
//ssh_print_hexa("Public key hash", hash, hlen);
fprintf(stderr, "For security reasons, connection will be stopped\n");
ssh_clean_pubkey_hash(&hash);
return -1;
case SSH_KNOWN_HOSTS_OTHER:
fprintf(stderr, "The host key for this server was not found but an other"
"type of key exists.\n");
fprintf(stderr, "An attacker might change the default server key to"
"confuse your client into thinking the key does not exist\n");
ssh_clean_pubkey_hash(&hash);
return -1;
case SSH_KNOWN_HOSTS_NOT_FOUND:
fprintf(stderr, "Could not find known host file.\n");
fprintf(stderr, "If you accept the host key here, the file will be"
"automatically created.\n");
/* FALL THROUGH to SSH_SERVER_NOT_KNOWN behavior */
case SSH_KNOWN_HOSTS_UNKNOWN:
hexa = ssh_get_hexa(hash, hlen);
fprintf(stderr,"The server is unknown. Do you trust the host key?\n");
fprintf(stderr, "Public key hash: %s\n", hexa);
ssh_string_free_char(hexa);
ssh_clean_pubkey_hash(&hash);
p = fgets(buf, sizeof(buf), stdin);
if (p == NULL) {
return -1;
}
cmp = strncasecmp(buf, "yes", 3);
if (cmp != 0) {
return -1;
}
rc = ssh_session_update_known_hosts(session);
if (rc < 0) {
fprintf(stderr, "Error %s\n", strerror(errno));
return -1;
}
break;
case SSH_KNOWN_HOSTS_ERROR:
fprintf(stderr, "Error %s", ssh_get_error(session));
ssh_clean_pubkey_hash(&hash);
return -1;
}
ssh_clean_pubkey_hash(&hash);
return 0;
}
void ssh_sftp_close(sftp_session sftp)
{
ssh_session ssh = sftp_ssh(sftp);
sftp_free(sftp);
ssh_disconnect(ssh);
ssh_free(ssh);
ssh_session ssh = sftp_ssh(sftp);
sftp_free(sftp);
ssh_disconnect(ssh);
ssh_free(ssh);
}
int sftp_write2(sftp_file sf, const void *buf, size_t len, size_t sftp_buf_sz)
{
int ret, nbytes;
int ret, nbytes;
for (nbytes = 0; nbytes < len;) {
ret = sftp_write(sf, buf + nbytes,
min(len - nbytes, sftp_buf_sz));
if (ret < 0)
return ret;
nbytes += ret;
}
return nbytes;
for (nbytes = 0; nbytes < len;) {
ret = sftp_write(sf, buf + nbytes,
min(len - nbytes, sftp_buf_sz));
if (ret < 0)
return ret;
nbytes += ret;
}
return nbytes;
}
int sftp_read2(sftp_file sf, void *buf, size_t len, size_t sftp_buf_sz)
{
int ret, nbytes;
int ret, nbytes;
for (nbytes = 0; nbytes < len;) {
ret = sftp_read(sf, buf + nbytes,
min(len - nbytes, sftp_buf_sz));
if (ret < 0)
return ret;
nbytes += ret;
}
return nbytes;
for (nbytes = 0; nbytes < len;) {
ret = sftp_read(sf, buf + nbytes,
min(len - nbytes, sftp_buf_sz));
if (ret < 0)
return ret;
nbytes += ret;
}
return nbytes;
}

14
src/ssh.h
View File

@@ -6,14 +6,14 @@
struct ssh_opts {
char *login_name; /* -l */
char *port; /* -p */
char *identity; /* -i */
char *cipher; /* -c */
int compress; /* -C */
int debuglevel; /* -v */
char *login_name; /* -l */
char *port; /* -p */
char *identity; /* -i */
char *cipher; /* -c */
int compress; /* -C */
int debuglevel; /* -v */
char *password; /* filled at the first connecting phase */
char *password; /* filled at the first connecting phase */
};
/* ssh_make_sftp_session() creates sftp_session. sshdst accpets

6
src/util.h
View File

@@ -12,7 +12,7 @@
#define pr(fmt, ...) fprintf(stderr, fmt, ##__VA_ARGS__)
#define pr_info(fmt, ...) fprintf(stderr, "INFO:%s(): " fmt, \
__func__, ##__VA_ARGS__)
__func__, ##__VA_ARGS__)
#define pr_warn(fmt, ...) fprintf(stderr, "\x1b[1m\x1b[33m" \
"WARN:%s():\x1b[0m " fmt, \
@@ -24,8 +24,8 @@
#ifdef DEBUG
#define pr_debug(fmt, ...) fprintf(stderr, "\x1b[1m\x1b[33m" \
"DEBUG:%s():\x1b[0m " fmt, \
__func__, ##__VA_ARGS__);
"DEBUG:%s():\x1b[0m " fmt, \
__func__, ##__VA_ARGS__);
#else
#define pr_debug(fmt, ...)
#endif