1176 lines
31 KiB
C
1176 lines
31 KiB
C
#include <curses.h>
|
|
#include <cdk.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sqlite3.h>
|
|
#include <fts.h>
|
|
#include <sys/stat.h>
|
|
#include <libgen.h>
|
|
#include "../../src/inih/ini.h"
|
|
#include "filecenter.h"
|
|
|
|
struct files {
|
|
char *name;
|
|
char *description;
|
|
int approved;
|
|
int dlcount;
|
|
time_t uploadtime;
|
|
};
|
|
|
|
struct file_directory **file_directories;
|
|
int file_directory_count = 0;
|
|
CDKSCREEN *cdkscreen = 0;
|
|
//CDKMENTRY *desc_entry = 0;
|
|
WINDOW *desc_win = 0;
|
|
WINDOW *instruction_win = 0;
|
|
|
|
char instructions[] = "t - toggle approval\na - approve all\nu - unapprove all\nd - delete file\nm - move file\ns - scan for files\ne - edit description";
|
|
char *bbspath;
|
|
char *configpath;
|
|
|
|
int current_dir;
|
|
int current_sub;
|
|
|
|
struct files **f;
|
|
int fcount = 0;
|
|
char **filenames;
|
|
|
|
struct archiver **archivers;
|
|
int archiver_count = 0;
|
|
|
|
static int archiver_config_handler(void* user, const char* section, const char* name,
|
|
const char* value)
|
|
{
|
|
int i;
|
|
|
|
for (i=0;i<archiver_count;i++) {
|
|
if (strcasecmp(archivers[i]->name, section) == 0) {
|
|
// found it
|
|
if (strcasecmp(name, "extension") == 0) {
|
|
archivers[i]->extension = strdup(value);
|
|
} else if (strcasecmp(name, "unpack") == 0) {
|
|
archivers[i]->unpack = strdup(value);
|
|
} else if (strcasecmp(name, "pack") == 0) {
|
|
archivers[i]->pack = strdup(value);
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if (archiver_count == 0) {
|
|
archivers = (struct archiver **)malloc(sizeof(struct archiver *));
|
|
} else {
|
|
archivers = (struct archiver **)realloc(archivers, sizeof(struct archiver *) * (archiver_count + 1));
|
|
}
|
|
|
|
archivers[archiver_count] = (struct archiver *)malloc(sizeof(struct archiver));
|
|
|
|
archivers[archiver_count]->name = strdup(section);
|
|
|
|
if (strcasecmp(name, "extension") == 0) {
|
|
archivers[archiver_count]->extension = strdup(value);
|
|
} else if (strcasecmp(name, "unpack") == 0) {
|
|
archivers[archiver_count]->unpack = strdup(value);
|
|
} else if (strcasecmp(name, "pack") == 0) {
|
|
archivers[archiver_count]->pack = strdup(value);
|
|
}
|
|
archiver_count++;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int bbs_cfg_handler(void *user, const char* section, const char* name, const char *value)
|
|
{
|
|
if (strcasecmp(section, "paths") == 0) {
|
|
if (strcasecmp(name, "bbs path") == 0) {
|
|
bbspath = strdup(value);
|
|
}
|
|
if (strcasecmp(name, "config path") == 0) {
|
|
configpath = strdup(value);
|
|
}
|
|
}
|
|
if (strcasecmp(section, "file directories") == 0) {
|
|
if (file_directory_count == 0) {
|
|
file_directories = (struct file_directory **)malloc(sizeof(struct file_directory *));
|
|
} else {
|
|
file_directories = (struct file_directory **)realloc(file_directories, sizeof(struct file_directory *) * (file_directory_count + 1));
|
|
}
|
|
|
|
file_directories[file_directory_count] = (struct file_directory *)malloc(sizeof(struct file_directory));
|
|
file_directories[file_directory_count]->name = strdup(name);
|
|
file_directories[file_directory_count]->path = strdup(value);
|
|
file_directories[file_directory_count]->file_sub_count = 0;
|
|
file_directories[file_directory_count]->display_on_web = 0;
|
|
file_directory_count++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int file_sub_handler(void* user, const char* section, const char* name,
|
|
const char* value)
|
|
{
|
|
struct file_directory *fd = (struct file_directory *)user;
|
|
int i;
|
|
|
|
if (strcasecmp(section, "main") == 0) {
|
|
if (strcasecmp(name, "visible sec level") == 0) {
|
|
fd->sec_level = atoi(value);
|
|
} else if (strcasecmp(name, "visible on web") == 0) {
|
|
if (strcasecmp(value, "true") == 0) {
|
|
fd->display_on_web = 1;
|
|
} else {
|
|
fd->display_on_web = 0;
|
|
}
|
|
}
|
|
} else {
|
|
// check if it's partially filled in
|
|
for (i=0;i<fd->file_sub_count;i++) {
|
|
if (strcasecmp(fd->file_subs[i]->name, section) == 0) {
|
|
if (strcasecmp(name, "upload sec level") == 0) {
|
|
fd->file_subs[i]->upload_sec_level = atoi(value);
|
|
} else if (strcasecmp(name, "download sec level") == 0) {
|
|
fd->file_subs[i]->download_sec_level = atoi(value);
|
|
} else if (strcasecmp(name, "database") == 0) {
|
|
fd->file_subs[i]->database = strdup(value);
|
|
} else if (strcasecmp(name, "upload path") == 0) {
|
|
fd->file_subs[i]->upload_path = strdup(value);
|
|
}
|
|
return 1;
|
|
}
|
|
}
|
|
if (fd->file_sub_count == 0) {
|
|
fd->file_subs = (struct file_sub **)malloc(sizeof(struct file_sub *));
|
|
} else {
|
|
fd->file_subs = (struct file_sub **)realloc(fd->file_subs, sizeof(struct file_sub *) * (fd->file_sub_count + 1));
|
|
}
|
|
|
|
fd->file_subs[fd->file_sub_count] = (struct file_sub *)malloc(sizeof(struct file_sub));
|
|
|
|
fd->file_subs[fd->file_sub_count]->name = strdup(section);
|
|
if (strcasecmp(name, "upload sec level") == 0) {
|
|
fd->file_subs[fd->file_sub_count]->upload_sec_level = atoi(value);
|
|
} else if (strcasecmp(name, "download sec level") == 0) {
|
|
fd->file_subs[fd->file_sub_count]->download_sec_level = atoi(value);
|
|
} else if (strcasecmp(name, "database") == 0) {
|
|
fd->file_subs[fd->file_sub_count]->database = strdup(value);
|
|
} else if (strcasecmp(name, "upload path") == 0) {
|
|
fd->file_subs[fd->file_sub_count]->upload_path = strdup(value);
|
|
}
|
|
fd->file_sub_count++;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static void doApprove(int index) {
|
|
char sql_approve[] = "UPDATE files SET approved=1 WHERE filename LIKE ?";
|
|
sqlite3_stmt *res;
|
|
int rc;
|
|
struct stat st;
|
|
sqlite3 *db;
|
|
char database[PATH_MAX];
|
|
|
|
snprintf(database, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[current_dir]->file_subs[current_sub]->database);
|
|
|
|
// populate scroll list
|
|
rc = sqlite3_open(database, &db);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
return;
|
|
}
|
|
sqlite3_busy_timeout(db, 5000);
|
|
|
|
|
|
if (stat(f[index]->name, &st) == 0) {
|
|
f[index]->approved = 1;
|
|
sprintf(filenames[index], "</24>%s (approved)<!24>", basename(f[index]->name));
|
|
rc = sqlite3_prepare_v2(db, sql_approve, -1, &res, 0);
|
|
if (rc != SQLITE_OK) {
|
|
sqlite3_close(db);
|
|
return;
|
|
}
|
|
sqlite3_bind_text(res, 1, f[index]->name, -1, 0);
|
|
|
|
sqlite3_step(res);
|
|
|
|
sqlite3_finalize(res);
|
|
}
|
|
sqlite3_close(db);
|
|
}
|
|
|
|
static void doDisapprove(int index) {
|
|
char sql_approve[] = "UPDATE files SET approved=0 WHERE filename LIKE ?";
|
|
sqlite3 *db;
|
|
sqlite3_stmt *res;
|
|
int rc;
|
|
struct stat s;
|
|
char database[PATH_MAX];
|
|
|
|
snprintf(database, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[current_dir]->file_subs[current_sub]->database);
|
|
|
|
// populate scroll list
|
|
rc = sqlite3_open(database, &db);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
return;
|
|
}
|
|
sqlite3_busy_timeout(db, 5000);
|
|
|
|
f[index]->approved = 0;
|
|
if (stat(f[index]->name, &s) != 0) {
|
|
sprintf(filenames[index], "</16>%s (missing)<!16>", basename(f[index]->name));
|
|
} else {
|
|
sprintf(filenames[index], "</32>%s (unapproved)<!32>", basename(f[index]->name));
|
|
}
|
|
rc = sqlite3_prepare_v2(db, sql_approve, -1, &res, 0);
|
|
if (rc != SQLITE_OK) {
|
|
sqlite3_close(db);
|
|
return;
|
|
}
|
|
sqlite3_bind_text(res, 1, f[index]->name, -1, 0);
|
|
|
|
sqlite3_step(res);
|
|
|
|
sqlite3_finalize(res);
|
|
sqlite3_close(db);
|
|
}
|
|
|
|
static int deleteFile(EObjectType cdktype, void *object, void *clientData, chtype input) {
|
|
CDKSCROLL *s = (CDKSCROLL *)object;
|
|
|
|
int index = getCDKScrollCurrent(s);
|
|
sqlite3 *db;
|
|
sqlite3_stmt *res;
|
|
int rc;
|
|
struct stat st;
|
|
char database[PATH_MAX];
|
|
int i;
|
|
|
|
char sql_delete[] = "DELETE FROM files WHERE filename LIKE ?";
|
|
|
|
if (index >= fcount) {
|
|
return FALSE;
|
|
}
|
|
|
|
snprintf(database, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[current_dir]->file_subs[current_sub]->database);
|
|
|
|
rc = sqlite3_open(database, &db);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
return FALSE;
|
|
}
|
|
sqlite3_busy_timeout(db, 5000);
|
|
|
|
rc = sqlite3_prepare_v2(db, sql_delete, -1, &res, 0);
|
|
if (rc != SQLITE_OK) {
|
|
sqlite3_close(db);
|
|
return FALSE;
|
|
}
|
|
sqlite3_bind_text(res, 1, f[index]->name, -1, 0);
|
|
|
|
sqlite3_step(res);
|
|
|
|
sqlite3_finalize(res);
|
|
sqlite3_close(db);
|
|
|
|
|
|
if (stat(f[index]->name, &st) == 0) {
|
|
remove(f[index]->name);
|
|
}
|
|
|
|
free(f[index]->name);
|
|
free(f[index]->description);
|
|
free(f[index]);
|
|
free(filenames[index]);
|
|
|
|
|
|
for (i=index; i < fcount - 1; i++) {
|
|
filenames[i] = filenames[i+1];
|
|
f[i] = f[i+1];
|
|
}
|
|
|
|
fcount--;
|
|
|
|
if (fcount == 0) {
|
|
free(filenames);
|
|
free(f);
|
|
filenames = NULL;
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
eraseCDKScroll(s);
|
|
drawCDKScroll(s, TRUE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
return FALSE;
|
|
}
|
|
|
|
filenames = (char **)realloc(filenames, sizeof(char *) * (fcount));
|
|
f = (struct files **)realloc(f, sizeof(struct files *) * (fcount));
|
|
|
|
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
eraseCDKScroll(s);
|
|
drawCDKScroll(s, TRUE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
return FALSE;
|
|
}
|
|
|
|
static int approveFile(EObjectType cdktype, void *object, void *clientData, chtype input) {
|
|
CDKSCROLL *s = (CDKSCROLL *)object;
|
|
|
|
|
|
int index = getCDKScrollCurrent(s);
|
|
if (index >= fcount) {
|
|
return FALSE;
|
|
}
|
|
if (f[index]->approved == 1) {
|
|
doDisapprove(index);
|
|
} else {
|
|
doApprove(index);
|
|
}
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
return FALSE;
|
|
}
|
|
|
|
static int approveAll(EObjectType cdktype, void *object, void *clientData, chtype input) {
|
|
CDKSCROLL *s = (CDKSCROLL *)object;
|
|
int i;
|
|
|
|
for (i=0;i<fcount;i++) {
|
|
if (f[i]->approved == 0) {
|
|
doApprove(i);
|
|
}
|
|
}
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
static int disapproveAll(EObjectType cdktype, void *object, void *clientData, chtype input) {
|
|
CDKSCROLL *s = (CDKSCROLL *)object;
|
|
int i;
|
|
|
|
for (i=0;i<fcount;i++) {
|
|
if (f[i]->approved == 1) {
|
|
doDisapprove(i);
|
|
}
|
|
}
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
int copy_file(char *src, char *dest) {
|
|
FILE *src_file;
|
|
FILE *dest_file;
|
|
|
|
char c;
|
|
|
|
src_file = fopen(src, "rb");
|
|
if (!src_file) {
|
|
return -1;
|
|
}
|
|
dest_file = fopen(dest, "wb");
|
|
if (!dest_file) {
|
|
fclose(src_file);
|
|
return -1;
|
|
}
|
|
|
|
while(1) {
|
|
c = fgetc(src_file);
|
|
if (!feof(src_file)) {
|
|
fputc(c, dest_file);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
fclose(src_file);
|
|
fclose(dest_file);
|
|
return 0;
|
|
}
|
|
|
|
int recursive_delete(const char *dir) {
|
|
int ret = 0;
|
|
FTS *ftsp = NULL;
|
|
FTSENT *curr;
|
|
|
|
char *files[] = { (char *) dir, NULL };
|
|
|
|
ftsp = fts_open(files, FTS_NOCHDIR | FTS_PHYSICAL | FTS_XDEV, NULL);
|
|
if (!ftsp) {
|
|
ret = -1;
|
|
goto finish;
|
|
}
|
|
|
|
while ((curr = fts_read(ftsp))) {
|
|
switch (curr->fts_info) {
|
|
case FTS_NS:
|
|
case FTS_DNR:
|
|
case FTS_ERR:
|
|
break;
|
|
|
|
case FTS_DC:
|
|
case FTS_DOT:
|
|
case FTS_NSOK:
|
|
break;
|
|
|
|
case FTS_D:
|
|
break;
|
|
|
|
case FTS_DP:
|
|
case FTS_F:
|
|
case FTS_SL:
|
|
case FTS_SLNONE:
|
|
case FTS_DEFAULT:
|
|
if (remove(curr->fts_accpath) < 0) {
|
|
ret = -1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
finish:
|
|
if (ftsp) {
|
|
fts_close(ftsp);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int moveFile(EObjectType cdktype, void *object, void *clientData, chtype input) {
|
|
CDKSCROLL *s = (CDKSCROLL *)object;
|
|
CDKSCROLL *dirScrollList;
|
|
CDKSCROLL *subScrollList;
|
|
|
|
int dir_sel;
|
|
int sub_sel;
|
|
|
|
char **filedirs;
|
|
char **filesubs;
|
|
|
|
char dest_file[PATH_MAX];
|
|
|
|
int index = getCDKScrollCurrent(s);
|
|
|
|
char title[42];
|
|
sqlite3 *db;
|
|
sqlite3_stmt *res;
|
|
int rc;
|
|
struct stat st;
|
|
char database[PATH_MAX];
|
|
int i;
|
|
char create_sql[] = "CREATE TABLE IF NOT EXISTS files ("
|
|
"Id INTEGER PRIMARY KEY,"
|
|
"filename TEXT,"
|
|
"description TEXT,"
|
|
"size INTEGER,"
|
|
"dlcount INTEGER,"
|
|
"uploaddate INTEGER,"
|
|
"approved INTEGER);";
|
|
|
|
char sql_delete[] = "DELETE FROM files WHERE filename LIKE ?";
|
|
char sql_insert[] = "INSERT INTO files (filename, description, size, dlcount, uploaddate, approved) VALUES(?, ?, ?, ?, ?, ?)";
|
|
|
|
char *err_msg = 0;
|
|
|
|
if (index >= fcount) {
|
|
return FALSE;
|
|
}
|
|
|
|
dirScrollList = newCDKScroll(cdkscreen, 9, 1, 1, 12, 36, "</48>File Directories<!48>", NULL, 0, FALSE, A_REVERSE, TRUE, TRUE);
|
|
|
|
filedirs = (char **)malloc(sizeof(char *) * file_directory_count);
|
|
|
|
for (i=0;i<file_directory_count;i++) {
|
|
filedirs[i] = strdup(file_directories[i]->name);
|
|
}
|
|
|
|
setCDKScrollItems(dirScrollList, filedirs, file_directory_count, FALSE);
|
|
|
|
while(1) {
|
|
dir_sel = activateCDKScroll(dirScrollList, 0);
|
|
if (dirScrollList->exitType == vESCAPE_HIT) {
|
|
break;
|
|
} else if (dirScrollList->exitType == vNORMAL) {
|
|
snprintf(title, 42, "</48>%s<!48>", file_directories[dir_sel]->name);
|
|
|
|
subScrollList = newCDKScroll(cdkscreen, 12, 1, 1, 12, 36, title, NULL, 0, FALSE, A_REVERSE, TRUE, TRUE);
|
|
|
|
filesubs = (char **)malloc(sizeof(char *) * file_directory_count);
|
|
|
|
for (i=0;i<file_directories[dir_sel]->file_sub_count;i++) {
|
|
filesubs[i] = strdup(file_directories[dir_sel]->file_subs[i]->name);
|
|
}
|
|
|
|
setCDKScrollItems(subScrollList, filesubs, file_directories[dir_sel]->file_sub_count, FALSE);
|
|
|
|
while (1) {
|
|
sub_sel = activateCDKScroll(subScrollList, 0);
|
|
if (subScrollList->exitType == vESCAPE_HIT) {
|
|
for (i=0;i<file_directories[dir_sel]->file_sub_count;i++) {
|
|
free(filesubs[i]);
|
|
}
|
|
free(filesubs);
|
|
destroyCDKScroll(subScrollList);
|
|
break;
|
|
} else if (subScrollList->exitType == vNORMAL) {
|
|
snprintf(dest_file, PATH_MAX, "%s/%s", file_directories[dir_sel]->file_subs[sub_sel]->upload_path, basename(f[index]->name));
|
|
|
|
if (stat(dest_file, &st) != 0) {
|
|
// move file
|
|
if (copy_file(f[index]->name, dest_file) == 0) {
|
|
// success
|
|
unlink(f[index]->name);
|
|
// remove from database
|
|
snprintf(database, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[current_dir]->file_subs[current_sub]->database);
|
|
rc = sqlite3_open(database, &db);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
break;
|
|
}
|
|
sqlite3_busy_timeout(db, 5000);
|
|
|
|
rc = sqlite3_prepare_v2(db, sql_delete, -1, &res, 0);
|
|
if (rc != SQLITE_OK) {
|
|
sqlite3_close(db);
|
|
break;
|
|
}
|
|
sqlite3_bind_text(res, 1, f[index]->name, -1, 0);
|
|
|
|
sqlite3_step(res);
|
|
|
|
sqlite3_finalize(res);
|
|
sqlite3_close(db);
|
|
|
|
// add to dest database
|
|
snprintf(database, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[dir_sel]->file_subs[sub_sel]->database);
|
|
rc = sqlite3_open(database, &db);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
break;
|
|
}
|
|
sqlite3_busy_timeout(db, 5000);
|
|
|
|
rc = sqlite3_exec(db, create_sql, 0, 0, &err_msg);
|
|
if (rc != SQLITE_OK ) {
|
|
sqlite3_free(err_msg);
|
|
sqlite3_close(db);
|
|
return FALSE;
|
|
}
|
|
|
|
rc = sqlite3_prepare_v2(db, sql_insert, -1, &res, 0);
|
|
if (rc != SQLITE_OK) {
|
|
sqlite3_close(db);
|
|
return FALSE;
|
|
}
|
|
|
|
stat(dest_file, &st);
|
|
sqlite3_bind_text(res, 1, dest_file, -1, 0);
|
|
sqlite3_bind_text(res, 2, f[index]->description, -1, 0);
|
|
sqlite3_bind_int(res, 3, st.st_size);
|
|
sqlite3_bind_int(res, 4, f[index]->dlcount);
|
|
sqlite3_bind_int(res, 5, f[index]->uploadtime);
|
|
sqlite3_bind_int(res, 6, f[index]->approved);
|
|
sqlite3_step(res);
|
|
|
|
sqlite3_finalize(res);
|
|
sqlite3_close(db);
|
|
// remove from current memory
|
|
|
|
free(filenames[index]);
|
|
free(f[index]->name);
|
|
free(f[index]->description);
|
|
free(f[index]);
|
|
|
|
for (i=index;i<fcount-1;i++) {
|
|
f[i] = f[i+1];
|
|
filenames[i] = filenames[i+1];
|
|
}
|
|
|
|
fcount--;
|
|
|
|
f = (struct files **)realloc(f, sizeof(struct files *) * fcount);
|
|
filenames = (char **)realloc(filenames, sizeof(char *) * fcount);
|
|
|
|
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
for (i=0;i<file_directories[dir_sel]->file_sub_count;i++) {
|
|
free(filesubs[i]);
|
|
}
|
|
free(filesubs);
|
|
eraseCDKScroll(subScrollList);
|
|
destroyCDKScroll(subScrollList);
|
|
}
|
|
for (i=0;i<file_directory_count;i++) {
|
|
free(filedirs[i]);
|
|
}
|
|
free(filedirs);
|
|
eraseCDKScroll(dirScrollList);
|
|
destroyCDKScroll(dirScrollList);
|
|
|
|
break;
|
|
}
|
|
}
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
eraseCDKScroll(s);
|
|
drawCDKScroll(s, TRUE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
}
|
|
|
|
static int editFileID(EObjectType cdktyp, void *object, void *clientData, chtype input) {
|
|
FILE *fptr;
|
|
CDKSCROLL *s = (CDKSCROLL *)object;
|
|
int index = getCDKScrollCurrent(s);
|
|
struct stat st;
|
|
char buffer[PATH_MAX];
|
|
sqlite3 *db;
|
|
sqlite3_stmt *res;
|
|
int rc;
|
|
char sql_update[] = "UPDATE files SET description=? WHERE filename LIKE ?";
|
|
snprintf(buffer, PATH_MAX, "/tmp/filecenter_id.txt");
|
|
|
|
fptr = fopen(buffer, "w");
|
|
|
|
if (!fptr) {
|
|
return FALSE;
|
|
}
|
|
|
|
fputs(f[index]->description, fptr);
|
|
|
|
fclose(fptr);
|
|
|
|
snprintf(buffer, PATH_MAX, "./editor.sh");
|
|
if (stat(buffer, &st) != 0) {
|
|
snprintf(buffer, PATH_MAX, "/usr/bin/nano");
|
|
if (stat(buffer, &st) != 0) {
|
|
snprintf(buffer, PATH_MAX, "/usr/bin/vi");
|
|
if (stat(buffer, &st) != 0) {
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
strncat(buffer, " /tmp/filecenter_id.txt", PATH_MAX);
|
|
def_prog_mode();
|
|
savetty();
|
|
system(buffer);
|
|
resetty();
|
|
reset_prog_mode();
|
|
snprintf(buffer, PATH_MAX, "/tmp/filecenter_id.txt");
|
|
|
|
if (stat(buffer, &st) != 0) {
|
|
return FALSE;
|
|
}
|
|
fptr = fopen(buffer, "r");
|
|
if (!fptr) {
|
|
return FALSE;
|
|
}
|
|
free(f[index]->description);
|
|
|
|
f[index]->description = (char *)malloc(sizeof(char) * (st.st_size + 1));
|
|
memset(f[index]->description, 0, st.st_size + 1);
|
|
|
|
|
|
fread(f[index]->description, 1, st.st_size, fptr);
|
|
|
|
fclose(fptr);
|
|
unlink(buffer);
|
|
|
|
// update file descripiton
|
|
snprintf(buffer, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[current_dir]->file_subs[current_sub]->database);
|
|
|
|
rc = sqlite3_open(buffer, &db);
|
|
|
|
if (rc != SQLITE_OK) {
|
|
return FALSE;
|
|
}
|
|
sqlite3_busy_timeout(db, 5000);
|
|
|
|
rc = sqlite3_prepare_v2(db, sql_update, -1, &res, 0);
|
|
|
|
sqlite3_bind_text(res, 1, f[index]->description, -1, 0);
|
|
sqlite3_bind_text(res, 2, f[index]->name, -1, 0);
|
|
|
|
sqlite3_step(res);
|
|
|
|
sqlite3_finalize(res);
|
|
sqlite3_close(db);
|
|
|
|
// update display
|
|
refreshCDKScreen(cdkscreen);
|
|
werase(desc_win);
|
|
waddstr(desc_win, f[index]->description);
|
|
wrefresh(desc_win);
|
|
werase(instruction_win);
|
|
waddstr(instruction_win, instructions);
|
|
wrefresh(instruction_win);
|
|
}
|
|
|
|
static int scanFiles(EObjectType cdktype, void *object, void *clientData, chtype input) {
|
|
DIR *ind = opendir(file_directories[current_dir]->file_subs[current_sub]->upload_path);
|
|
FILE *fptr;
|
|
struct dirent *dent;
|
|
int i;
|
|
int j;
|
|
int bpos;
|
|
int gotdesc = 0;
|
|
char buffer[PATH_MAX];
|
|
int found;
|
|
char *description;
|
|
char addfilesql[] = "INSERT INTO files (filename, description, size, dlcount, uploaddate, approved) VALUES(?, ?, ?, 0, ?, 0)";
|
|
char database[PATH_MAX];
|
|
sqlite3 *db;
|
|
int rc;
|
|
sqlite3_stmt *res;
|
|
struct stat st;
|
|
int fdate;
|
|
int len;
|
|
CDKSCROLL *s = (CDKSCROLL *)object;
|
|
|
|
if (!ind) {
|
|
return FALSE;
|
|
}
|
|
|
|
while ((dent = readdir(ind)) != NULL) {
|
|
if (strcmp(dent->d_name, ".") == 0 || strcmp(dent->d_name, "..") == 0) {
|
|
continue;
|
|
}
|
|
|
|
sprintf(buffer, "%s/%s", file_directories[current_dir]->file_subs[current_sub]->upload_path, dent->d_name);
|
|
|
|
stat(buffer, &st);
|
|
|
|
if (!S_ISREG(st.st_mode)) {
|
|
continue;
|
|
}
|
|
|
|
found = 0;
|
|
for (j=0;j<fcount;j++) {
|
|
if (strcmp(basename(f[j]->name), dent->d_name) == 0) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (found == 1) {
|
|
continue;
|
|
}
|
|
|
|
gotdesc = 0;
|
|
description = NULL;
|
|
|
|
for (i=0;i<archiver_count;i++) {
|
|
if (strlen(dent->d_name) >= strlen(archivers[i]->extension) + 1) {
|
|
if (strcasecmp(&dent->d_name[strlen(dent->d_name) - strlen(archivers[i]->extension)], archivers[i]->extension) == 0) {
|
|
// match
|
|
bpos = 0;
|
|
for (j=0;j<strlen(archivers[i]->unpack);j++) {
|
|
if (archivers[i]->unpack[j] == '*') {
|
|
j++;
|
|
if (archivers[i]->unpack[j] == 'a') {
|
|
sprintf(&buffer[bpos], "%s/%s", file_directories[current_dir]->file_subs[current_sub]->upload_path, dent->d_name);
|
|
bpos = strlen(buffer);
|
|
} else if (archivers[i]->unpack[j] == 'd') {
|
|
sprintf(&buffer[bpos], "/tmp/filecenter_temp");
|
|
bpos = strlen(buffer);
|
|
} else if (archivers[i]->unpack[j] == '*') {
|
|
buffer[bpos++] = '*';
|
|
buffer[bpos] = '\0';
|
|
}
|
|
} else {
|
|
buffer[bpos++] = archivers[i]->unpack[j];
|
|
buffer[bpos] = '\0';
|
|
}
|
|
}
|
|
|
|
system(buffer);
|
|
|
|
snprintf(buffer, PATH_MAX, "/tmp/filecenter_temp/FILE_ID.DIZ");
|
|
if (stat(buffer, &st) != 0) {
|
|
snprintf(buffer, PATH_MAX, "/tmp/filecenter_temp/file_id.diz");
|
|
if (stat(buffer, &st) != 0) {
|
|
gotdesc = 0;
|
|
snprintf(buffer, PATH_MAX, "/tmp/filecenter_temp");
|
|
recursive_delete(buffer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
description = (char *)malloc(st.st_size + 1);
|
|
|
|
fptr = fopen(buffer, "rb");
|
|
|
|
fread(description, 1, st.st_size, fptr);
|
|
description[st.st_size] = '\0';
|
|
fclose(fptr);
|
|
|
|
bpos = 0;
|
|
len = strlen(description);
|
|
for (j=0;j<len;j++) {
|
|
if (description[j] == '\r') {
|
|
continue;
|
|
} else {
|
|
description[bpos++] = description[j];
|
|
}
|
|
}
|
|
description[bpos] = '\0';
|
|
|
|
gotdesc = 1;
|
|
snprintf(buffer, PATH_MAX, "/tmp/filecenter_temp");
|
|
recursive_delete(buffer);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!gotdesc) {
|
|
description = strdup("No Description.");
|
|
}
|
|
|
|
if (fcount == 0) {
|
|
filenames = (char **)malloc(sizeof(char *));
|
|
} else {
|
|
filenames = (char **)realloc(filenames, sizeof(char *) * (fcount + 1));
|
|
}
|
|
filenames[fcount] = (char *)malloc(strlen(dent->d_name) + 30);
|
|
sprintf(filenames[fcount], "</32>%s (unapproved)<!32>", dent->d_name);
|
|
|
|
if (fcount == 0) {
|
|
f = (struct files **)malloc(sizeof(struct files *));
|
|
} else {
|
|
f = (struct files **)realloc(f, sizeof(struct files *) * (fcount + 1));
|
|
}
|
|
f[fcount] = (struct files *)malloc(sizeof(struct files));
|
|
f[fcount]->name = (char *)malloc(strlen(file_directories[current_dir]->file_subs[current_sub]->upload_path) + strlen(dent->d_name) + 2);
|
|
sprintf(f[fcount]->name, "%s/%s", file_directories[current_dir]->file_subs[current_sub]->upload_path, dent->d_name);
|
|
f[fcount]->description = description;
|
|
f[fcount]->approved = 0;
|
|
|
|
// add to database
|
|
snprintf(database, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[current_dir]->file_subs[current_sub]->database);
|
|
|
|
rc = sqlite3_open(database, &db);
|
|
if (rc != SQLITE_OK) {
|
|
free(f[fcount]->name);
|
|
free(f[fcount]->description);
|
|
free(filenames[fcount]);
|
|
free(f[fcount]);
|
|
if (fcount == 0) {
|
|
free(f);
|
|
free(filenames);
|
|
} else {
|
|
f = (struct files **)realloc(f, sizeof(struct files *) * fcount);
|
|
filenames = (char **)realloc(filenames, sizeof(char *) * fcount);
|
|
}
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
eraseCDKScroll(s);
|
|
drawCDKScroll(s, TRUE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
closedir(ind);
|
|
return FALSE;
|
|
}
|
|
|
|
sqlite3_busy_timeout(db, 5000);
|
|
rc = sqlite3_prepare_v2(db, addfilesql, -1, &res, 0);
|
|
if (rc != SQLITE_OK) {
|
|
sqlite3_close(db);
|
|
free(f[fcount]->name);
|
|
free(f[fcount]->description);
|
|
free(filenames[fcount]);
|
|
free(f[fcount]);
|
|
if (fcount == 0) {
|
|
free(f);
|
|
free(filenames);
|
|
} else {
|
|
f = (struct files **)realloc(f, sizeof(struct files *) * fcount);
|
|
filenames = (char **)realloc(filenames, sizeof(char *) * fcount);
|
|
}
|
|
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
eraseCDKScroll(s);
|
|
drawCDKScroll(s, TRUE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
closedir(ind);
|
|
return FALSE;
|
|
}
|
|
stat(f[fcount]->name, &st);
|
|
|
|
sqlite3_bind_text(res, 1, f[fcount]->name, -1, 0);
|
|
sqlite3_bind_text(res, 2, f[fcount]->description, -1, 0);
|
|
sqlite3_bind_int(res, 3, st.st_size);
|
|
fdate = time(NULL);
|
|
sqlite3_bind_int(res, 4, fdate);
|
|
|
|
sqlite3_step(res);
|
|
|
|
sqlite3_finalize(res);
|
|
sqlite3_close(db);
|
|
fcount++;
|
|
|
|
}
|
|
setCDKScrollItems(s, filenames, fcount, FALSE);
|
|
eraseCDKScroll(s);
|
|
drawCDKScroll(s, TRUE);
|
|
// refreshCDKScreen(cdkscreen);
|
|
closedir(ind);
|
|
return FALSE;
|
|
}
|
|
|
|
int desc_function(EObjectType objtype, void *obj, void *clientData, chtype input) {
|
|
CDKSCROLL *s = (CDKSCROLL *)obj;
|
|
|
|
if (fcount == 0) return FALSE;
|
|
int index = getCDKScrollCurrent(s);
|
|
|
|
werase(desc_win);
|
|
waddstr(desc_win, f[index]->description);
|
|
wrefresh(desc_win);
|
|
// setCDKMentryValue(desc_entry, f[index]->description);
|
|
return FALSE;
|
|
}
|
|
|
|
void list_files(int dir, int sub) {
|
|
CDKSCROLL *scrollList = 0;
|
|
int selection;
|
|
int i;
|
|
char title[42];
|
|
sqlite3 *db;
|
|
sqlite3_stmt *res;
|
|
int rc;
|
|
struct stat s;
|
|
char sql_read[] = "SELECT filename, description, approved, dlcount, uploaddate FROM files";
|
|
char create_sql[] = "CREATE TABLE IF NOT EXISTS files ("
|
|
"Id INTEGER PRIMARY KEY,"
|
|
"filename TEXT,"
|
|
"description TEXT,"
|
|
"size INTEGER,"
|
|
"dlcount INTEGER,"
|
|
"uploaddate INTEGER,"
|
|
"approved INTEGER);";
|
|
char database[PATH_MAX];
|
|
char *err_msg;
|
|
|
|
|
|
current_dir = dir;
|
|
current_sub = sub;
|
|
|
|
|
|
snprintf(title, 42, "</48>%s<!48>", file_directories[dir]->file_subs[sub]->name);
|
|
snprintf(database, PATH_MAX, "%s/%s.sq3", bbspath, file_directories[dir]->file_subs[sub]->database);
|
|
|
|
// populate scroll list
|
|
rc = sqlite3_open(database, &db);
|
|
|
|
|
|
if (rc != SQLITE_OK) {
|
|
return;
|
|
}
|
|
sqlite3_busy_timeout(db, 5000);
|
|
rc = sqlite3_exec(db, create_sql, 0, 0, &err_msg);
|
|
if (rc != SQLITE_OK ) {
|
|
sqlite3_free(err_msg);
|
|
sqlite3_close(db);
|
|
return;
|
|
}
|
|
rc = sqlite3_prepare_v2(db, sql_read, -1, &res, 0);
|
|
|
|
f = NULL;
|
|
filenames = NULL;
|
|
|
|
while(sqlite3_step(res) == SQLITE_ROW) {
|
|
if (fcount == 0) {
|
|
f = (struct files **)malloc(sizeof(struct files *));
|
|
filenames = (char **)malloc(sizeof(char *));
|
|
} else {
|
|
f = (struct files **)realloc(f, sizeof(struct files *) * (fcount + 1));
|
|
filenames = (char **)realloc(filenames, sizeof(char *) * (fcount + 1));
|
|
}
|
|
|
|
f[fcount] = (struct files *)malloc(sizeof(struct files));
|
|
f[fcount]->name = strdup((char *)sqlite3_column_text(res, 0));
|
|
f[fcount]->description = strdup((char *)sqlite3_column_text(res, 1));
|
|
f[fcount]->approved = sqlite3_column_int(res, 2);
|
|
f[fcount]->dlcount = sqlite3_column_int(res, 3);
|
|
f[fcount]->uploadtime = sqlite3_column_int(res, 4);
|
|
filenames[fcount] = (char *)malloc(strlen(basename(f[fcount]->name)) + 30);
|
|
if (stat(f[fcount]->name, &s) != 0) {
|
|
sprintf(filenames[fcount], "</16>%s (missing)<!16>", basename(f[fcount]->name));
|
|
if (f[fcount]->approved == 1) {
|
|
// unapprove missing file
|
|
doDisapprove(fcount);
|
|
}
|
|
} else if (f[fcount]->approved) {
|
|
sprintf(filenames[fcount], "</24>%s (approved)<!24>", basename(f[fcount]->name));
|
|
} else {
|
|
sprintf(filenames[fcount], "</32>%s (unapproved)<!32>", basename(f[fcount]->name));
|
|
}
|
|
fcount++;
|
|
}
|
|
|
|
sqlite3_finalize(res);
|
|
sqlite3_close(db);
|
|
|
|
scrollList = newCDKScroll(cdkscreen, 6, 1, 1, 12, 36, title, NULL, 0, FALSE, A_REVERSE, TRUE, TRUE);
|
|
if (!scrollList) {
|
|
for (i=0;i<fcount;i++) {
|
|
free(f[i]->name);
|
|
free(f[i]->description);
|
|
free(f[i]);
|
|
free(filenames[i]);
|
|
}
|
|
|
|
free(f);
|
|
free(filenames);
|
|
fcount = 0;
|
|
return;
|
|
}
|
|
if (fcount > 0) {
|
|
werase(desc_win);
|
|
waddstr(desc_win, f[0]->description);
|
|
// setCDKMentryValue(desc_entry, f[0]->description);
|
|
} else {
|
|
// setCDKMentryValue(desc_entry, "");
|
|
werase(desc_win);
|
|
}
|
|
wrefresh(desc_win);
|
|
setCDKScrollPostProcess(scrollList, desc_function, NULL);
|
|
setCDKScrollItems(scrollList, filenames, fcount, FALSE);
|
|
|
|
bindCDKObject (vSCROLL, scrollList, 'm', moveFile, NULL);
|
|
bindCDKObject (vSCROLL, scrollList, 'u', disapproveAll, NULL);
|
|
bindCDKObject (vSCROLL, scrollList, 'a', approveAll, NULL);
|
|
bindCDKObject (vSCROLL, scrollList, 't', approveFile, NULL);
|
|
bindCDKObject (vSCROLL, scrollList, 'd', deleteFile, NULL);
|
|
bindCDKObject (vSCROLL, scrollList, 's', scanFiles, NULL);
|
|
bindCDKObject (vSCROLL, scrollList, 'e', editFileID, NULL);
|
|
|
|
while(1) {
|
|
selection = activateCDKScroll(scrollList, 0);
|
|
if (scrollList->exitType == vESCAPE_HIT) {
|
|
break;
|
|
}
|
|
}
|
|
for (i=0;i<fcount;i++) {
|
|
free(f[i]->name);
|
|
free(f[i]->description);
|
|
free(f[i]);
|
|
free(filenames[i]);
|
|
}
|
|
if (fcount != 0) {
|
|
free(f);
|
|
free(filenames);
|
|
}
|
|
fcount = 0;
|
|
destroyCDKScroll(scrollList);
|
|
}
|
|
|
|
void list_subdirs(int selected) {
|
|
CDKSCROLL *scrollList = 0;
|
|
int selection;
|
|
int i;
|
|
char title[42];
|
|
|
|
char **filesubs = (char **)malloc(sizeof(char *) * file_directories[selected]->file_sub_count);
|
|
|
|
snprintf(title, 42, "</48>%s<!48>", file_directories[selected]->name);
|
|
|
|
for (i=0;i<file_directories[selected]->file_sub_count;i++) {
|
|
filesubs[i] = strdup(file_directories[selected]->file_subs[i]->name);
|
|
}
|
|
|
|
scrollList = newCDKScroll(cdkscreen, 4, 1, 1, 12, 36, title, NULL, 0, FALSE, A_REVERSE, TRUE, TRUE);
|
|
if (!scrollList) {
|
|
fprintf(stderr, "Unable to make scrolllist!");
|
|
destroyCDKScreen(cdkscreen);
|
|
endCDK();
|
|
exit(-1);
|
|
}
|
|
setCDKScrollItems(scrollList, filesubs, file_directories[selected]->file_sub_count, FALSE);
|
|
while(1) {
|
|
selection = activateCDKScroll(scrollList, 0);
|
|
if (scrollList->exitType == vESCAPE_HIT) {
|
|
break;
|
|
} else if (scrollList->exitType == vNORMAL) {
|
|
list_files(selected, selection);
|
|
}
|
|
}
|
|
|
|
destroyCDKScroll(scrollList);
|
|
for (i=0;i<file_directories[selected]->file_sub_count;i++) {
|
|
free(filesubs[i]);
|
|
}
|
|
|
|
free(filesubs);
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
int i;
|
|
CDK_PARAMS params;
|
|
WINDOW *cursesWin = 0;
|
|
CDKSCROLL *scrollList = 0;
|
|
int selection;
|
|
char **filedirs;
|
|
char buffer[PATH_MAX];
|
|
|
|
CDKparseParams(argc, argv, ¶ms, "c:" CDK_CLI_PARAMS);
|
|
|
|
if (ini_parse(CDKparamString (¶ms, 'c'), bbs_cfg_handler, NULL) <0) {
|
|
fprintf(stderr, "Unable to load configuration ini (%s)!\n", argv[1]);
|
|
exit(-1);
|
|
}
|
|
|
|
snprintf(buffer, 1024, "%s/archivers.ini", configpath);
|
|
if (ini_parse(buffer, archiver_config_handler, NULL) <0) {
|
|
fprintf(stderr, "Unable to load configuration ini %s\n", buffer);
|
|
exit(-1);
|
|
}
|
|
|
|
for (i=0;i<file_directory_count;i++) {
|
|
snprintf(buffer, PATH_MAX, "%s/%s", bbspath, file_directories[i]->path);
|
|
if (ini_parse(buffer, file_sub_handler, file_directories[i])) {
|
|
fprintf(stderr, "Unable to load %s\n", buffer);
|
|
exit(-1);
|
|
}
|
|
}
|
|
cursesWin = initscr();
|
|
cdkscreen = initCDKScreen(cursesWin);
|
|
|
|
desc_win = newwin(10, 46, 14, 1);
|
|
instruction_win = newwin(10, 32, 14, 47);
|
|
|
|
waddstr(instruction_win, instructions);
|
|
|
|
wrefresh(instruction_win);
|
|
|
|
scrollList = newCDKScroll(cdkscreen, 2, 1, 1, 12, 36, "</48>File Directories<!48>", NULL, 0, FALSE, A_REVERSE, TRUE, TRUE);
|
|
if (!scrollList) {
|
|
fprintf(stderr, "Unable to make scrolllist!");
|
|
destroyCDKScreen(cdkscreen);
|
|
endCDK();
|
|
exit(-1);
|
|
}
|
|
|
|
filedirs = (char **)malloc(sizeof(char *) * file_directory_count);
|
|
|
|
for (i=0;i<file_directory_count;i++) {
|
|
filedirs[i] = strdup(file_directories[i]->name);
|
|
}
|
|
|
|
setCDKScrollItems(scrollList, filedirs, file_directory_count, FALSE);
|
|
|
|
while(1) {
|
|
selection = activateCDKScroll(scrollList, 0);
|
|
if (scrollList->exitType == vESCAPE_HIT) {
|
|
break;
|
|
} else if (scrollList->exitType == vNORMAL) {
|
|
list_subdirs(selection);
|
|
}
|
|
}
|
|
|
|
destroyCDKScroll(scrollList);
|
|
destroyCDKScreen(cdkscreen);
|
|
endCDK();
|
|
} |