static void
do_cmd(int client, char *buf)
{
char *cp = buf+strlen(buf)-1;
while ((*cp == '\n') || (*cp == '\r')) {
*cp-- = '\0'; // Remove trailing terminators
}
printf("Command: %s\n", buf);
if (strncmp(buf, "ls", 2) == 0) {
do_ls(client, buf);
} else
if (strncmp(buf, "show_all", 8) == 0) {
do_show_all(client, buf);
} else
if (strncmp(buf, "show", 4) == 0) {
do_show(client, buf);
} else
if (strncmp(buf, "time", 4) == 0) {
do_time(client, buf);
} else
if (strncmp(buf, "get", 3) == 0) {
do_get(client, buf);
} else
if (strncmp(buf, "rm", 2) == 0) {
do_rm(client, buf);
} else
{
fdprintf(client, "Unknown command: %s\n", buf);
}
}
short process_cmd(void) {
char cmd[4];
short ret = 0;
RECV(STDIN, cmd, sizeof(cmd));
if (0 == memcmp((void *)CMD_BUY, cmd, sizeof(CMD_BUY))) {
ret = do_buy();
} else if (0 == memcmp((void *)CMD_CHECK, cmd, sizeof(CMD_CHECK))) {
ret = do_check();
} else if (0 == memcmp((void *)CMD_ADD, cmd, sizeof(CMD_ADD))) {
ret = do_add();
} else if (0 == memcmp((void *)CMD_RM, cmd, sizeof(CMD_RM))) {
ret = do_rm();
} else if (0 == memcmp((void *)CMD_UPDATE, cmd, sizeof(CMD_UPDATE))) {
ret = do_update();
} else if (0 == memcmp((void *)CMD_ONSALE, cmd, sizeof(CMD_ONSALE))) {
ret = do_onsale();
} else if (0 == memcmp((void *)CMD_NOSALE, cmd, sizeof(CMD_NOSALE))) {
ret = do_nosale();
} else if (0 == memcmp((void *)CMD_LIST, cmd, sizeof(CMD_LIST))) {
ret = do_list();
} else if (0 == memcmp((void *)CMD_QUIT, cmd, sizeof(CMD_QUIT))) {
ret = -2;
} else {
ret = -1;
}
return ret;
}
void do_mv()
{
if(!src[0]) scanf("%s %s",src,dest);
strcpy(rmfile,src);
errno=0;
do_cp();
if(errno==0) do_rm();
_clear(src); _clear(dest);
_clear(rmfile);
}
int
main(void)
{
int cmd, ret;
vfs_init(&vfs);
// Set up filesystem
create_dir(&vfs, "/etc");
crond = create_dir(&vfs, "/etc/crond");
create_dir(&vfs, "/home");
pwd = create_dir(&vfs, "/home/user");
pwd->owner = USER_UID;
while (1) {
// Simulate a period cron job
do_cron();
if (read_all(STDIN, &cmd, sizeof(cmd)) != sizeof(cmd))
continue;
if (cmd == -1)
break;
switch (cmd) {
case CD:
ret = do_cd();
break;
case READ:
ret = do_read();
break;
case WRITE:
ret = do_write();
break;
case LN:
ret = do_ln();
break;
case RM:
ret = do_rm();
break;
default:
continue;
}
write_all(STDOUT, &ret, sizeof(ret));
}
vfs_destroy(&vfs);
return 0;
}
/**
* Process the next incoming request
*
* @return status response
*/
status_t process_req() {
msg_t *msg = malloc(sizeof(msg_t));
resp_t *resp = NULL;
if (!EREADDATA(*msg)) {
debug("Disconnected!\n");
return DISCON;
}
msg->buf[sizeof(msg->buf)-1] = '\0';
switch (msg->type) {
case MKDIR:
resp = do_mkdir(msg);
break;
case LIST:
resp = do_list(msg);
break;
case PUT:
resp = do_put(msg);
break;
case GET:
resp = do_get(msg);
break;
case RM:
resp = do_rm(msg);
break;
case RMDIR:
resp = do_rmdir(msg);
break;
case QUIT:
return EXIT;
default:
return ERR;
}
if (!resp)
return ERR;
ESENDDATA(*resp);
if (last)
free(last);
last = (char *)resp;
return OK;
}
int main(int argc, char **argv)
{
check_for_root_maybe_die();
if (argc <= 1)
usage();
argc--; argv++;
if (!strncmp("help", argv[0], strlen("help")))
usage();
else if (!strncmp("version", argv[0], strlen("version")))
version();
else if (!strncmp("preload", argv[0], strlen("preload")))
do_preload(--argc, ++argv);
else if (!strncmp("add", argv[0], strlen("add")))
do_add(--argc, ++argv);
else if (!strncmp("set", argv[0], strlen("set")))
do_set(--argc, ++argv);
else if (!strncmp("rm", argv[0], strlen("rm")))
do_rm(--argc, ++argv);
else if (!strncmp("flag", argv[0], strlen("flag")))
do_flag(--argc, ++argv);
else if (!strncmp("unflag", argv[0], strlen("unflag")))
do_unflag(--argc, ++argv);
else if (!strncmp("bind-e", argv[0], strlen("bind-e")))
do_bind(--argc, ++argv, BIND_TYPE_EGR);
else if (!strncmp("bind-i", argv[0], strlen("bind-i")))
do_bind(--argc, ++argv, BIND_TYPE_INGR);
else if (!strncmp("bind", argv[0], strlen("bind")))
do_bind(--argc, ++argv, BIND_TYPE_NORM);
else if (!strncmp("unbind-e", argv[0], strlen("unbind-e")))
do_unbind(--argc, ++argv, BIND_TYPE_EGR);
else if (!strncmp("unbind-i", argv[0], strlen("unbind-i")))
do_unbind(--argc, ++argv, BIND_TYPE_INGR);
else if (!strncmp("unbind", argv[0], strlen("unbind")))
do_unbind(--argc, ++argv, BIND_TYPE_NORM);
else if (!strncmp("replace", argv[0], strlen("replace")))
do_replace(--argc, ++argv, 0);
else if (!strncmp("replace-drop", argv[0], strlen("replace-drop")))
do_replace(--argc, ++argv, 1);
else if (!strncmp("subscribe", argv[0], strlen("subscribe")))
do_subscribe(--argc, ++argv);
else if (!strncmp("unsubscribe", argv[0], strlen("unsubscribe")))
do_unsubscribe(--argc, ++argv);
else
usage();
return 0;
}
static int
perform(enum mode mode, int optind, int argc, char **argv, struct xs_handle *xsh,
xs_transaction_t xth, int prefix, int tidy, int upto, int recurse, int nr_watches)
{
switch (mode) {
case MODE_ls:
if (optind == argc)
{
optind=0;
argc=1;
argv[0] = "/";
}
break;
default:
break;
}
while (optind < argc) {
switch (mode) {
case MODE_unknown:
/* CANNOT BE REACHED */
errx(1, "invalid mode %d", mode);
case MODE_read: {
static struct expanding_buffer ebuf;
unsigned len;
char *val = xs_read(xsh, xth, argv[optind], &len);
if (val == NULL) {
warnx("couldn't read path %s", argv[optind]);
return 1;
}
if (prefix)
output("%s: ", argv[optind]);
output("%s\n", sanitise_value(&ebuf, val, len));
free(val);
optind++;
break;
}
case MODE_write: {
static struct expanding_buffer ebuf;
char *val_spec = argv[optind + 1];
unsigned len;
expanding_buffer_ensure(&ebuf, strlen(val_spec)+1);
unsanitise_value(ebuf.buf, &len, val_spec);
if (!xs_write(xsh, xth, argv[optind], ebuf.buf, len)) {
warnx("could not write path %s", argv[optind]);
return 1;
}
optind += 2;
} break;
case MODE_rm: {
/* Remove the specified path. If the tidy flag is set, then also
remove any containing directories that are both empty and have no
value attached, and repeat, recursing all the way up to the root if
necessary.
*/
char *slash, *path = argv[optind];
if (tidy) {
/* Copy path, because we can't modify argv because we will need it
again if xs_transaction_end gives us EAGAIN. */
char *p = malloc(strlen(path) + 1);
strcpy(p, path);
path = p;
again:
if (do_rm(path, xsh, xth)) {
return 1;
}
slash = strrchr(p, '/');
if (slash) {
char *val;
unsigned len;
*slash = '\0';
val = xs_read(xsh, xth, p, &len);
if (val && len == 0) {
unsigned int num;
char ** list = xs_directory(xsh, xth, p, &num);
if (list) {
free(list);
if (num == 0)
goto again;
}
}
}
free(path);
}
else {
if (do_rm(path, xsh, xth)) {
return 1;
}
}
optind++;
break;
}
case MODE_exists: {
char *val = xs_read(xsh, xth, argv[optind], NULL);
if (val == NULL) {
return 1;
}
free(val);
optind++;
break;
}
case MODE_list: {
unsigned int i, num;
char **list = xs_directory(xsh, xth, argv[optind], &num);
if (list == NULL) {
warnx("could not list path %s", argv[optind]);
return 1;
}
for (i = 0; i < num; i++) {
if (prefix)
output("%s/", argv[optind]);
output("%s\n", list[i]);
}
free(list);
optind++;
break;
}
case MODE_ls: {
do_ls(xsh, argv[optind], 0, prefix);
optind++;
break;
}
case MODE_chmod: {
/* save path pointer: */
char *path = argv[optind++];
int nperms = argc - optind;
struct xs_permissions perms[nperms];
int i;
for (i = 0; argv[optind]; optind++, i++)
{
perms[i].id = atoi(argv[optind]+1);
switch (argv[optind][0])
{
case 'n':
perms[i].perms = XS_PERM_NONE;
break;
case 'r':
perms[i].perms = XS_PERM_READ;
break;
case 'w':
perms[i].perms = XS_PERM_WRITE;
break;
case 'b':
perms[i].perms = XS_PERM_READ | XS_PERM_WRITE;
break;
default:
errx(1, "Invalid permission specification: '%c'",
argv[optind][0]);
}
}
do_chmod(path, perms, nperms, upto, recurse, xsh, xth);
break;
}
case MODE_watch: {
for (; argv[optind]; optind++) {
const char *w = argv[optind];
if (!xs_watch(xsh, w, w))
errx(1, "Unable to add watch on %s\n", w);
}
do_watch(xsh, nr_watches);
}
}
}
return 0;
}
int
main (int argc, char **argv)
{
int exit = 0;
char *buffer = g_new (char, 1024) ;
GIOChannel *ioc;
guint watch_id = 0;
GOptionContext *ctx = NULL;
GError *error = NULL;
/* default to interactive on a terminal */
interactive = isatty (0);
ctx = g_option_context_new("test-vfs");
g_option_context_add_main_entries(ctx, options, NULL);
if (!g_option_context_parse(ctx, &argc, &argv, &error)) {
g_printerr("main: %s\n", error->message);
g_error_free(error);
g_option_context_free(ctx);
return 1;
}
g_option_context_free(ctx);
files = g_hash_table_new (g_str_hash, g_str_equal);
if (noninteractive)
interactive = FALSE;
if (interactive)
vfserr = stderr;
else
vfserr = stdout;
if (!mate_vfs_init ()) {
fprintf (vfserr, "Cannot initialize mate-vfs.\n");
return 1;
}
mate_vfs_module_callback_push
(MATE_VFS_MODULE_CALLBACK_AUTHENTICATION,
authentication_callback, NULL, NULL);
if (argc == 1)
cur_dir = g_get_current_dir ();
else
cur_dir = g_strdup(argv[1]);
if (cur_dir && !G_IS_DIR_SEPARATOR (cur_dir [strlen (cur_dir) - 1]))
cur_dir = g_strconcat (cur_dir, G_DIR_SEPARATOR_S, NULL);
if (interactive == TRUE) {
main_loop = g_main_loop_new (NULL, TRUE);
ioc = g_io_channel_unix_new (0 /* stdin */);
g_io_channel_set_encoding (ioc, NULL, NULL);
g_io_channel_set_buffered (ioc, FALSE);
watch_id = g_io_add_watch (ioc,
G_IO_IN | G_IO_HUP | G_IO_ERR,
callback, buffer);
g_io_channel_unref (ioc);
}
while (!exit) {
char *ptr;
if (interactive) {
fprintf (stdout,"\n%s > ", cur_dir);
fflush (stdout);
strcpy (buffer, "");
g_main_loop_run (main_loop);
} else {
/* In non-interactive mode we just do this evil
* thingie */
buffer[0] = '\0';
fgets (buffer, 1023, stdin);
if (!buffer [0]) {
exit = 1;
continue;
}
}
if (!buffer || buffer [0] == '#')
continue;
arg_data = g_strsplit (g_strchomp (buffer), delim, -1);
arg_cur = 0;
if ((!arg_data || !arg_data[0]) && interactive) continue;
if (!interactive)
printf ("Command : '%s'\n", arg_data [0]);
ptr = arg_data[arg_cur++];
if (!ptr)
continue;
if (g_ascii_strcasecmp (ptr, "ls") == 0)
do_ls ();
else if (g_ascii_strcasecmp (ptr, "cd") == 0)
do_cd ();
else if (g_ascii_strcasecmp (ptr, "dump") == 0)
do_dump ();
else if (g_ascii_strcasecmp (ptr, "type") == 0 ||
g_ascii_strcasecmp (ptr, "cat") == 0)
do_cat ();
else if (g_ascii_strcasecmp (ptr, "cp") == 0)
do_cp ();
else if (g_ascii_strcasecmp (ptr, "rm") == 0)
do_rm ();
else if (g_ascii_strcasecmp (ptr, "mkdir") == 0)
do_mkdir ();
else if (g_ascii_strcasecmp (ptr, "rmdir") == 0)
do_rmdir ();
else if (g_ascii_strcasecmp (ptr, "mv") == 0)
do_mv ();
else if (g_ascii_strcasecmp (ptr, "info") == 0 ||
g_ascii_strcasecmp (ptr, "stat") == 0)
do_info ();
else if (g_ascii_strcasecmp (ptr, "findtrash") == 0)
do_findtrash ();
else if (g_ascii_strcasecmp (ptr, "ssl") == 0)
do_ssl ();
else if (g_ascii_strcasecmp (ptr, "sync") == 0)
fprintf (vfserr, "a shell is like a boat, it lists or syncs (RMS)\n");
else if (g_ascii_strcasecmp (ptr,"help") == 0 ||
g_ascii_strcasecmp (ptr,"?") == 0 ||
g_ascii_strcasecmp (ptr,"info") == 0 ||
g_ascii_strcasecmp (ptr,"man") == 0)
list_commands ();
else if (g_ascii_strcasecmp (ptr,"exit") == 0 ||
g_ascii_strcasecmp (ptr,"quit") == 0 ||
g_ascii_strcasecmp (ptr,"q") == 0 ||
g_ascii_strcasecmp (ptr,"bye") == 0)
exit = 1;
/* File ops */
else if (g_ascii_strcasecmp (ptr, "open") == 0)
do_open ();
else if (g_ascii_strcasecmp (ptr, "create") == 0)
do_create ();
else if (g_ascii_strcasecmp (ptr, "close") == 0)
do_close ();
else if (g_ascii_strcasecmp (ptr, "handleinfo") == 0)
do_handleinfo ();
else if (g_ascii_strcasecmp (ptr, "read") == 0)
do_read ();
else if (g_ascii_strcasecmp (ptr, "seek") == 0)
do_seek ();
else
fprintf (vfserr, "Unknown command '%s'", ptr);
g_strfreev (arg_data);
arg_data = NULL;
}
if (interactive) {
g_source_remove (watch_id);
g_main_loop_unref (main_loop);
main_loop = NULL;
}
g_free (buffer);
g_free (cur_dir);
close_files ();
return 0;
}
void addFilespec(FILE *fd, int squash_uids, int squash_perms)
{
unsigned long rmode, mode, uid, gid, major, minor, i;
unsigned long start, increment, count, octmode, decmode;
char *c, *dir, *name, *dname = NULL, *path = NULL, *path2 = NULL, *line = NULL;
char type;
size_t len;
int argv, i2, overWrite = 0, lineno = 0;
__u16 inodeType;
while ( getline(&line, &len, fd) >= 0 ) {
rmode = mode = uid = gid = major = minor = start = count = overWrite = 0;
increment = 1;
lineno++;
if (( c = strchr(line, '#'))) *c = 0;
if ( path ) {
free( path ); path = NULL;
}
if ( path2 ) {
free( path2 ); path2 = NULL;
}
argv = sscanf(line, "%" SCANF_PREFIX "s %c %ld %lu %lu %lu %lu %lu %lu %lu",
SCANF_STRING(path), &type, &rmode, &uid, &gid, &major, &minor,
&start, &increment, &count);
if ( argv < 3 ) {
if ( argv > 0 )
log_warning("device table[%d]: bad format for entry '%s' [skip]", lineno, path);
continue;
}
i2 = 0;
octmode = rmode;
decmode = 0;
while ( octmode != 0 ) {
decmode = decmode + (octmode % 10) * pow(8, i2++);
octmode = octmode / 10;
}
if ( squash_uids ) uid = gid = 0;
mode = decmode;
path2 = strdup( path );
name = basename( path );
dir = dirname( path2 );
if (( !strcmp(name, ".")) || ( !strcmp(name, "..")) || ( !strcmp(name, "/"))) {
log_warning("device table[%d]: [skip]", lineno);
continue;
}
log_action(ACT_CHDIR, dir, NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir(dir)) {
log_warning("device table[%d]: target directory '%s' for entry '%s' does not exist [skip]", lineno, dir, name);
log_action(ACT_CHDIR, "/", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir("/"))
log_error("[Filesystem error] cannot chdir to root");
continue;
}
if (( type != 'd' ) && ( type != 'f' ) && ( type != 'p' ) && ( type != 'c' ) && ( type != 'b' ) && ( type != 's')) {
log_warning("device table[%d]: bad type '%c' for entry '%s' [skip]", lineno, type, name);
continue;
}
if (squash_perms) {
mode &= ~( LINUX_S_IRWXG | LINUX_S_IRWXO );
rmode &= ~( LINUX_S_IRWXG | LINUX_S_IRWXO);
}
if ( count > 0 ) {
if ( dname ) {
free( dname );
dname = NULL;
}
unsigned len;
len = strlen(name) + 10;
dname = malloc(len + 1);
for ( i = start; i < count; i++ ) {
snprintf(dname, len, "%s%lu", name, i);
if (( overWrite = name_to_inode(dname)))
inodeType = inode_mode(dname);
if (( type == 'd' ) && ( overWrite ) && ( !LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but isn't a directory when it should be.", log_cwd(), dname);
else if (( type != 'd' ) && ( overWrite )) {
if ( LINUX_S_ISDIR(inodeType))
log_error("[Remote fs mismatch] %s/%s exists but is a directory when it shouldn't be.", log_cwd(), dname);
if ((!LINUX_S_ISREG(inodeType)) && (!LINUX_S_ISLNK(inodeType)) &&
(!LINUX_S_ISBLK(inodeType)) && (!LINUX_S_ISCHR(inodeType)) &&
(!LINUX_S_ISFIFO(inodeType)) && (!LINUX_S_ISSOCK(inodeType)))
log_error("[Remote fs mismatch] Existing file %s/%s has unknown/unsupported type [0x%x].", log_cwd(), dname, inodeType);
}
switch ( type ) {
case 'd':
mode |= LINUX_S_IFDIR;
log_action(ACT_MKDIR, dname, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !overWrite )
if ( !do_mkdir(dname))
log_error("[Filesystem error] cannot mkdir %s/%s", log_cwd(), dname);
break;
case 'c':
case 'b':
if ( type == 'c' )
mode |= LINUX_S_IFCHR;
else
mode |= LINUX_S_IFBLK;
if ( overWrite ) {
log_action(ACT_RM, dname, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(dname))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), dname);
}
log_action(ACT_MKNOD, dname, NULL, 0, 0, 0, type, major, minor + ((i * increment) - start), overWrite);
if ( !do_mknod(dname, type, major, minor + ((i * increment) - start)))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), dname);
break;
case 's':
case 'p':
if ( type == 's' )
mode |= LINUX_S_IFSOCK;
else mode |= LINUX_S_IFIFO;
if ( overWrite ) {
log_action(ACT_RM, dname, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(dname))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), dname);
}
log_action(ACT_MKNOD, dname, NULL, 0, 0, 0, type, 0, 0, overWrite);
if ( !do_mknod(dname, type, 0, 0))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), dname);
break;
}
log_action(ACT_CHMOD, dname, NULL, rmode, 0, 0, 0, 0, 0, 0);
if ( !do_chmod(dname, rmode))
log_error("[Filesystem error] cannot chmod %s/%s", log_cwd(), dname);
log_action(ACT_CHOWN, dname, NULL, 0, uid, gid, 0, 0, 0, 0);
if ( !do_chown(dname, uid, gid))
log_error("[Filesystem error] cannot chown %s/%s", log_cwd(), dname);
}
log_action(ACT_CHDIR, "/", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir("/"))
log_error("[Filesystem error] cannot chdir to root");
free(dname);
dname = NULL;
} else {
if (( overWrite = name_to_inode(name)))
inodeType = inode_mode(name);
if (( type == 'd' ) && ( overWrite ) && ( !LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but isn't a directory when it should be.", log_cwd(), dname);
else if ( type != 'd' ) {
if (( overWrite ) && ( LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but is a directory when it shouldn't be.", log_cwd(), dname);
if (( overWrite ) && (!LINUX_S_ISREG(inodeType)) && (!LINUX_S_ISLNK(inodeType)) &&
(!LINUX_S_ISBLK(inodeType)) && (!LINUX_S_ISCHR(inodeType)) &&
(!LINUX_S_ISFIFO(inodeType)) && (!LINUX_S_ISSOCK(inodeType)))
log_error("[Remote fs mismatch] Existing file %s/%s has unknown/unsupported type [0x%x].", log_cwd(), dname, inodeType);
}
switch ( type ) {
case 'd':
mode |= LINUX_S_IFDIR;
log_action(ACT_MKDIR, name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !overWrite )
if ( !do_mkdir(name))
log_error("[Filesystem error] cannot mkdir %s/%s", log_cwd(), name);
break;
case 'c':
case 'b':
if ( type == 'c' )
mode |= LINUX_S_IFCHR;
else
mode |= LINUX_S_IFBLK;
if ( overWrite ) {
log_action(ACT_RM, name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), name);
}
log_action(ACT_MKNOD, name, NULL, 0, 0, 0, type, major, minor, overWrite);
if ( !do_mknod(name, type, major, minor))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), name);
break;
case 's':
case 'p':
if ( type == 's' )
mode |= LINUX_S_IFSOCK;
else mode |= LINUX_S_IFIFO;
if ( overWrite ) {
log_action(ACT_RM, name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), name);
}
log_action(ACT_MKNOD, name, NULL, 0, 0, 0, type, 0, 0, overWrite);
if ( !do_mknod(name, type, 0, 0))
log_error("[Filesystem error] cannot mknod %s/%s", log_cwd(), name);
break;
}
log_action(ACT_CHMOD, name, NULL, rmode, 0, 0, 0, 0, 0, 0);
if ( !do_chmod(name, rmode))
log_error("[Filesystem error] cannot chmod %s/%s", log_cwd(), name);
log_action(ACT_CHOWN, name, NULL, 0, uid, gid, 0, 0, 0, 0);
if ( !do_chown(name, uid, gid))
log_error("[Filesystem error] cannot chown %s/%s", log_cwd(), name);
log_action(ACT_CHDIR, "/", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir("/"))
log_error("[Filesystem error] cannot chdir to root");
}
}
if ( line ) {
free( line ); line = NULL;
}
if ( path ) {
free( path ); path = NULL;
}
if ( path2 ) {
free( path2 ); path2 = NULL;
}
}
void addPath(const char *path, int squash_uids, int squash_perms)
{
size_t len;
char *full_name = NULL, *lnk = NULL;
struct dirent *file = NULL;
DIR *direc = NULL;
struct stat st;
int overWrite;
__u16 inodeType;
direc = opendir(path);
if ( !direc )
log_error("[Local fs opendir] Cannot open directory %s", path);
while (( file = readdir(direc)) != NULL ) {
if (( !strcmp(file->d_name, "." )) || ( !strcmp(file->d_name, ".." )))
continue;
len = strlen(path) + strlen( file->d_name ) + 3;
if ( full_name ) {
free( full_name );
full_name = NULL;
}
full_name = (char*)malloc(len + 2);
if ( !full_name )
log_error("[Local fs stat] Memory allocation error ( full_name --> %s/%s )", path, file->d_name);
memset(full_name, 0, len + 2);
snprintf(full_name, len, "%s/%s", path, file->d_name);
lstat(full_name, &st);
mode_t fmt = st.st_mode & S_IFMT;
if ( squash_uids )
st.st_uid = st.st_gid = 0;
if ( squash_perms )
st.st_mode &= ~( LINUX_S_IRWXG | LINUX_S_IRWXO );
overWrite = name_to_inode( file->d_name );
if ( st.st_nlink > 1 ) {
if (( lnk = linklist_add(st.st_dev, st.st_ino, full_name + modPath_path_len))) {
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
log_action(ACT_HARDLINK, file->d_name, lnk, 0, 0, 0, 0, 0, 0, overWrite);
if (!do_hardlink(&st, lnk, file->d_name))
log_error("[Filesystem error] cannot hardlink %s --> %s", file->d_name, lnk);
continue;
}
}
if ( overWrite )
inodeType = inode_mode( file->d_name );
if (( fmt == S_IFDIR ) && ( overWrite ) && ( !LINUX_S_ISDIR(inodeType)))
log_error("[Remote fs mismatch] %s/%s exists but isn't a directory when it should be.", log_cwd(), file->d_name);
else if (( fmt != S_IFDIR) && ( overWrite )) {
if ( LINUX_S_ISDIR(inodeType))
log_error("[Remote fs mismatch] %s/%s exists but is a directory when it shouldn't be.", log_cwd(), file->d_name);
if ((!LINUX_S_ISREG(inodeType)) && (!LINUX_S_ISLNK(inodeType)) &&
(!LINUX_S_ISBLK(inodeType)) && (!LINUX_S_ISCHR(inodeType)) &&
(!LINUX_S_ISFIFO(inodeType)) && (!LINUX_S_ISSOCK(inodeType)))
log_error("[Remote fs mismatch] Existing file %s/%s has unknown/unsupported type [0x%x].", log_cwd(), file->d_name);
}
switch ( fmt ) {
case S_IFDIR: // Directory
log_action(ACT_MKDIR, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !overWrite )
if ( !do_mkdir( &st, file->d_name ))
log_error("[Filesystem error] cannot mkdir %s/%s", log_cwd(), file->d_name);
log_action(ACT_CHMODE, file->d_name, NULL, st.st_mode, 0, 0, 0, 0, 0, overWrite);
if ( !do_chmode(file->d_name, st.st_mode))
log_error("[Filesystem error] Failed to chmode 0x%x for directory %s/%s", st.st_mode, log_cwd(), file->d_name);
log_action(ACT_CHOWN, file->d_name, NULL, 0, st.st_uid, st.st_gid, 0, 0, 0, 0);
if ( !do_chown(file->d_name, st.st_uid, st.st_gid))
log_error("[Filesystem error] Failed to chown %ld, %ld for directory %s/%s", st.st_uid, st.st_gid, log_cwd(), file->d_name);
log_action(ACT_CHDIR, file->d_name, NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir( file->d_name ))
log_error("[Filesystem error] cannot chdir to newly created %s/%s", log_cwd(), file->d_name);
addPath(full_name, squash_uids, squash_perms);
log_action(ACT_CHDIR, "..", NULL, 0, 0, 0, 0, 0, 0, 0);
if ( !do_chdir(".."))
log_error("[Filesystem error] cannot chdir to parent directory");
break;
case S_IFREG: // Regular file
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
log_action(ACT_WRITE, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_write(full_name, file->d_name))
log_error("[Filesystem error] cannot write %s/%s", log_cwd(), file->d_name);
break;
case S_IFLNK: // Symbolic link
lnk = (char*)malloc(MAX_PATHSIZE + 2);
if ( !lnk )
log_error("[symlink] Memory allocation error (lnk)");
int len = readlink(full_name, lnk, MAX_PATHSIZE);
if ( len == -1 ) {
free(lnk);
log_error("[Local filesystem error] Cannot read destination for link %s/%s", log_cwd(), file->d_name);
} else lnk[len] = '\0';
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
log_action(ACT_SYMLINK, file->d_name, lnk, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_symlink(&st, lnk, file->d_name))
log_error("[Filesystem error] cannot symlink %s/%s --> %s", log_cwd(), file->d_name, lnk);
free(lnk);
break;
case S_IFBLK: // Block device node
case S_IFCHR: // Character device node
case S_IFSOCK: // socket
case S_IFIFO: // fifo
if ( overWrite ) {
log_action(ACT_RM, file->d_name, NULL, 0, 0, 0, 0, 0, 0, overWrite);
if ( !do_rm(file->d_name))
log_error("[Filesystem error] cannot rm %s/%s", log_cwd(), file->d_name);
}
char nodetype = ( fmt == S_IFBLK ? 'b' : ( fmt == S_IFCHR ? 'c' : ( fmt == S_IFSOCK ? 's' : 'p' )));
unsigned long major = 0, minor = 0;
if (( nodetype == 'b' ) || ( nodetype == 'c' )) {
major = (long)major(st.st_rdev);
minor = (long)minor(st.st_rdev);
}
log_action(ACT_MKNOD, file->d_name, NULL, 0, 0, 0, nodetype, major, minor, overWrite);
if ( !do_mknod(file->d_name, nodetype, major, minor))
log_error("[Filesystem error] cannot mknod %c %ld,%ld %s/%s", log_cwd(), nodetype, major, minor, log_cwd(), file->d_name);
break;
}
if ( fmt != S_IFDIR ) { // Not dir ?
log_action(ACT_CHMODE, file->d_name, NULL, st.st_mode, 0, 0, 0, 0, 0, overWrite);
if ( !do_chmode(file->d_name, st.st_mode))
log_error("[Filesystem error] Failed to chmode 0x%x for file %s/%s", st.st_mode, log_cwd(), file->d_name);
log_action(ACT_CHOWN, file->d_name, NULL, 0, st.st_uid, st.st_gid, 0, 0, 0, 0);
if ( !do_chown(file->d_name, st.st_uid, st.st_gid))
log_error("[Filesystem error] Failed to chown %ld, %ld for file %s/%s", st.st_uid, st.st_gid, log_cwd(), file->d_name);
}
if ( full_name ) {
free( full_name );
full_name = NULL;
}
}
closedir(direc);
}
void runProcess( Proc *proc, pid_t pgid, int fg, int inputFile, int outputFile, int errorFile)
{
// wrzucenie procesu do grupy procesow i danie przekazanie grupy terminalowu jezeli jest to stosowne
// utowrzenie grupy lub dolaczenie do juz istniejacej
pid_t pid = getpid();
if( pgid == 0 )
pgid = pid;
setpgid(pid, pgid);
// jesli w foreground to oddajemy terminal dla grupy procesow
if(fg == 1)
{
tcsetpgrp( shellTerminal, pgid );
}
struct sigaction act;
act.sa_handler = SIG_DFL; /* set up signal handler */
act.sa_flags = 0;
// kiedy shell przejmuje kontrole, powinien ignorowac ponizsze sygnaly, zeby samemu sie przypadkowo nie killnac
sigaction(SIGINT, &act, NULL);
// powrot do ustawien domyslnych (przez nasz shell te sygnaly byly ignorowane)
sigaction(SIGINT, &act, NULL);
sigaction(SIGQUIT, &act, NULL);
sigaction(SIGCHLD, &act, NULL);
sigaction(SIGTSTP, &act, NULL);
sigaction(SIGTTIN, &act, NULL);
sigaction(SIGTTOU, &act, NULL);
// ustawienie standardowego I/O dla nowego procesu
// jesli wyjscia sa inne niz standardowe to zamieniamy je - przekierowanie wyjscia
if(inputFile != STDIN_FILENO)
{
dup2(inputFile, STDIN_FILENO);
close(inputFile);
}
if(outputFile != STDOUT_FILENO)
{
dup2(outputFile, STDOUT_FILENO);
close(outputFile);
}
if(errorFile != STDERR_FILENO)
{
dup2(errorFile, STDERR_FILENO);
close(errorFile);
} if(strcmp(proc->argv[0], "pwd") == 0)
{
do_pwd();
}
else if(strcmp(proc->argv[0], "cd") == 0)
{
do_cd(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "ls") == 0)
{
do_ls(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "mkdir") == 0)
{
do_mkdir(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "rmdir") == 0)
{
do_rmdir(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "touch") == 0)
{
do_touch(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "rm") == 0)
{
do_rm(proc->argv[1]);
}
else if(strcmp(proc->argv[0], "cp") == 0)
{
do_cp(proc->argv[1], proc->argv[2]);
}
else if(strcmp(proc->argv[0], "echo") == 0)
{
do_echo(proc->argv[1]);
}
else
run(proc->argv[0], proc->argv);
//execvp(proc->argv[0], proc->argv);
// nie powinien wykonac exit'a przy poprawnym wykonaniu
//exit(-1);
}
static int
parse_dispatch_command(struct sftp_conn *conn, const char *cmd, char **pwd,
int err_abort)
{
char *path1, *path2, *tmp;
int pflag, lflag, iflag, cmdnum, i;
unsigned long n_arg;
Attrib a, *aa;
char path_buf[MAXPATHLEN];
int err = 0;
glob_t g;
path1 = path2 = NULL;
cmdnum = parse_args(&cmd, &pflag, &lflag, &iflag, &n_arg,
&path1, &path2);
if (iflag != 0)
err_abort = 0;
memset(&g, 0, sizeof(g));
/* Perform command */
switch (cmdnum) {
case 0:
/* Blank line */
break;
case -1:
/* Unrecognized command */
err = -1;
break;
case I_GET:
err = process_get(conn, path1, path2, *pwd, pflag);
break;
case I_PUT:
err = process_put(conn, path1, path2, *pwd, pflag);
break;
case I_RENAME:
path1 = make_absolute(path1, *pwd);
path2 = make_absolute(path2, *pwd);
err = do_rename(conn, path1, path2);
break;
case I_SYMLINK:
path2 = make_absolute(path2, *pwd);
err = do_symlink(conn, path1, path2);
break;
case I_RM:
path1 = make_absolute(path1, *pwd);
remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
printf("Removing %s\n", g.gl_pathv[i]);
err = do_rm(conn, g.gl_pathv[i]);
if (err != 0 && err_abort)
break;
}
break;
case I_MKDIR:
path1 = make_absolute(path1, *pwd);
attrib_clear(&a);
a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
a.perm = 0777;
err = do_mkdir(conn, path1, &a);
break;
case I_RMDIR:
path1 = make_absolute(path1, *pwd);
err = do_rmdir(conn, path1);
break;
case I_CHDIR:
path1 = make_absolute(path1, *pwd);
if ((tmp = do_realpath(conn, path1)) == NULL) {
err = 1;
break;
}
if ((aa = do_stat(conn, tmp, 0)) == NULL) {
xfree(tmp);
err = 1;
break;
}
if (!(aa->flags & SSH2_FILEXFER_ATTR_PERMISSIONS)) {
error("Can't change directory: Can't check target");
xfree(tmp);
err = 1;
break;
}
if (!S_ISDIR(aa->perm)) {
error("Can't change directory: \"%s\" is not "
"a directory", tmp);
xfree(tmp);
err = 1;
break;
}
xfree(*pwd);
*pwd = tmp;
break;
case I_LS:
if (!path1) {
do_globbed_ls(conn, *pwd, *pwd, lflag);
break;
}
/* Strip pwd off beginning of non-absolute paths */
tmp = NULL;
if (*path1 != '/')
tmp = *pwd;
path1 = make_absolute(path1, *pwd);
err = do_globbed_ls(conn, path1, tmp, lflag);
break;
case I_LCHDIR:
if (chdir(path1) == -1) {
error("Couldn't change local directory to "
"\"%s\": %s", path1, strerror(errno));
err = 1;
}
break;
case I_LMKDIR:
if (mkdir(path1, 0777) == -1) {
error("Couldn't create local directory "
"\"%s\": %s", path1, strerror(errno));
err = 1;
}
break;
case I_LLS:
local_do_ls(cmd);
break;
case I_SHELL:
local_do_shell(cmd);
break;
case I_LUMASK:
umask(n_arg);
printf("Local umask: %03lo\n", n_arg);
break;
case I_CHMOD:
path1 = make_absolute(path1, *pwd);
attrib_clear(&a);
a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
a.perm = n_arg;
remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
printf("Changing mode on %s\n", g.gl_pathv[i]);
err = do_setstat(conn, g.gl_pathv[i], &a);
if (err != 0 && err_abort)
break;
}
break;
case I_CHOWN:
case I_CHGRP:
path1 = make_absolute(path1, *pwd);
remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
if (!(aa = do_stat(conn, g.gl_pathv[i], 0))) {
if (err != 0 && err_abort)
break;
else
continue;
}
if (!(aa->flags & SSH2_FILEXFER_ATTR_UIDGID)) {
error("Can't get current ownership of "
"remote file \"%s\"", g.gl_pathv[i]);
if (err != 0 && err_abort)
break;
else
continue;
}
aa->flags &= SSH2_FILEXFER_ATTR_UIDGID;
if (cmdnum == I_CHOWN) {
printf("Changing owner on %s\n", g.gl_pathv[i]);
aa->uid = n_arg;
} else {
printf("Changing group on %s\n", g.gl_pathv[i]);
aa->gid = n_arg;
}
err = do_setstat(conn, g.gl_pathv[i], aa);
if (err != 0 && err_abort)
break;
}
break;
case I_PWD:
printf("Remote working directory: %s\n", *pwd);
break;
case I_LPWD:
if (!getcwd(path_buf, sizeof(path_buf))) {
error("Couldn't get local cwd: %s", strerror(errno));
err = -1;
break;
}
printf("Local working directory: %s\n", path_buf);
break;
case I_QUIT:
/* Processed below */
break;
case I_HELP:
help();
break;
case I_VERSION:
printf("SFTP protocol version %u\n", sftp_proto_version(conn));
break;
case I_PROGRESS:
showprogress = !showprogress;
if (showprogress)
printf("Progress meter enabled\n");
else
printf("Progress meter disabled\n");
break;
default:
fatal("%d is not implemented", cmdnum);
}
if (g.gl_pathc)
globfree(&g);
if (path1)
xfree(path1);
if (path2)
xfree(path2);
/* If an unignored error occurs in batch mode we should abort. */
if (err_abort && err != 0)
return (-1);
else if (cmdnum == I_QUIT)
return (1);
return (0);
}
