int prerun(GList **config)
{
// fix gtk graphical bug : forward button is clicked in
set_page_completed();
set_page_incompleted();
long long *compsize = (long long*)data_get(*config,"compsizepkg");
if(compsize != NULL)
compressedsize = *compsize;
makepath(TARGETDIR "/dev");
fw_system("mount /dev -o bind " TARGETDIR "/dev");
if(data_get(*config, "srcdev") != NULL) {
if(install_pkgs_discs((GList*)data_get(*config, "packages"), (char*)data_get(*config, "srcdev")) == -1) {
fwife_error(_("An error occurs during packages installation (see /var/log/fwife.log for more details)"));
return -1;
}
} else {
if(install_pkgs((GList*)data_get(*config, "packages")) == -1) {
fwife_error(_("An error occurs during packages installation (see /var/log/fwife.log for more details)"));
return -1;
}
}
gtk_label_set_label(GTK_LABEL(labelpkg), _("Packages installation completed"));
set_page_completed();
return 0;
}
void servo_update(void){
if(data_get(SERVO_DONE)){
int angle = T3_VALUE * 0.06 +
(data_get(SERVO_ANGLE) * T3_VALUE *(0.24-0.06) / 90 );
SetPulseOC1(0, angle);
data_set(SERVO_DONE, 0);
}
}
static ssize_t data_triplet_format_t_lookup(data_t *data, fastcall_crud *fargs) { // {{{
ssize_t ret;
uintmax_t offset;
data_t converted;
data_t d_key;
data_t *d_key_ptr = &d_key;
data_t storage_item;
triplet_format_t *fdata = (triplet_format_t *)data->ptr;
// fetch value from storage
data_t sl_key = DATA_SLICET(fargs->key, 1, ~0);
fastcall_lookup r_lookup = {
{ 4, ACTION_LOOKUP },
&sl_key,
&storage_item
};
if( (ret = data_query(&fdata->storage, &r_lookup)) < 0)
return ret;
// get offset for this data
if(helper_key_current(fargs->key, &d_key) < 0) {
d_key_ptr = fargs->key;
data_get(ret, TYPE_UINTT, offset, d_key_ptr);
} else {
data_get(ret, TYPE_UINTT, offset, d_key_ptr);
data_free(&d_key);
}
if(ret < 0)
return ret;
data_t sl_value = DATA_SLICET(&storage_item, offset, ~0);
fastcall_unpack r_unpack = {
{ 4, ACTION_UNPACK },
offset == 0 ?
&storage_item :
&sl_value,
&converted,
FORMAT(packed)
};
if( (ret = data_query(&fdata->slave, &r_unpack)) < 0)
goto exit;
*fargs->value = converted;
exit:
data_free(&storage_item);
return ret;
} // }}}
int main(void)
{
sleep(5);
init_PWM();
FILE *fd;
char *data;
while(1)
{
data = malloc(50);
fd = fopen("/dev/shm/setariweb", "r");
if(fd < 0)
{
perror("Settings file open error");
exit(1);
}
fread(data, 1, 50, fd);
data_get(data);
if(activ)
{
release_door();
sleep(5); //at least 5 seconds between feedings
}
else
{
usleep(100000); //sleep to avoid massive cpu usage
}
fclose(fd);
free(data);
}
return 0;
}
ssize_t action_write_to_fast(void *userdata, request_t *request, f_hash_to_fast callback){ // {{{
ssize_t ret;
data_t *r_buffer;
data_t *r_size;
uintmax_t offset = 0;
uintmax_t size = ~0;
hash_data_get(ret, TYPE_UINTT, offset, request, HK(offset));
if( (r_size = hash_data_find(request, HK(size))) != NULL){
data_get(ret, TYPE_UINTT, size, r_size);
}
if( (r_buffer = hash_data_find(request, HK(buffer))) == NULL)
return -EINVAL;
data_t d_slice = DATA_SLICET(userdata, offset, size); // FIXME
fastcall_convert_to r_convert = { { 5, ACTION_CONVERT_TO }, &d_slice, FORMAT(native) };
ret = data_query(r_buffer, &r_convert);
fastcall_write r_write = { { 5, ACTION_WRITE }, 0, &r_convert.transfered, sizeof(r_convert.transfered) };
if(r_size)
data_query(r_size, &r_write);
return ret;
} // }}}
static ssize_t data_length_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
length_t *fdata;
if(dst->ptr != NULL)
return -EINVAL;
switch(fargs->format){
case FORMAT(hash):;
hash_t *config;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return ret;
if( (fdata = malloc(sizeof(length_t))) == NULL)
return -ENOMEM;
hash_holder_consume(ret, fdata->data, config, HK(data));
if(ret != 0){
free(fdata);
return -EINVAL;
}
fdata->format = FORMAT(clean);
hash_data_get(ret, TYPE_FORMATT, fdata->format, config, HK(format));
dst->ptr = fdata;
return 0;
default:
break;
}
return -ENOSYS;
} // }}}
static ssize_t data_file_t_convert_from(data_t *data, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
if(fargs->src == NULL)
return -EINVAL;
switch(fargs->format){
case FORMAT(config):;
case FORMAT(human):;
case FORMAT(native):;
request_t r_config[] = {
{ HK(filename), *fargs->src },
hash_end
};
return file_new((file_t **)&data->ptr, r_config);
case FORMAT(hash):;
hash_t *config;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
return file_new((file_t **)&data->ptr, config);
default:
break;
};
return -ENOSYS;
} // }}}
int run(GList **config)
{
char *fn, *name, *from;
gboolean toggled;
GList *newmirrorlist = NULL;
if(data_get(*config, "srcdev") != NULL)
return 0;
GtkTreeIter iter;
GtkTreeView *treeview = (GtkTreeView *)viewserver;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
fn = g_strdup_printf("%s/%s", PACCONFPATH, PACCONF);
if(gtk_tree_model_get_iter_first (model, &iter) == FALSE) {
return(0);
} else {
do {
gtk_tree_model_get (model, &iter, COLUMN_USE, &toggled, COLUMN_NAME, &name, COLUMN_FROM, &from, -1);
if(toggled == TRUE) {
newmirrorlist = g_list_prepend(newmirrorlist, strdup(from));
newmirrorlist = g_list_prepend(newmirrorlist, strdup(name));
} else {
newmirrorlist = g_list_append(newmirrorlist, strdup(name));
newmirrorlist = g_list_append(newmirrorlist, strdup(from));
}
} while(gtk_tree_model_iter_next(model, &iter));
}
updateconfig(fn, newmirrorlist);
free(fn);
return(0);
}
QByteArray VkGet::GET(QUrl r) //Сетевое взаимодействие с сервером ВКонтакте
{
try
{
QNetworkAccessManager* manager = new QNetworkAccessManager(this);
connect(manager, SIGNAL(sslErrors(QNetworkReply*,QList<QSslError>)),
this, SLOT(SSLerror(QNetworkReply*,QList<QSslError>)));
QNetworkReply* reply;
reply = manager->get(QNetworkRequest(r));
QEventLoop wait;
connect(manager, SIGNAL(finished(QNetworkReply*)), &wait, SLOT(quit()));
QTimer::singleShot(20000, &wait, SLOT(quit()));
connect(manager, SIGNAL(finished(QNetworkReply*)), manager, SLOT(deleteLater()));
wait.exec();
QByteArray answer = " ";
if(!reply->error())
answer = reply->readAll();
reply->deleteLater();
emit data_get(answer);
return answer;
}
catch(QException)
{
return "";
}
}
static ssize_t data_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct gpio_sw_classdev *gpio_sw_cdev = dev_get_drvdata(dev);
gpio_sw_cdev->data = data_get(gpio_sw_cdev);
return sprintf(buf, "%u\n", gpio_sw_cdev->data);
}
data_t * _any_getattr(data_t *self, char _unused_ *func_name, arguments_t *args) {
data_t *attrname = arguments_get_arg(args, 0);
name_t *name = name_create(1, data_tostring(attrname));
data_t *ret;
ret = data_get(self, name);
name_free(name);
return ret;
}
int prerun(GList **config)
{
struct stat buf;
char *ptr;
//* disable x configuration if no x server detected *//
ptr = g_strdup_printf("%s/usr/bin/X", TARGETDIR);
if(!stat(ptr, &buf))
{
gtk_widget_set_sensitive(pHBoxFrameX, TRUE);
xlayout = (char*)data_get(*config, "xlayout");
xvariant = (char*)data_get(*config, "xvariant");
}
// configure kernel modules
ptr = g_strdup_printf("chroot %s /sbin/depmod -a", TARGETDIR);
fw_system(ptr);
FREE(ptr);
return 0;
}
static ssize_t data_emitter_t_handler (data_t *data, fastcall_header *hargs) { // {{{
ssize_t ret = 0;
emitter_t *fdata = (emitter_t *)data->ptr;
switch(hargs->action) {
case ACTION_CONVERT_FROM:
;
hash_t *parameters;
fastcall_convert_from *fargs = (fastcall_convert_from *)hargs;
data_get(ret, TYPE_HASHT, parameters, fargs->src);
if(ret != 0)
return -EINVAL;
if(fdata == NULL) {
if( (data->ptr = fdata = calloc(1, sizeof(emitter_t))) == NULL)
return -ENOMEM;
fdata->allocated = 1;
}
hash_data_consume(ret, TYPE_MACHINET, fdata->machine, parameters, HK(machine));
hash_data_consume(ret, TYPE_HASHT, fdata->request, parameters, HK(request));
if(fdata->machine != NULL && fdata->request != NULL)
break;
fdata->request = NULL;
ret = -EFAULT;
// fall
case ACTION_FREE:
if(fdata == NULL)
return -EFAULT;
shop_destroy(fdata->machine);
hash_free(fdata->request);
if(fdata->allocated)
free(data->ptr);
data->ptr = NULL;
break;
default:
if(fdata == NULL)
return -EFAULT;
return machine_query(fdata->machine, fdata->request);
}
return ret;
} // }}}
static ssize_t data_machine_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
char buffer[DEF_BUFFER_SIZE];
if(fargs->src == NULL)
return -EINVAL;
switch(fargs->format){
case FORMAT(native):;
if(fargs->src->type != TYPE_MACHINET)
return -EFAULT;
dst->ptr = fargs->src->ptr;
machine_acquire(dst->ptr);
return 0;
case FORMAT(hash):;
hash_t *config;
hash_t *pipelines;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
if( (ret = pipelines_new(&pipelines, config)) < 0)
return ret;
*dst = pipelines[0].data;
data_set_void(&pipelines[0].data);
hash_free(pipelines);
goto check;
case FORMAT(config):;
case FORMAT(human):; // TODO data_convert call with FORMAT(native) :(
default:;
fastcall_read r_read = { { 5, ACTION_READ }, 0, &buffer, sizeof(buffer) - 1 };
if(data_query(fargs->src, &r_read) != 0)
return -EFAULT;
buffer[r_read.buffer_size] = '\0';
dst->ptr = machine_find(buffer);
goto check;
}
check:
if(dst->ptr != NULL)
return 0;
return -EFAULT;
} // }}}
int main(void) {
int i;
_config = config_create(FILE_CONFIG);
_log = log_create(FILE_LOG, "Nodo", false, LOG_LEVEL_INFO);
_data = data_get(config_get_string_value(_config, CONFIG_ARCHIVO_BIN));
bloques_set();
////////////////////////
pthread_t p_fs;
if (pthread_create(&p_fs, NULL, (void*) fs_conectar, NULL) != 0) {
perror("pthread_create");
exit(1);
}
pthread_join(p_fs, (void**) NULL);
/*
void* saludo = malloc(BLOQUE_SIZE);
strcpy(saludo, "ahora cambio el mensaje!");
setBloque(0, saludo);
void* dataget = getBloque(0);
char* saludoget =(char*) malloc(strlen(saludo)+1);
memcpy(saludoget, dataget, strlen(saludo)+1);
printf("%s\n", saludoget);
free_null(saludo);
free_null(saludoget);
free_null(dataget);
*/
/*
char *d = NULL;
d = getFileContent("hola");
for(i=0;i<10;i++)
printf("%c", d[i]);
file_mmap_free(d, "hola");
*/
data_destroy();
config_destroy(_config);
printf("fin ok");
//while (true);
return EXIT_SUCCESS;
}
ssize_t data_list_query(data_t *data, request_t *list){ // {{{
ssize_t ret;
action_t action;
data_get(ret, TYPE_ACTIONT, action, &list->data);
if(
ret != 0 ||
action >= ACTION_INVALID
)
return -ENOSYS;
hash_rename(list, api_data_from_list[action]);
return data_hash_query(data, list);
} // }}}
int prerun(GList **config)
{
GtkTreeIter iter;
char *fn, *testurl;
int i;
// get the branch used
PACCONF = data_get(*config, "pacconf");
if(run_discs_config(config) == 1)
return 0;
while(run_net_config(config) == -1) {}
if(mirrorlist == NULL) {
fn = g_strdup_printf("%s/%s", PACCONFPATH, PACCONF);
mirrorlist = getmirrors(fn);
free(fn);
GtkWidget *cellview = gtk_cell_view_new ();
GdkPixbuf *pixgood = gtk_widget_render_icon(cellview, GTK_STOCK_YES, GTK_ICON_SIZE_BUTTON, NULL);
GdkPixbuf *pixbad = gtk_widget_render_icon(cellview, GTK_STOCK_NO, GTK_ICON_SIZE_BUTTON, NULL);
for(i=0; i < g_list_length(mirrorlist); i+=3) {
gtk_list_store_append(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(viewserver))), &iter);
testurl = strdup(((char*)g_list_nth_data(mirrorlist, i)) + 6);
strchr(testurl, '/')[0] = '\0';
if(is_connected(testurl, 80, 1) < 1) {
gtk_list_store_set(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(viewserver))), &iter,
COLUMN_USE, (gboolean)(GPOINTER_TO_INT(g_list_nth_data(mirrorlist, i+2))),
COLUMN_STATUS, pixbad,
COLUMN_NAME, (gchar*)g_list_nth_data(mirrorlist, i),
COLUMN_FROM, (gchar*)g_list_nth_data(mirrorlist, i+1), -1);
} else {
gtk_list_store_set(GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(viewserver))), &iter,
COLUMN_USE, (gboolean)(GPOINTER_TO_INT(g_list_nth_data(mirrorlist, i+2))),
COLUMN_STATUS, pixgood,
COLUMN_NAME, (gchar*)g_list_nth_data(mirrorlist, i),
COLUMN_FROM, (gchar*)g_list_nth_data(mirrorlist, i+1), -1);
}
free(testurl);
}
}
return 0;
}
void category_changed(GtkTreeSelection *selection, gpointer data)
{
GtkTreeModel *model;
GtkTreeIter iter;
char *selected;
gboolean checked = FALSE;
int i;
gtk_label_set_label(GTK_LABEL(package_info), "");
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter, 1, &selected, -1);
gtk_tree_model_get (model, &iter, 0, &checked, -1);
if(all_packages)
packages_current = (GList*)data_get(all_packages, selected);
if(packages_current)
{
gtk_list_store_clear(
GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(package_list)))
);
for(i=0; i < g_list_length(packages_current); i+=4 ) {
gtk_list_store_append(
GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(package_list))),
&iter
);
gtk_list_store_set(
GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(package_list))),
&iter,
0, (gboolean)GPOINTER_TO_INT(g_list_nth_data(packages_current, i+3)),
1, (char*)g_list_nth_data(packages_current, i),
2, (char*)g_list_nth_data(packages_current, i+1), -1
);
}
}
/* disable package selection if category unselected */
if(checked == FALSE)
g_object_set (package_list, "sensitive", FALSE, NULL);
else
g_object_set (package_list, "sensitive", TRUE, NULL);
}
}
static ssize_t data_pcre_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
pcre_t *fdata;
if(fargs->src == NULL)
return -EINVAL;
switch( fargs->format ){
case FORMAT(hash):;
hash_t *config;
data_t data;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
if( (ret = pcre_t_new((pcre_t **)&dst->ptr, config)) < 0)
return ret;
fdata = (pcre_t *)dst->ptr;
hash_holder_consume(ret, data, config, HDK(data));
if(ret == 0){
fdata->freeit = data;
fdata->data = &fdata->freeit;
}
return 0;
case FORMAT(config):;
case FORMAT(human):;
request_t r_config[] = {
{ HDK(regexp), *fargs->src },
hash_end
};
return pcre_t_new((pcre_t **)&dst->ptr, r_config);
default:
break;
};
return -ENOSYS;
} // }}}
static ssize_t data_complexkey_t_lookup(data_t *data, fastcall_lookup *fargs){ // {{{
ssize_t ret;
uintmax_t key = 0;
data_t d_key = DATA_PTR_UINTT(&key);
complexkey_t *fdata = (complexkey_t *)data->ptr;
if(fargs->value == NULL)
return -EINVAL;
data_get(ret, TYPE_UINTT, key, fargs->key);
if(ret < 0)
return ret;
if(key == 0)
return data_notconsumable_t(fargs->value, fdata->value);
key--;
fastcall_lookup r_lookup = { { 4, ACTION_LOOKUP }, &d_key, fargs->value };
return data_query(&fdata->cnext, &r_lookup);
} // }}}
static ssize_t data_allocator_fixed_t_convert_from(data_t *data, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
if(fargs->src == NULL)
return -EINVAL;
switch(fargs->format){
case FORMAT(hash):;
hash_t *config;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
return allocator_new((allocator_fixed_t **)&data->ptr, config);
default:
break;
};
return -ENOSYS;
} // }}}
static ssize_t data_list_t_lookup(data_t *data, fastcall_lookup *fargs){ // {{{
ssize_t ret;
uintmax_t key_uint;
data_t d_key;
data_t *d_key_ptr = &d_key;
list_t *fdata = (list_t *)data->ptr;
if(fargs->key == NULL || fargs->value == NULL)
return -EINVAL;
if(helper_key_current(fargs->key, &d_key) < 0)
d_key_ptr = fargs->key;
data_get(ret, TYPE_UINTT, key_uint, d_key_ptr);
if(ret == 0){
ctx_lookup ctx = { key_uint };
if(list_t_enum(fdata, (list_t_callback)&iter_list_t_lookup, &ctx) != 0)
return data_notconsumable_t(fargs->value, ctx.output);
}
return -EINVAL;
} // }}}
static ssize_t data_triplet_format_t_convert_from(data_t *dst, fastcall_convert_from *fargs) { // {{{
ssize_t ret;
switch(fargs->format) {
case FORMAT(hash):
;
hash_t *config;
if(dst->ptr != NULL)
return -EINVAL;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
return data_triplet_format_t_from_config(dst, config);
default:
break;
}
return -ENOSYS;
} // }}}
int mountdev(char *dev, char *mountpoint, GList **config)
{
char *type=NULL;
char *tmp=NULL;
FILE* fp;
// open fstab
if ((fp = fopen((char*)data_get(*config, "fstab"), "a")) == NULL)
{
perror(_("Could not open output file for writing"));
return(-1);
}
// mount
tmp = g_strdup_printf("%s/%s", TARGETDIR, mountpoint);
makepath(tmp);
FREE(tmp);
umount_if_needed(mountpoint);
tmp = g_strdup_printf("mount %s %s/%s",
dev, TARGETDIR, mountpoint);
fw_system(tmp);
FREE(tmp);
// unlink a possible stale lockfile
tmp = g_strdup_printf("%s/%s/tmp/pacman-g2.lck", TARGETDIR, mountpoint);
unlink(tmp);
FREE(tmp);
// make fstab entry
type = findmount(dev, 0);
char *uuid = get_uuid(dev);
fprintf(fp, "%-16s %-16s %-11s %-16s %-3s %s\n", uuid, mountpoint,
type, "defaults", "1", "1");
free(uuid);
free(type);
fclose(fp);
return(0);
}
static ssize_t data_ref_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret;
if(dst->ptr != NULL)
return data_ref_t_handler(dst, (fastcall_header *)fargs); // already inited - pass to underlying data
switch(fargs->format){
case FORMAT(hash):;
hash_t *config;
data_t data;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
hash_holder_consume(ret, data, config, HK(data));
return ( (dst->ptr = ref_t_alloc(&data)) == NULL ) ? -EFAULT : 0;
default:
break;
}
return -ENOSYS;
} // }}}
void msg_processing(uint8_t * mess) {
int data;
// Fonction:
// 0x01 pour READ
// 0x10 pour WRITE
switch(mess[FUNC]) {
case READ:
data = data_get(mess[ADDR]);
PutCharInFifo ( &descrFifoTX, START_BYTE);
PutCharInFifo ( &descrFifoTX, mess[FUNC]);
PutCharInFifo ( &descrFifoTX, mess[ADDR]);
PutCharInFifo ( &descrFifoTX, data);
break;
case WRITE:
data_set(mess[ADDR], mess[VALUE]);
break;
default:
break;
}
}
int run(GList **config)
{
GList *partlist;
char **nrdevs, *ptr, *op, *np, *dest;
int ret;
char my_buffer[MAX_LEN + 1] = "";
detect_parts(0);
// select swap partitions to use
partlist = selswap();
// format swap partitions
if(doswap(partlist, config) == -1)
return(-1);
// root partition
ptr = selrootdev();
if(ptr == NULL)
return(-1);
if(formatdev(ptr) == -1)
return(-1);
mountdev(ptr, "/", config);
// move temporarily stuff to the final location
chdir(TARGETDIR);
np = g_strdup_printf("%s/%s", TARGETDIR, "/etc/profile.d");
makepath(np);
FREE(np);
op = (char*)data_get(*config, "fstab");
np = g_strdup_printf("%s/%s", TARGETDIR, "/etc/fstab");
copyfile(op, np);
unlink(op);
chmod (np, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
data_put(config, "fstab", strdup(np));
FREE(np);
np = g_strdup_printf("%s/%s", TARGETDIR, "/etc/sysconfig");
makepath(np);
FREE(np);
// so that 1) the user can't mount a partition as /dev because
// it'll be used 2) install scriptlets will be able to do
// >/dev/null
makepath(TARGETDIR "/dev");
makepath(TARGETDIR "/proc");
makepath(TARGETDIR "/sys");
fw_system("mount none -t devtmpfs " TARGETDIR "/dev");
fw_system("mount none -t proc " TARGETDIR "/proc");
fw_system("mount none -t sysfs " TARGETDIR "/sys");
// non-root partitions
dialog_vars.backtitle=gen_backtitle(_("Selecting other partitions"));
while(1)
{
dialog_vars.input_result = my_buffer;
nrdevs = parts2dialog(parts);
dlg_put_backtitle();
dlg_clear();
dialog_vars.cancel_label = _("Continue");
dialog_vars.input_result = my_buffer;
dialog_vars.input_result[0]='\0';
ret = dialog_menu(
_("Select other Linux partitions for /etc/fstab"),
_("You may use your other partitions to distribute your Linux "
"system across more than one partition. Currently, you have "
"only mounted your / partition. You might want to mount "
"directories such as /boot, /home or /usr/local on separate "
"partitions. You should not try to mount /usr, /etc, /sbin or "
"/bin on their own partitions since they contain utilities "
"needed to bring the system up and mount partitions. Also, "
"do not reuse a partition that you've already entered before. "
"Please select one of the partitions listed below, or if "
"you're done, hit Continue."),
0, 0, 0, g_list_length(parts)/2, nrdevs);
dialog_vars.cancel_label = '\0';
FREE(nrdevs);
if (ret != DLG_EXIT_CANCEL)
{
if(!strcmp(_("(in use)"), dialog_vars.input_result))
continue;
ptr = strdup(dialog_vars.input_result);
if(formatdev(ptr) == -1)
return(-1);
dest = asktowhere(ptr);
if(dest == NULL)
return(-1);
mountdev(ptr, dest, config);
FREE(dest);
FREE(ptr);
}
else
break;
}
makepath(g_strdup_printf("%s/%s", TARGETDIR, "/var/log"));
np = g_strdup_printf("%s/%s", TARGETDIR, LOGFILE);
copyfile(LOGFILE, np);
unlink(LOGFILE);
chmod (np, S_IRUSR|S_IWUSR);
FREE(np);
// disable caching for cds
// this is needed here since when the cds is loaded we had no
// formatted root partition
if((char*)data_get(*config, "netinstall")==NULL)
{
char *pacbindir = g_strdup_printf("%s/frugalware-%s", SOURCEDIR, ARCH);
char *ptr;
ptr = g_strdup_printf("%s/var/cache/pacman-g2/pkg", TARGETDIR);
makepath(ptr);
FREE(ptr);
disable_cache(pacbindir);
FREE(pacbindir);
}
return(0);
}
static ssize_t data_list_t_convert_from(data_t *dst, fastcall_convert_from *fargs){ // {{{
ssize_t ret = 0;
list_t *fdata;
uintmax_t transfered = 0;
data_t sl_input = DATA_SLIDERT(fargs->src, 0);
switch(fargs->format){
case FORMAT(native):
case FORMAT(human):
case FORMAT(config):;
return data_list_t(dst);
case FORMAT(hash):;
hash_t *config;
data_get(ret, TYPE_HASHT, config, fargs->src);
if(ret != 0)
return -EINVAL;
if((fdata = dst->ptr) == NULL){
if( (fdata = dst->ptr = list_t_alloc()) == NULL)
return -ENOMEM;
}
if(hash_iter(config, (hash_iterator)&iter_list_t_convert_from, dst, 0) != ITER_OK){
list_t_free(dst->ptr);
return -EFAULT;
}
return 0;
case FORMAT(packed):;
data_t item;
data_t d_item = DATA_PTR_DATAT(&item);
if((fdata = dst->ptr) == NULL){
if( (fdata = dst->ptr = list_t_alloc()) == NULL)
return -ENOMEM;
}
while(1){
data_set_void(&item);
fastcall_convert_from r_convert = { { 5, ACTION_CONVERT_FROM }, &sl_input, FORMAT(packed) };
if( (ret = data_query(&d_item, &r_convert)) < 0)
break;
data_slider_t_set_offset(&sl_input, r_convert.transfered, SEEK_CUR);
if(item.type == TYPE_LISTENDT)
break;
if( (ret = list_t_push(fdata, &item)) < 0)
break;
}
transfered = data_slider_t_get_offset(&sl_input);
break;
default:
return -ENOSYS;
};
if(fargs->header.nargs >= 5)
fargs->transfered = transfered;
return ret;
} // }}}
int run(GList **config)
{
GList *drives=NULL;
int i;
int found = 0;
char *ptr;
umount_if_needed(SOURCEDIR);
dialog_vars.backtitle=gen_backtitle(_("Selecting source media"));
dlg_put_backtitle();
dlg_clear();
dialog_msgbox(_("Scanning"), _("Scanning for a CD/DVD drive containing "
"a Frugalware install disc..."), 0, 0, 0);
drives = grep_drives("/proc/sys/dev/cdrom/info");
for (i=0; i<g_list_length(drives); i++)
{
ptr = get_blkid((char*)g_list_nth_data(drives, i));
if(ptr && !strcmp(ptr, "Frugalware Install"))
{
LOG("install medium found in %s", (char*)g_list_nth_data(drives, i));
FREE(ptr);
ptr = g_strdup_printf("mount -o ro -t iso9660 /dev/%s %s", (char*)g_list_nth_data(drives, i),
SOURCEDIR);
fw_system(ptr);
data_put(config, "srcdev", (char*)g_list_nth_data(drives, i));
dlg_put_backtitle();
dialog_msgbox(_("CD/DVD drive found"), g_strdup_printf(_("A Frugalware install disc was found in device /dev/%s."), (char*)g_list_nth_data(drives, i)), 0, 0, 0);
if(is_netinstall(SOURCEDIR))
{
data_put(config, "netinstall", "");
LOG("install medium contains no packages, performing a network installation");
}
else
LOG("install medium contains packages, performing an offline installation");
found = 1;
break;
}
else
LOG("skipping non-install medium in %s", (char*)g_list_nth_data(drives, i));
FREE(ptr);
}
if(!found)
{
LOG("no package database found, performing a network installation");
data_put(config, "netinstall", "");
}
// disable caching for cds
if((char*)data_get(*config, "netinstall")==NULL)
{
char *pacbindir = g_strdup_printf("%s/frugalware-%s", SOURCEDIR, ARCH);
disable_cache(pacbindir);
FREE(pacbindir);
}
if(data_get(*config, "srcdev")==NULL)
{
LOG("no cd/dvd drive found, this is normal if you are running setup from a pendrive or in an emulator");
}
return(0);
}
