// Check that appending to a buffer works OK.
static void test_sc_string_append()
{
union {
char bigbuf[6];
struct {
signed char canary1;
char buf[4];
signed char canary2;
};
} data = {
.buf = {
'f', '\0', 0xFF, 0xFF},.canary1 = ~0,.canary2 = ~0,};
// Sanity check, ensure that the layout of structures is as spelled above.
// (first canary1, then buf and finally canary2.
g_assert_cmpint(((char *)&data.buf[0]) - ((char *)&data.canary1), ==,
1);
g_assert_cmpint(((char *)&data.buf[4]) - ((char *)&data.canary2), ==,
0);
sc_string_append(data.buf, sizeof data.buf, "oo");
// Check that we didn't corrupt either canary.
g_assert_cmpint(data.canary1, ==, ~0);
g_assert_cmpint(data.canary2, ==, ~0);
// Check that we got the result that was expected.
g_assert_cmpstr(data.buf, ==, "foo");
}
const char *sc_umount_cmd(char *buf, size_t buf_size, const char *target,
int flags)
{
sc_string_init(buf, buf_size);
sc_string_append(buf, buf_size, "umount");
if (flags & MNT_FORCE) {
sc_string_append(buf, buf_size, " --force");
}
if (flags & MNT_DETACH) {
sc_string_append(buf, buf_size, " --lazy");
}
if (flags & MNT_EXPIRE) {
// NOTE: there's no real command line option for MNT_EXPIRE
sc_string_append(buf, buf_size, " --expire");
}
if (flags & UMOUNT_NOFOLLOW) {
// NOTE: there's no real command line option for UMOUNT_NOFOLLOW
sc_string_append(buf, buf_size, " --no-follow");
}
if (target != NULL) {
sc_string_append(buf, buf_size, " ");
sc_string_append(buf, buf_size, target);
}
return buf;
}
// Check that `src' cannot be NULL.
static void test_sc_string_append__NULL_str()
{
if (g_test_subprocess()) {
char buf[4];
sc_string_append(buf, sizeof buf, NULL);
g_test_message("expected sc_string_append not to return");
g_test_fail();
return;
}
g_test_trap_subprocess(NULL, 0, 0);
g_test_trap_assert_failed();
g_test_trap_assert_stderr("cannot append string: string is NULL\n");
}
// Check that the uninitialized buffer detection works.
static void test_sc_string_append__uninitialized_buf()
{
if (g_test_subprocess()) {
char buf[4] = { 0xFF, 0xFF, 0xFF, 0xFF };
// Try to append a string to a buffer which is not a valic C-string.
sc_string_append(buf, sizeof buf, "");
g_test_message("expected sc_string_append not to return");
g_test_fail();
return;
}
g_test_trap_subprocess(NULL, 0, 0);
g_test_trap_assert_failed();
g_test_trap_assert_stderr
("cannot append string: dst is unterminated\n");
}
// Check that the overflow detection works.
static void test_sc_string_append__overflow()
{
if (g_test_subprocess()) {
char buf[4] = { 0, };
// Try to append a string that's one character too long.
sc_string_append(buf, sizeof buf, "1234");
g_test_message("expected sc_string_append not to return");
g_test_fail();
return;
}
g_test_trap_subprocess(NULL, 0, 0);
g_test_trap_assert_failed();
g_test_trap_assert_stderr
("cannot append string: str is too long or unterminated\n");
}
const char *sc_mount_opt2str(char *buf, size_t buf_size, unsigned long flags)
{
unsigned long used = 0;
sc_string_init(buf, buf_size);
#define F(FLAG, TEXT) do { \
if (flags & (FLAG)) { \
sc_string_append(buf, buf_size, #TEXT ","); flags ^= (FLAG); \
} \
} while (0)
F(MS_RDONLY, ro);
F(MS_NOSUID, nosuid);
F(MS_NODEV, nodev);
F(MS_NOEXEC, noexec);
F(MS_SYNCHRONOUS, sync);
F(MS_REMOUNT, remount);
F(MS_MANDLOCK, mand);
F(MS_DIRSYNC, dirsync);
F(MS_NOATIME, noatime);
F(MS_NODIRATIME, nodiratime);
if (flags & MS_BIND) {
if (flags & MS_REC) {
sc_string_append(buf, buf_size, "rbind,");
used |= MS_REC;
} else {
sc_string_append(buf, buf_size, "bind,");
}
flags ^= MS_BIND;
}
F(MS_MOVE, move);
// The MS_REC flag handled separately by affected flags (MS_BIND,
// MS_PRIVATE, MS_SLAVE, MS_SHARED)
// XXX: kernel has MS_VERBOSE, glibc has MS_SILENT, both use the same constant
F(MS_SILENT, silent);
F(MS_POSIXACL, acl);
F(MS_UNBINDABLE, unbindable);
if (flags & MS_PRIVATE) {
if (flags & MS_REC) {
sc_string_append(buf, buf_size, "rprivate,");
used |= MS_REC;
} else {
sc_string_append(buf, buf_size, "private,");
}
flags ^= MS_PRIVATE;
}
if (flags & MS_SLAVE) {
if (flags & MS_REC) {
sc_string_append(buf, buf_size, "rslave,");
used |= MS_REC;
} else {
sc_string_append(buf, buf_size, "slave,");
}
flags ^= MS_SLAVE;
}
if (flags & MS_SHARED) {
if (flags & MS_REC) {
sc_string_append(buf, buf_size, "rshared,");
used |= MS_REC;
} else {
sc_string_append(buf, buf_size, "shared,");
}
flags ^= MS_SHARED;
}
flags ^= used; // this is just for MS_REC
F(MS_RELATIME, relatime);
F(MS_KERNMOUNT, kernmount);
F(MS_I_VERSION, iversion);
F(MS_STRICTATIME, strictatime);
#ifndef MS_LAZYTIME
#define MS_LAZYTIME (1<<25)
#endif
F(MS_LAZYTIME, lazytime);
#ifndef MS_NOSEC
#define MS_NOSEC (1 << 28)
#endif
F(MS_NOSEC, nosec);
#ifndef MS_BORN
#define MS_BORN (1 << 29)
#endif
F(MS_BORN, born);
F(MS_ACTIVE, active);
F(MS_NOUSER, nouser);
#undef F
// Render any flags that are unaccounted for.
if (flags) {
char of[128] = { 0 };
sc_must_snprintf(of, sizeof of, "%#lx", flags);
sc_string_append(buf, buf_size, of);
}
// Chop the excess comma from the end.
size_t len = strnlen(buf, buf_size);
if (len > 0 && buf[len - 1] == ',') {
buf[len - 1] = 0;
}
return buf;
}
const char *sc_mount_cmd(char *buf, size_t buf_size, const char *source, const char
*target, const char *fs_type, unsigned long mountflags, const
void *data)
{
sc_string_init(buf, buf_size);
sc_string_append(buf, buf_size, "mount");
// Add filesysystem type if it's there and doesn't have the special value "none"
if (fs_type != NULL && strncmp(fs_type, "none", 5) != 0) {
sc_string_append(buf, buf_size, " -t ");
sc_string_append(buf, buf_size, fs_type);
}
// Check for some special, dedicated options, that aren't represented with
// the generic mount option argument (mount -o ...), by collecting those
// options that we will display as command line arguments in
// used_special_flags. This is used below to filter out these arguments
// from mount_flags when calling sc_mount_opt2str().
int used_special_flags = 0;
// Bind-ounts (bind)
if (mountflags & MS_BIND) {
if (mountflags & MS_REC) {
sc_string_append(buf, buf_size, " --rbind");
used_special_flags |= MS_REC;
} else {
sc_string_append(buf, buf_size, " --bind");
}
used_special_flags |= MS_BIND;
}
// Moving mount point location (move)
if (mountflags & MS_MOVE) {
sc_string_append(buf, buf_size, " --move");
used_special_flags |= MS_MOVE;
}
// Shared subtree operations (shared, slave, private, unbindable).
if (MS_SHARED & mountflags) {
if (mountflags & MS_REC) {
sc_string_append(buf, buf_size, " --make-rshared");
used_special_flags |= MS_REC;
} else {
sc_string_append(buf, buf_size, " --make-shared");
}
used_special_flags |= MS_SHARED;
}
if (MS_SLAVE & mountflags) {
if (mountflags & MS_REC) {
sc_string_append(buf, buf_size, " --make-rslave");
used_special_flags |= MS_REC;
} else {
sc_string_append(buf, buf_size, " --make-slave");
}
used_special_flags |= MS_SLAVE;
}
if (MS_PRIVATE & mountflags) {
if (mountflags & MS_REC) {
sc_string_append(buf, buf_size, " --make-rprivate");
used_special_flags |= MS_REC;
} else {
sc_string_append(buf, buf_size, " --make-private");
}
used_special_flags |= MS_PRIVATE;
}
if (MS_UNBINDABLE & mountflags) {
if (mountflags & MS_REC) {
sc_string_append(buf, buf_size, " --make-runbindable");
used_special_flags |= MS_REC;
} else {
sc_string_append(buf, buf_size, " --make-unbindable");
}
used_special_flags |= MS_UNBINDABLE;
}
// If regular option syntax exists then use it.
if (mountflags & ~used_special_flags) {
char opts_buf[1000] = { 0 };
sc_mount_opt2str(opts_buf, sizeof opts_buf, mountflags &
~used_special_flags);
sc_string_append(buf, buf_size, " -o ");
sc_string_append(buf, buf_size, opts_buf);
}
// Add source and target locations
if (source != NULL && strncmp(source, "none", 5) != 0) {
sc_string_append(buf, buf_size, " ");
sc_string_append(buf, buf_size, source);
}
if (target != NULL && strncmp(target, "none", 5) != 0) {
sc_string_append(buf, buf_size, " ");
sc_string_append(buf, buf_size, target);
}
return buf;
}
