272 lines
6.9 KiB
C
272 lines
6.9 KiB
C
/*
|
|
* pacsync.c
|
|
*
|
|
* Copyright (c) 2002 by Judd Vinet <jvinet@zeroflux.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
|
* USA.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
#include <ftplib.h>
|
|
/* pacman */
|
|
#include "list.h"
|
|
#include "package.h"
|
|
#include "db.h"
|
|
#include "util.h"
|
|
#include "pacsync.h"
|
|
#include "pacman.h"
|
|
|
|
static int log_progress(netbuf *ctl, int xfered, void *arg);
|
|
static char sync_fnm[25];
|
|
static int offset;
|
|
|
|
/* pacman options */
|
|
extern char *pmo_root;
|
|
extern char *pmo_dbpath;
|
|
extern unsigned short pmo_nopassiveftp;
|
|
|
|
/* sync servers */
|
|
extern PMList *pmc_syncs;
|
|
extern int maxcols;
|
|
|
|
int sync_synctree()
|
|
{
|
|
char ldir[PATH_MAX] = "";
|
|
char path[PATH_MAX];
|
|
mode_t oldmask;
|
|
PMList *files = NULL;
|
|
PMList *i;
|
|
int success = 0;
|
|
|
|
for(i = pmc_syncs; i; i = i->next) {
|
|
sync_t *sync = (sync_t*)i->data;
|
|
snprintf(ldir, PATH_MAX, "%s%s", pmo_root, pmo_dbpath);
|
|
|
|
/* build a one-element list */
|
|
snprintf(path, PATH_MAX, "%s.db.tar.gz", sync->treename);
|
|
files = list_add(files, strdup(path));
|
|
|
|
success = 1;
|
|
if(downloadfiles(sync->servers, ldir, files)) {
|
|
fprintf(stderr, "failed to synchronize %s\n", sync->treename);
|
|
success = 0;
|
|
}
|
|
list_free(files);
|
|
files = NULL;
|
|
snprintf(path, PATH_MAX, "%s/%s.db.tar.gz", ldir, sync->treename);
|
|
|
|
if(success) {
|
|
snprintf(ldir, PATH_MAX, "%s%s/%s", pmo_root, pmo_dbpath, sync->treename);
|
|
/* remove the old dir */
|
|
vprint("removing %s (if it exists)\n", ldir);
|
|
rmrf(ldir);
|
|
|
|
/* make the new dir */
|
|
oldmask = umask(0000);
|
|
mkdir(ldir, 0755);
|
|
umask(oldmask);
|
|
|
|
/* uncompress the sync database */
|
|
vprint("Unpacking %s...\n", path);
|
|
if(unpack(path, ldir)) {
|
|
return(1);
|
|
}
|
|
}
|
|
/* remove the .tar.gz */
|
|
unlink(path);
|
|
}
|
|
|
|
return(!success);
|
|
}
|
|
|
|
int downloadfiles(PMList *servers, char *localpath, PMList *files)
|
|
{
|
|
int fsz;
|
|
netbuf *control = NULL;
|
|
PMList *lp;
|
|
int done = 0;
|
|
PMList *complete = NULL;
|
|
PMList *i;
|
|
|
|
if(files == NULL) {
|
|
return(0);
|
|
}
|
|
|
|
for(i = servers; i && !done; i = i->next) {
|
|
server_t *server = (server_t*)i->data;
|
|
|
|
if(!strcmp(server->protocol, "ftp")) {
|
|
FtpInit();
|
|
if(!FtpConnect(server->server, &control)) {
|
|
fprintf(stderr, "error: cannot connect to %s\n", server->server);
|
|
continue;
|
|
}
|
|
if(!FtpLogin("anonymous", "arch@guest", control)) {
|
|
fprintf(stderr, "error: anonymous login failed\n");
|
|
FtpQuit(control);
|
|
continue;
|
|
}
|
|
if(!FtpChdir(server->path, control)) {
|
|
fprintf(stderr, "error: could not cwd to %s: %s\n", server->path,
|
|
FtpLastResponse(control));
|
|
continue;
|
|
}
|
|
if(!pmo_nopassiveftp) {
|
|
if(!FtpOptions(FTPLIB_CONNMODE, FTPLIB_PASSIVE, control)) {
|
|
fprintf(stderr, "warning: failed to set passive mode\n");
|
|
}
|
|
} else {
|
|
vprint("FTP passive mode not set\n");
|
|
}
|
|
}
|
|
|
|
/* get each file in the list */
|
|
for(lp = files; lp; lp = lp->next) {
|
|
char output[PATH_MAX];
|
|
int j;
|
|
char *fn = (char*)lp->data;
|
|
struct stat st;
|
|
|
|
if(is_in(fn, complete)) {
|
|
continue;
|
|
}
|
|
|
|
snprintf(output, PATH_MAX, "%s/%s.part", localpath, fn);
|
|
strncpy(sync_fnm, lp->data, 24);
|
|
for(j = strlen(sync_fnm); j < 24; j++) {
|
|
sync_fnm[j] = ' ';
|
|
}
|
|
sync_fnm[24] = '\0';
|
|
offset = 0;
|
|
|
|
if(!strcmp(server->protocol, "ftp")) {
|
|
if(!FtpSize(fn, &fsz, FTPLIB_IMAGE, control)) {
|
|
fprintf(stderr, "warning: failed to get filesize for %s\n", fn);
|
|
}
|
|
if(!stat(output, &st)) {
|
|
offset = (int)st.st_size;
|
|
if(!FtpRestart(offset, control)) {
|
|
fprintf(stderr, "warning: failed to resume download -- restarting\n");
|
|
/* can't resume: */
|
|
/* unlink the file in order to restart download from scratch */
|
|
unlink(output);
|
|
}
|
|
}
|
|
/* set up our progress bar's callback */
|
|
FtpOptions(FTPLIB_CALLBACK, (long)log_progress, control);
|
|
FtpOptions(FTPLIB_IDLETIME, (long)1000, control);
|
|
FtpOptions(FTPLIB_CALLBACKARG, (long)&fsz, control);
|
|
FtpOptions(FTPLIB_CALLBACKBYTES, (10*1024), control);
|
|
|
|
if(!FtpGet(output, lp->data, FTPLIB_IMAGE, control)) {
|
|
fprintf(stderr, "\nfailed downloading %s from %s: %s\n",
|
|
fn, server->server, FtpLastResponse(control));
|
|
/* we leave the partially downloaded file in place so it can be resumed later */
|
|
} else {
|
|
char completefile[PATH_MAX];
|
|
log_progress(control, fsz-offset, &fsz);
|
|
complete = list_add(complete, fn);
|
|
/* rename "output.part" file to "output" file */
|
|
snprintf(completefile, PATH_MAX, "%s/%s", localpath, fn);
|
|
rename(output, completefile);
|
|
}
|
|
printf("\n");
|
|
fflush(stdout);
|
|
} else if(!strcmp(server->protocol, "file")) {
|
|
/* local repository, just copy the file */
|
|
char src[PATH_MAX], dest[PATH_MAX];
|
|
snprintf(src, PATH_MAX, "%s%s", server->path, fn);
|
|
snprintf(dest, PATH_MAX, "%s/%s", localpath, fn);
|
|
vprint("copying %s to %s\n", src, dest);
|
|
if(copyfile(src, dest)) {
|
|
fprintf(stderr, "failed copying %s\n", src);
|
|
} else {
|
|
char out[56];
|
|
printf(" %s [", sync_fnm);
|
|
strncpy(out, server->path, 33);
|
|
printf("%s", out);
|
|
for(j = strlen(out); j < maxcols-44; j++) {
|
|
printf(" ");
|
|
}
|
|
fputs("] 100% | LOCAL\n", stdout);
|
|
fflush(stdout);
|
|
|
|
complete = list_add(complete, fn);
|
|
}
|
|
}
|
|
}
|
|
if(list_count(complete) == list_count(files)) {
|
|
done = 1;
|
|
}
|
|
|
|
if(!strcmp(server->protocol, "ftp")) {
|
|
FtpQuit(control);
|
|
}
|
|
}
|
|
|
|
return(!done);
|
|
}
|
|
|
|
static int log_progress(netbuf *ctl, int xfered, void *arg)
|
|
{
|
|
int fsz = *(int*)arg;
|
|
int pct = ((float)(xfered+offset) / fsz) * 100;
|
|
int i, cur;
|
|
char *cenv = NULL;
|
|
|
|
cenv = getenv("COLUMNS");
|
|
if(cenv) {
|
|
maxcols = atoi(cenv);
|
|
}
|
|
|
|
printf(" %s [", sync_fnm);
|
|
cur = (int)((maxcols-44)*pct/100);
|
|
for(i = 0; i < maxcols-44; i++) {
|
|
(i < cur) ? printf("#") : printf(" ");
|
|
}
|
|
printf("] %3d%% | %6dK\r", pct, ((xfered+offset)/1024));
|
|
fflush(stdout);
|
|
return(1);
|
|
}
|
|
|
|
/* Test for existance of a package in a PMList* of syncpkg_t*
|
|
* If found, return a pointer to the respective syncpkg_t*
|
|
*/
|
|
syncpkg_t* find_pkginsync(char *needle, PMList *haystack)
|
|
{
|
|
PMList *i;
|
|
syncpkg_t *sync;
|
|
int found = 0;
|
|
|
|
for(i = haystack; i && !found; i = i->next) {
|
|
sync = (syncpkg_t*)i->data;
|
|
if(sync && !strcmp(sync->pkg->name, needle)) {
|
|
found = 1;
|
|
}
|
|
}
|
|
if(!found) {
|
|
sync = NULL;
|
|
}
|
|
|
|
return sync;
|
|
}
|
|
|
|
/* vim: set ts=2 sw=2 noet: */
|