void Table::ajouter(unsigned int sock, std::string nom) { ENTER("ajouter(unsigned int sock, std::string nom)"); ADD_ARG("sock", sock); ADD_ARG("nom", nom); unsigned int i = 0; while(i < joueurs.size() && joueurs[i] >= 0) i++; if(i < joueurs.size()) { joueurs[i] = sock; noms[i] = nom; //Si on est complet, on lance la partie i = 0 ; while(i < joueurs.size() && joueurs[i] >= 0) i++; if(i >= joueurs.size()) { DEBUG<<"La partie commence..."<<std::endl; doit_recommencer(); emit complet(this); } } else { //En fait, la table était déjà pleine ! ERROR<<"Erreur : la table est pleine."<<std::endl; emit complet(this); emit doit_deconnecter(sock); //Sinon, la socket sera perdue } DEBUG<<"Joueurs : "<<joueurs<<std::endl; DEBUG<<"Noms : "<<noms<<std::endl; DEBUG<<"Ordres : "<<ordre<<std::endl; }
int do_wipefs (const char *device) { int force; int r; CLEANUP_FREE char *err = NULL; const size_t MAX_ARGS = 16; const char *argv[MAX_ARGS]; size_t i = 0; force = wipefs_has_force_option (); if (force == -1) return -1; ADD_ARG (argv, i, str_wipefs); ADD_ARG (argv, i, "-a"); if (force) ADD_ARG (argv, i, "--force"); ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s", err); return -1; } return 0; }
/* Takes optional arguments, consult optargs_bitmask. */ int do_ntfsfix (const char *device, int clearbadsectors) { const char *argv[MAX_ARGS]; size_t i = 0; int r; CLEANUP_FREE char *err = NULL; ADD_ARG (argv, i, str_ntfsfix); if ((optargs_bitmask & GUESTFS_NTFSFIX_CLEARBADSECTORS_BITMASK) && clearbadsectors) ADD_ARG (argv, i, "-b"); ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", device, err); return -1; } return 0; }
void Table::comprendre(unsigned int sock, Protocole::Message m) { ENTER("comprendre(unsigned int sock, Message m)"); ADD_ARG("sock", sock); ADD_ARG("m", m); //Attention : je ne suis pas sûr que sock fasse partie de la table ! for(unsigned int i = 0 ; i < joueurs.size() ; i++) { if(joueurs[ordre[i]] == (int)sock) { Protocole::Message reponse; switch(partie.tester(i, m)) { case 1 : reponse.type = Protocole::ERREUR_PROTOCOLE; DEBUG<<"Erreur de protocole détectée."<<std::endl; emit doit_emettre(sock, reponse); break; case 2 : reponse.type = Protocole::REFUSE; emit doit_emettre(sock, reponse); break; default : partie.assimiler(m); } i = joueurs.size(); } } }
/* Internal function used to wipe disks before we do 'mkfs'-type * operations on them. For the rationale see RHBZ#889888 and * RHBZ#907554. * * Note this is really destructive, so only call it just before doing * the 'mkfs' operation (ie. after doing as much pre-checking as * possible). Otherwise you could end up with a 'mkfs' operation * failing with an error but still wiping data. */ void wipe_device_before_mkfs (const char *device) { int force; const size_t MAX_ARGS = 16; const char *argv[MAX_ARGS]; size_t i = 0; force = wipefs_has_force_option (); if (force == -1) return; ADD_ARG (argv, i, str_wipefs); ADD_ARG (argv, i, "-a"); if (force) ADD_ARG (argv, i, "--force"); ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); ignore_value (commandv (NULL, NULL, argv)); /* XXX We could fall back to overwriting bits of disk here, but if * they don't have working wipefs, it seems unlikely they are using * btrfs which is what mostly causes this problem. See: * http://www.spinics.net/lists/linux-btrfs/msg21197.html */ }
int do_luks_kill_slot (const char *device, const char *key, int keyslot) { char *tempfile = write_key_to_temp (key); if (!tempfile) return -1; const char *argv[MAX_ARGS]; char keyslot_s[16]; size_t i = 0; ADD_ARG (argv, i, str_cryptsetup); ADD_ARG (argv, i, "-q"); ADD_ARG (argv, i, "-d"); ADD_ARG (argv, i, tempfile); ADD_ARG (argv, i, "luksKillSlot"); ADD_ARG (argv, i, device); snprintf (keyslot_s, sizeof keyslot_s, "%d", keyslot); ADD_ARG (argv, i, keyslot_s); ADD_ARG (argv, i, NULL); char *err; int r = commandv (NULL, &err, (const char * const *) argv); remove_temp (tempfile); if (r == -1) { reply_with_error ("%s", err); free (err); return -1; } free (err); return 0; }
void Table::doit_transmettre(unsigned int j, Protocole::Message m, bool analyser) { ENTER("doit_transmettre(unsigned int j, Protocole::Message m, bool analyser)"); ADD_ARG("j", j); ADD_ARG("m", m); ADD_ARG("analyser", analyser); DEBUG<<"Transmission à "<<j<<std::endl; DEBUG<<"Joueurs : "<<joueurs<<std::endl; DEBUG<<"Noms : "<<noms<<std::endl; DEBUG<<"Ordres : "<<ordre<<std::endl; emit doit_emettre(joueurs[ordre[j]], m); if(analyser) partie.assimiler(m); }
void libpd_add_symbol(const char *s) { t_symbol *x; sys_lock(); x = gensym(s); sys_unlock(); ADD_ARG(SETSYMBOL); }
void Table::enlever(unsigned int sock) { ENTER("enlever(unsigned int sock)"); ADD_ARG("sock", sock); //Attention : sock ne fait peut-être pas partie de la table ! unsigned int i = 0 ; while(i < joueurs.size() && (joueurs[i] < 0 || (unsigned int)joueurs[i] != sock)) i++; if(i < joueurs.size()) { joueurs[i] = -1 ; noms[i] = ""; //Comptons les joueurs restants. S'ils sont 4, il faut envoyer //le signal incomplet. unsigned int j = 0 ; for(unsigned int k = 0 ; k < joueurs.size() ; k++) if(joueurs[k]>=0) j++; if(j == 4) { //On vire tout le monde. Ça fait un paquet d'appels //récursifs, mais tant pis. for(unsigned int i = 0 ; i < joueurs.size() ; i++) { if(joueurs[i]>=0) { DEBUG<<"Déconnexion de "<<joueurs[i]<<std::endl; emit doit_deconnecter(joueurs[i]); } } DEBUG<<"Émission de Table::incomplet(Table *)..."<<std::endl; emit incomplet(this); } } }
Table::Table(QObject * parent) : QObject(parent) { ENTER("Table(QObject * parent)"); ADD_ARG("parent", parent); //Création des ordres : for(int i = 0 ; i < 5 ; i++) { joueurs.push_back(-1); // -1 : pas de joueur ordre.push_back(i); noms.push_back(""); } //Mélange de ordre : int r = 0 ; int tmp; for(unsigned int i = 1 ; i < ordre.size() ; i++) { r = rand() % (i + 1) ; //échange des cases i et r tmp = ordre[r]; ordre[r] = ordre[i]; ordre[i] = tmp; } QObject::connect(&partie, SIGNAL(doit_emettre (unsigned int, Protocole::Message, bool)), this, SLOT(doit_transmettre (unsigned int, Protocole::Message, bool))); QObject::connect(&partie, SIGNAL(termine()), this, SLOT(doit_recommencer())); nombre_tables++; DEBUG<<"Il y a maintenant "<<nombre_tables<<" table(s)."<<std::endl; }
static int luks_format (const char *device, const char *key, int keyslot, const char *cipher) { char *tempfile = write_key_to_temp (key); if (!tempfile) return -1; const char *argv[MAX_ARGS]; char keyslot_s[16]; size_t i = 0; ADD_ARG (argv, i, str_cryptsetup); ADD_ARG (argv, i, "-q"); if (cipher) { ADD_ARG (argv, i, "--cipher"); ADD_ARG (argv, i, cipher); } ADD_ARG (argv, i, "--key-slot"); snprintf (keyslot_s, sizeof keyslot_s, "%d", keyslot); ADD_ARG (argv, i, keyslot_s); ADD_ARG (argv, i, "luksFormat"); ADD_ARG (argv, i, device); ADD_ARG (argv, i, tempfile); ADD_ARG (argv, i, NULL); char *err; int r = commandv (NULL, &err, (const char * const *) argv); remove_temp (tempfile); if (r == -1) { reply_with_error ("%s", err); free (err); return -1; } free (err); udev_settle (); return 0; }
static int rsync (const char *src, const char *src_orig, const char *dest, const char *dest_orig, int archive, int deletedest) { const char *argv[MAX_ARGS]; size_t i = 0; int r; CLEANUP_FREE char *err = NULL; ADD_ARG (argv, i, str_rsync); if (archive) ADD_ARG (argv, i, "--archive"); if (deletedest) ADD_ARG (argv, i, "--delete"); ADD_ARG (argv, i, src); ADD_ARG (argv, i, dest); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("'%s' to '%s': %s", src_orig, dest_orig, err); return -1; } return 0; }
static int luks_open (const char *device, const char *key, const char *mapname, int readonly) { /* Sanity check: /dev/mapper/mapname must not exist already. Note * that the device-mapper control device (/dev/mapper/control) is * always there, so you can't ever have mapname == "control". */ size_t len = strlen (mapname); char devmapper[len+32]; snprintf (devmapper, len+32, "/dev/mapper/%s", mapname); if (access (devmapper, F_OK) == 0) { reply_with_error ("%s: device already exists", devmapper); return -1; } char *tempfile = write_key_to_temp (key); if (!tempfile) return -1; const char *argv[MAX_ARGS]; size_t i = 0; ADD_ARG (argv, i, str_cryptsetup); ADD_ARG (argv, i, "-d"); ADD_ARG (argv, i, tempfile); if (readonly) ADD_ARG (argv, i, "--readonly"); ADD_ARG (argv, i, "luksOpen"); ADD_ARG (argv, i, device); ADD_ARG (argv, i, mapname); ADD_ARG (argv, i, NULL); char *err; int r = commandv (NULL, &err, (const char * const *) argv); remove_temp (tempfile); if (r == -1) { reply_with_error ("%s", err); free (err); return -1; } free (err); udev_settle (); return 0; }
/* Takes optional arguments, consult optargs_bitmask. */ int do_mkswap (const char *device, const char *label, const char *uuid) { const size_t MAX_ARGS = 64; const char *argv[MAX_ARGS]; size_t i = 0; int r; CLEANUP_FREE char *err = NULL; ADD_ARG (argv, i, "mkswap"); ADD_ARG (argv, i, "-f"); if (optargs_bitmask & GUESTFS_MKSWAP_LABEL_BITMASK) { assert (label != NULL); /* suppress a warning with -O3 */ if (strlen (label) > SWAP_LABEL_MAX) { reply_with_error ("%s: Linux swap labels are limited to %d bytes", label, SWAP_LABEL_MAX); return -1; } ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, label); } if (optargs_bitmask & GUESTFS_MKSWAP_UUID_BITMASK) { ADD_ARG (argv, i, "-U"); ADD_ARG (argv, i, uuid); } ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); wipe_device_before_mkfs (device); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", device, err); return -1; } udev_settle (); return 0; }
/* Takes optional arguments, consult optargs_bitmask. */ int do_e2fsck (const char *device, int correct, int forceall) { const char *argv[MAX_ARGS]; CLEANUP_FREE char *err = NULL; size_t i = 0; int r; /* Default if not selected. */ if (!(optargs_bitmask & GUESTFS_E2FSCK_CORRECT_BITMASK)) correct = 0; if (!(optargs_bitmask & GUESTFS_E2FSCK_FORCEALL_BITMASK)) forceall = 0; if (correct && forceall) { reply_with_error ("only one of the options 'correct', 'forceall' may be specified"); return -1; } ADD_ARG (argv, i, str_e2fsck); ADD_ARG (argv, i, "-f"); if (correct) ADD_ARG (argv, i, "-p"); if (forceall) ADD_ARG (argv, i, "-y"); ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); r = commandrvf (NULL, &err, COMMAND_FLAG_FOLD_STDOUT_ON_STDERR, argv); /* 0 = no errors, 1 = errors corrected. * * >= 4 means uncorrected or other errors. * * 2, 3 means errors were corrected and we require a reboot. This is * a difficult corner case. */ if (r == -1 || r >= 2) { reply_with_error ("%s", err); return -1; } return 0; }
/* Takes optional arguments, consult optargs_bitmask. */ int do_ntfsresize (const char *device, int64_t size, int force) { char *err; int r; const char *argv[MAX_ARGS]; size_t i = 0; char size_str[32]; ADD_ARG (argv, i, str_ntfsresize); ADD_ARG (argv, i, "-P"); if (optargs_bitmask & GUESTFS_NTFSRESIZE_SIZE_BITMASK) { if (size <= 0) { reply_with_error ("size is zero or negative"); return -1; } snprintf (size_str, sizeof size_str, "%" PRIi64, size); ADD_ARG (argv, i, "--size"); ADD_ARG (argv, i, size_str); } if (optargs_bitmask & GUESTFS_NTFSRESIZE_FORCE_BITMASK && force) ADD_ARG (argv, i, "--force"); ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", device, err); free (err); return -1; } free (err); return 0; }
/* generate arguments to create OpenVZ container return -1 - error 0 - OK */ static int openvzDomainDefineCmd(const char *args[], int maxarg, virDomainDefPtr vmdef) { int narg; for (narg = 0; narg < maxarg; narg++) args[narg] = NULL; if (vmdef == NULL) { openvzError(VIR_ERR_INTERNAL_ERROR, "%s", _("Container is not defined")); return -1; } #define ADD_ARG(thisarg) \ do { \ if (narg >= maxarg) \ goto no_memory; \ args[narg++] = thisarg; \ } while (0) #define ADD_ARG_LIT(thisarg) \ do { \ if (narg >= maxarg) \ goto no_memory; \ if ((args[narg++] = strdup(thisarg)) == NULL) \ goto no_memory; \ } while (0) narg = 0; ADD_ARG_LIT(VZCTL); ADD_ARG_LIT("--quiet"); ADD_ARG_LIT("create"); ADD_ARG_LIT(vmdef->name); ADD_ARG_LIT("--name"); ADD_ARG_LIT(vmdef->name); if (vmdef->nfss == 1 && vmdef->fss[0]->type == VIR_DOMAIN_FS_TYPE_TEMPLATE) { ADD_ARG_LIT("--ostemplate"); ADD_ARG_LIT(vmdef->fss[0]->src); } #if 0 if ((vmdef->profile && *(vmdef->profile))) { ADD_ARG_LIT("--config"); ADD_ARG_LIT(vmdef->profile); } #endif ADD_ARG(NULL); return 0; no_memory: openvzError(VIR_ERR_INTERNAL_ERROR, _("Could not put argument to %s"), VZCTL); return -1; #undef ADD_ARG #undef ADD_ARG_LIT }
static int mount_fstype(fsu_fs_t *fs, const char *fsdev, char *mntopts, char *puffsexec, char *specopts, struct mount_data_s *mntdp, int verbose) { int argvlen; mntdp->mntd_fs = fs; mntdp->mntd_argc = mntdp->mntd_flags = 0; argvlen = 7; if (specopts != NULL) argvlen += fsu_str2argc(specopts); if (argvlen > mntdp->mntd_argv_size) { char **tmp; tmp = realloc(mntdp->mntd_argv, argvlen * sizeof(char *)); if (tmp == NULL) { if (mntdp->mntd_argv != NULL) free(mntdp->mntd_argv); return -1; } mntdp->mntd_argv = tmp; mntdp->mntd_argv_size = argvlen; } /* setting up the argv array */ ADD_ARG(mntdp, __UNCONST(getprogname())); #ifdef WITH_SYSPUFFS if (puffsexec != NULL && fs->fs_name == MOUNT_PUFFS) ADD_ARG(mntdp, puffsexec); #endif if (mntopts != NULL) { ADD_ARG(mntdp, __UNCONST("-o")); ADD_ARG(mntdp, mntopts); } if (specopts != NULL) { int tmpargc; fsu_str2arg(specopts, &tmpargc, mntdp->mntd_argv + mntdp->mntd_argc, argvlen - 6); mntdp->mntd_argc += tmpargc; } ADD_ARG(mntdp, __UNCONST(fsdev)); ADD_ARG(mntdp, __UNCONST("/")); mntdp->mntd_argv[mntdp->mntd_argc] = NULL; /* filesystem given */ if (fs != NULL) return mount_struct(verbose, mntdp); /* filesystem not given (auto detection) */ for (fs = fslist; fs->fs_name != NULL; ++fs) { if (verbose) printf("Trying with fs %s\n", fs->fs_name); if (fs->fs_flags & FS_NO_AUTO) continue; mntdp->mntd_flags = 0; mntdp->mntd_fs = fs; if (mount_struct(verbose > 1, mntdp) == 0) return 0; } return -1; }
/* Takes optional arguments, consult optargs_bitmask. */ int do_mkfs_opts (const char *fstype, const char *device, int blocksize, const char *features, int inode, int sectorsize) { const char *argv[MAX_ARGS]; size_t i = 0; char blocksize_str[32]; char inode_str[32]; char sectorsize_str[32]; int r; char *err; char mke2fs[] = "mke2fs"; int extfs = 0; if (STREQ (fstype, "ext2") || STREQ (fstype, "ext3") || STREQ (fstype, "ext4")) extfs = 1; /* For ext2/3/4 run the mke2fs program directly. This is because * the mkfs program "eats" some options, in particular the -F * option. */ if (extfs) { if (e2prog (mke2fs) == -1) return -1; ADD_ARG (argv, i, mke2fs); } else ADD_ARG (argv, i, "mkfs"); ADD_ARG (argv, i, "-t"); ADD_ARG (argv, i, fstype); /* Force mke2fs to create a filesystem, even if it thinks it * shouldn't (RHBZ#690819). */ if (extfs) ADD_ARG (argv, i, "-F"); /* mkfs.ntfs requires the -Q argument otherwise it writes zeroes * to every block and does bad block detection, neither of which * are useful behaviour for virtual devices. */ if (STREQ (fstype, "ntfs")) ADD_ARG (argv, i, "-Q"); /* mkfs.reiserfs produces annoying interactive prompts unless you * tell it to be quiet. * mkfs.jfs is the same * mkfs.xfs must force to make xfs filesystem when the device already * has a filesystem on it */ if (STREQ (fstype, "reiserfs") || STREQ (fstype, "jfs") || STREQ (fstype, "xfs")) ADD_ARG(argv, i, "-f"); /* For GFS, GFS2, assume a single node. */ if (STREQ (fstype, "gfs") || STREQ (fstype, "gfs2")) { ADD_ARG (argv, i, "-p"); ADD_ARG (argv, i, "lock_nolock"); /* The man page says this is default, but it doesn't seem to be: */ ADD_ARG (argv, i, "-j"); ADD_ARG (argv, i, "1"); /* Don't ask questions: */ ADD_ARG (argv, i, "-O"); } /* Process blocksize parameter if set. */ if (optargs_bitmask & GUESTFS_MKFS_OPTS_BLOCKSIZE_BITMASK) { if (blocksize <= 0 || !is_power_of_2 (blocksize)) { reply_with_error ("block size must be > 0 and a power of 2"); return -1; } if (STREQ (fstype, "vfat") || STREQ (fstype, "msdos")) { /* For VFAT map the blocksize into a cluster size. However we * have to determine the block device sector size in order to do * this. */ int sectorsize = do_blockdev_getss (device); if (sectorsize == -1) return -1; int sectors_per_cluster = blocksize / sectorsize; if (sectors_per_cluster < 1 || sectors_per_cluster > 128) { reply_with_error ("unsupported cluster size for %s filesystem (requested cluster size = %d, sector size = %d, trying sectors per cluster = %d)", fstype, blocksize, sectorsize, sectors_per_cluster); return -1; } snprintf (blocksize_str, sizeof blocksize_str, "%d", sectors_per_cluster); ADD_ARG (argv, i, "-s"); ADD_ARG (argv, i, blocksize_str); } else if (STREQ (fstype, "ntfs")) { /* For NTFS map the blocksize into a cluster size. */ snprintf (blocksize_str, sizeof blocksize_str, "%d", blocksize); ADD_ARG (argv, i, "-c"); ADD_ARG (argv, i, blocksize_str); } else { /* For all other filesystem types, try the -b option. */ snprintf (blocksize_str, sizeof blocksize_str, "%d", blocksize); ADD_ARG (argv, i, "-b"); ADD_ARG (argv, i, blocksize_str); } } if (optargs_bitmask & GUESTFS_MKFS_OPTS_FEATURES_BITMASK) { ADD_ARG (argv, i, "-O"); ADD_ARG (argv, i, features); } if (optargs_bitmask & GUESTFS_MKFS_OPTS_INODE_BITMASK) { if (!extfs) { reply_with_error ("inode size (-I) can only be set on ext2/3/4 filesystems"); return -1; } if (inode <= 0) { reply_with_error ("inode size must be larger than zero"); return -1; } snprintf (inode_str, sizeof inode_str, "%d", inode); ADD_ARG (argv, i, "-I"); ADD_ARG (argv, i, inode_str); } if (optargs_bitmask & GUESTFS_MKFS_OPTS_SECTORSIZE_BITMASK) { if (!STREQ (fstype, "ufs")) { reply_with_error ("sector size (-S) can only be set on ufs filesystems"); return -1; } if (sectorsize <= 0) { reply_with_error ("sector size must be larger than zero"); return -1; } snprintf (sectorsize_str, sizeof sectorsize_str, "%d", sectorsize); ADD_ARG (argv, i, "-S"); ADD_ARG (argv, i, sectorsize_str); } ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s: %s", fstype, device, err); free (err); return -1; } free (err); return 0; }
int do_xfs_admin (const char *device, int extunwritten, int imgfile, int v2log, int projid32bit, int lazycounter, const char *label, const char *uuid) { int r; CLEANUP_FREE char *err = NULL; const char *argv[MAX_ARGS]; size_t i = 0; ADD_ARG (argv, i, str_xfs_admin); /* Optional arguments */ if (!(optargs_bitmask & GUESTFS_XFS_ADMIN_EXTUNWRITTEN_BITMASK)) extunwritten = 0; if (!(optargs_bitmask & GUESTFS_XFS_ADMIN_IMGFILE_BITMASK)) imgfile = 0; if (!(optargs_bitmask & GUESTFS_XFS_ADMIN_V2LOG_BITMASK)) v2log = 0; if (!(optargs_bitmask & GUESTFS_XFS_ADMIN_PROJID32BIT_BITMASK)) projid32bit = 0; if (extunwritten) ADD_ARG (argv, i, "-e"); if (imgfile) ADD_ARG (argv, i, "-f"); if (v2log) ADD_ARG (argv, i, "-j"); if (projid32bit) ADD_ARG (argv, i, "-p"); if (optargs_bitmask & GUESTFS_XFS_ADMIN_LAZYCOUNTER_BITMASK) { if (lazycounter) { ADD_ARG (argv, i, "-c"); ADD_ARG (argv, i, "1"); } else { ADD_ARG (argv, i, "-c"); ADD_ARG (argv, i, "0"); } } if (optargs_bitmask & GUESTFS_XFS_ADMIN_LABEL_BITMASK) { if (strlen (label) > XFS_LABEL_MAX) { reply_with_error ("%s: xfs labels are limited to %d bytes", label, XFS_LABEL_MAX); return -1; } ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, label); } if (optargs_bitmask & GUESTFS_XFS_ADMIN_UUID_BITMASK) { ADD_ARG (argv, i, "-U"); ADD_ARG (argv, i, uuid); } ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", device, err); return -1; } return 0; }
static int mount_alias(struct fsu_fsalias_s *al, char *mntopts, char *specopts, struct mount_data_s *mntdp, int verbose) { fsu_fs_t *cur; int argvlen; mntdp->mntd_argc = mntdp->mntd_flags = 0; argvlen = 9; if (specopts != NULL) argvlen += fsu_str2argc(specopts); if (argvlen > mntdp->mntd_argv_size) { char **tmp; tmp = realloc(mntdp->mntd_argv, argvlen * sizeof(char *)); if (tmp == NULL) { free(mntdp->mntd_argv); return -1; } mntdp->mntd_argv = tmp; mntdp->mntd_argv_size = argvlen; } ADD_ARG(mntdp, __UNCONST(getprogname())); #ifdef WITH_SYSPUFFS if (al->fsa_puffsexec != NULL) ADD_ARG(mntdp, al->fsa_puffsexec); #endif if (al->fsa_mntopt != NULL) { ADD_ARG(mntdp, __UNCONST("-o")); ADD_ARG(mntdp, al->fsa_mntopt); setenv("FSU_MNTOPTS", al->fsa_mntopt, 1); } if (mntopts != NULL) { ADD_ARG(mntdp, __UNCONST("-o")); ADD_ARG(mntdp, mntopts); setenv("FSU_MNTOPTS", mntopts, 1); } if (specopts != NULL) { int tmpargc; fsu_str2arg(specopts, &tmpargc, mntdp->mntd_argv + mntdp->mntd_argc, argvlen - 8); mntdp->mntd_argc += tmpargc; } ADD_ARG(mntdp, al->fsa_path); ADD_ARG(mntdp, __UNCONST("/")); mntdp->mntd_argv[mntdp->mntd_argc] = NULL; for (cur = fslist; cur->fs_name != NULL; ++cur) if (strcmp(cur->fs_name, al->fsa_type) == 0) break; if (cur->fs_name == NULL) return -1; mntdp->mntd_fs = cur; return mount_struct(verbose, mntdp); }
int do_xfs_repair (const char *device, int forcelogzero, int nomodify, int noprefetch, int forcegeometry, int64_t maxmem, int64_t ihashsize, int64_t bhashsize, int64_t agstride, const char *logdev, const char *rtdev) { int r; CLEANUP_FREE char *err = NULL, *buf = NULL; const char *argv[MAX_ARGS]; char maxmem_s[64]; char ihashsize_s[70]; char bhashsize_s[70]; char agstride_s[74]; size_t i = 0; int is_device; ADD_ARG (argv, i, str_xfs_repair); /* Optional arguments */ if (optargs_bitmask & GUESTFS_XFS_REPAIR_FORCELOGZERO_BITMASK) { if (forcelogzero) ADD_ARG (argv, i, "-L"); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_NOMODIFY_BITMASK) { if (nomodify) ADD_ARG (argv, i, "-n"); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_NOPREFETCH_BITMASK) { if (noprefetch) ADD_ARG (argv, i, "-P"); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_FORCEGEOMETRY_BITMASK) { if (forcegeometry) { ADD_ARG (argv, i, "-o"); ADD_ARG (argv, i, "force_geometry"); } } if (optargs_bitmask & GUESTFS_XFS_REPAIR_MAXMEM_BITMASK) { if (maxmem < 0) { reply_with_error ("maxmem must be >= 0"); return -1; } snprintf (maxmem_s, sizeof maxmem_s, "%" PRIi64, maxmem); ADD_ARG (argv, i, "-m"); ADD_ARG (argv, i, maxmem_s); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_IHASHSIZE_BITMASK) { if (ihashsize < 0) { reply_with_error ("ihashsize must be >= 0"); return -1; } snprintf (ihashsize_s, sizeof ihashsize_s, "ihash=" "%" PRIi64, ihashsize); ADD_ARG (argv, i, "-o"); ADD_ARG (argv, i, ihashsize_s); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_BHASHSIZE_BITMASK) { if (bhashsize < 0) { reply_with_error ("bhashsize must be >= 0"); return -1; } snprintf (bhashsize_s, sizeof bhashsize_s, "bhash=" "%" PRIi64, bhashsize); ADD_ARG (argv, i, "-o"); ADD_ARG (argv, i, bhashsize_s); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_AGSTRIDE_BITMASK) { if (agstride < 0) { reply_with_error ("agstride must be >= 0"); return -1; } snprintf (agstride_s, sizeof agstride_s, "ag_stride=" "%" PRIi64, agstride); ADD_ARG (argv, i, "-o"); ADD_ARG (argv, i, agstride_s); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_LOGDEV_BITMASK) { ADD_ARG (argv, i, "-l"); ADD_ARG (argv, i, logdev); } if (optargs_bitmask & GUESTFS_XFS_REPAIR_RTDEV_BITMASK) { ADD_ARG (argv, i, "-r"); ADD_ARG (argv, i, rtdev); } is_device = STREQLEN (device, "/dev/", 5); if (!is_device) { buf = sysroot_path (device); if (buf == NULL) { reply_with_perror ("malloc"); return -1; } ADD_ARG (argv, i, "-f"); ADD_ARG (argv, i, buf); } else { ADD_ARG (argv, i, device); } ADD_ARG (argv, i, NULL); r = commandrv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", device, err); return -1; } return r; }
static void get_client_info(char *info, const struct device *d) { int l = 0; struct group *g = d->group; struct db_device *dd = d->db_data; struct db_group *dg = g->db_data; struct db_discuss *dsc = g->discuss.current; struct db_vote *dvt = d->vote.v ? g->vote.current : NULL; const char *ver = get_client_version(); #define ADD_ARG(fmt, a...) SEP_ADD(info, l, ":", fmt, ##a) ADD_ARG("client_version=%s", ver[0]? ver:"0"); ADD_ARG("user_id=%s", dd->user_id); ADD_ARG("user_name=%s", dd->user_name); ADD_ARG("user_gender=%d", dd->user_gender); ADD_ARG("tag=%d", dd->tagid); ADD_ARG("sub=%d,%d", dd->sub1, dd->sub2); ADD_ARG("discuss_mode=%d", dg->discuss_mode); ADD_ARG("discuss_num=%d", dsc? g->discuss.curr_num : -1); ADD_ARG("discuss_name=%s", dsc? dsc->name : "0"); ADD_ARG("discuss_nmembers=%d", g->discuss.nmembers); ADD_ARG("discuss_idlist=%s", dsc? dsc->members : "0"); ADD_ARG("discuss_userlist=%s", dsc? g->discuss.membernames : "0"); ADD_ARG("discuss_chair=%d", dd->discuss_chair); ADD_ARG("discuss_open=%d", dd->discuss_open); ADD_ARG("regist_start=%d", dg->regist_start); ADD_ARG("regist_master=%d", dd->regist_master); ADD_ARG("regist_mode=%d", dg->regist_mode); ADD_ARG("regist_reg=%d", d->regist.reg); ADD_ARG("vote_num=%d", dvt? g->vote.curr_num : -1); ADD_ARG("vote_nmembers=%d", g->vote.nmembers); ADD_ARG("vote_idlist=%s", dvt? dvt->members : "0"); ADD_ARG("vote_userlist=%s", dvt? g->vote.membernames : "0"); ADD_ARG("vote_master=%d", dvt? dd->vote_master:0); ADD_ARG("vote_name=%s", dvt? dvt->name:"0"); ADD_ARG("vote_type=%d", dvt? dvt->type:0); ADD_ARG("vote_options=%s", dvt? dvt->options:"0"); ADD_ARG("vote_total=%d", d->vote.v? d->vote.v->n_members:0); ADD_ARG("vote_results=%s", dg->vote_results); ADD_ARG("vote_choice=%d", dd->vote_choice); }
int do_xfs_growfs (const char *path, int datasec, int logsec, int rtsec, int64_t datasize, int64_t logsize, int64_t rtsize, int64_t rtextsize, int32_t maxpct) { int r; CLEANUP_FREE char *buf = NULL, *err = NULL; const char *argv[MAX_ARGS]; char datasize_s[64]; char logsize_s[64]; char rtsize_s[64]; char rtextsize_s[64]; char maxpct_s[32]; size_t i = 0; buf = sysroot_path (path); if (buf == NULL) { reply_with_perror ("malloc"); return -1; } ADD_ARG (argv, i, str_xfs_growfs); /* Optional arguments */ if (!(optargs_bitmask & GUESTFS_XFS_GROWFS_DATASEC_BITMASK)) datasec = 0; if (!(optargs_bitmask & GUESTFS_XFS_GROWFS_LOGSEC_BITMASK)) logsec = 0; if (!(optargs_bitmask & GUESTFS_XFS_GROWFS_RTSEC_BITMASK)) rtsec = 0; if (datasec) ADD_ARG (argv, i, "-d"); if (logsec) ADD_ARG (argv, i, "-l"); if (rtsec) ADD_ARG (argv, i, "-r"); if (optargs_bitmask & GUESTFS_XFS_GROWFS_DATASIZE_BITMASK) { if (datasize < 0) { reply_with_error ("datasize must be >= 0"); return -1; } snprintf (datasize_s, sizeof datasize_s, "%" PRIi64, datasize); ADD_ARG (argv, i, "-D"); ADD_ARG (argv, i, datasize_s); } if (optargs_bitmask & GUESTFS_XFS_GROWFS_LOGSIZE_BITMASK) { if (logsize < 0) { reply_with_error ("logsize must be >= 0"); return -1; } snprintf (logsize_s, sizeof logsize_s, "%" PRIi64, logsize); ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, logsize_s); } if (optargs_bitmask & GUESTFS_XFS_GROWFS_RTSIZE_BITMASK) { if (rtsize < 0) { reply_with_error ("rtsize must be >= 0"); return -1; } snprintf (rtsize_s, sizeof rtsize_s, "%" PRIi64, rtsize); ADD_ARG (argv, i, "-R"); ADD_ARG (argv, i, rtsize_s); } if (optargs_bitmask & GUESTFS_XFS_GROWFS_RTEXTSIZE_BITMASK) { if (rtextsize < 0) { reply_with_error ("rtextsize must be >= 0"); return -1; } snprintf (rtextsize_s, sizeof rtextsize_s, "%" PRIi64, rtextsize); ADD_ARG (argv, i, "-e"); ADD_ARG (argv, i, rtextsize_s); } if (optargs_bitmask & GUESTFS_XFS_GROWFS_MAXPCT_BITMASK) { if (maxpct < 0) { reply_with_error ("maxpct must be >= 0"); return -1; } snprintf (maxpct_s, sizeof maxpct_s, "%" PRIi32, maxpct); ADD_ARG (argv, i, "-m"); ADD_ARG (argv, i, maxpct_s); } ADD_ARG (argv, i, buf); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", path, err); return -1; } return 0; }
/* Takes optional arguments, consult optargs_bitmask. */ int do_tune2fs (const char *device, /* only required parameter */ int force, int maxmountcount, int mountcount, const char *errorbehavior, int64_t group, int intervalbetweenchecks, int reservedblockspercentage, const char *lastmounteddirectory, int64_t reservedblockscount, int64_t user) { const char *argv[MAX_ARGS]; size_t i = 0; int r; CLEANUP_FREE char *err = NULL; char maxmountcount_s[64]; char mountcount_s[64]; char group_s[64]; char intervalbetweenchecks_s[64]; char reservedblockspercentage_s[64]; char reservedblockscount_s[64]; char user_s[64]; ADD_ARG (argv, i, str_tune2fs); if (optargs_bitmask & GUESTFS_TUNE2FS_FORCE_BITMASK) { if (force) ADD_ARG (argv, i, "-f"); } if (optargs_bitmask & GUESTFS_TUNE2FS_MAXMOUNTCOUNT_BITMASK) { if (maxmountcount < 0) { reply_with_error ("maxmountcount cannot be negative"); return -1; } ADD_ARG (argv, i, "-c"); snprintf (maxmountcount_s, sizeof maxmountcount_s, "%d", maxmountcount); ADD_ARG (argv, i, maxmountcount_s); } if (optargs_bitmask & GUESTFS_TUNE2FS_MOUNTCOUNT_BITMASK) { if (mountcount < 0) { reply_with_error ("mountcount cannot be negative"); return -1; } ADD_ARG (argv, i, "-C"); snprintf (mountcount_s, sizeof mountcount_s, "%d", mountcount); ADD_ARG (argv, i, mountcount_s); } if (optargs_bitmask & GUESTFS_TUNE2FS_ERRORBEHAVIOR_BITMASK) { if (STRNEQ (errorbehavior, "continue") && STRNEQ (errorbehavior, "remount-ro") && STRNEQ (errorbehavior, "panic")) { reply_with_error ("invalid errorbehavior parameter: %s", errorbehavior); return -1; } ADD_ARG (argv, i, "-e"); ADD_ARG (argv, i, errorbehavior); } if (optargs_bitmask & GUESTFS_TUNE2FS_GROUP_BITMASK) { if (group < 0) { reply_with_error ("group cannot be negative"); return -1; } ADD_ARG (argv, i, "-g"); snprintf (group_s, sizeof group_s, "%" PRIi64, group); ADD_ARG (argv, i, group_s); } if (optargs_bitmask & GUESTFS_TUNE2FS_INTERVALBETWEENCHECKS_BITMASK) { if (intervalbetweenchecks < 0) { reply_with_error ("intervalbetweenchecks cannot be negative"); return -1; } ADD_ARG (argv, i, "-i"); if (intervalbetweenchecks > 0) { /* -i <NN>s is not documented in the man page, but has been * supported in tune2fs for several years. */ snprintf (intervalbetweenchecks_s, sizeof intervalbetweenchecks_s, "%ds", intervalbetweenchecks); ADD_ARG (argv, i, intervalbetweenchecks_s); } else ADD_ARG (argv, i, "0"); } if (optargs_bitmask & GUESTFS_TUNE2FS_RESERVEDBLOCKSPERCENTAGE_BITMASK) { if (reservedblockspercentage < 0) { reply_with_error ("reservedblockspercentage cannot be negative"); return -1; } ADD_ARG (argv, i, "-m"); snprintf (reservedblockspercentage_s, sizeof reservedblockspercentage_s, "%d", reservedblockspercentage); ADD_ARG (argv, i, reservedblockspercentage_s); } if (optargs_bitmask & GUESTFS_TUNE2FS_LASTMOUNTEDDIRECTORY_BITMASK) { ADD_ARG (argv, i, "-M"); ADD_ARG (argv, i, lastmounteddirectory); } if (optargs_bitmask & GUESTFS_TUNE2FS_RESERVEDBLOCKSCOUNT_BITMASK) { if (reservedblockscount < 0) { reply_with_error ("reservedblockscount cannot be negative"); return -1; } ADD_ARG (argv, i, "-r"); snprintf (reservedblockscount_s, sizeof reservedblockscount_s, "%" PRIi64, reservedblockscount); ADD_ARG (argv, i, reservedblockscount_s); } if (optargs_bitmask & GUESTFS_TUNE2FS_USER_BITMASK) { if (user < 0) { reply_with_error ("user cannot be negative"); return -1; } ADD_ARG (argv, i, "-u"); snprintf (user_s, sizeof user_s, "%" PRIi64, user); ADD_ARG (argv, i, user_s); } ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", device, err); return -1; } return 0; }
void libpd_add_float(float x) { ADD_ARG(SETFLOAT); }
int do_mke2fs (const char *device, /* 0 */ int64_t blockscount, int64_t blocksize, int64_t fragsize, int64_t blockspergroup, int64_t numberofgroups, /* 5 */ int64_t bytesperinode, int64_t inodesize, int64_t journalsize, int64_t numberofinodes, int64_t stridesize, /* 10 */ int64_t stripewidth, int64_t maxonlineresize, int reservedblockspercentage, int mmpupdateinterval, const char *journaldevice, /* 15 */ const char *label, const char *lastmounteddir, const char *creatoros, const char *fstype, const char *usagetype, /* 20 */ const char *uuid, int forcecreate, int writesbandgrouponly, int lazyitableinit, int lazyjournalinit, /* 25 */ int testfs, int discard, int quotatype, int extent, int filetype, /* 30 */ int flexbg, int hasjournal, int journaldev, int largefile, int quota, /* 35 */ int resizeinode, int sparsesuper, int uninitbg) { int r; CLEANUP_FREE char *err = NULL; const char *argv[MAX_ARGS]; char blockscount_s[64]; char blocksize_s[64]; char fragsize_s[64]; char blockspergroup_s[64]; char numberofgroups_s[64]; char bytesperinode_s[64]; char inodesize_s[64]; char journalsize_s[64]; CLEANUP_FREE char *journaldevice_translated = NULL; CLEANUP_FREE char *journaldevice_s = NULL; char reservedblockspercentage_s[64]; char numberofinodes_s[64]; char mmpupdateinterval_s[84]; char stridesize_s[74]; char stripewidth_s[84]; char maxonlineresize_s[74]; size_t i = 0; ADD_ARG (argv, i, str_mke2fs); if (optargs_bitmask & GUESTFS_MKE2FS_BLOCKSIZE_BITMASK) { if (blocksize < 0) { reply_with_error ("blocksize must be >= 0"); return -1; } snprintf (blocksize_s, sizeof blocksize_s, "%" PRIi64, blocksize); ADD_ARG (argv, i, "-b"); ADD_ARG (argv, i, blocksize_s); } if (optargs_bitmask & GUESTFS_MKE2FS_FRAGSIZE_BITMASK) { if (fragsize < 0) { reply_with_error ("fragsize must be >= 0"); return -1; } snprintf (fragsize_s, sizeof fragsize_s, "%" PRIi64, fragsize); ADD_ARG (argv, i, "-f"); ADD_ARG (argv, i, fragsize_s); } if (optargs_bitmask & GUESTFS_MKE2FS_FORCECREATE_BITMASK) { if (forcecreate) ADD_ARG (argv, i, "-F"); } if (optargs_bitmask & GUESTFS_MKE2FS_BLOCKSPERGROUP_BITMASK) { if (blockspergroup < 0) { reply_with_error ("blockspergroup must be >= 0"); return -1; } snprintf (blockspergroup_s, sizeof blockspergroup_s, "%" PRIi64, blockspergroup); ADD_ARG (argv, i, "-g"); ADD_ARG (argv, i, blockspergroup_s); } if (optargs_bitmask & GUESTFS_MKE2FS_NUMBEROFGROUPS_BITMASK) { if (numberofgroups < 0) { reply_with_error ("numberofgroups must be >= 0"); return -1; } snprintf (numberofgroups_s, sizeof numberofgroups_s, "%" PRIi64, numberofgroups); ADD_ARG (argv, i, "-G"); ADD_ARG (argv, i, numberofgroups_s); } if (optargs_bitmask & GUESTFS_MKE2FS_BYTESPERINODE_BITMASK) { if (bytesperinode < 0) { reply_with_error ("bytesperinode must be >= 0"); return -1; } snprintf (bytesperinode_s, sizeof bytesperinode_s, "%" PRIi64, bytesperinode); ADD_ARG (argv, i, "-i"); ADD_ARG (argv, i, bytesperinode_s); } if (optargs_bitmask & GUESTFS_MKE2FS_INODESIZE_BITMASK) { if (inodesize < 0) { reply_with_error ("inodesize must be >= 0"); return -1; } snprintf (inodesize_s, sizeof inodesize_s, "%" PRIi64, inodesize); ADD_ARG (argv, i, "-I"); ADD_ARG (argv, i, inodesize_s); } if (optargs_bitmask & GUESTFS_MKE2FS_JOURNALSIZE_BITMASK) { if (journalsize < 0) { reply_with_error ("journalsize must be >= 0"); return -1; } snprintf (journalsize_s, sizeof journalsize_s, "size=" "%" PRIi64, journalsize); ADD_ARG (argv, i, "-J"); ADD_ARG (argv, i, journalsize_s); } if (optargs_bitmask & GUESTFS_MKE2FS_JOURNALDEVICE_BITMASK) { if (journaldevice) { /* OString doesn't do device name translation (RHBZ#876579). We * have to do it manually here, but note that LABEL=.. and * UUID=.. are valid strings which do not require translation. */ if (STRPREFIX (journaldevice, "/dev/")) { if (is_root_device (journaldevice)) { reply_with_error ("%s: device not found", journaldevice); return -1; } journaldevice_translated = device_name_translation (journaldevice); if (journaldevice_translated == NULL) { reply_with_perror ("%s", journaldevice); return -1; } journaldevice_s = malloc (strlen (journaldevice_translated) + 8); if (!journaldevice_s) { reply_with_perror ("malloc"); return -1; } sprintf (journaldevice_s, "device=%s", journaldevice_translated); } else { journaldevice_s = malloc (strlen (journaldevice) + 8); if (!journaldevice_s) { reply_with_perror ("malloc"); return -1; } sprintf (journaldevice_s, "device=%s", journaldevice); } ADD_ARG (argv, i, "-J"); ADD_ARG (argv, i, journaldevice_s); } } if (optargs_bitmask & GUESTFS_MKE2FS_LABEL_BITMASK) { if (label) { ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, label); } } if (optargs_bitmask & GUESTFS_MKE2FS_RESERVEDBLOCKSPERCENTAGE_BITMASK) { if (reservedblockspercentage < 0) { reply_with_error ("reservedblockspercentage must be >= 0"); return -1; } snprintf (reservedblockspercentage_s, sizeof reservedblockspercentage_s, "%" PRIi32, reservedblockspercentage); ADD_ARG (argv, i, "-m"); ADD_ARG (argv, i, reservedblockspercentage_s); } if (optargs_bitmask & GUESTFS_MKE2FS_LASTMOUNTEDDIR_BITMASK) { if (lastmounteddir) { ADD_ARG (argv, i, "-M"); ADD_ARG (argv, i, lastmounteddir); } } if (optargs_bitmask & GUESTFS_MKE2FS_NUMBEROFINODES_BITMASK) { if (numberofinodes < 0) { reply_with_error ("numberofinodes must be >= 0"); return -1; } snprintf (numberofinodes_s, sizeof numberofinodes_s, "%" PRIi64, numberofinodes); ADD_ARG (argv, i, "-N"); ADD_ARG (argv, i, numberofinodes_s); } if (optargs_bitmask & GUESTFS_MKE2FS_CREATOROS_BITMASK) { if (creatoros) { ADD_ARG (argv, i, "-o"); ADD_ARG (argv, i, creatoros); } } if (optargs_bitmask & GUESTFS_MKE2FS_WRITESBANDGROUPONLY_BITMASK) { if (writesbandgrouponly) ADD_ARG (argv, i, "-S"); } if (optargs_bitmask & GUESTFS_MKE2FS_FSTYPE_BITMASK) { if (fstype) { if (!fstype_is_extfs (fstype)) { reply_with_error ("%s: not a valid extended filesystem type", fstype); return -1; } ADD_ARG (argv, i, "-t"); ADD_ARG (argv, i, fstype); } } if (optargs_bitmask & GUESTFS_MKE2FS_USAGETYPE_BITMASK) { if (usagetype) { ADD_ARG (argv, i, "-T"); ADD_ARG (argv, i, usagetype); } } if (optargs_bitmask & GUESTFS_MKE2FS_UUID_BITMASK) { if (uuid) { ADD_ARG (argv, i, "-U"); ADD_ARG (argv, i, uuid); } } if (optargs_bitmask & GUESTFS_MKE2FS_MMPUPDATEINTERVAL_BITMASK) { if (mmpupdateinterval < 0) { reply_with_error ("mmpupdateinterval must be >= 0"); return -1; } snprintf (mmpupdateinterval_s, sizeof mmpupdateinterval_s, "mmp_update_interval=" "%" PRIi32, mmpupdateinterval); ADD_ARG (argv, i, "-E"); ADD_ARG (argv, i, mmpupdateinterval_s); } if (optargs_bitmask & GUESTFS_MKE2FS_STRIDESIZE_BITMASK) { if (stridesize < 0) { reply_with_error ("stridesize must be >= 0"); return -1; } snprintf (stridesize_s, sizeof stridesize_s, "stride=" "%" PRIi64, stridesize); ADD_ARG (argv, i, "-E"); ADD_ARG (argv, i, stridesize_s); } if (optargs_bitmask & GUESTFS_MKE2FS_STRIPEWIDTH_BITMASK) { if (stripewidth< 0) { reply_with_error ("stripewidth must be >= 0"); return -1; } snprintf (stripewidth_s, sizeof stripewidth_s, "stripe_width=" "%" PRIi64, stripewidth); ADD_ARG (argv, i, "-E"); ADD_ARG (argv, i, stripewidth_s); } if (optargs_bitmask & GUESTFS_MKE2FS_MAXONLINERESIZE_BITMASK) { if (maxonlineresize < 0) { reply_with_error ("maxonlineresize must be >= 0"); return -1; } snprintf (maxonlineresize_s, sizeof maxonlineresize_s, "resize=" "%" PRIi64, maxonlineresize); ADD_ARG (argv, i, "-E"); ADD_ARG (argv, i, maxonlineresize_s); } if (optargs_bitmask & GUESTFS_MKE2FS_LAZYITABLEINIT_BITMASK) { ADD_ARG (argv, i, "-E"); if (lazyitableinit) ADD_ARG (argv, i, "lazy_itable_init=1"); else ADD_ARG (argv, i, "lazy_itable_init=0"); } if (optargs_bitmask & GUESTFS_MKE2FS_LAZYJOURNALINIT_BITMASK) { ADD_ARG (argv, i, "-E"); if (lazyjournalinit) ADD_ARG (argv, i, "lazy_journal_init=1"); else ADD_ARG (argv, i, "lazy_journal_init=0"); } if (optargs_bitmask & GUESTFS_MKE2FS_TESTFS_BITMASK) { if (testfs) { ADD_ARG (argv, i, "-E"); ADD_ARG (argv, i, "test_fs"); } } if (optargs_bitmask & GUESTFS_MKE2FS_DISCARD_BITMASK) { ADD_ARG (argv, i, "-E"); if (discard) ADD_ARG (argv, i, "discard"); else ADD_ARG (argv, i, "nodiscard"); } if (optargs_bitmask & GUESTFS_MKE2FS_EXTENT_BITMASK) { ADD_ARG (argv, i, "-O"); if (extent) ADD_ARG (argv, i, "extent"); else ADD_ARG (argv, i, "^extent"); } if (optargs_bitmask & GUESTFS_MKE2FS_FILETYPE_BITMASK) { ADD_ARG (argv, i, "-O"); if (filetype) ADD_ARG (argv, i, "filetype"); else ADD_ARG (argv, i, "^filetype"); } if (optargs_bitmask & GUESTFS_MKE2FS_FLEXBG_BITMASK) { ADD_ARG (argv, i, "-O"); if (flexbg) ADD_ARG (argv, i, "flexbg"); else ADD_ARG (argv, i, "^flexbg"); } if (optargs_bitmask & GUESTFS_MKE2FS_HASJOURNAL_BITMASK) { ADD_ARG (argv, i, "-O"); if (hasjournal) ADD_ARG (argv, i, "has_journal"); else ADD_ARG (argv, i, "^has_journal"); } if (optargs_bitmask & GUESTFS_MKE2FS_JOURNALDEV_BITMASK) { ADD_ARG (argv, i, "-O"); if (journaldev) ADD_ARG (argv, i, "journal_dev"); else ADD_ARG (argv, i, "^journal_dev"); } if (optargs_bitmask & GUESTFS_MKE2FS_LARGEFILE_BITMASK) { ADD_ARG (argv, i, "-O"); if (largefile) ADD_ARG (argv, i, "large_file"); else ADD_ARG (argv, i, "^large_file"); } if (optargs_bitmask & GUESTFS_MKE2FS_QUOTA_BITMASK) { ADD_ARG (argv, i, "-O"); if (quota) ADD_ARG (argv, i, "quota"); else ADD_ARG (argv, i, "^quota"); } if (optargs_bitmask & GUESTFS_MKE2FS_RESIZEINODE_BITMASK) { ADD_ARG (argv, i, "-O"); if (resizeinode) ADD_ARG (argv, i, "resize_inode"); else ADD_ARG (argv, i, "^resize_inode"); } if (optargs_bitmask & GUESTFS_MKE2FS_SPARSESUPER_BITMASK) { ADD_ARG (argv, i, "-O"); if (sparsesuper) ADD_ARG (argv, i, "sparse_super"); else ADD_ARG (argv, i, "^sparse_super"); } if (optargs_bitmask & GUESTFS_MKE2FS_UNINITBG_BITMASK) { ADD_ARG (argv, i, "-O"); if (uninitbg) ADD_ARG (argv, i, "uninit_bg"); else ADD_ARG (argv, i, "^uninit_bg"); } ADD_ARG (argv, i, device); if (optargs_bitmask & GUESTFS_MKE2FS_BLOCKSCOUNT_BITMASK) { if (blockscount < 0) { reply_with_error ("blockscount must be >= 0"); return -1; } snprintf (blockscount_s, sizeof blockscount_s, "%" PRIi64, blockscount); ADD_ARG (argv, i, blockscount_s); } ADD_ARG (argv, i, NULL); wipe_device_before_mkfs (device); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s", device, err); return -1; } return 0; }
void ppp_start(struct device_list *entry) { int pgrpid; /* Run pppd directly here and set up to wait for the iface */ entry->status = 1; entry->link_pid = fork(); if (entry->link_pid < 0) { syslog(LOG_ERR, "failed to fork pppd: %m"); exit(EXIT_FAILURE); } #define ADD_ARG(arg) { argv[i] = arg; argv_len += strlen(argv[i++]) + 1; } if (entry->link_pid == 0) { char **argv = (char **)malloc(sizeof(char *)*(pppd_argc+12)); int argv_len = 0; char buf[24], tmpbuf[50], *argv_buf, connect[70]; int i = 0, j; ADD_ARG(path_pppd); ADD_ARG(entry->device); ADD_ARG("-defaultroute"); ADD_ARG("-detach"); if (modem){ ADD_ARG("modem"); ADD_ARG("connect"); sprintf(connect, // should add ABORT 'BLACKLISTED' here // pppd dies when it is set "/usr/sbin/chat -v ABORT 'BUSY' ABORT " "'NO CARRIER' '' ATZ OK ATDT%s CONNECT", iptotel((char *)inet_ntoa(*entry->raddr))); ADD_ARG(connect); } else{ ADD_ARG("local"); } ADD_ARG("115200"); sprintf(buf, "%s:", inet_ntoa(*entry->laddr)); sprintf(tmpbuf, "%s%s", buf, inet_ntoa(*entry->raddr)); ADD_ARG(tmpbuf); // if (crtscts) ADD_ARG("crtscts"); // ADD_ARG("mtu"); // sprintf(buf,"%d",mtu); // ADD_ARG(strdup(buf)); // ADD_ARG("mru"); // sprintf(buf,"%d",mru); // ADD_ARG(strdup(buf)); // if (netmask) { // ADD_ARG("netmask"); // ADD_ARG(netmask); // } for (j = 0; j < pppd_argc; j++) { ADD_ARG(pppd_argv[j]); } argv[i++] = 0; if ((argv_buf = (char *)malloc(argv_len + 1))) { argv_len = i - 1; *argv_buf = '\0'; for (i = 0; i < argv_len; i++) { strcat(argv_buf, argv[i]); strcat(argv_buf, " "); } syslog(LOG_DEBUG, "Running pppd: %s", argv_buf); } /* make sure pppd is the session leader and has the controlling * terminal so it gets the SIGHUP's */ pgrpid = setsid(); ioctl(modem_fd, TIOCSCTTY, 1); tcsetpgrp(modem_fd, pgrpid); setreuid(getuid(), getuid()); setregid(getgid(), getgid()); if (modem_fd != 0) dup2(modem_fd, 0); else fcntl(modem_fd, F_SETFD, 0); dup2(0, 1); execv(path_pppd,argv); syslog(LOG_ERR, "could not exec %s: %m",path_pppd); _exit(99); /* NOTREACHED */ } syslog(LOG_INFO,"Running pppd (pid = %d).",entry->link_pid); }
/* Takes optional arguments, consult optargs_bitmask. */ int do_md_create (const char *name, char *const *devices, int64_t missingbitmap, int nrdevices, int spare, int64_t chunk, const char *level) { char nrdevices_s[32]; char spare_s[32]; char chunk_s[32]; size_t j; int r; char *err; uint64_t umissingbitmap = (uint64_t) missingbitmap; /* Check the optional parameters and set defaults where appropriate. */ if (!(optargs_bitmask & GUESTFS_MD_CREATE_MISSINGBITMAP_BITMASK)) umissingbitmap = 0; if (optargs_bitmask & GUESTFS_MD_CREATE_SPARE_BITMASK) { if (spare < 0) { reply_with_error ("spare must not be negative"); return -1; } } else spare = 0; if (optargs_bitmask & GUESTFS_MD_CREATE_NRDEVICES_BITMASK) { if (nrdevices < 2) { reply_with_error ("nrdevices is less than 2"); return -1; } } else nrdevices = count_strings (devices) + count_bits (umissingbitmap); if (optargs_bitmask & GUESTFS_MD_CREATE_LEVEL_BITMASK) { if (STRNEQ (level, "linear") && STRNEQ (level, "raid0") && STRNEQ (level, "0") && STRNEQ (level, "stripe") && STRNEQ (level, "raid1") && STRNEQ (level, "1") && STRNEQ (level, "mirror") && STRNEQ (level, "raid4") && STRNEQ (level, "4") && STRNEQ (level, "raid5") && STRNEQ (level, "5") && STRNEQ (level, "raid6") && STRNEQ (level, "6") && STRNEQ (level, "raid10") && STRNEQ (level, "10")) { reply_with_error ("unknown level parameter: %s", level); return -1; } } else level = "raid1"; if (optargs_bitmask & GUESTFS_MD_CREATE_CHUNK_BITMASK) { /* chunk is bytes in the libguestfs API, but K when we pass it to mdadm */ if ((chunk & 1023) != 0) { reply_with_error ("chunk size must be a multiple of 1024 bytes"); return -1; } } /* Check invariant. */ if (count_strings (devices) + count_bits (umissingbitmap) != (size_t) (nrdevices + spare)) { reply_with_error ("devices (%zu) + bits set in missingbitmap (%zu) is not equal to nrdevices (%d) + spare (%d)", count_strings (devices), count_bits (umissingbitmap), nrdevices, spare); return -1; } size_t MAX_ARGS = nrdevices + 16; const char *argv[MAX_ARGS]; size_t i = 0; ADD_ARG (argv, i, "mdadm"); ADD_ARG (argv, i, "--create"); /* --run suppresses "Continue creating array" question */ ADD_ARG (argv, i, "--run"); ADD_ARG (argv, i, name); ADD_ARG (argv, i, "--level"); ADD_ARG (argv, i, level); ADD_ARG (argv, i, "--raid-devices"); snprintf (nrdevices_s, sizeof nrdevices_s, "%d", nrdevices); ADD_ARG (argv, i, nrdevices_s); if (optargs_bitmask & GUESTFS_MD_CREATE_SPARE_BITMASK) { ADD_ARG (argv, i, "--spare-devices"); snprintf (spare_s, sizeof spare_s, "%d", spare); ADD_ARG (argv, i, spare_s); } if (optargs_bitmask & GUESTFS_MD_CREATE_CHUNK_BITMASK) { ADD_ARG (argv, i, "--chunk"); snprintf (chunk_s, sizeof chunk_s, "%" PRIi64, chunk / 1024); ADD_ARG (argv, i, chunk_s); } /* Add devices and "missing". */ j = 0; while (devices[j] != NULL || umissingbitmap != 0) { if (umissingbitmap & 1) ADD_ARG (argv, i, "missing"); else { ADD_ARG (argv, i, devices[j]); j++; } umissingbitmap >>= 1; } ADD_ARG (argv, i, NULL); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("mdadm: %s: %s", name, err); free (err); return -1; } free (err); udev_settle (); return 0; }
/* Takes optional arguments, consult optargs_bitmask. */ int do_mkfs (const char *fstype, const char *device, int blocksize, const char *features, int inode, int sectorsize, const char *label) { const char *argv[MAX_ARGS]; size_t i = 0; char blocksize_str[32]; char inode_str[32]; char sectorsize_str[32]; int r; CLEANUP_FREE char *err = NULL; int extfs = 0; if (fstype_is_extfs (fstype)) extfs = 1; /* For ext2/3/4 run the mke2fs program directly. This is because * the mkfs program "eats" some options, in particular the -F * option. */ if (extfs) ADD_ARG (argv, i, str_mke2fs); else ADD_ARG (argv, i, str_mkfs); ADD_ARG (argv, i, "-t"); ADD_ARG (argv, i, fstype); /* Force mke2fs to create a filesystem, even if it thinks it * shouldn't (RHBZ#690819). */ if (extfs) ADD_ARG (argv, i, "-F"); /* mkfs.ntfs requires the -Q argument otherwise it writes zeroes to * every block and does bad block detection, neither of which are * useful behaviour for virtual devices. Also recent versions need * to be forced to create filesystems on non-partitions. */ if (STREQ (fstype, "ntfs")) { ADD_ARG (argv, i, "-Q"); ADD_ARG (argv, i, "-F"); } /* mkfs.reiserfs produces annoying interactive prompts unless you * tell it to be quiet. * mkfs.jfs is the same * mkfs.xfs must force to make xfs filesystem when the device already * has a filesystem on it */ if (STREQ (fstype, "reiserfs") || STREQ (fstype, "jfs") || STREQ (fstype, "xfs")) ADD_ARG (argv, i, "-f"); /* For GFS, GFS2, assume a single node. */ if (STREQ (fstype, "gfs") || STREQ (fstype, "gfs2")) { ADD_ARG (argv, i, "-p"); ADD_ARG (argv, i, "lock_nolock"); /* The man page says this is default, but it doesn't seem to be: */ ADD_ARG (argv, i, "-j"); ADD_ARG (argv, i, "1"); /* Don't ask questions: */ ADD_ARG (argv, i, "-O"); } /* Force mkfs.fat to create a whole disk filesystem (RHBZ#1039995). */ if (STREQ (fstype, "fat") || STREQ (fstype, "vfat") || STREQ (fstype, "msdos")) ADD_ARG (argv, i, "-I"); /* Process blocksize parameter if set. */ if (optargs_bitmask & GUESTFS_MKFS_BLOCKSIZE_BITMASK) { if (blocksize <= 0 || !is_power_of_2 (blocksize)) { reply_with_error ("block size must be > 0 and a power of 2"); return -1; } if (STREQ (fstype, "vfat") || STREQ (fstype, "msdos")) { /* For VFAT map the blocksize into a cluster size. However we * have to determine the block device sector size in order to do * this. */ int ss = do_blockdev_getss (device); if (ss == -1) return -1; int sectors_per_cluster = blocksize / ss; if (sectors_per_cluster < 1 || sectors_per_cluster > 128) { reply_with_error ("unsupported cluster size for %s filesystem (requested cluster size = %d, sector size = %d, trying sectors per cluster = %d)", fstype, blocksize, ss, sectors_per_cluster); return -1; } snprintf (blocksize_str, sizeof blocksize_str, "%d", sectors_per_cluster); ADD_ARG (argv, i, "-s"); ADD_ARG (argv, i, blocksize_str); } else if (STREQ (fstype, "ntfs")) { /* For NTFS map the blocksize into a cluster size. */ snprintf (blocksize_str, sizeof blocksize_str, "%d", blocksize); ADD_ARG (argv, i, "-c"); ADD_ARG (argv, i, blocksize_str); } else if (STREQ (fstype, "btrfs")) { /* For btrfs, blocksize cannot be specified (RHBZ#807905). */ reply_with_error ("blocksize cannot be set on btrfs filesystems, use 'mkfs-btrfs'"); return -1; } else if (STREQ (fstype, "xfs")) { /* mkfs -t xfs -b size=<size> (RHBZ#981715). */ snprintf (blocksize_str, sizeof blocksize_str, "size=%d", blocksize); ADD_ARG (argv, i, "-b"); ADD_ARG (argv, i, blocksize_str); } else { /* For all other filesystem types, try the -b option. */ snprintf (blocksize_str, sizeof blocksize_str, "%d", blocksize); ADD_ARG (argv, i, "-b"); ADD_ARG (argv, i, blocksize_str); } } if (optargs_bitmask & GUESTFS_MKFS_FEATURES_BITMASK) { ADD_ARG (argv, i, "-O"); ADD_ARG (argv, i, features); } if (optargs_bitmask & GUESTFS_MKFS_INODE_BITMASK) { if (!extfs) { reply_with_error ("inode size (-I) can only be set on ext2/3/4 filesystems"); return -1; } if (inode <= 0) { reply_with_error ("inode size must be larger than zero"); return -1; } snprintf (inode_str, sizeof inode_str, "%d", inode); ADD_ARG (argv, i, "-I"); ADD_ARG (argv, i, inode_str); } if (optargs_bitmask & GUESTFS_MKFS_SECTORSIZE_BITMASK) { if (!STREQ (fstype, "ufs")) { reply_with_error ("sector size (-S) can only be set on ufs filesystems"); return -1; } if (sectorsize <= 0) { reply_with_error ("sector size must be larger than zero"); return -1; } snprintf (sectorsize_str, sizeof sectorsize_str, "%d", sectorsize); ADD_ARG (argv, i, "-S"); ADD_ARG (argv, i, sectorsize_str); } if (optargs_bitmask & GUESTFS_MKFS_LABEL_BITMASK) { if (extfs) { if (strlen (label) > EXT2_LABEL_MAX) { reply_with_error ("%s: ext2/3/4 labels are limited to %d bytes", label, EXT2_LABEL_MAX); return -1; } ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, label); } else if (STREQ (fstype, "fat") || STREQ (fstype, "vfat") || STREQ (fstype, "msdos")) { ADD_ARG (argv, i, "-n"); ADD_ARG (argv, i, label); } else if (STREQ (fstype, "ntfs")) { ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, label); } else if (STREQ (fstype, "xfs")) { if (strlen (label) > XFS_LABEL_MAX) { reply_with_error ("%s: xfs labels are limited to %d bytes", label, XFS_LABEL_MAX); return -1; } ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, label); } else if (STREQ (fstype, "btrfs")) { ADD_ARG (argv, i, "-L"); ADD_ARG (argv, i, label); } else { reply_with_error ("don't know how to set the label for '%s' filesystems", fstype); return -1; } } ADD_ARG (argv, i, device); ADD_ARG (argv, i, NULL); wipe_device_before_mkfs (device); r = commandv (NULL, &err, argv); if (r == -1) { reply_with_error ("%s: %s: %s", fstype, device, err); return -1; } return 0; }