/** Check if we need to close a FAF server file.
* @author Renaud Lottiaux
*
* @param file The file to check.
*
* We can close a FAF server file if local f_count == 1 and DVFS count == 1.
* This means the FAF server is the last process cluster wide using the file.
*/
void check_close_faf_srv_file(struct file *file)
{
struct dvfs_file_struct *dvfs_file;
unsigned long objid = file->f_objid;
int close_file = 0;
/* Pre-check the file count to avoid a useless call to get_dvfs */
if (file_count (file) != 1)
return;
dvfs_file = get_dvfs_file_struct(objid);
/* If dvfs file is NULL, someone else did the job before us */
if (dvfs_file->file == NULL)
goto done;
BUG_ON (dvfs_file->file != file);
/* Re-check f_count in case it changed during the get_dvfs */
if ((dvfs_file->count == 1) && (file_count (file) == 1)) {
/* The FAF server file is the last one used in the cluster.
* We can now close it.
*/
close_file = 1;
dvfs_file->file = NULL;
}
done:
put_dvfs_file_struct (objid);
if (close_file)
close_faf_file(file);
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval;
#if 0
if (((struct _fcb *)filp)->fcb$b_type==DYN$C_FCB)
return 0;
#else
return 0;
#endif
if (!file_count(filp)) {
printk(KERN_ERR "VFS: Close: file count is 0\n");
return 0;
}
retval = 0;
if (filp->f_op && filp->f_op->flush) {
lock_kernel();
retval = filp->f_op->flush(filp);
unlock_kernel();
}
extern is_tty_fops(struct file * f);
if (!is_tty_fops(filp)) {
locks_remove_posix(filp, id);
fput(filp);
}
return retval;
}
/** Close a file in the FAF deamon.
* @author Renaud Lottiaux
*
* @param file The file to close.
*/
int close_faf_file(struct file * file)
{
struct files_struct *files = first_krgrpc->files;
struct file * faf_file;
struct fdtable *fdt;
int fd = file->f_faf_srv_index;
BUG_ON (!(file->f_flags & O_FAF_SRV));
BUG_ON (file_count(file) != 1);
/* Remove the file from the FAF server file table */
spin_lock(&files->file_lock);
fdt = files_fdtable(files);
if (fd >= fdt->max_fds)
BUG();
faf_file = fdt->fd[fd];
if (!faf_file)
BUG();
BUG_ON (faf_file != file);
rcu_assign_pointer(fdt->fd[fd], NULL);
FD_CLR(fd, fdt->close_on_exec);
__put_unused_fd(files, fd);
spin_unlock(&files->file_lock);
/* Cleanup Kerrighed flags but not objid to pass through the regular
* kernel close file code plus kh_put_file() only.
*/
file->f_flags = file->f_flags & (~O_FAF_SRV);
return filp_close(faf_file, files);
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int err, retval;
if (!file_count(filp)) {
printk(KERN_ERR "VFS: Close: file count is 0\n");
return 0;
}
retval = 0;
if (filp->f_op && filp->f_op->flush) {
lock_kernel();
retval = filp->f_op->flush(filp);
unlock_kernel();
}
if (filp->f_dentry && filp->f_dentry->d_inode &&
filp->f_dentry->d_inode->i_mapping) {
struct address_space *mapping = filp->f_dentry->d_inode->i_mapping;
err = mapping_get_error(mapping);
if (err && !retval)
retval = err;
}
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
fput(filp);
return retval;
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval;
/* Report and clear outstanding errors */
retval = filp->f_error;
if (retval)
filp->f_error = 0;
if (!file_count(filp)) {
printk(KERN_ERR "VFS: Close: file count is 0\n");
return retval;
}
if (filp->f_op && filp->f_op->flush) {
int err = filp->f_op->flush(filp);
if (!retval)
retval = err;
}
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
fput(filp);
return retval;
}
/**
* mark_files_ro - mark all files read-only
* @sb: superblock in question
*
* All files are marked read-only. We don't care about pending
* delete files so this should be used in 'force' mode only.
*/
void mark_files_ro(struct super_block *sb)
{
struct file *f;
retry:
lg_global_lock(files_lglock);
do_file_list_for_each_entry(sb, f) {
struct vfsmount *mnt;
if (!S_ISREG(f->f_path.dentry->d_inode->i_mode))
continue;
if (!file_count(f))
continue;
if (!(f->f_mode & FMODE_WRITE))
continue;
spin_lock(&f->f_lock);
f->f_mode &= ~FMODE_WRITE;
spin_unlock(&f->f_lock);
if (file_check_writeable(f) != 0)
continue;
file_release_write(f);
mnt = mntget(f->f_path.mnt);
/* This can sleep, so we can't hold the spinlock. */
lg_global_unlock(files_lglock);
mnt_drop_write(mnt);
mntput(mnt);
goto retry;
} while_file_list_for_each_entry;
lg_global_unlock(files_lglock);
}
static int make_xino(struct seq_file *seq, struct sysaufs_args *args,
int *do_size)
{
int err;
struct super_block *sb = args->sb;
aufs_bindex_t bindex, bend;
struct file *xf;
struct inode *xi;
TraceEnter();
AuDebugOn(args->index != SysaufsSb_XINO);
SiMustReadLock(sb);
*do_size = 0;
err = seq_printf(seq, "%lu %lu\n", (unsigned long)sizeof(struct xino),
(unsigned long)atomic_long_read(&stosi(sb)->si_xino));
bend = sbend(sb);
for (bindex = 0; !err && bindex <= bend; bindex++) {
xf = stobr(sb, bindex)->br_xino;
xi = xf->f_dentry->d_inode;
err = seq_printf(seq, "%d: %d, %Lux%d %Ld\n",
bindex, file_count(xf),
(u64)xi->i_blocks, 1 << xi->i_blkbits,
i_size_read(xi));
}
return err;
}
STATIC int
xfs_file_close(
struct file *filp,
fl_owner_t id)
{
return -bhv_vop_close(vn_from_inode(filp->f_path.dentry->d_inode), 0,
file_count(filp) > 1 ? L_FALSE : L_TRUE, NULL);
}
int main(int argc, char **argv)
{
FILE* input;
int i;
file_count(argc, argv);
Filenames = malloc(sizeof(char*) * Num_Files);
if(Filenames == NULL)
{
printf("Error: Failed To Allocate %lu Bytes\n", (sizeof(char*) * Num_Files));
printf("Terminating Program . . .\n");
return 1;
}
command_parser(argc, argv);
if(!(Options & HELP))
{
/* If no files are supplied, Num_Files is set to 1for stdin */
if(*Filenames == NULL)
Num_Files++;
for(i = 0; i < Num_Files; i++)
{
/* Determine the input */
if(*Filenames)
{
input = fopen(Filenames[i], "rt");
if(input == NULL)
{
printf("Error: Failed To Open %s\n", Filenames[i]);
printf("Terminating Program . . .\n");
return 1;
}
}
else
input = stdin;
filter(input, space_per_tab, replace_arg, delete_arg);
if(*Filenames)
free(input);
}
}
else
help();
free(Filenames);
return 0;
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval = 0;
if (!file_count(filp)) {
printk(KERN_ERR "VFS: Close: file count is 0\n");
return 0;
}
if (filp->f_op && filp->f_op->flush)
retval = filp->f_op->flush(filp, id);
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
fput(filp);
return retval;
}
int coda_flush(struct file *file)
{
unsigned short flags = (file->f_flags) & (~O_EXCL);
unsigned short cflags;
struct coda_inode_info *cii;
struct file *cfile;
struct inode *cinode, *inode;
int err = 0, fcnt;
coda_vfs_stat.flush++;
/* No need to make an upcall when we have not made any modifications
* to the file */
if ((file->f_flags & O_ACCMODE) == O_RDONLY)
return 0;
if (use_coda_close)
return 0;
fcnt = file_count(file);
if (fcnt > 1) return 0;
cflags = coda_flags_to_cflags(flags);
inode = file->f_dentry->d_inode;
cii = ITOC(inode);
cfile = cii->c_container;
if (!cfile) BUG();
cinode = cfile->f_dentry->d_inode;
CDEBUG(D_FILE, "FLUSH coda (file %p ct %d)\n", file, fcnt);
err = venus_store(inode->i_sb, coda_i2f(inode), cflags,
(struct coda_cred *)file->private_data);
if (err == -EOPNOTSUPP) {
use_coda_close = 1;
err = 0;
}
CDEBUG(D_FILE, "coda_flush: result: %d\n", err);
return err;
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval;
if (!file_count(filp)) {
printk("VFS: Close: file count is 0\n");
return 0;
}
retval = 0;
if (filp->f_op && filp->f_op->flush) {
lock_kernel();
retval = filp->f_op->flush(filp);
unlock_kernel();
}
fcntl_dirnotify(0, filp, 0);
locks_remove_posix(filp, id);
fput(filp);
return retval;
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval = 0;
if (!file_count(filp)) {
#ifdef CONFIG_TX_KSTM_WARNINGS
printk(KERN_ERR " (%d) VFS: Close: file count is 0, count lives at %p\n", current->pid, &filp->f_count);
#endif
return 0;
}
if (filp->f_op && filp->f_op->flush)
retval = filp->f_op->flush(filp, id);
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
fput(filp);
return retval;
}
void kv_array_t::info ( std::stringstream & ss )
{
unsigned int count = file_count ();
for ( unsigned int i = 0; i < count; ++ i )
{
i_kv_t * p = get_file ( i );
if ( p )
{
p->info ( ss );
if ( i < count - 1 )
{
ss << ",";
}
}
}
}
int coda_flush(struct file *coda_file, fl_owner_t id)
{
unsigned short flags = coda_file->f_flags & ~O_EXCL;
unsigned short coda_flags = coda_flags_to_cflags(flags);
struct coda_file_info *cfi;
struct inode *coda_inode;
int err = 0, fcnt;
lock_kernel();
coda_vfs_stat.flush++;
/* last close semantics */
fcnt = file_count(coda_file);
if (fcnt > 1)
goto out;
/* No need to make an upcall when we have not made any modifications
* to the file */
if ((coda_file->f_flags & O_ACCMODE) == O_RDONLY)
goto out;
if (use_coda_close)
goto out;
cfi = CODA_FTOC(coda_file);
BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
coda_inode = coda_file->f_dentry->d_inode;
err = venus_store(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags,
coda_file->f_uid);
if (err == -EOPNOTSUPP) {
use_coda_close = 1;
err = 0;
}
out:
unlock_kernel();
return err;
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval = 0;
if (!file_count(filp)) {
printk(KERN_ERR "VFS: Close: file count is 0\n");
return 0;
}
if (filp->f_op && filp->f_op->flush)
retval = filp->f_op->flush(filp, id);
if (likely(!(filp->f_mode & FMODE_PATH))) {
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
}
security_file_close(filp);
fput(filp);
return retval;
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval = 0;
if (!file_count(filp)) {
printk(KERN_ERR "VFS: %s: ERROR! file count is 0. PID: %d, Task: %.*s\n",
__func__, current->pid, TASK_COMM_LEN, current->comm);
return 0;
}
if (filp->f_op && filp->f_op->flush)
retval = filp->f_op->flush(filp, id);
if (likely(!(filp->f_mode & FMODE_PATH))) {
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
}
fput(filp);
return retval;
}
/* do_emergency_sync helper function */
static void go_sync(struct super_block *sb, int remount_flag)
{
int orig_loglevel;
orig_loglevel = console_loglevel;
console_loglevel = 7;
printk(KERN_INFO "%sing device %s ... ",
remount_flag ? "Remount" : "Sync",
kdevname(sb->s_dev));
if (remount_flag) { /* Remount R/O */
int ret, flags;
struct list_head *p;
if (sb->s_flags & MS_RDONLY) {
printk("R/O\n");
return;
}
file_list_lock();
for (p = sb->s_files.next; p != &sb->s_files; p = p->next) {
struct file *file = list_entry(p, struct file, f_list);
if (file->f_dentry && file_count(file)
&& S_ISREG(file->f_dentry->d_inode->i_mode))
file->f_mode &= ~2;
}
file_list_unlock();
DQUOT_OFF(sb);
fsync_dev(sb->s_dev);
flags = MS_RDONLY;
if (sb->s_op && sb->s_op->remount_fs) {
ret = sb->s_op->remount_fs(sb, &flags, NULL);
if (ret)
printk("error %d\n", ret);
else {
sb->s_flags = (sb->s_flags & ~MS_RMT_MASK) | (flags & MS_RMT_MASK);
printk("OK\n");
}
} else
printk("nothing to do\n");
} else { /* Sync only */
static void hw3d_vma_close(struct vm_area_struct *vma)
{
struct file *file = vma->vm_file;
struct hw3d_data *data = file->private_data;
int i;
pr_debug("hw3d: current %u ppid %u file %p count %ld\n",
current->pid, current->parent->pid, file, file_count(file));
BUG_ON(!data);
mutex_lock(&data->mutex);
for (i = 0; i < HW3D_NUM_REGIONS; ++i) {
if (data->vmas[i] == vma) {
data->vmas[i] = NULL;
goto done;
}
}
pr_warning("%s: vma %p not of ours during vma_close\n", __func__, vma);
done:
mutex_unlock(&data->mutex);
}
static int do_pri_file(aufs_bindex_t bindex, struct file *file)
{
char a[32];
if (!file || IS_ERR(file)) {
dpri("f%d: err %ld\n", bindex, PTR_ERR(file));
return -1;
}
a[0] = 0;
if (bindex < 0
&& file->f_dentry
&& au_test_aufs(file->f_dentry->d_sb)
&& au_fi(file))
snprintf(a, sizeof(a), ", gen %d, mmapped %d",
au_figen(file), atomic_read(&au_fi(file)->fi_mmapped));
dpri("f%d: mode 0x%x, flags 0%o, cnt %ld, v %llu, pos %llu%s\n",
bindex, file->f_mode, file->f_flags, (long)file_count(file),
file->f_version, file->f_pos, a);
if (file->f_dentry)
do_pri_dentry(bindex, file->f_dentry);
return 0;
}
/*
* "id" is the POSIX thread ID. We use the
* files pointer for this..
*/
int filp_close(struct file *filp, fl_owner_t id)
{
int retval = 0;
long ret;
ret = file_count(filp);
if (ret <= 0) {
printk(KERN_ERR "VFS: Close: file count is %ld\n", ret);
WARN_ON(ret < 0);
return 0;
}
if (filp->f_op && filp->f_op->flush)
retval = filp->f_op->flush(filp, id);
if (likely(!(filp->f_mode & FMODE_PATH))) {
dnotify_flush(filp, id);
locks_remove_posix(filp, id);
}
fput(filp);
return retval;
}
int coda_flush(struct file *coda_file)
{
unsigned short flags = coda_file->f_flags & ~O_EXCL;
unsigned short coda_flags = coda_flags_to_cflags(flags);
struct coda_file_info *cfi;
struct inode *coda_inode;
int err = 0, fcnt;
coda_vfs_stat.flush++;
/* No need to make an upcall when we have not made any modifications
* to the file */
if ((coda_file->f_flags & O_ACCMODE) == O_RDONLY)
return 0;
if (use_coda_close)
return 0;
fcnt = file_count(coda_file);
if (fcnt > 1) return 0;
coda_inode = coda_file->f_dentry->d_inode;
cfi = CODA_FTOC(coda_file);
if (!cfi || cfi->cfi_magic != CODA_MAGIC) BUG();
err = venus_store(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags,
&cfi->cfi_cred);
if (err == -EOPNOTSUPP) {
use_coda_close = 1;
err = 0;
}
return err;
}
// filtloc and filter operate on the filenames and determine whether they
// may be selected:
// ALL: don't filter, in this case, filter can be NULL
// BASE: filter with cmp_base(filename, filter) - only show when part up to
// last extension matches
// EXT: filter with cmp_ext(filename, filter) - only show when (last) extension
// matches
// NAME: filter with strcasecmp(filename, filter) - only show when whole name
// matches
char * select_file(enum filter_spec filtloc, char *filter) {
char *selected_file, str[256];
int npages, pagenum = 1;
const int perpage = PERPAGE - 1;
DECL_LINE(backbtn);
DECL_LINE(prevpage);
DECL_LINE(nextpage);
strcpy(sbstr, "file browser");
selected_file = malloc(PATH_MAX * sizeof(char));
selected_file[0] = '\0';
while (selected_file[0] == '\0') {
char *pwd = NULL;
int n;
int *by, *kept;
int j, nkept;
int match, keep;
uint16_t mode;
sel = -1;
clear_screen();
START_LIST(8, 48, 448, 0xFF404040, 0xFF808080, 0xFFC0C0C0)
update_dir_list();
n = file_count();
by = malloc(n * sizeof(int));
kept = malloc(n * sizeof(int));
npages = 1 + n / perpage;
pwd = getcwd(pwd, PATH_MAX);
text(pwd, 16, 24, 1, 1, 0xFF606060, 0xFF000000);
DRAW_LINE(backbtn, "back", "return to previous menu without making a selection");
if (pagenum > 1) {
DRAW_LINE(prevpage, "previous page", "not all files are shown");
}
j = 0;
for (int i = 0; i < n; ++i) {
switch (filtloc) {
case ANY:
match = 1;
break;
case BASE:
match = !cmp_base(file_name(i), filter);
break;
case EXT:
match = !cmp_ext(file_name(i), filter);
break;
case NAME:
match = !strcasecmp(file_name(i), filter);
break;
default:
match = 0;
}
if (file_is_dir(i) || match) {
kept[j] = i;
++j;
}
}
nkept = j;
for (int i = perpage * (pagenum - 1); i < nkept; ++i) {
if (i > pagenum * perpage) break;
snprintf(str, sizeof(str), "permissions = %o", file_mode(kept[i]) & 07777);
USECOLR = !USECOLR;
CURCOLR = USECOLR ? BG1COLR : BG2COLR;
current_y += 48;
by[i] = current_y;
fill_rect(0, by[i], 1024, 44, CURCOLR);
text(file_name(kept[i]), col1_x, by[i] + 8, 1, 1, 0xFFFFFFFF, CURCOLR);
text(str, col2_x, by[i] + 8, 1, 1, 0xFFFFFFFF, CURCOLR);
}
if (pagenum < npages) {
DRAW_LINE(nextpage, "next page", "not all files are shown");
}
while (sel == -1) {
update_screen();
input_read();
if (BTN_CLICKED(backbtn)) {
free(by);
free(kept);
return NULL;
}
for (int i = perpage * (pagenum - 1); i <= nkept; ++i)
if (was_clicked(0, by[i], 1024, 44))
sel = kept[i];
if (BTN_CLICKED(prevpage)) {
--pagenum;
break;
} else if (BTN_CLICKED(nextpage)) {
++pagenum;
break;
}
}
if (sel != -1) {
free(by);
free(kept);
pagenum = 1;
if (file_is_dir(sel)) {
if (chdir(file_name(sel)) == -1)
perror("chdir");
} else {
strcpy(selected_file, pwd);
strcat(selected_file, "/");
strcat(selected_file, file_name(sel));
}
}
}
return selected_file;
}
/* read (extract) 'zipfile' in current directory */
int zread(const char *zipfile, unsigned long long maxsize)
{
struct filedesc *fdesc;
int err, fd;
size_t len;
struct zip *zip;
zip_int64_t z64;
zip_uint64_t uz64;
unsigned int count, index;
struct zip_file *zfile;
struct zip_stat zstat;
char buffer[32768];
ssize_t sizr, sizw;
size_t esize;
/* open the zip file */
zip = zip_open(zipfile, ZIP_CHECKCONS, &err);
if (!zip) {
ERROR("Can't connect to file %s", zipfile);
return -1;
}
z64 = zip_get_num_entries(zip, 0);
if (z64 < 0 || z64 > UINT_MAX) {
ERROR("too many entries in %s", zipfile);
goto error;
}
count = (unsigned int)z64;
/* records the files */
file_reset();
esize = 0;
for (index = 0 ; index < count ; index++) {
err = zip_stat_index(zip, index, ZIP_FL_ENC_GUESS, &zstat);
/* check the file name */
if (!is_valid_filename(zstat.name)) {
ERROR("invalid entry %s found in %s", zstat.name, zipfile);
goto error;
}
if (zstat.name[0] == '/') {
ERROR("absolute entry %s found in %s", zstat.name, zipfile);
goto error;
}
len = strlen(zstat.name);
if (len == 0) {
ERROR("empty entry found in %s", zipfile);
goto error;
}
if (zstat.name[len - 1] == '/')
/* record */
fdesc = file_add_directory(zstat.name);
else {
/* get the size */
esize += zstat.size;
/* record */
fdesc = file_add_file(zstat.name);
}
if (!fdesc)
goto error;
fdesc->zindex = index;
}
/* check the size */
if (maxsize && esize > maxsize) {
ERROR("extracted size %zu greater than allowed size %llu", esize, maxsize);
goto error;
}
/* unpack the recorded files */
assert(count == file_count());
for (index = 0 ; index < count ; index++) {
fdesc = file_of_index(index);
assert(fdesc != NULL);
err = zip_stat_index(zip, fdesc->zindex, ZIP_FL_ENC_GUESS, &zstat);
assert(zstat.name[0] != '/');
len = strlen(zstat.name);
assert(len > 0);
if (zstat.name[len - 1] == '/') {
/* directory name */
err = create_directory((char*)zstat.name, MODE_OF_DIRECTORY_CREATION);
if (err && errno != EEXIST)
goto error;
} else {
/* file name */
zfile = zip_fopen_index(zip, fdesc->zindex, 0);
if (!zfile) {
ERROR("Can't open %s in %s", zstat.name, zipfile);
goto error;
}
fd = create_file((char*)zstat.name, MODE_OF_FILE_CREATION, MODE_OF_DIRECTORY_CREATION);
if (fd < 0)
goto errorz;
/* extract */
uz64 = zstat.size;
while (uz64) {
sizr = zip_fread(zfile, buffer, sizeof buffer);
if (sizr < 0) {
ERROR("error while reading %s in %s", zstat.name, zipfile);
goto errorzf;
}
sizw = write(fd, buffer, (size_t)sizr);
if (sizw < 0) {
ERROR("error while writing %s", zstat.name);
goto errorzf;
}
uz64 -= (size_t)sizw;
}
close(fd);
zip_fclose(zfile);
}
}
zip_close(zip);
return 0;
errorzf:
close(fd);
errorz:
zip_fclose(zfile);
error:
zip_close(zip);
return -1;
}
//-----------------------------------------------------------------//
void list_name() {
for(size_t i = 0; i < file_count(); ++i) {
const std::string& s = get_file_name(i);
std::cout << s << std::endl;
}
}
int
main(int argc, char *argv[])
{
int n, l, complete_type = 0, not_allowed = 0, argv_mode = 0;
#ifdef USING_GLFTPD
int gnum = 0, unum = 0;
char myflags[20];
#endif
char *ext, exec[4096], *complete_bar = 0, *inc_point[2];
unsigned int crc;
struct stat fileinfo;
uid_t f_uid;
gid_t f_gid;
double temp_time = 0;
DIR *dir, *parent;
struct dirent *dp;
long loc;
time_t timenow;
#if (test_for_password || extract_nfo || zip_clean)
off_t tempstream;
#endif
short rescan_quick = rescan_default_to_quick;
char one_name[NAME_MAX];
char *temp_p = NULL;
int chdir_allowed = 0, argnum = 0;
GLOBAL g;
#if (enable_rescan_script)
char target[PATH_MAX+NAME_MAX];
#endif
#if ( program_uid > 0 )
setegid(program_gid);
seteuid(program_uid);
#endif
umask(0666 & 000);
d_log("rescan: PZS-NG (rescan v2) %s debug log.\n", ng_version);
d_log("rescan: Rescan executed by: (uid/gid) %d/%d\n", geteuid(), getegid());
#ifdef _ALT_MAX
d_log("rescan: PATH_MAX not found - using predefined settings! Please report to the devs!\n");
#endif
d_log("rescan: Allocating memory for variables\n");
g.ui = ng_realloc2(g.ui, sizeof(*g.ui) * 30, 1, 1, 1);
g.gi = ng_realloc2(g.gi, sizeof(*g.gi) * 30, 1, 1, 1);
bzero(one_name, NAME_MAX);
#ifdef USING_GLFTPD
if (getenv("FLAGS")) {
strlcpy(myflags, getenv("FLAGS"), sizeof(myflags));
n = strlen(myflags);
while (n > 0) {
--n;
l = strlen(rescan_chdir_flags);
while(l > 0) {
--l;
if (myflags[n] == rescan_chdir_flags[l])
chdir_allowed = 1;
}
}
}
if (!geteuid())
chdir_allowed = 1;
#endif
/* With glftpd we can use env vars, rest of the world: commandline. */
#ifndef USING_GLFTPD
if (argc < 7) {
print_syntax(chdir_allowed);
ng_free(g.ui);
ng_free(g.gi);
return 0;
}
argnum = 6;
if (chdir(argv[5]) != 0) {
printf("Could not chdir to <cwd = '%s'>, ftpd agnostic mode: %s\n", argv[5], strerror(errno));
d_log("rescan: Could not chdir to <cwd = '%s'>, ftpd agnostic mode: %s\n", argv[5], strerror(errno));
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
#else
argnum = 1;
#endif
while ((argnum < argc) && argc > 1) {
if (!strncasecmp(argv[argnum], "--quick", 7))
rescan_quick = TRUE;
else if (!strncasecmp(argv[argnum], "--normal", 8))
rescan_quick = FALSE;
else if (!strncasecmp(argv[argnum], "--dir=", 6) && (strlen(argv[argnum]) > 7) && chdir_allowed) {
temp_p = argv[argnum] + 6;
if ((!matchpath(nocheck_dirs, temp_p)) && (matchpath(zip_dirs, temp_p) || matchpath(sfv_dirs, temp_p)) && !matchpath(group_dirs, temp_p)) {
if (chdir(temp_p)) {
d_log("rescan: Failed to chdir() to %s : %s\n", temp_p, strerror(errno));
not_allowed = 1;
}
} else {
printf("Not allowed to chdir() to %s\n", temp_p);
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
printf("PZS-NG Rescan %s: Rescanning %s\n", ng_version, temp_p);
argv_mode = 1;
} else if (!strncasecmp(argv[argnum], "--chroot=", 9) && (strlen(argv[argnum]) > 10) && chdir_allowed) {
if (temp_p == NULL) {
temp_p = argv[argnum] + 9;
if (chroot(temp_p) == -1) {
d_log("rescan: Failed to chroot() to %s : %s\n", temp_p, strerror(errno));
not_allowed = 1;
}
} else {
temp_p = argv[argnum] + 9;
printf("Not allowed to chroot() to %s\n", temp_p);
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
printf("PZS-NG Rescan %s: Chroot'ing to %s\n", ng_version, temp_p);
argv_mode = 1;
} else if (!strncasecmp(argv[argnum], "--help", 6) || !strncasecmp(argv[argnum], "/?", 2) || !strncasecmp(argv[argnum], "--?", 3)) {
print_syntax(chdir_allowed);
ng_free(g.ui);
ng_free(g.gi);
return 0;
} else {
strlcpy(one_name, argv[argnum], sizeof(one_name));
rescan_quick = FALSE;
printf("PZS-NG Rescan %s: Rescanning in FILE mode\n", ng_version);
if (one_name[strlen(one_name) - 1] == '*') {
one_name[strlen(one_name) - 1] = '\0';
} else if (!fileexists(one_name)) {
d_log("PZS-NG Rescan: No file named '%s' exists.\n", one_name);
one_name[0] = '\0';
not_allowed = 1;
}
argv_mode = 1;
}
argnum++;
}
if (one_name[0] == '\0') {
if (rescan_quick == TRUE) {
printf("PZS-NG Rescan %s: Rescanning in QUICK mode.\n", ng_version);
} else {
printf("PZS-NG Rescan %s: Rescanning in NORMAL mode.\n", ng_version);
}
}
printf("PZS-NG Rescan %s: Use --help for options.\n\n", ng_version);
if (not_allowed) {
ng_free(g.ui);
ng_free(g.gi);
return 1;
}
if (!getcwd(g.l.path, PATH_MAX)) {
d_log("rescan: getcwd() failed: %s\n", strerror(errno));
}
if (subcomp(g.l.path, g.l.basepath) && (g.l.basepath[0] == '\0'))
strlcpy(g.l.basepath, g.l.path, sizeof(g.l.basepath));
if (strncmp(g.l.path, g.l.basepath, PATH_MAX))
d_log("rescan: We are in subdir of %s\n", g.l.basepath);
strlcpy(g.v.misc.current_path, g.l.path, sizeof(g.v.misc.current_path));
strlcpy(g.v.misc.basepath, g.l.basepath, sizeof(g.v.misc.basepath));
if ((matchpath(nocheck_dirs, g.l.path) && !rescan_nocheck_dirs_allowed) || (matchpath(group_dirs, g.l.path) && argv_mode) || (!matchpath(nocheck_dirs, g.l.path) && !matchpath(zip_dirs, g.l.path) && !matchpath(sfv_dirs, g.l.path) && !matchpath(group_dirs, g.l.path)) || insampledir(g.l.path)) {
d_log("rescan: Dir matched with nocheck_dirs/sample_list, or is not in the zip/sfv/group-dirs.\n");
d_log("rescan: Freeing memory, and exiting.\n");
printf("Notice: Unable to rescan this dir - check config.\n\n");
ng_free(g.ui);
ng_free(g.gi);
return 0;
}
g.v.misc.slowest_user[0] = ULONG_MAX;
bzero(&g.v.total, sizeof(struct race_total));
g.v.misc.fastest_user[0] = 0;
g.v.misc.release_type = RTYPE_NULL;
g.v.misc.write_log = 0;
#ifdef USING_GLFTPD
if (getenv("SECTION") == NULL) {
sprintf(g.v.sectionname, "DEFAULT");
} else {
snprintf(g.v.sectionname, sizeof(g.v.sectionname), "%s", getenv("SECTION"));
}
#else
snprintf(g.v.sectionname, sizeof(g.v.sectionname), argv[4]);
#endif
g.l.length_path = (int)strlen(g.l.path);
g.l.length_zipdatadir = sizeof(storage);
n = g.l.length_path + g.l.length_zipdatadir + 11;
g.l.race = ng_realloc2(g.l.race, n, 1, 1, 1);
g.l.sfv = ng_realloc2(g.l.sfv, n - 1, 1, 1, 1);
g.l.sfvbackup = ng_realloc2(g.l.sfvbackup, n + 1, 1, 1, 1);
g.l.leader = ng_realloc2(g.l.leader, n - 2, 1, 1, 1);
g.l.sfv_incomplete = 0;
getrelname(&g);
#ifdef USING_GLFTPD
gnum = buffer_groups(GROUPFILE, 0);
unum = buffer_users(PASSWDFILE, 0);
#endif
sprintf(g.l.sfv, storage "/%s/sfvdata", g.l.path);
sprintf(g.l.sfvbackup, storage "/%s/sfvbackup", g.l.path);
sprintf(g.l.leader, storage "/%s/leader", g.l.path);
sprintf(g.l.race, storage "/%s/racedata", g.l.path);
d_log("rescan: Creating directory to store racedata in\n");
maketempdir(g.l.path);
d_log("rescan: Locking release\n");
while (1) {
if ((l = create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 3, 0))) {
d_log("rescan: Failed to lock release.\n");
if (l == 1) {
d_log("rescan: version mismatch. Exiting.\n");
printf("Error. You need to rm -fR ftp-data/pzs-ng/* before rescan will work.\n"); /* */
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(EXIT_FAILURE);
}
if (l == PROGTYPE_POSTDEL) {
n = (signed int)g.v.data_incrementor;
d_log("rescan: Detected postdel running - sleeping for one second.\n");
if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
break;
usleep(1000000);
if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
break;
if ( n == (signed int)g.v.data_incrementor) {
d_log("rescan: Failed to get lock. Forcing unlock.\n");
if (create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 2, g.v.data_queue)) {
d_log("rescan: Failed to force a lock.\n");
d_log("rescan: Exiting with error.\n");
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(EXIT_FAILURE);
}
break;
}
} else {
for (l = 0; l <= max_seconds_wait_for_lock * 10; ++l) {
d_log("rescan: sleeping for .1 second before trying to get a lock (queue: %d).\n", g.v.data_queue);
usleep(100000);
if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
break;
}
if (l >= max_seconds_wait_for_lock * 10) {
d_log("rescan: Failed to get lock. Will not force unlock.\n");
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(EXIT_FAILURE);
}
}
}
usleep(10000);
if (update_lock(&g.v, 1, 0) != -1)
break;
}
move_progress_bar(1, &g.v, g.ui, g.gi);
if (g.l.incomplete)
unlink(g.l.incomplete);
if (del_completebar)
removecomplete();
dir = opendir(".");
parent = opendir("..");
if (!((rescan_quick && findfileext(dir, ".sfv")) || *one_name)) {
if (g.l.sfv)
unlink(g.l.sfv);
if (g.l.race)
unlink(g.l.race);
}
printf("Rescanning files...\n");
if (findfileext(dir, ".zip")) {
if (!fileexists(unzip_bin)) {
printf("rescan: ERROR! Not able to check zip-files - %s does not exist!\n", unzip_bin);
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
exit(EXIT_FAILURE);
} else {
crc = 0;
rewinddir(dir);
timenow = time(NULL);
while ((dp = readdir(dir))) {
ext = find_last_of(dp->d_name, ".");
if (*ext == '.')
ext++;
if (!strcasecmp(ext, "zip")) {
stat(dp->d_name, &fileinfo);
f_uid = fileinfo.st_uid;
f_gid = fileinfo.st_gid;
if ((timenow == fileinfo.st_ctime) && (fileinfo.st_mode & 0111)) {
d_log("rescan.c: Seems this file (%s) is in the process of being uploaded. Ignoring for now.\n", dp->d_name);
continue;
}
#ifdef USING_GLFTPD
strlcpy(g.v.user.name, get_u_name(f_uid), sizeof(g.v.user.name));
strlcpy(g.v.user.group, get_g_name(f_gid), sizeof(g.v.user.group));
#else
strlcpy(g.v.user.name, argv[1], sizeof(g.v.user.name));
strlcpy(g.v.user.group, argv[2], sizeof(g.v.user.group));
#endif
strlcpy(g.v.file.name, dp->d_name, sizeof(g.v.file.name));
g.v.file.speed = 2005 * 1024;
g.v.file.size = fileinfo.st_size;
g.v.total.start_time = 0;
#if (test_for_password || extract_nfo)
tempstream = telldir(dir);
if ((!findfileextcount(dir, ".nfo") || findfileextcount(dir, ".zip")) && !mkdir(".unzipped", 0777))
snprintf(exec, sizeof(exec), "%s -qqjo \"%s\" -d .unzipped 2>.delme", unzip_bin, g.v.file.name);
else
snprintf(exec, sizeof(exec), "%s -qqt \"%s\" 2>.delme", unzip_bin, g.v.file.name);
seekdir(dir, tempstream);
#else
snprintf(exec, sizeof(exec), "%s -qqt \"%s\" 2>.delme", unzip_bin, g.v.file.name);
#endif
if (system(exec) == 0 || (allow_error2_in_unzip == TRUE && errno < 3 )) {
writerace(g.l.race, &g.v, crc, F_CHECKED);
} else {
writerace(g.l.race, &g.v, crc, F_BAD);
if (g.v.file.name)
unlink(g.v.file.name);
removedir(".unzipped");
continue;
}
#if (test_for_password || extract_nfo || zip_clean)
tempstream = telldir(dir);
if ((!findfileextcount(dir, ".nfo") || findfileextcount(dir, ".zip")) && check_zipfile(".unzipped", g.v.file.name, findfileextcount(dir, ".nfo"))) {
d_log("rescan: File %s is password protected.\n", g.v.file.name);
writerace(g.l.race, &g.v, crc, F_BAD);
if (g.v.file.name)
unlink(g.v.file.name);
seekdir(dir, tempstream);
continue;
}
seekdir(dir, tempstream);
#endif
if (!fileexists("file_id.diz")) {
snprintf(exec, sizeof(exec), "%s -qqjnCLL \"%s\" file_id.diz 2>.delme", unzip_bin, g.v.file.name);
if (execute(exec) != 0) {
d_log("rescan: No file_id.diz found (#%d): %s\n", errno, strerror(errno));
} else {
if (fileexists("file_id.diz.bad")) {
loc = findfile(dir, "file_id.diz.bad");
seekdir(dir, loc);
dp = readdir(dir);
unlink(dp->d_name);
}
if (chmod("file_id.diz", 0666))
d_log("rescan: Failed to chmod %s: %s\n", "file_id.diz", strerror(errno));
}
}
}
}
if (fileexists(".delme"))
unlink(".delme");
g.v.total.files = read_diz();
if (!g.v.total.files) {
g.v.total.files = 1;
unlink("file_id.diz");
}
g.v.total.files_missing = g.v.total.files;
readrace(g.l.race, &g.v, g.ui, g.gi);
sortstats(&g.v, g.ui, g.gi);
if (g.v.total.files_missing < 0) {
g.v.total.files -= g.v.total.files_missing;
g.v.total.files_missing = 0;
}
buffer_progress_bar(&g.v);
if (g.v.total.files_missing == 0) {
complete(&g, complete_type);
createstatusbar(convert(&g.v, g.ui, g.gi, zip_completebar));
#if (chmod_completebar)
if (!matchpath(group_dirs, g.l.path)) {
if (chmod_each(convert(&g.v, g.ui, g.gi, zip_completebar), 0222))
d_log("rescan: Failed to chmod a statusbar: %s\n", strerror(errno));
}
#endif
} else {
if (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) {
if (create_incomplete()) {
d_log("rescan: create_incomplete() returned something\n");
}
}
move_progress_bar(0, &g.v, g.ui, g.gi);
}
if (g.l.nfo_incomplete) {
if (findfileext(dir, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else if (matchpath(check_for_missing_nfo_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
if (!g.l.in_cd_dir) {
d_log("rescan: Creating missing-nfo indicator %s.\n", g.l.nfo_incomplete);
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
} else {
if (findfileextparent(parent, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else {
d_log("rescan: Creating missing-nfo indicator (base) %s.\n", g.l.nfo_incomplete);
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
}
}
}
}
}
} else if ((temp_p = findfileext(dir, ".sfv")) || (create_missing_sfv && file_count(dir))) {
if (!temp_p && create_missing_sfv && file_count(dir)) {
d_log("rescan: No sfv found - creating one.\n");
make_sfv(g.l.path);
if (!(temp_p = findfileext(dir, ".sfv"))) {
d_log("rescan: Freeing memory, removing lock and exiting.\n");
unlink(g.l.sfv);
if (fileexists(g.l.sfvbackup))
unlink(g.l.sfvbackup);
unlink(g.l.race);
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
return 0;
}
}
#if ( create_missing_sfv_link == TRUE )
d_log("rescan: Removing missing-sfv indicator (if any)\n");
unlink(g.l.sfv_incomplete);
#endif
strlcpy(g.v.file.name, temp_p, sizeof(g.v.file.name));
maketempdir(g.l.path);
stat(g.v.file.name, &fileinfo);
if (copysfv(g.v.file.name, g.l.sfv, &g.v)) {
printf("Found invalid entries in SFV - Exiting.\n");
while ((dp = readdir(dir))) {
ext = find_last_of(dp->d_name, "-");
if (!strcasecmp(ext, "-missing"))
unlink(dp->d_name);
}
d_log("rescan: Freeing memory, removing lock and exiting\n");
unlink(g.l.sfv);
if (fileexists(g.l.sfvbackup))
unlink(g.l.sfvbackup);
unlink(g.l.race);
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
return 0;
}
g.v.total.start_time = 0;
rewinddir(dir);
while ((dp = readdir(dir))) {
if (*one_name && strncasecmp(one_name, dp->d_name, strlen(one_name)))
continue;
l = (int)strlen(dp->d_name);
ext = find_last_of(dp->d_name, ".-");
if (*ext == '.')
ext++;
if (!update_lock(&g.v, 1, 0)) {
d_log("rescan: Another process wants the lock - will comply and remove lock, then exit.\n");
closedir(dir);
closedir(parent);
ng_free(g.ui);
ng_free(g.gi);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
ng_free(g.l.race);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
remove_lock(&g.v);
exit(EXIT_FAILURE);
}
if (
!strcomp(ignored_types, ext) &&
(!(strcomp(allowed_types, ext) && !matchpath(allowed_types_exemption_dirs, g.l.path))) &&
strcasecmp("sfv", ext) &&
strcasecmp("nfo", ext) &&
strcasecmp("bad", ext) &&
strcasecmp("-missing", ext) &&
strncmp(dp->d_name, ".", 1)
) {
stat(dp->d_name, &fileinfo);
if (S_ISDIR(fileinfo.st_mode))
continue;
if (ignore_zero_sized_on_rescan && !fileinfo.st_size)
continue;
f_uid = fileinfo.st_uid;
f_gid = fileinfo.st_gid;
#ifdef USING_GLFTPD
strlcpy(g.v.user.name, get_u_name(f_uid), sizeof(g.v.user.name));
strlcpy(g.v.user.group, get_g_name(f_gid), sizeof(g.v.user.group));
#else
strlcpy(g.v.user.name, argv[1], sizeof(g.v.user.name));
strlcpy(g.v.user.group, argv[2], sizeof(g.v.user.group));
#endif
strlcpy(g.v.file.name, dp->d_name, sizeof(g.v.file.name));
g.v.file.speed = 2005 * 1024;
g.v.file.size = fileinfo.st_size;
temp_time = fileinfo.st_mtime;
if (g.v.total.start_time == 0)
g.v.total.start_time = temp_time;
else
g.v.total.start_time = (g.v.total.start_time < temp_time ? g.v.total.start_time : temp_time);
g.v.total.stop_time = (temp_time > g.v.total.stop_time ? temp_time : g.v.total.stop_time);
/* Hide users in group_dirs */
if (matchpath(group_dirs, g.l.path) && (hide_group_uploaders == TRUE)) {
d_log("rescan: Hiding user in group-dir:\n");
if ((int)strlen(hide_gname) > 0) {
snprintf(g.v.user.group, sizeof(g.v.user.group), "%s", hide_gname);
d_log("rescan: Changing groupname\n");
}
if ((int)strlen(hide_uname) > 0) {
snprintf(g.v.user.name, sizeof(g.v.user.name), "%s", hide_uname);
d_log("rescan: Changing username\n");
}
#if (show_users_in_group_dirs == FALSE)
if ((int)strlen(hide_uname) == 0) {
d_log("rescan: Making username = groupname\n");
snprintf(g.v.user.name, sizeof(g.v.user.name), "%s", g.v.user.group);
}
#endif
}
if (!rescan_quick || (g.l.race && !match_file(g.l.race, dp->d_name)))
crc = calc_crc32(dp->d_name);
else
crc = 1;
if (!S_ISDIR(fileinfo.st_mode)) {
if (g.v.file.name)
unlink_missing(g.v.file.name);
if (l > 44) {
if (crc == 1)
printf("\nFile: %s CHECKED", dp->d_name + l - 44);
else
printf("\nFile: %s %.8x", dp->d_name + l - 44, crc);
} else {
if (crc == 1)
printf("\nFile: %-44s CHECKED", dp->d_name);
else
printf("\nFile: %-44s %.8x", dp->d_name, crc);
}
}
if(fflush(stdout))
d_log("rescan: ERROR: %s\n", strerror(errno));
if (!rescan_quick || (g.l.race && !match_file(g.l.race, dp->d_name)) || !fileexists(dp->d_name))
writerace(g.l.race, &g.v, crc, F_NOTCHECKED);
}
}
printf("\n");
testfiles(&g.l, &g.v, 1);
printf("\n");
readsfv(g.l.sfv, &g.v, 0);
readrace(g.l.race, &g.v, g.ui, g.gi);
sortstats(&g.v, g.ui, g.gi);
buffer_progress_bar(&g.v);
if (g.l.nfo_incomplete) {
if (findfileext(dir, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else if (matchpath(check_for_missing_nfo_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
if (!g.l.in_cd_dir) {
d_log("rescan: Creating missing-nfo indicator %s.\n", g.l.nfo_incomplete);
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
} else {
if (findfileextparent(parent, ".nfo")) {
d_log("rescan: Removing missing-nfo indicator (if any)\n");
remove_nfo_indicator(&g);
} else {
d_log("rescan: Creating missing-nfo indicator (base) %s.\n", g.l.nfo_incomplete);
/* This is not pretty, but should be functional. */
if ((inc_point[0] = find_last_of(g.l.path, "/")) != g.l.path)
*inc_point[0] = '\0';
if ((inc_point[1] = find_last_of(g.v.misc.release_name, "/")) != g.v.misc.release_name)
*inc_point[1] = '\0';
if (create_incomplete_nfo()) {
d_log("rescan: create_incomplete_nfo() returned something\n");
}
if (*inc_point[0] == '\0')
*inc_point[0] = '/';
if (*inc_point[1] == '\0')
*inc_point[1] = '/';
}
}
}
}
#if (create_missing_sample_link)
if (g.l.sample_incomplete) {
if (findfileextsub(dir) || matchpartialdirname(missing_sample_check_ignore_list, g.v.misc.release_name, missing_sample_check_ignore_dividers)) {
d_log("rescan: Removing missing-sample indicator (if any)\n");
remove_sample_indicator(&g);
} else if (matchpath(check_for_missing_sample_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
if (!g.l.in_cd_dir) {
d_log("rescan: Creating missing-sample indicator %s.\n", g.l.sample_incomplete);
if (create_incomplete_sample()) {
d_log("rescan: create_incomplete_sample() returned something\n");
}
} else {
if (findfileextsubp(dir)) {
d_log("rescan: Removing missing-sample indicator (if any)\n");
remove_sample_indicator(&g);
} else {
d_log("rescan: Creating missing-sample indicator (base) %s.\n", g.l.sample_incomplete);
/* This is not pretty, but should be functional. */
if ((inc_point[0] = find_last_of(g.l.path, "/")) != g.l.path)
*inc_point[0] = '\0';
if ((inc_point[1] = find_last_of(g.v.misc.release_name, "/")) != g.v.misc.release_name)
*inc_point[1] = '\0';
if (create_incomplete_sample()) {
d_log("rescan: create_incomplete_sample() returned something\n");
}
if (*inc_point[0] == '\0')
*inc_point[0] = '/';
if (*inc_point[1] == '\0')
*inc_point[1] = '/';
}
}
}
}
#endif
if (g.v.misc.release_type == RTYPE_AUDIO) {
get_audio_info(findfileextfromlist(dir, audio_types), &g.v.audio);
/* Sort if we're not in a group-dir/nosort-dir. */
if (!matchpath(group_dirs, g.l.path) && !matchpath(audio_nosort_dirs, g.l.path)) {
printf(" Resorting release.\n");
audioSort(&g.v.audio, g.l.link_source, g.l.link_target);
}
}
if ((g.v.total.files_missing == 0) && (g.v.total.files > 0)) {
switch (g.v.misc.release_type) {
case RTYPE_RAR:
complete_bar = rar_completebar;
break;
case RTYPE_OTHER:
complete_bar = other_completebar;
break;
case RTYPE_AUDIO:
complete_bar = audio_completebar;
#if ( create_m3u == TRUE )
n = snprintf(exec, sizeof(exec), "%s", findfileext(dir, ".sfv"));
strcpy(exec + n - 3, "m3u");
create_indexfile(g.l.race, &g.v, exec);
#endif
break;
case RTYPE_VIDEO:
complete_bar = video_completebar;
break;
}
complete(&g, complete_type);
if (complete_bar) {
createstatusbar(convert(&g.v, g.ui, g.gi, complete_bar));
#if (chmod_completebar)
if (!matchpath(group_dirs, g.l.path)) {
if (chmod_each(convert(&g.v, g.ui, g.gi, complete_bar), 0222))
d_log("rescan: Failed to chmod a statusbar: %s\n", strerror(errno));
}
#endif
}
#if (enable_rescan_script)
d_log("rescan: Executing rescan_script script\n");
if (!fileexists(rescan_script)) {
d_log("rescan: Warning - rescan_script (%s) - file does not exist!\n", rescan_script);
} else {
snprintf(target, sizeof(target), rescan_script " \"%s\"", g.v.file.name);
if (execute(target) != 0)
d_log("rescan: Failed to execute rescan_script: %s\n", strerror(errno));
}
#endif
} else {
if (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) {
if (create_incomplete()) {
d_log("rescan: create_incomplete() returned something\n");
}
}
move_progress_bar(0, &g.v, g.ui, g.gi);
}
} else {
int empty = 1;
#if (create_missing_sfv_link == TRUE)
if ((!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) && g.l.sfv_incomplete && !matchpath(nocheck_dirs, g.l.path) && !matchpath(allowed_types_exemption_dirs, g.l.path)) {
rewinddir(dir);
while ((dp = readdir(dir))) {
stat(dp->d_name, &fileinfo);
if (S_ISREG(fileinfo.st_mode)) {
ext = find_last_of(dp->d_name, ".");
if (*ext == '.')
ext++;
if (*ext && get_filetype(&g, ext) == 3) {
d_log("rescan: Creating missing-sfv indicator %s.\n", g.l.sfv_incomplete);
if (create_incomplete_sfv())
d_log("rescan: create_incomplete_sfv() returned something.\n");
empty = 0;
break;
}
}
}
}
#endif
if (empty && mark_empty_dirs_as_incomplete_on_rescan) {
if (create_incomplete()) {
d_log("rescan: create_incomplete() returned something\n");
}
printf(" Empty dir - marking as incomplete.\n");
}
}
printf(" Passed : %i\n", (int)g.v.total.files - (int)g.v.total.files_missing);
printf(" Failed : %i\n", (int)g.v.total.files_bad);
printf(" Missing: %i\n", (int)g.v.total.files_missing);
printf(" Total : %i\n", (int)g.v.total.files);
if (g.v.total.files && !g.v.total.files_missing) {
g.v.misc.data_completed = 1;
} else {
g.v.misc.data_completed = 0;
}
d_log("rescan: Freeing memory and removing lock.\n");
closedir(dir);
closedir(parent);
ng_free(g.l.race);
ng_free(g.l.sfv);
ng_free(g.l.sfvbackup);
ng_free(g.l.leader);
remove_lock(&g.v);
updatestats_free(&g);
#ifdef USING_GLFTPD
buffer_groups(GROUPFILE, gnum);
buffer_users(PASSWDFILE, unum);
#endif
exit(0);
}
int work_directory(char * dir_name, dummy_dir * dir_st, char * root_name)
{
struct dirent *dp = NULL;
LOG("[enter]Ptr is %x\n", (unsigned int) dir_st);
LOG("[enter]DirName is %s\n", dir_name);
// List subdirs and files
// Get count; alocate accordingly
int dir_c = dir_count( dir_name );
dir_st->subdirs_count = dir_c;
LOG_S("Parsing directories\n");
if( dir_c == 0 )
{
dir_st->subdirs = NULL;
}
else
{
dir_st->subdirs = malloc(sizeof(dummy_dir) * dir_c);
DIR *dir = opendir(dir_name);
int i = 0;
while( (dp = readdir(dir)) != NULL )
{
if(dp->d_type != DT_DIR || !strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
continue;
// Allocate and call recursively (for each dir)
dummy_dir * new_child = dir_st->subdirs + i++;
LOG("Ptr is %x\n" , (unsigned int)new_child);
LOG("Working directory %s\n", dp->d_name);
new_child->parent = dir_st;
// Init name here, its easier than decomposing the full path in the recursive call.
init( &new_child->name );
LOG("Before adding dir %s\n", dp->d_name);
write( &new_child->name, dp->d_name, strlen(dp->d_name) + 1 );
// Prepare for recursive call
buffer * full_path = malloc(sizeof(full_path));
init( full_path );
write( full_path, dir_name, strlen(dir_name) + 1);
cat_paths( full_path, dp->d_name );
LOG( "Cat'ed dir is = %s\n", full_path->buffer );
// Call recursively
work_directory( full_path->buffer, new_child, root_name );
destroy( full_path );
free( full_path );
}
closedir(dir);
}
LOG_S("Parsing files\n");
// Get count; alocate accordingly
int file_c = file_count( dir_name );
dir_st->files_count = file_c;
if( file_c == 0 )
{
dir_st->files = NULL;
}
else
{
dir_st->files = malloc(sizeof(dummy_file) * file_c);
DIR *dir = opendir(dir_name);
int i = 0;
while( (dp = readdir(dir)) != NULL )
{
if(dp->d_type != DT_REG)
continue;
// Allocate and call recursively (for each dir)
dummy_file * new_child = dir_st->files + i++;
LOG("Ptr is %x\n" , (unsigned int)new_child);
LOG("Working file %s\n", dp->d_name);
init( &new_child->name );
LOG("Before adding file %s\n", dp->d_name);
write( &new_child->name, dp->d_name, strlen(dp->d_name) + 1 );
}
closedir(dir);
}
return WRKDIR_SUCCESS;
}
static long
kdbus_memfd_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
void __user *argp = (void __user *)arg;
struct kdbus_memfile *mf = file->private_data;
long ret = 0;
mutex_lock(&mf->lock);
switch (cmd) {
case KDBUS_CMD_MEMFD_SIZE_GET: {
u64 size = i_size_read(file_inode(mf->fp));
if (!KDBUS_IS_ALIGNED8(arg)) {
ret = -EFAULT;
goto exit;
}
if (copy_to_user(argp, &size, sizeof(__u64))) {
ret = -EFAULT;
goto exit;
}
break;
}
case KDBUS_CMD_MEMFD_SIZE_SET: {
u64 size;
if (!KDBUS_IS_ALIGNED8(arg)) {
ret = -EFAULT;
goto exit;
}
if (copy_from_user(&size, argp, sizeof(__u64))) {
ret = -EFAULT;
goto exit;
}
/* deny a writable access to a sealed file */
if (mf->sealed) {
if (size == i_size_read(file_inode(mf->fp)))
ret = -EALREADY;
else
ret = -EPERM;
goto exit;
}
if (size != i_size_read(file_inode(mf->fp)))
ret = vfs_truncate(&mf->fp->f_path, size);
break;
}
case KDBUS_CMD_MEMFD_SEAL_GET: {
int __user *addr = argp;
if (put_user(mf->sealed, addr)) {
ret = -EFAULT;
goto exit;
}
break;
}
case KDBUS_CMD_MEMFD_SEAL_SET: {
struct mm_struct *mm = current->mm;
/*
* Make sure we have only one single user of the file
* before we seal, we rely on the fact there is no
* any other possibly writable references to the file.
*
* Protect mmap() racing against us, take mm->mmap_sem
* when accessing mf->sealed.
*/
down_read(&mm->mmap_sem);
if (file_count(mf->fp) != 1) {
if (mf->sealed == !!argp)
ret = -EALREADY;
else
ret = -ETXTBSY;
}
if (ret == 0)
mf->sealed = !!argp;
up_read(&mm->mmap_sem);
break;
}
default:
ret = -ENOTTY;
break;
}
exit:
mutex_unlock(&mf->lock);
return ret;
}
int main()
{
int selection;;
//Loop with switch statement drives the user interface
//User keeps entering options until they quit
do
{
printf("Please Select an Option\n");
printf("1-Computing pi\n");
printf("2-Computing Square Root\n");
printf("3-Displaying Primes\n");
printf("4-Processing Grades\n");
printf("5-Computing Tax\n");
printf("6-Solving Quadratic\n");
printf("7-Computing Factorials\n");
printf("8-Counting File\n");
printf("9-Sorting File\n");
printf("10-Student File\n");
printf("11-Quit\n");
scanf("%d",&selection);
switch(selection)
{
case 1: //Compute pi
{
int n;
printf("How many terms of pi do you wish to compute: ");
scanf("%d",&n);
printf("pi to %d terms is %lf\n",n,compute_pi(n));
break;
}
case 2: //Compute square root
{
double n;
printf("Which square root do you wish to compute: ");
scanf("%lf",&n);
printf("the square root of %lf is %lf\n",n,compute_sqrt(n));
break;
}
case 3: //Display primes
{
int n;
printf("Enter an number to calculate primes up to: ");
scanf("%d",&n);
display_primes(n);
break;
}
case 4: //Process grades
{
process_scores();
break;
}
case 5: //Compute tax
{
int income;
char status[10];
char state;
printf("What is your income: ");
scanf("%d",&income);
printf("In state or out of state: ");
scanf("\n%c",&state);
printf("Are you single or married: ");
scanf("%s",status);
printf("Your taxes are: %lf\n",compute_tax(income,status,state));
break;
}
case 6: //Solving quadratic
{
double solution1;
double solution2;
double a;
double b;
double c;
int solutions;
printf("enter a: ");
scanf("%lf",&a);
printf("enter b: ");
scanf("%lf",&b);
printf("enter c: ");
scanf("%lf",&c);
solutions = quadratic(a,b,c,&solution1,&solution2);
if (solutions)
{
printf("Solution 1: %lf\n",solution1);
printf("Solution 2: %lf\n",solution2);
}
else
{
printf("There were no solutions\n");
}
break;
}
case 7: //Computing factorial
{
int n;
printf("Enter the factorial to compute: ");
scanf("%d",&n);
printf("%d! is %d\n",n, factorial(n));
break;
}
case 8: //counting file
{
char input_file[50];
int characters;
int lines;
printf("Enter the file name to open: ");
scanf("%s",input_file);
file_count(input_file,&characters,&lines);
printf("Number of lines: %d\n",lines);
printf("Number of characters including EOF: %d\n",characters);
break;
}
case 9: //sorting file
{
char input_file[50];
char output_file[50];
printf("Enter the input file name: ");
scanf("%s",input_file);
printf("Enter the output file name: ");
scanf("%s",output_file);
file_sort(input_file,output_file);
printf("Operation Complete\n");
break;
}
case 10: //student file
{
char input_file[50];
printf("Enter the input file name: ");
scanf("%s",input_file);
file_student(input_file);
printf("Operation Complete\n");
break;
}
case 11: //quit
{
break;
}
default: //Error for incorrect entries
printf("Your entry is invalid. Please try again\n");
}
}while(selection != 11); //do until user quits
return 0;
}
