/* parse the client order */
int parse_clnt_order(SSL *ssl,int order)
{
int n;
int ret = 0;
n = order_isexist(order);
if(n < 0)
{
fprintf(stderr,"order is not exist!\n");
return -1;
}
switch(order)
{
case CIN: ret = clnt_login(ssl,order);break;
case CREG: ret = clnt_register(ssl,order);break;
case CLIST: scan_main(ssl,order);break;
case CUP: upload_files(ssl,order);break;
case CDOWN: download_files(ssl,order);break;
case CMODIFY_PASSWD: modify_passwd(ssl,order);break;
case CONSOLE: console(ssl);break;
case COUT: ret=logout(ssl,order);break;
default: fprintf(stderr,"null order!\n");
ret = -1;break;
}
return ret;
}
int bootstrap_module_main(int argc, char *argv[], const pt::wptree &data)
{
init();
check_version(data.get<int>(L"bootstrap.tools.version"));
wpath base_dir = current_path();
wpath download_dir = base_dir / BOOTSTRAP_DOWNLOADS;
download_files(download_dir, current_path(), data.get_child(L"tools"));
PRINT("Bootstraped Polygon-4 Tools successfully");
return 0;
}
/*--------------------------------------------------------------------------*/
static void got_remote_list( GnomeVFSURI *uri, GList *list, gint n )
{
gchar *home_data_dir = gb_util_get_home_data_dir();
gb_debug (DEBUG_UPDATE, "START");
/*
* Now we have a list of remote redemption files, now lets remove any
* files from that list that we already have locally.
*/
list = prune_list_from_dir( list, &n, REDEMPTION_DATA_DIR );
list = prune_list_from_dir( list, &n, home_data_dir );
/*
* Now begin download of what's left.
*/
download_files( uri, list, n );
g_free( home_data_dir );
gb_debug (DEBUG_UPDATE, "END");
}
int _alpm_sync_commit(alpm_handle_t *handle, alpm_list_t **data)
{
alpm_list_t *i;
alpm_list_t *deltas = NULL;
size_t numtargs, current = 0, replaces = 0;
int errors;
alpm_trans_t *trans = handle->trans;
if(download_files(handle, &deltas)) {
alpm_list_free(deltas);
return -1;
}
if(validate_deltas(handle, deltas, data)) {
alpm_list_free(deltas);
return -1;
}
alpm_list_free(deltas);
/* Check integrity of packages */
numtargs = alpm_list_count(trans->add);
EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_START, NULL, NULL);
errors = 0;
for(i = trans->add; i; i = i->next, current++) {
alpm_pkg_t *spkg = i->data;
int percent = (current * 100) / numtargs;
const char *filename;
char *filepath;
alpm_siglevel_t level;
PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", percent,
numtargs, current);
if(spkg->origin == PKG_FROM_FILE) {
continue; /* pkg_load() has been already called, this package is valid */
}
filename = alpm_pkg_get_filename(spkg);
filepath = _alpm_filecache_find(handle, filename);
alpm_db_t *sdb = alpm_pkg_get_db(spkg);
level = alpm_db_get_siglevel(sdb);
/* load the package file and replace pkgcache entry with it in the target list */
/* TODO: alpm_pkg_get_db() will not work on this target anymore */
_alpm_log(handle, ALPM_LOG_DEBUG,
"replacing pkgcache entry with package file for target %s\n",
spkg->name);
alpm_pkg_t *pkgfile =_alpm_pkg_load_internal(handle, filepath, 1, spkg->md5sum,
spkg->base64_sig, level);
if(!pkgfile) {
errors++;
*data = alpm_list_add(*data, strdup(filename));
FREE(filepath);
continue;
}
FREE(filepath);
pkgfile->reason = spkg->reason; /* copy over install reason */
i->data = pkgfile;
_alpm_pkg_free_trans(spkg); /* spkg has been removed from the target list */
}
PROGRESS(trans, ALPM_TRANS_PROGRESS_INTEGRITY_START, "", 100,
numtargs, current);
EVENT(trans, ALPM_TRANS_EVT_INTEGRITY_DONE, NULL, NULL);
if(errors) {
RET_ERR(handle, ALPM_ERR_PKG_INVALID, -1);
}
if(trans->flags & ALPM_TRANS_FLAG_DOWNLOADONLY) {
return 0;
}
trans->state = STATE_COMMITING;
replaces = alpm_list_count(trans->remove);
/* fileconflict check */
if(!(trans->flags & ALPM_TRANS_FLAG_FORCE)) {
EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_START, NULL, NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "looking for file conflicts\n");
alpm_list_t *conflict = _alpm_db_find_fileconflicts(handle,
trans->add, trans->remove);
if(conflict) {
if(data) {
*data = conflict;
} else {
alpm_list_free_inner(conflict, (alpm_list_fn_free)_alpm_fileconflict_free);
alpm_list_free(conflict);
}
RET_ERR(handle, ALPM_ERR_FILE_CONFLICTS, -1);
}
EVENT(trans, ALPM_TRANS_EVT_FILECONFLICTS_DONE, NULL, NULL);
}
/* check available disk space */
if(handle->checkspace) {
EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_START, NULL, NULL);
_alpm_log(handle, ALPM_LOG_DEBUG, "checking available disk space\n");
if(_alpm_check_diskspace(handle) == -1) {
_alpm_log(handle, ALPM_LOG_ERROR, "%s\n", _("not enough free disk space"));
return -1;
}
EVENT(trans, ALPM_TRANS_EVT_DISKSPACE_DONE, NULL, NULL);
}
/* remove conflicting and to-be-replaced packages */
if(replaces) {
_alpm_log(handle, ALPM_LOG_DEBUG, "removing conflicting and to-be-replaced packages\n");
/* we want the frontend to be aware of commit details */
if(_alpm_remove_packages(handle) == -1) {
_alpm_log(handle, ALPM_LOG_ERROR, _("could not commit removal transaction\n"));
return -1;
}
}
/* install targets */
_alpm_log(handle, ALPM_LOG_DEBUG, "installing packages\n");
if(_alpm_upgrade_packages(handle) == -1) {
_alpm_log(handle, ALPM_LOG_ERROR, _("could not commit transaction\n"));
return -1;
}
return 0;
}
Uint32 update(const char* server, const char* file, const char* dir,
const char* zip, progress_fnc update_progress_function, void* user_data)
{
char *tmp[MAX_OLD_UPDATE_FILES];
const size_t tmp_size = 1024;
char *path = NULL;
const size_t path_size = 1024;
char *str = NULL;
const size_t str_size = 1024;
char *etag = NULL;
const size_t etag_size = 1024;
char md5[33];
unzFile source_zips[MAX_OLD_UPDATE_FILES];
zipFile dest_zip;
update_info_t* infos;
Uint32 count, result, i;
path = (char*)calloc(sizeof(char), path_size);
safe_snprintf(path, path_size, "http://%s/%s/", server, dir);
str = (char *)calloc(sizeof(char), str_size);
safe_snprintf(str, str_size, "Downloading from server %s", path);
update_progress_function(str, 0, 0, user_data);
for (i = 0; i < MAX_OLD_UPDATE_FILES; i++)
{
tmp[i] = (char *)calloc(sizeof(char), tmp_size);
safe_snprintf(tmp[i], tmp_size, "%s%s%i", zip, ".t", i);
}
safe_snprintf(str, str_size, "Opening %s", zip);
update_progress_function(str, 0, 0, user_data);
memset(str, 0, str_size);
source_zips[0] = unzOpen64(zip);
unzGetGlobalComment(source_zips[0], str, str_size);
unzClose(source_zips[0]);
infos = 0;
count = 0;
etag = (char *)calloc(sizeof(char), etag_size);
memset(md5, 0, sizeof(md5));
sscanf(str, "ETag: %s MD5: %32s", etag, md5);
result = build_update_list(server, file, path, &infos, &count, md5,
etag_size, etag, update_progress_function, user_data);
if (result != 0)
{
free(path);
free(str);
free(etag);
for (i = 0; i < MAX_OLD_UPDATE_FILES; i++)
free(tmp[i]);
if (result == 1)
return 0;
free(infos);
return 3;
}
source_zips[0] = unzOpen64(zip);
remove(tmp[MAX_OLD_UPDATE_FILES - 1]);
for (i = MAX_OLD_UPDATE_FILES - 1; i > 0; i--)
{
rename(tmp[i - 1], tmp[i]);
source_zips[i] = unzOpen64(tmp[i]);
}
dest_zip = zipOpen64(tmp[0], APPEND_STATUS_CREATE);
result = download_files(infos, count, server, path,
MAX_OLD_UPDATE_FILES, source_zips, dest_zip,
update_progress_function, user_data);
if (result == 0)
{
memset(str, 0, str_size);
safe_snprintf(str, str_size, "ETag: %s MD5: %s", etag, md5);
}
for (i = 0; i < MAX_OLD_UPDATE_FILES; i++)
{
unzClose(source_zips[i]);
}
zipClose(dest_zip, str);
if (result == 2)
{
update_progress_function("Canceled updating", 0, 0,
user_data);
}
free(infos);
if (result != 0)
{
free(path);
free(str);
free(etag);
for (i = 0; i < MAX_OLD_UPDATE_FILES; i++)
free(tmp[i]);
return result;
}
unload_zip_archive(zip);
remove(zip);
rename(tmp[0], zip);
load_zip_archive(zip);
for (i = 1; i < MAX_OLD_UPDATE_FILES; i++)
{
remove(tmp[i]);
}
update_progress_function("Update complete", 0, 0, user_data);
free(path);
free(str);
free(etag);
for (i = 0; i < MAX_OLD_UPDATE_FILES; i++)
free(tmp[i]);
return 0;
}
