/**
* Copy content of a directory
*
* @param dst_path Destination path
* @param src_path Source path
*
* @return 0 on success, negative value in case of an error
*/
int copy_dir_content(const char *dst_path, const char *src_path)
{
file_info *file_list = 0, *dir_list = 0;
int ret = -1;
ret = generate_file_list(src_path, &file_list, &dir_list);
if (ret < 0) {
LOGE("generate_file_list for %s failed\n", src_path);
goto err;
}
ret = create_dirs(&dir_list, src_path, dst_path);
if (ret < 0) {
LOGE("create_dirs for %s failed\n", src_path);
goto err;
}
ret = copy_files(&file_list, src_path, dst_path);
if (ret < 0) {
LOGE("copy_files for %s failed\n", src_path);
goto err;
}
free_list(&file_list);
free_list(&dir_list);
return 0;
err:
free_list(&file_list);
free_list(&dir_list);
return ret;
}
static int install_binaries(const char *esp_path, bool force) {
struct dirent *de;
_cleanup_closedir_ DIR *d = NULL;
int r = 0;
if (force) {
/* Don't create any of these directories when we are
* just updating. When we update we'll drop-in our
* files (unless there are newer ones already), but we
* won't create the directories for them in the first
* place. */
r = create_dirs(esp_path);
if (r < 0)
return r;
}
d = opendir(BOOTLIBDIR);
if (!d)
return log_error_errno(errno, "Failed to open \""BOOTLIBDIR"\": %m");
FOREACH_DIRENT(de, d, break) {
int k;
if (!endswith_no_case(de->d_name, ".efi"))
continue;
k = copy_one_file(esp_path, de->d_name, force);
if (k < 0 && r == 0)
r = k;
}
return r;
}
const std::string get_user_dir(const UserDir userdir) {
std::string path;
std::string envVar;
if (userdir == UserDir::Config)
envVar = get_env_var("XDG_CONFIG_HOME");
else if (userdir == UserDir::Data)
envVar = get_env_var("XDG_DATA_HOME");
if (envVar.empty()) {
envVar = get_env_var("HOME");
if (!envVar.empty()) {
path += std::string(envVar);
if (userdir == UserDir::Config)
path += "/.config";
else if (userdir == UserDir::Data)
path += "/.local/share";
}
}
if (!path.empty()) {
path += "/" OBV_NAME "/";
if (create_dirs(path)) return path; // Check if dir already exists and create it otherwise
}
return "./"; // Something went wrong, use current dir
}
ssize_t write_file(const unsigned char *buffer, size_t len, mode_t mode,
const char *path_fmt, ...)
{
va_list ap;
char *path;
ssize_t r;
int fd;
va_start(ap, path_fmt);
path = g_strdup_vprintf(path_fmt, ap);
va_end(ap);
if (create_dirs(path, mode | S_IXUSR) != 0) {
g_free(path);
return -1;
}
fd = TFR(open(path, O_WRONLY | O_CREAT | O_TRUNC, mode));
if (fd == -1) {
g_free(path);
return -1;
}
r = TFR(write(fd, buffer, len));
TFR(close(fd));
if (r != (ssize_t) len) {
unlink(path);
r = -1;
}
g_free(path);
return r;
}
/*
* Create long-name directories
* @argv[1]: directory number
* @argv[2]: parent directory
*/
int main(int argc, char *argv[])
{
if (argc != 3) {
usage();
return 1;
}
names = atoi(argv[1]);
if (names > MAX_LEN3 || names <= 0) {
usage();
return 1;
}
parent_fd = open(argv[2], O_RDONLY);
if (parent_fd == -1) {
perror("open parent dir failed");
return 1;
}
init_name();
create_dirs(names);
return 0;
}
void storage_sync(const char *imsi, const char *store, GKeyFile *keyfile)
{
char *path;
char *data;
gsize length = 0;
if (imsi)
path = g_strdup_printf(STORAGEDIR "/%s/%s", imsi, store);
else
path = g_strdup_printf(STORAGEDIR "/%s", store);
if (path == NULL)
return;
if (create_dirs(path, S_IRUSR | S_IWUSR | S_IXUSR) != 0) {
g_free(path);
return;
}
data = g_key_file_to_data(keyfile, &length, NULL);
g_file_set_contents(path, data, length, NULL);
g_free(data);
g_free(path);
}
// returns a malloced file name pointer
char* get_out_filename (char *file, args cf) {
// the temporary filename to return
char *out_filename = calloc (FILENAME_MAX, 1);
char *tmp;
// copy anything from infront of the last pat component into the outfile name
strncpy (out_filename, file, strlen (file) - strlen (basename (file)));
// because strncpy may not have termintated the string we double check
out_filename[strlen (out_filename)] = '\0';
// add the subdir if it is not null [THIS WILL NEVER BE NULL]
if (NULL != cf->subdir) {
// add the subdir to the path
strcat (out_filename, cf->subdir);
// check to see if the path already exists and create it if necessary
if (!file_exists (out_filename))
// recurrsively create sub directories
create_dirs (out_filename);
// add the trailing slash
strcat (out_filename, "/");
}
// add the prefix if one is specified
if (NULL != cf->prefix) {
strcat (out_filename, cf->prefix);
}
// get the string
tmp = rem_ext (basename (file));
// copy the filename without the extention onto the end of the string
strcat (out_filename, tmp);
// free the string
free(tmp);
tmp = NULL;
// ensure the string is terminated properly
out_filename[strlen (out_filename)] = '\0';
// append the suffix to the file name
if (NULL != cf->suffix) {
strcat (out_filename, cf->suffix);
}
// append the file extention to the filename
strcat (out_filename, ".jpg");
// return the a pointer to the malloced file name
return out_filename;
} // get_out_filename ()
int main( int argc, char* argv[] ) {
gtk_init( &argc, &argv );
set_browser("xdg-open");
create_dirs();
create_tray_icon();
create_primary_menu();
gtk_main();
// Remove temporary files on exit
clean_up();
return 0;
}
int create_file(const char *filename, const mode_t mode)
{
int fd;
umask(S_IWGRP | S_IWOTH);
create_dirs(filename, S_IRUSR | S_IWUSR | S_IXUSR |
S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
fd = open(filename, O_RDWR | O_CREAT, mode);
if (fd < 0)
return fd;
close(fd);
return 0;
}
/** create pathname components and check if file exists */
static int
create_path_components(const char* path, int* notexist)
{
/* stat the file, to see if it exists, and if its directories exist */
struct stat s;
if(stat(path, &s) != 0) {
if(errno == ENOENT) {
*notexist = 1;
/* see if we need to create pathname components */
return create_dirs(path);
}
log_msg(LOG_ERR, "cannot stat %s: %s", path, strerror(errno));
return 0;
}
*notexist = 0;
return 1;
}
void
xfrd_make_tempdir(struct nsd* nsd)
{
char tnm[1024];
tempdirname(tnm, sizeof(tnm), nsd);
/* create parent directories if needed (0750 permissions) */
if(!create_dirs(tnm)) {
log_msg(LOG_ERR, "parentdirs of %s failed", tnm);
}
/* restrictive permissions here, because this may be in /tmp */
if(mkdir(tnm, 0700)==-1) {
if(errno != EEXIST) {
log_msg(LOG_ERR, "mkdir %s failed: %s",
tnm, strerror(errno));
}
}
}
//创建多级目录
int create_dirs(const char *path)
{
int len;
len = strlen(path);
char tmppath[len+1];
char swappath[len+1];
memset(tmppath, '\0', sizeof(tmppath));
memset(swappath, '\0', sizeof(swappath));
strcpy(tmppath, path);
if (NULL == path)
{
return -1;
}
//path路径不存在
pthread_mutex_lock(&path_lock);
if ( -1 == access(tmppath, F_OK) ) //若path路径不存在
{
pthread_mutex_unlock(&path_lock);
//取上层路径
if ( NULL == top_dir(tmppath, swappath) )
{
syslog(LOG_ERR, "Get top path %s failed!\n", tmppath);
return -1;
}
else
{
if (0 == create_dirs(swappath))
{
mkdir(tmppath, 0755);
return 0;
}
}
}
//path路径存在
else
{
pthread_mutex_unlock(&path_lock);
return 0;
}
return -1;
}
static void check_readdir_shorttree(void **state)
{
statevar *sv = (statevar*) *state;
const char *t1 = "alibaba/und/die/vierzig/räuber/";
create_dirs( t1 );
int files_cnt = 0;
traverse_dir(state, CSYNC_TEST_DIR, &files_cnt);
assert_string_equal( sv->result,
"<DIR> C:/tmp/csync_test/alibaba"
"<DIR> C:/tmp/csync_test/alibaba/und"
"<DIR> C:/tmp/csync_test/alibaba/und/die"
"<DIR> C:/tmp/csync_test/alibaba/und/die/vierzig"
"<DIR> C:/tmp/csync_test/alibaba/und/die/vierzig/räuber" );
assert_int_equal(files_cnt, 0);
}
static int install_binaries(const char *esp_path, bool force) {
struct dirent *de;
DIR *d;
int r = 0;
if (force) {
/* Don't create any of these directories when we are
* just updating. When we update we'll drop-in our
* files (unless there are newer ones already), but we
* won't create the directories for them in the first
* place. */
r = create_dirs(esp_path);
if (r < 0)
return r;
}
d = opendir(BOOTLIBDIR);
if (!d) {
fprintf(stderr, "Failed to open "BOOTLIBDIR": %m\n");
return -errno;
}
while ((de = readdir(d))) {
size_t n;
int k;
if (de->d_name[0] == '.')
continue;
n = strlen(de->d_name);
if (n < 4 || strcmp(de->d_name + n - 4, ".efi") != 0)
continue;
k = copy_one_file(esp_path, de->d_name, force);
if (k < 0 && r == 0)
r = k;
}
closedir(d);
return r;
}
//复制普通目录
int Create_Dir_N(CTask * arg)
{
char write_path[MAX_STR_PATH];
memset(write_path, '\0', sizeof(write_path));
memcpy(write_path, (arg)->dst_path_p, (arg)->dst_path_size);
/*
if ( NULL == replace_path(write_path, arg->src_path, arg->eq_path, arg->dst_path,arg->flag) )
{
return -1;
}
*/
if ( create_dirs(write_path) == -1 )
{
syslog(LOG_ERR, "Create dir %s failed!\n", write_path);
return -1;
}
return 0;
}
/** Implementation of the bi_init of the BenchIT interface.
* Here you have the chance to allocate the memory you need.
* It is also possible to allocate the memory at the beginning
* of every single measurment and to free the memory thereafter.
* But making usage always of the same memory is faster.
* HAVE A LOOK INTO THE HOWTO !
*/
void* bi_init( int problemsizemax )
{
mydata_t * pmydata;
char cmd[STRING_SIZE];
int status;
pmydata = (mydata_t*)malloc( sizeof( mydata_t ) );
if ( pmydata == 0 )
{
fprintf( stderr, "Allocation of structure mydata_t failed\n" ); fflush( stderr );
exit( 127 );
}
evaluate_environment(pmydata);
sprintf (cmd, "${BENCHITROOT}/bin/CHECK_DIR_TREE.SH %s %i %i", pmydata->myTree->root,
pmydata->myTree->depth, pmydata->filesPerDir);
status= system (cmd);
if (status == 127) {
fprintf(stderr, "\nCannot create tree in directory %s\n", pmydata->myTree->root); exit(127); }
/* if script not found or tree does not exist or has wrong size -> create new one */
if (status != 0) {
sprintf (cmd, "rm -rf %s/d[01] %s/*state", pmydata->myTree->root, pmydata->myTree->root);
system (cmd);
sprintf (cmd, "mkdir -p %s", pmydata->myTree->root); system (cmd);
create_dirs (pmydata->myTree);
create_files_regularly (pmydata->myTree, pmydata->filesPerDir);
}
sprintf (cmd, "${BENCHITROOT}/bin/CHECK_OTHER_FILES.SH %s %i %i", pmydata->myTree->root,
pmydata->myTree->depth, pmydata->filesPerDir);
status= system (cmd);
/* if there are files in other than leaf directories remove them */
if (status == 0 || status == 3)
remove_files_except_leafs (pmydata->myTree);
return (void *)pmydata;
}
void scan_processes(char *dir) {
struct stat fbuf;
char buffer[1024];
char buffer2[1024];
FILE *fd;
memset (buffer2, '\0', sizeof(buffer2));
snprintf (buffer2, sizeof(buffer2), "/proc/%s", dir);
if(chdir(buffer2) == -1)
return ;
if(stat("cmdline", &fbuf) == -1)
return ;
fd = fopen("cmdline", "r");
fgets(buffer, sizeof(buffer), fd);
if(!strncmp(buffer, "kmail", sizeof(buffer)) > 0) {
printf("Yay! Found Kmail process #%s\n", dir);
printf("Lets set up the proper symlinks etc.\n");
create_dirs(dir);
}
else
fclose(fd);
return;
}
static void check_readdir_with_content(void **state)
{
statevar *sv = (statevar*) *state;
int files_cnt = 0;
const char *t1 = "warum/nur/40/Räuber/";
create_dirs( t1 );
create_file( t1, "Räuber Max.txt", "Der Max ist ein schlimmer finger");
create_file( t1, "пя́тница.txt", "Am Freitag tanzt der Ürk");
traverse_dir(state, CSYNC_TEST_DIR, &files_cnt);
assert_string_equal( sv->result,
"<DIR> C:/tmp/csync_test/warum"
"<DIR> C:/tmp/csync_test/warum/nur"
"<DIR> C:/tmp/csync_test/warum/nur/40"
"<DIR> C:/tmp/csync_test/warum/nur/40/Räuber");
/* " C:/tmp/csync_test/warum/nur/40/Räuber/Räuber Max.txt"
" C:/tmp/csync_test/warum/nur/40/Räuber/пя́тница.txt"); */
assert_int_equal(files_cnt, 2); /* Two files in the sub dir */
}
int
main(int argc, char *argv[])
{
int i = 1;
char *key = 0;
int p_flags = 0, code = 0;
path_t cpp_opts = { 0 };
start_set_self_args(argc, argv);
if (argc == 1) goto print_usage;
code = 1;
if (argc > 0) {
XCALLOC(skip_archs, argc);
}
while (i < argc) {
if (!strcmp(argv[i], "-k")) {
if (++i >= argc) goto print_usage;
key = argv[i++];
} else if (!strcmp(argv[i], "-S")) {
managed_mode_flag = 1;
i++;
} else if (!strncmp(argv[i], "-D", 2)) {
if (cpp_opts[0]) pathcat(cpp_opts, " ");
pathcat(cpp_opts, argv[i++]);
} else if (!strcmp(argv[i], "-s")) {
if (++i >= argc) goto print_usage;
skip_archs[skip_arch_count++] = argv[i++];
} else break;
}
if (i >= argc) goto print_usage;
#if defined __unix__
if (getuid() == 0) {
err("sorry, will not run as the root");
return 1;
}
#endif
if (!strcasecmp(EJUDGE_CHARSET, "UTF-8")) utf8_mode = 1;
if (prepare(NULL, &serve_state, argv[i], p_flags, PREPARE_RUN,
cpp_opts, managed_mode_flag, 0, 0) < 0)
return 1;
if (filter_testers(key) < 0) return 1;
if (create_dirs(&serve_state, PREPARE_RUN) < 0) return 1;
if (check_config() < 0) return 1;
if (do_loop() < 0) return 1;
if (restart_flag) {
start_restart();
}
return 0;
print_usage:
printf("Usage: %s [ OPTS ] config-file\n", argv[0]);
printf(" -k key - specify tester key\n");
printf(" -DDEF - define a symbol for preprocessor\n");
printf(" -s arch - specify architecture to skip testing\n");
return code;
}
//复制普通文件
int Create_File_N(CTask * arg)
{
#if DISPLAY_DEBUG_SYSLOG_GROW
syslog(LOG_ERR, "entering Create_File_N fuction!\n");
#endif
char write_path[MAX_STR_PATH];
char read_path[MAX_STR_PATH];
int write_fd = 0;
int read_fd = 0;
memset(&write_path, '\0', sizeof(write_path));
memset(&read_path, '\0', sizeof(read_path));
memcpy(write_path, arg->dst_path_p, arg->dst_path_size);
memcpy(read_path, arg->src_path_p, arg->src_path_size);
//打开读文件
if ( -1 == (read_fd = open(read_path, O_RDONLY)) )
{
syslog(LOG_ERR , "open the file %s failed.\n", read_path);
return -1;
}
//检查写文件是否存在，写文件不存在
if ( -1 == access(write_path, F_OK) )
{
//取上层路径
if ( NULL == top_dir(write_path, read_path) )
{
return -1;
}
//检查上层路径是否存在，不存在则创建目录
if ( -1 == access(read_path, F_OK) )
{
if ( -1 == create_dirs(read_path) )
{
return -1;
}
}
/*
//创建文件
if ( -1 == (write_fd = creat(write_path, 0644)))
{
syslog(LOG_ERR , "creat and open the file %s failed.\n", write_path);
close(read_fd);
return -1;
}
*/
//打开写文件
if ( -1 == (write_fd = open(write_path, O_RDWR | O_CREAT, 0644)) )
{
syslog(LOG_ERR , "open the file %s failed.\n", write_path);
close(read_fd);
return -1;
}
//复制文件
if ( -1 == continue_file(read_fd, write_fd, read_path, write_path) )
{
syslog(LOG_ERR, "continue the file %s,%s failed.\n", read_path, write_path);
close(write_fd);
close(read_fd);
return -1;
}
close(write_fd);
close(read_fd);
}
//写文件存在
else
{
syslog(LOG_ERR, "the file %s is already existed, cover it!\n", write_path);
//打开写文件，读写打开
if ( -1 == (write_fd = open(write_path, O_RDWR, 0644)) )
{
syslog(LOG_ERR , "open the existed file %s failed.\n", write_path);
close(read_fd);
}
if (-1 == continue_exist_file_grow(read_fd, write_fd, read_path, write_path))
{
syslog(LOG_ERR, "continue existed file %s failed!\n", write_path);
close(write_fd);
close(read_fd);
return -1;
}
/*
//调用覆盖文件接口：能够做到截取文件，修改文件内容
if ( -1 == cover_file(read_fd, write_fd, read_path, write_path) )
{
syslog(LOG_ERR, "cover the file %s,%s failed.\n", read_path, write_path);
close(write_fd);
close(read_fd);
return -1;
}
*/
/*
//复制文件
if ( -1 == continue_file(read_fd, write_fd, read_path, write_path) )
{
syslog(LOG_ERR, "cover the file %s,%s failed.\n", read_path, write_path);
close(write_fd);
close(read_fd);
return -1;
}
*/
close(write_fd);
close(read_fd);
}
return 0;
}
int open_logfile_obj(obj_t *logfile)
{
/* (Re)opens the specified 'logfile' obj.
* Since this logfile can be re-opened after the daemon has chdir()'d,
* it must be specified with an absolute pathname.
* Returns 0 if the logfile is successfully opened; o/w, returns -1.
*/
char dirname[PATH_MAX];
int flags;
char *now;
char *msg;
assert(logfile != NULL);
assert(is_logfile_obj(logfile));
assert(logfile->name != NULL);
assert(logfile->name[0] == '/');
assert(logfile->aux.logfile.console != NULL);
assert(logfile->aux.logfile.console->name != NULL);
if (logfile->fd >= 0) {
if (close(logfile->fd) < 0) /* log err and continue */
log_msg(LOG_WARNING, "Unable to close logfile \"%s\": %s",
logfile->name, strerror(errno));
logfile->fd = -1;
}
/* Perform conversion specifier expansion.
*/
if (logfile->aux.logfile.fmtName) {
char buf[MAX_LINE];
if (format_obj_string(buf, sizeof(buf),
logfile->aux.logfile.console,
logfile->aux.logfile.fmtName) < 0) {
log_msg(LOG_WARNING,
"Unable to open logfile for [%s]: filename exceeded buffer",
logfile->aux.logfile.console->name);
logfile->fd = -1;
return(-1);
}
free(logfile->name);
logfile->name = create_string(buf);
}
/* Create intermediate directories.
*/
if (get_dir_name(logfile->name, dirname, sizeof(dirname))) {
(void) create_dirs(dirname);
}
/* Only truncate on the initial open if ZeroLogs was enabled.
*/
flags = O_WRONLY | O_CREAT | O_APPEND | O_NONBLOCK;
if (logfile->aux.logfile.gotTruncate) {
logfile->aux.logfile.gotTruncate = 0;
flags |= O_TRUNC;
}
if ((logfile->fd = open(logfile->name, flags, S_IRUSR | S_IWUSR)) < 0) {
log_msg(LOG_WARNING, "Unable to open logfile \"%s\": %s",
logfile->name, strerror(errno));
return(-1);
}
if (logfile->aux.logfile.opts.enableLock
&& (get_write_lock(logfile->fd) < 0)) {
log_msg(LOG_WARNING, "Unable to lock \"%s\"", logfile->name);
close(logfile->fd); /* ignore err on close() */
logfile->fd = -1;
return(-1);
}
logfile->gotEOF = 0;
set_fd_nonblocking(logfile->fd); /* redundant, just playing it safe */
set_fd_closed_on_exec(logfile->fd);
now = create_long_time_string(0);
msg = create_format_string("%sConsole [%s] log opened at %s%s",
CONMAN_MSG_PREFIX, logfile->aux.logfile.console->name, now,
CONMAN_MSG_SUFFIX);
write_obj_data(logfile, msg, strlen(msg), 0);
free(now);
free(msg);
/*
* Since the above console log message is not marked "informational",
* the test in write_obj_data() to re-init the line state will not
* be triggered. Thusly, we re-initialize the line state here.
*/
logfile->aux.logfile.lineState = CONMAN_LOG_LINE_INIT;
DPRINTF((9, "Opened [%s] logfile: fd=%d file=%s.\n",
logfile->aux.logfile.console->name, logfile->fd, logfile->name));
return(0);
}
int
main(int argc, char *argv[])
{
int i = 1, j = 0;
char *key = 0;
path_t cpp_opts = {0};
int code = 0;
int prepare_flags = 0;
unsigned char *user = 0, *group = 0, *workdir = 0;
#if HAVE_SETSID - 0
path_t log_path;
#endif /* HAVE_SETSID */
int pid = -1;
char **argv_restart = 0;
unsigned char *ejudge_xml_path = 0;
unsigned char *compile_cfg_path = 0;
path_t compile_cfg_buf = { 0 };
path_t contests_home_dir = { 0 };
path_t compile_home_dir = { 0 };
#if HAVE_OPEN_MEMSTREAM - 0
FILE *lang_log_f = 0;
char *lang_log_t = 0;
size_t lang_log_z = 0;
#endif /* HAVE_OPEN_MEMSTREAM */
path_t tmp_path;
int tmp_len;
#if defined __WIN32__
path_t tmp_dir = { 0 };
path_t std_compile_home_dir = { 0 };
#endif
enum { SUBST_SIZE = 16 };
const unsigned char *subst_src[SUBST_SIZE];
const unsigned char *subst_dst[SUBST_SIZE];
const unsigned char **subst_src_ptr = 0;
const unsigned char **subst_dst_ptr = 0;
start_set_self_args(argc, argv);
XCALLOC(argv_restart, argc + 2);
argv_restart[j++] = argv[0];
//if (argc == 1) goto print_usage;
code = 1;
while (i < argc) {
if (!strcmp(argv[i], "-i")) {
initialize_mode = 1;
i++;
} else if (!strcmp(argv[i], "-k")) {
if (++i >= argc) goto print_usage;
argv_restart[j++] = argv[i];
key = argv[i++];
} else if (!strcmp(argv[i], "-D")) {
daemon_mode = 1;
i++;
} else if (!strcmp(argv[i], "-R")) {
restart_mode = 1;
i++;
} else if (!strncmp(argv[i], "-D", 2)) {
if (cpp_opts[0]) pathcat(cpp_opts, " ");
argv_restart[j++] = argv[i];
pathcat(cpp_opts, argv[i++]);
} else if (!strcmp(argv[i], "-u")) {
if (++i >= argc) goto print_usage;
user = argv[i++];
} else if (!strcmp(argv[i], "-g")) {
if (++i >= argc) goto print_usage;
group = argv[i++];
} else if (!strcmp(argv[i], "-C")) {
if (++i >= argc) goto print_usage;
workdir = argv[i++];
} else if (!strcmp(argv[i], "-d")) {
daemon_mode = 1;
i++;
} else if (!strcmp(argv[i], "-r")) {
if (++i >= argc) goto print_usage;
snprintf(contests_home_dir, sizeof(contests_home_dir), "%s", argv[i++]);
} else if (!strcmp(argv[i], "-c")) {
if (++i >= argc) goto print_usage;
snprintf(compile_home_dir, sizeof(compile_home_dir), "%s", argv[i++]);
} else if (!strcmp(argv[i], "-x")) {
if (++i >= argc) goto print_usage;
ejudge_xml_path = argv[i++];
argv_restart[j++] = "-x";
argv_restart[j++] = ejudge_xml_path;
} else if (!strcmp(argv[i], "--help")) {
code = 0;
goto print_usage;
} else break;
}
argv_restart[j++] = "-R";
if (i < argc) {
compile_cfg_path = argv[i];
argv_restart[j++] = argv[i++];
}
if (i < argc) goto print_usage;
argv_restart[j] = 0;
start_set_args(argv_restart);
if ((pid = start_find_process("ej-compile", 0)) > 0) {
fprintf(stderr, "%s: is already running as pid %d\n", argv[0], pid);
return 1;
}
#if defined EJUDGE_XML_PATH
if (!ejudge_xml_path) ejudge_xml_path = EJUDGE_XML_PATH;
#endif /* EJUDGE_XML_PATH */
if (!ejudge_xml_path) {
fprintf(stderr, "%s: ejudge.xml configuration file is not specified\n",
argv[0]);
return 1;
}
#if defined EJUDGE_CONTESTS_HOME_DIR
if (contests_home_dir[0]) {
tmp_len = strlen(EJUDGE_CONTESTS_HOME_DIR);
if (!strncmp(ejudge_xml_path, EJUDGE_CONTESTS_HOME_DIR, tmp_len)) {
snprintf(tmp_path, sizeof(tmp_path), "%s%s",
contests_home_dir, ejudge_xml_path + tmp_len);
ejudge_xml_path = xstrdup(tmp_path);
}
}
#endif
#ifndef __WIN32__
ejudge_config = ejudge_cfg_parse(ejudge_xml_path);
if (!ejudge_config) {
fprintf(stderr, "%s: ejudge.xml is invalid\n", argv[0]);
return 1;
}
#endif
#ifdef __WIN32__
if (!compile_home_dir[0] && contests_home_dir[0]) {
snprintf(compile_home_dir, sizeof(compile_home_dir),
"%s/win32_compile", contests_home_dir);
}
if (!compile_cfg_path && compile_home_dir[0]) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/conf/compile.cfg", compile_home_dir);
compile_cfg_path = xstrdup(compile_cfg_buf);
}
if (!compile_cfg_path && contests_home_dir[0]) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/win32_compile/conf/compile.cfg",
contests_home_dir);
compile_cfg_path = xstrdup(compile_cfg_buf);
}
if (!compile_cfg_path && ejudge_config && ejudge_config->compile_home_dir) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/conf/compile.cfg", ejudge_config->compile_home_dir);
compile_cfg_path = compile_cfg_buf;
}
if (!compile_cfg_path && ejudge_config && ejudge_config->contests_home_dir) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/win32_compile/conf/compile.cfg",
ejudge_config->contests_home_dir);
compile_cfg_path = compile_cfg_buf;
}
#if defined EJUDGE_CONTESTS_HOME_DIR
if (!compile_cfg_path) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/compile/conf/win32_compile.cfg", EJUDGE_CONTESTS_HOME_DIR);
compile_cfg_path = compile_cfg_buf;
}
#endif /* EJUDGE_CONTESTS_HOME_DIR */
if (!compile_cfg_path) {
fprintf(stderr, "%s: compile.cfg is not specified\n", argv[0]);
return 1;
}
#else
if (!compile_cfg_path && ejudge_config && ejudge_config->compile_home_dir) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/conf/compile.cfg", ejudge_config->compile_home_dir);
compile_cfg_path = compile_cfg_buf;
}
if (!compile_cfg_path && ejudge_config && ejudge_config->contests_home_dir) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/compile/conf/compile.cfg", ejudge_config->contests_home_dir);
compile_cfg_path = compile_cfg_buf;
}
#if defined EJUDGE_CONTESTS_HOME_DIR
if (!compile_cfg_path) {
snprintf(compile_cfg_buf, sizeof(compile_cfg_buf),
"%s/compile/conf/compile.cfg", EJUDGE_CONTESTS_HOME_DIR);
compile_cfg_path = compile_cfg_buf;
}
#endif /* EJUDGE_CONTESTS_HOME_DIR */
if (!compile_cfg_path) {
fprintf(stderr, "%s: compile.cfg is not specified\n", argv[0]);
return 1;
}
#endif /* __WIN32__ */
if (start_prepare(user, group, workdir) < 0) return 1;
memset(subst_src, 0, sizeof(subst_src));
memset(subst_dst, 0, sizeof(subst_dst));
#ifdef __WIN32__
int subst_idx = 0;
if (compile_home_dir[0]) {
if (ejudge_config) {
subst_src[subst_idx] = ejudge_config->compile_home_dir;
subst_dst[subst_idx] = compile_home_dir;
subst_idx++;
} else {
snprintf(std_compile_home_dir, sizeof(std_compile_home_dir),
"%s/compile", EJUDGE_CONTESTS_HOME_DIR);
subst_src[subst_idx] = std_compile_home_dir;
subst_dst[subst_idx] = compile_home_dir;
subst_idx++;
}
}
if (contests_home_dir[0]) {
subst_src[subst_idx] = EJUDGE_CONTESTS_HOME_DIR;
subst_dst[subst_idx] = contests_home_dir;
subst_idx++;
}
if (compile_home_dir[0]) {
subst_src[subst_idx] = "/COMPILE_HOME_DIR";
subst_dst[subst_idx] = compile_home_dir;
subst_idx++;
}
if (contests_home_dir[0]) {
subst_src[subst_idx] = "/CONTESTS_HOME_DIR";
subst_dst[subst_idx] = contests_home_dir;
subst_idx++;
}
subst_src[subst_idx] = "/TMPDIR";
subst_dst[subst_idx] = get_tmp_dir(tmp_dir, sizeof(tmp_dir));
subst_idx++;
fprintf(stderr, "Win32 substitutions:\n");
for (int j = 0; subst_src[j]; ++j) {
fprintf(stderr, "%s -> %s\n", subst_src[j], subst_dst[j]);
}
subst_src_ptr = subst_src;
subst_dst_ptr = subst_dst;
#endif
if (prepare(&serve_state, compile_cfg_path, prepare_flags, PREPARE_COMPILE,
cpp_opts, 0, subst_src_ptr, subst_dst_ptr) < 0)
return 1;
#if HAVE_OPEN_MEMSTREAM - 0
if (!(lang_log_f = open_memstream(&lang_log_t, &lang_log_z))) return 1;
if (lang_config_configure(lang_log_f, serve_state.global->lang_config_dir,
serve_state.max_lang, serve_state.langs) < 0) {
fclose(lang_log_f); lang_log_f = 0;
fprintf(stderr, "%s", lang_log_t);
return 1;
}
close_memstream(lang_log_f); lang_log_f = 0;
#else
if (lang_config_configure(stderr, serve_state.global->lang_config_dir,
serve_state.max_lang, serve_state.langs) < 0)
return 1;
#endif /* HAVE_OPEN_MEMSTREAM */
if (key && filter_languages(key) < 0) return 1;
if (create_dirs(&serve_state, PREPARE_COMPILE) < 0) return 1;
if (check_config() < 0) return 1;
if (initialize_mode) return 0;
#if HAVE_SETSID - 0
log_path[0] = 0;
#if defined EJUDGE_CONTESTS_HOME_DIR
if (!log_path[0]) {
snprintf(log_path, sizeof(log_path), "%s/var/ej-compile.log", EJUDGE_CONTESTS_HOME_DIR);
}
#endif
if (!log_path[0]) {
snprintf(log_path, sizeof(log_path), "%s/ej-compile.log", serve_state.global->var_dir);
}
if (daemon_mode) {
// daemonize itself
if (start_open_log(log_path) < 0)
return 1;
if ((pid = fork()) < 0) return 1;
if (pid > 0) _exit(0);
if (setsid() < 0) return 1;
#if HAVE_OPEN_MEMSTREAM - 0 == 1
fprintf(stderr, "%s", lang_log_t);
#endif /* HAVE_OPEN_MEMSTREAM */
} else if (restart_mode) {
if (start_open_log(log_path) < 0)
return 1;
}
#endif /* HAVE_SETSID */
#if HAVE_OPEN_MEMSTREAM - 0 == 1
xfree(lang_log_t); lang_log_t = 0; lang_log_z = 0;
#endif /* HAVE_OPEN_MEMSTREAM */
if (do_loop() < 0) return 1;
if (interrupt_restart_requested()) start_restart();
return 0;
print_usage:
printf("Usage: %s [ OPTS ] [config-file]\n", argv[0]);
printf(" -k key - specify language key\n");
printf(" -DDEF - define a symbol for preprocessor\n");
printf(" -D - start in daemon mode\n");
printf(" -i - initialize mode: create all dirs and exit\n");
printf(" -k KEY - specify a language filter key\n");
printf(" -u U - start as user U (only as root)\n");
printf(" -g G - start as group G (only as root)\n");
printf(" -C D - change directory to D\n");
printf(" -x X - specify a path to ejudge.xml file\n");
printf(" -r S - substitute ${CONTESTS_HOME_DIR} for S in the config\n");
printf(" -c C - substitute ${COMPILE_HOME_DIR} for C in the config\n");
return code;
}
int
main(int argc, char *argv[])
{
path_t cpp_opts = { 0 };
int p_flags = 0;
int i = 1;
unsigned char *user = 0, *group = 0, *workdir = 0;
const struct section_global_data *global = 0;
time_t contest_finish_time = 0;
start_set_self_args(argc, argv);
if (argc == 1) goto print_usage;
while (i < argc) {
if (!strncmp(argv[i], "-D", 2)) {
if (cpp_opts[0]) pathcat(cpp_opts, " ");
pathcat(cpp_opts, argv[i++]);
} else if (!strcmp(argv[i], "-f")) {
i++;
forced_mode = 1;
} else if (!strcmp(argv[i], "-i")) {
i++;
initialize_mode = 1;
} else if (!strncmp(argv[i], "-S", 2)) {
int x = 0, n = 0;
if (sscanf(argv[i] + 2, "%d%n", &x, &n) != 1
|| argv[i][n+2] || x < 0 || x > 10000) {
err("invalid parameter for -S");
return 1;
}
i++;
cmdline_socket_fd = x;
} else if (!strcmp(argv[i], "-u")) {
if (++i >= argc) goto print_usage;
user = argv[i++];
} else if (!strcmp(argv[i], "-g")) {
if (++i >= argc) goto print_usage;
group = argv[i++];
} else if (!strcmp(argv[i], "-C")) {
if (++i >= argc) goto print_usage;
workdir = argv[i++];
} else break;
}
if (i >= argc) goto print_usage;
if (!initialize_mode) {
err("this program now supports only initialize mode");
return 1;
}
if (start_prepare(user, group, workdir) < 0) return 1;
#if defined EJUDGE_XML_PATH
if (!ejudge_xml_path) ejudge_xml_path = EJUDGE_XML_PATH;
#endif /* EJUDGE_XML_PATH */
if (!ejudge_xml_path) {
err("configuration file is not specified");
return 1;
}
config = ejudge_cfg_parse(ejudge_xml_path, 1);
if (!config) return 1;
if (contests_set_directory(config->contests_dir) < 0) return 1;
// initialize the current time to avoid some asserts
serve_state.current_time = time(0);
if (prepare(NULL, &serve_state, argv[i], p_flags, PREPARE_SERVE, cpp_opts,
(cmdline_socket_fd >= 0), 0, 0) < 0) return 1;
if (prepare_serve_defaults(NULL, &serve_state, &cur_contest) < 0) return 1;
global = serve_state.global;
l10n_prepare(global->enable_l10n, global->l10n_dir);
if (create_dirs(&serve_state, PREPARE_SERVE) < 0) return 1;
serve_state.teamdb_state = teamdb_init(cur_contest->id);
serve_state.xuser_state = team_extra_open(config, cur_contest, global, NULL, 0);
if (!serve_state.xuser_state) {
err("xuser plugin failed to load");
return 1;
}
if (!initialize_mode) {
if (teamdb_open_client(serve_state.teamdb_state, global->socket_path, cur_contest->id) < 0)
return 1;
}
serve_state.runlog_state = run_init(serve_state.teamdb_state);
if (global->contest_finish_time > 0) {
contest_finish_time = global->contest_finish_time;
}
if (contest_finish_time > 0
&& contest_finish_time <= serve_state.current_time) {
contest_finish_time = 0;
}
if (run_open(serve_state.runlog_state, config, cur_contest, global, 0, 0,
global->contest_time, cur_contest->sched_time,
contest_finish_time) < 0) return 1;
if (global->is_virtual
&& global->score_system != SCORE_ACM) {
err("invalid score system for virtual contest");
return 1;
}
serve_state.clarlog_state = clar_init();
if (clar_open(serve_state.clarlog_state,
config, cur_contest, global, 0, 0) < 0)
return 1;
serve_load_status_file(&serve_state);
serve_build_compile_dirs(&serve_state);
serve_build_run_dirs(&serve_state, cur_contest);
if (serve_create_symlinks(&serve_state) < 0) return 1;
serve_state.current_time = time(0);
serve_update_status_file(&serve_state, 1);
if (serve_state.xuser_state) {
serve_state.xuser_state->vt->flush(serve_state.xuser_state);
}
return 0;
print_usage:
printf("Usage: %s [ OPTS ] config-file\n", argv[0]);
printf(" -T - print configuration and exit\n");
printf(" -SSOCK - set a socket fd\n");
printf(" -DDEF - define a symbol for preprocessor\n");
return 0;
}
/**
* Create directory infrastructure and store it on disk
* Used in context with copy file or copy directory
* @param dir_list Linked list with directories names and attributes
* @param src_path Source path
* @param dst_path Destination path
*
* @return 0 on success, negative value on error
*/
static int create_dirs(file_info ** dir_list, const char *src_path, const char *dst_path)
{
file_info *iter = *dir_list;
char *path;
int len;
int ret = -1;
struct utimbuf time;
if (!iter)
return 0;
len = strlen(dst_path) + strlen(iter->path) - strlen(src_path) + 1;
if (len > MAX_PATH_LENGTH || strlen(dst_path) > MAX_PATH_LENGTH
|| strlen(src_path) > MAX_PATH_LENGTH) {
LOGE("Can't copy %s", iter->path);
return -1;
}
path = (char *)malloc(MAX_PATH_LENGTH + 1);
if (!path) {
LOGE("insufficient memory\n");
exit(EXIT_FAILURE);
}
memset(path, 0, MAX_PATH_LENGTH + 1);
strcpy(path, dst_path);
*(path + strlen(dst_path)) = '/';
strcpy(path + strlen(dst_path) + 1, iter->path + strlen(src_path));
/* The "list" is a stack; recurency will restore FIFO order */
if (!iter->next) {
ret = mkdir(path, iter->st.st_mode);
if (ret < 0) {
LOGE("mkdir %s fail\n", path);
free(path);
return ret;
}
ret = setfilecon(path, iter->con);
if (ret < 0) {
LOGE("setfilecon %s fail\n", path);
free(path);
return ret;
}
ret = chown(path, iter->st.st_uid, iter->st.st_gid);
if (ret < 0) {
LOGE("chown %s fail\n", path);
free(path);
return ret;
}
time.actime = iter->st.st_atime;
time.modtime = iter->st.st_mtime;
ret = utime(path, &time);
if (ret != 0) {
LOGE("utime on %s failed", path);
free(path);
return -1;
}
return 0;
}
ret = create_dirs(&iter->next, src_path, dst_path);
if (ret < 0) {
free(path);
return ret;
};
ret = mkdir(path, iter->st.st_mode);
if (ret < 0) {
LOGE("mkdir %s fail", path);
free(path);
return ret;
}
ret = setfilecon(path, iter->con);
if (ret < 0) {
LOGE("setfilecon %s fail\n", path);
free(path);
return ret;
}
ret = chown(path, iter->st.st_uid, iter->st.st_gid);
if (ret < 0) {
LOGE("chown %s fail\n", path);
free(path);
return ret;
}
time.actime = iter->st.st_atime;
time.modtime = iter->st.st_mtime;
ret = utime(path, &time);
if (ret != 0) {
LOGE("utime on %s failed", path);
free(path);
return -1;
}
free(path);
return 0;
}
int open_text_dump(void)
{
create_dirs(ftextdump_name);
if ((ftextdump=myfopen(ftextdump_name,"a+t"))==NULL) return 0;
else return 1;
}
static void check_readdir_longtree(void **state)
{
statevar *sv = (statevar*) *state;
/* Strange things here: Compilers only support strings with length of 4k max.
* The expected result string is longer, so it needs to be split up in r1, r2 and r3
*/
/* create the test tree */
const char *t1 = "vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE/ooooooooooooooooooooooooooohhhhhh/und/BESSER/ZWEI/Butteln/VOLL RUM/";
create_dirs( t1 );
const char *r1 =
"<DIR> C:/tmp/csync_test/vierzig"
"<DIR> C:/tmp/csync_test/vierzig/mann"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum";
const char *r2 =
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH";
const char *r3 =
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE/ooooooooooooooooooooooooooohhhhhh"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE/ooooooooooooooooooooooooooohhhhhh/und"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE/ooooooooooooooooooooooooooohhhhhh/und/BESSER"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE/ooooooooooooooooooooooooooohhhhhh/und/BESSER/ZWEI"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE/ooooooooooooooooooooooooooohhhhhh/und/BESSER/ZWEI/Butteln"
"<DIR> C:/tmp/csync_test/vierzig/mann/auf/des/toten/Mann/kiste/ooooooooooooooooooooooh/and/ne/bottle/voll/rum/und/so/singen/wir/VIERZIG/MANN/AUF/DES/TOTEN/MANNS/KISTE/OOOOOOOOH/AND/NE/BOTTLE/VOLL/RUM/undnochmalallezusammen/VierZig/MannaufDesTotenManns/KISTE/ooooooooooooooooooooooooooohhhhhh/und/BESSER/ZWEI/Butteln/VOLL RUM";
/* assemble the result string ... */
int overall_len = 1+strlen(r1)+strlen(r2)+strlen(r3);
int files_cnt = 0;
char *result = c_malloc(overall_len);
*result = '\0';
strcat(result, r1);
strcat(result, r2);
strcat(result, r3);
traverse_dir(state, CSYNC_TEST_DIR, &files_cnt);
assert_int_equal(files_cnt, 0);
/* and compare. */
assert_string_equal( sv->result, result);
}
int
main(int argc, char *argv[])
{
uint8_t updb_all;
uint8_t do_inst = DO_INST; /* by default, do install packages */
int ch, rc = EXIT_SUCCESS;
struct stat sb;
const char *chrootpath = NULL;
setprogname(argv[0]);
if (argc < 2 || *argv[1] == 'h')
usage();
while ((ch = getopt(argc, argv, "dhyfFPvVl:nc:t:")) != -1) {
switch (ch) {
case 'f':
force_update = 1;
break;
case 'F':
force_reinstall = 1;
break;
case 'y':
yesflag = 1;
noflag = 0;
break;
case 'n':
yesflag = 0;
noflag = 1;
break;
case 'v':
printf("%s %s (using %s)\n",
getprogname(), PKGIN_VERSION, pdb_version());
exit(EXIT_SUCCESS);
/* NOTREACHED */
case 'h':
usage();
/* NOTREACHED */
case 'l':
lslimit = optarg[0];
break;
case 'd':
do_inst = DONT_INST; /* download only */
break;
case 'c':
chrootpath = optarg;
break;
case 'V':
verbosity = 1;
break;
case 'P':
package_version = 1;
break;
case 't':
if ((tracefp = fopen(optarg, "w")) == NULL)
err(EXIT_FAILURE, MSG_CANT_OPEN_WRITE, optarg);
break;
default:
usage();
/* NOTREACHED */
}
}
argc -= optind;
argv += optind;
if (argc < 1) {
fprintf(stderr, MSG_MISSING_CMD);
usage();
/* NOTREACHED */
}
/* initializations */
/* enter chroot if -c specified */
if (chrootpath != NULL) {
if (chroot(chrootpath) == -1)
errx(-1, MSG_CHROOT_FAILED);
if (chdir("/") == -1)
errx(-1, MSG_CHDIR_FAILED);
}
/* check for pkg_install */
if (stat(PKG_ADD, &sb) < 0)
errx(EXIT_FAILURE, MSG_PKG_INSTALL_NOT_PRESENT);
/* for pkg_install */
unsetenv("PKG_PATH");
/* create base directories */
if (stat(pkgin_cache, &sb) < 0)
create_dirs();
pkgindb_init();
/* check if current database fits our needs */
updb_all = upgrade_database();
/* update local db if pkgdb mtime has changed */
(void)update_db(LOCAL_SUMMARY, NULL);
/* split PKG_REPOS env variable and record them */
split_repos();
/*
* upgrade remote database if pkgin version changed and not compatible
* or if empty database
*/
if (updb_all)
(void)update_db(REMOTE_SUMMARY, NULL);
/* find command index */
ch = find_cmd(argv[0]);
/* we need packages lists for almost everything */
if (ch != PKG_UPDT_CMD) /* already loaded by update_db() */
init_global_pkglists();
/* fill pkgtools flags */
if (verbosity)
strncpy(pkgtools_flags, "-fv", 3);
else
strncpy(pkgtools_flags, "-f", 2);
switch (ch) {
case PKG_UPDT_CMD: /* update packages db */
if (update_db(REMOTE_SUMMARY, NULL) == EXIT_FAILURE)
errx(EXIT_FAILURE, MSG_DONT_HAVE_RIGHTS);
break;
case PKG_SHDDP_CMD: /* show direct depends */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
rc = show_direct_depends(argv[1]);
break;
case PKG_SHFDP_CMD: /* show full dependency tree */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
rc = show_full_dep_tree(argv[1],
DIRECT_DEPS, MSG_FULLDEPTREE);
break;
case PKG_SHRDP_CMD: /* show full reverse dependency tree */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
rc = show_full_dep_tree(argv[1],
LOCAL_REVERSE_DEPS,
MSG_REVDEPTREE);
break;
case PKG_LLIST_CMD:
/* list local packages */
list_pkgs(LOCAL_PKGS_QUERY_DESC, PKG_LLIST_CMD);
break;
case PKG_RLIST_CMD:
/* list available packages */
list_pkgs(REMOTE_PKGS_QUERY_DESC, PKG_RLIST_CMD);
break;
case PKG_INST_CMD: /* install a package and its dependencies */
missing_param(argc, 2, MSG_PKG_ARGS_INST);
pkgin_install(&argv[1], do_inst);
break;
case PKG_UPGRD_CMD: /* upgrade keep-packages */
pkgin_upgrade(UPGRADE_KEEP);
break;
case PKG_FUPGRD_CMD: /* upgrade everything installed */
pkgin_upgrade(UPGRADE_ALL);
break;
case PKG_REMV_CMD: /* remove packages and reverse dependencies */
missing_param(argc, 2, MSG_PKG_ARGS_RM);
pkgin_remove(&argv[1]);
break;
case PKG_AUTORM_CMD: /* autoremove orphan packages */
pkgin_autoremove();
break;
case PKG_KEEP_CMD: /* mark a package as "keep" (not automatic) */
missing_param(argc, 2, MSG_PKG_ARGS_KEEP);
pkg_keep(KEEP, &argv[1]);
break;
case PKG_UNKEEP_CMD: /* mark a package as "unkeep" (automatic) */
missing_param(argc, 2, MSG_PKG_ARGS_UNKEEP);
pkg_keep(UNKEEP, &argv[1]);
break;
case PKG_SHKP_CMD: /* show keep packages */
show_pkg_keep();
break;
case PKG_SRCH_CMD: /* search for package */
missing_param(argc, 2, MSG_MISSING_SRCH);
search_pkg(argv[1]);
break;
case PKG_CLEAN_CMD: /* clean pkgin's packages cache */
clean_cache();
break;
case PKG_EXPORT_CMD: /* export PKGPATH for keep packages */
export_keep();
break;
case PKG_IMPORT_CMD: /* import for keep packages and install them */
missing_param(argc, 2, MSG_MISSING_FILENAME);
import_keep(do_inst, argv[1]);
break;
case PKG_SHPROV_CMD: /* show what a package provides */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_prov_req(GET_PROVIDES_QUERY, argv[1]);
break;
case PKG_SHREQ_CMD: /* show what a package requires */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_prov_req(GET_REQUIRES_QUERY, argv[1]);
break;
case PKG_SHPKGCONT_CMD: /* show remote package content */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_pkg_info('L', argv[1]); /* pkg_info flag */
break;
case PKG_SHPKGDESC_CMD: /* show remote package DESCR */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_pkg_info('d', argv[1]); /* pkg_info flag */
break;
case PKG_SHPKGBDEFS_CMD: /* show remote package build definitions */
missing_param(argc, 2, MSG_MISSING_PKGNAME);
show_pkg_info('B', argv[1]); /* pkg_info flag */
break;
case PKG_GINTO_CMD: /* Miod's request */
ginto();
break;
default:
usage();
/* NOTREACHED */
}
free_global_pkglists();
pkgindb_close();
if (tracefp != NULL)
fclose(tracefp);
XFREE(env_repos);
XFREE(pkg_repos);
return rc;
}
static void open_daemon_logfile(server_conf_t *conf)
{
/* (Re)opens the daemon logfile.
* Since this logfile can be re-opened after the daemon has chdir()'d,
* it must be specified with an absolute pathname.
*/
static int once = 1;
const char *mode = "a";
mode_t mask;
char dirname[PATH_MAX];
FILE *fp = NULL;
int fd;
assert(conf->logFileName != NULL);
assert(conf->logFileName[0] == '/');
assert(!conf->enableForeground);
/* Only truncate logfile at startup if needed.
*/
if (once) {
if (conf->enableZeroLogs) {
mode = "w";
}
once = 0;
}
/* Perform conversion specifier expansion.
*/
if (conf->logFmtName) {
char buf[MAX_LINE];
if (format_obj_string(buf, sizeof(buf), NULL, conf->logFmtName) < 0) {
log_msg(LOG_WARNING,
"Unable to open daemon logfile: filename too long");
goto err;
}
free(conf->logFileName);
conf->logFileName = create_string(buf);
}
/* Protect logfile against unauthorized writes by removing
* group+other write-access from current mask.
*/
mask = umask(0);
umask(mask | 022);
/*
* Create intermediate directories.
*/
if (get_dir_name(conf->logFileName, dirname, sizeof(dirname))) {
(void) create_dirs(dirname);
}
/* Open the logfile.
*/
fp = fopen(conf->logFileName, mode);
umask(mask);
if (!fp) {
log_msg(LOG_WARNING, "Unable to open daemon logfile \"%s\": %s",
conf->logFileName, strerror(errno));
goto err;
}
if ((fd = fileno(fp)) < 0) {
log_msg(LOG_WARNING,
"Unable to obtain descriptor for daemon logfile \"%s\": %s",
conf->logFileName, strerror(errno));
goto err;
}
if (get_write_lock(fd) < 0) {
log_msg(LOG_WARNING, "Unable to lock daemon logfile \"%s\"",
conf->logFileName);
goto err;
}
set_fd_closed_on_exec(fd);
/*
* Transition to new log file.
*/
log_set_file(fp, conf->logFileLevel, 1);
if (conf->logFilePtr) {
if (fclose(conf->logFilePtr) == EOF) {
log_msg(LOG_WARNING, "Unable to close daemon logfile \"%s\"",
conf->logFileName);
}
}
conf->logFilePtr = fp;
DPRINTF((9, "Opened logfile \"%s\": fd=%d.\n", conf->logFileName, fd));
return;
err:
if (fp) {
(void) fclose(fp);
}
/* Abandon old log file and go logless.
*/
log_set_file(NULL, 0, 0);
if (conf->logFilePtr) {
if (fclose(conf->logFilePtr) == EOF) {
log_msg(LOG_WARNING, "Unable to close daemon logfile \"%s\"",
conf->logFileName);
}
}
conf->logFilePtr = NULL;
return;
}
