int main(int argc, char *argv[])
{
int option;
char buf[MAX_MAILBOX_PATH+1];
int i, r;
char *alt_config = NULL;
struct incremental_record irec;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((option = getopt(argc, argv, "vC:")) != EOF) {
switch (option) {
case 'v':
verbose++;
break;
case 'C': /* alt config file */
alt_config = optarg;
break;
default:
usage(argv[0]);
break;
}
}
if (optind == argc) {
usage(argv[0]);
}
cyrus_init(alt_config, "dump", 0, CONFIG_NEED_PARTITION_DATA);
mboxlist_init(0);
mboxlist_open(NULL);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&dump_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
irec.incruid = 0;
for (i = optind; i < argc; i++) {
strlcpy(buf, argv[i], sizeof(buf));
/* Translate any separators in mailboxname */
mboxname_hiersep_tointernal(&dump_namespace, buf,
config_virtdomains ?
strcspn(buf, "@") : 0);
(*dump_namespace.mboxlist_findall)(&dump_namespace, buf, 1, 0, 0,
dump_me, &irec);
}
mboxlist_close();
mboxlist_done();
cyrus_done();
return 0;
}
int main(int argc, char *argv[])
{
extern char *optarg;
int opt,r;
char *alt_config = NULL;
if ((geteuid()) == 0 && (become_cyrus() != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
default:
usage();
break;
}
}
cyrus_init(alt_config, "tls_prune", 0);
r = tls_prune_sessions();
cyrus_done();
return r;
}
int main(int argc, char *argv[])
{
extern char *optarg;
int opt,r;
char *alt_config = NULL;
while ((opt = getopt(argc, argv, "C:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
default:
usage();
break;
}
}
cyrus_init(alt_config, "tls_prune", 0, 0);
r = tls_prune_sessions();
cyrus_done();
return r;
}
int main(int argc, char **argv)
{
int opt;
char *alt_config = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
default:
usage();
}
}
cyrus_init(alt_config, "syncnews", 0);
if (!argv[optind] || argv[optind+1]) usage();
readactive(argv[optind]);
do_syncnews();
cyrus_done();
return code;
}
int main(int argc, char **argv)
{
int opt, i, r;
int cmd = 0;
char buf[MAX_MAILBOX_PATH+1];
char *alt_config = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:t")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 't':
cmd = CMD_TIME;
break;
default:
usage();
}
}
cyrus_init(alt_config, "mbtool", 0, 0);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&recon_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
mboxlist_init(0);
mboxlist_open(NULL);
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
if (optind == argc) {
usage();
}
for (i = optind; i < argc; i++) {
/* Handle virtdomains and separators in mailboxname */
(*recon_namespace.mboxname_tointernal)(&recon_namespace, argv[i],
NULL, buf);
mboxlist_findall(&recon_namespace, buf, 1, 0, 0,
do_cmd, &cmd);
}
mboxlist_close();
mboxlist_done();
exit(0);
}
int main(int argc, char **argv)
{
int opt, r;
char *alt_config = NULL;
int allusers = 0;
const char *audit_tool = NULL;
while ((opt = getopt(argc, argv, "C:A:a")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'a':
allusers = 1;
break;
case 'A':
audit_tool = optarg;
break;
default:
usage();
}
}
cyrus_init(alt_config, "dav_reconstruct", 0, 0);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&recon_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EX_CONFIG);
}
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
sqldb_init();
/* Initialize libical */
ical_support_init();
if (allusers) {
mboxlist_alluser(do_user, (void *)audit_tool);
}
else if (optind == argc) {
usage();
}
else {
int i;
for (i = optind; i < argc; i++)
do_user(argv[i], (void *)audit_tool);
}
exit(code);
}
int main(int argc, char *argv[])
{
int option;
int i;
char *alt_config = NULL;
struct incremental_record irec;
progname = basename(argv[0]);
while ((option = getopt(argc, argv, "vC:")) != EOF) {
switch (option) {
case 'v':
verbose++;
break;
case 'C': /* alt config file */
alt_config = optarg;
break;
default:
usage();
break;
}
}
if (optind == argc) {
usage();
}
cyrus_init(alt_config, "dump", 0, CONFIG_NEED_PARTITION_DATA);
search_attr_init();
irec.incruid = 0;
strarray_t *array = strarray_new();
for (i = optind; i < argc; i++) {
strarray_append(array, argv[i]);
}
if (array->count)
mboxlist_findallmulti(NULL, array, 1, 0, 0, dump_me, &irec);
strarray_free(array);
cyrus_done();
return 0;
}
int main(int argc, char *argv[])
{
extern char *optarg;
int opt, r = 0, expire_days = 0;
char *alt_config = NULL;
if (geteuid() == 0) fatal("must run as the Cyrus user", EC_USAGE);
while ((opt = getopt(argc, argv, "C:E:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'E':
if (expire_days) usage();
expire_days = atoi(optarg);
break;
default:
usage();
break;
}
}
if (!expire_days) usage();
cyrus_init(alt_config, "delivered_expire", 0);
if (duplicate_init(NULL, 0) != 0) {
fprintf(stderr,
"cyr_expire: unable to init duplicate delivery database\n");
exit(1);
}
/* purge deliver.db entries of expired messages */
r = duplicate_prune(expire_days, NULL);
duplicate_done();
cyrus_done();
exit(r);
}
int main(int argc, char *argv[])
{
int opt, code = 0;
char *alt_config = NULL;
int meta = 0;
if ((geteuid()) == 0 && (become_cyrus() != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:m")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'm': /* check metapartitions */
meta = 1;
break;
default:
usage();
}
}
cyrus_init(alt_config, "cyr_df", 0);
printf("%-12s %12s %12s %12s %3s %s\n", "Partition",
"1k-blocks", "Used", "Available", "Use%", "Location");
config_foreachoverflowstring(get_part_stats, &meta);
cyrus_done();
exit(code);
}
int main(int argc, char **argv)
{
int opt, i, r;
char buf[MAX_MAILBOX_PATH+1];
char *alt_config = NULL;
int quotachk = 0;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:u:s:q")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'u':
if(wantvalue) usage();
wantuid = 1;
wantvalue = atoi(optarg);
break;
case 's':
if(wantvalue) usage();
wantvalue = atoi(optarg);
break;
case 'q':
quotachk = 1;
break;
default:
usage();
}
}
cyrus_init(alt_config, "mbexamine", 0, 0);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&recon_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
mboxlist_init(0);
mboxlist_open(NULL);
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
if (optind == argc) {
strlcpy(buf, "*", sizeof(buf));
mboxlist_findall(&recon_namespace, buf, 1, 0, 0,
quotachk ? do_quota : do_examine,
NULL);
}
for (i = optind; i < argc; i++) {
/* Handle virtdomains and separators in mailboxname */
char *intname = mboxname_from_external(argv[i], &recon_namespace, NULL);
mboxlist_findall(&recon_namespace, intname, 1, 0, 0,
quotachk ? do_quota : do_examine,
NULL);
free(intname);
}
mboxlist_close();
mboxlist_done();
exit(0);
}
int main(int argc, char **argv)
{
save_argv0(argv[0]);
struct cyrbu_cmd_options options = {0};
enum cyrbu_mode mode = CYRBU_MODE_UNSPECIFIED;
enum cyrbu_cmd cmd = CYRBU_CMD_UNSPECIFIED;
const char *alt_config = NULL;
const char *backup_name = NULL;
const char *command = NULL;
const char *subcommand = NULL;
struct backup *backup = NULL;
mbname_t *mbname = NULL;
int i, opt, r = 0;
while ((opt = getopt(argc, argv, "C:fmuv")) != EOF) {
switch (opt) {
case 'C':
alt_config = optarg;
break;
case 'f':
if (mode != CYRBU_MODE_UNSPECIFIED) usage();
mode = CYRBU_MODE_FILENAME;
break;
case 'm':
if (mode != CYRBU_MODE_UNSPECIFIED) usage();
mode = CYRBU_MODE_MBOXNAME;
break;
case 'u':
if (mode != CYRBU_MODE_UNSPECIFIED) usage();
mode = CYRBU_MODE_USERNAME;
break;
case 'v':
options.verbose++;
break;
default:
usage();
break;
}
}
/* default mode is username */
if (mode == CYRBU_MODE_UNSPECIFIED)
mode = CYRBU_MODE_USERNAME;
/* get the backup name */
if (optind == argc) usage();
backup_name = argv[optind++];
/* get the command */
if (optind == argc) usage();
command = argv[optind++];
/* get the subcommand */
if (optind == argc) usage();
subcommand = argv[optind++];
/* parse the command and subcommand */
cmd = parse_cmd_string(command, subcommand);
/* check remaining arguments based on command */
switch (cmd) {
case CYRBU_CMD_LIST_ALL:
case CYRBU_CMD_LIST_CHUNKS:
case CYRBU_CMD_LIST_MAILBOXES:
case CYRBU_CMD_LIST_MESSAGES:
/* these want no more arguments */
if (optind != argc) usage();
break;
case CYRBU_CMD_SHOW_CHUNKS:
case CYRBU_CMD_SHOW_MAILBOXES:
case CYRBU_CMD_SHOW_MESSAGES:
/* these need at least one more argument */
if (optind == argc) usage();
break;
case CYRBU_CMD_DUMP_CHUNK:
case CYRBU_CMD_DUMP_MAILBOX:
case CYRBU_CMD_DUMP_MESSAGE:
/* these need exactly one more argument */
if (argc - optind != 1) usage();
break;
default:
usage();
break;
}
/* build a nice args list */
options.argv = strarray_new();
for (i = optind; i < argc; i++) {
strarray_add(options.argv, argv[i]);
}
// FIXME finish parsing options
cyrus_init(alt_config, "cyr_backup", 0, 0);
/* open backup */
switch (mode) {
case CYRBU_MODE_FILENAME:
r = backup_open_paths(&backup, backup_name, NULL,
BACKUP_OPEN_NONBLOCK, BACKUP_OPEN_NOCREATE);
break;
case CYRBU_MODE_MBOXNAME:
mbname = mbname_from_intname(backup_name);
if (!mbname) usage();
r = backup_open(&backup, mbname,
BACKUP_OPEN_NONBLOCK, BACKUP_OPEN_NOCREATE);
break;
case CYRBU_MODE_USERNAME:
mbname = mbname_from_userid(backup_name);
if (!mbname) usage();
r = backup_open(&backup, mbname,
BACKUP_OPEN_NONBLOCK, BACKUP_OPEN_NOCREATE);
break;
default:
usage();
break;
}
/* run command */
if (!r && cmd_func[cmd])
r = cmd_func[cmd](backup, &options);
if (r)
fprintf(stderr, "%s: %s\n", backup_name, error_message(r));
/* close backup */
if (backup)
backup_close(&backup);
/* clean up and exit */
backup_cleanup_staging_path();
cyrus_done();
strarray_free(options.argv);
exit(r ? EC_TEMPFAIL : EC_OK);
}
/*
* On success, leave *EXIT_CODE untouched and return SVN_NO_ERROR. On error,
* either return an error to be displayed, or set *EXIT_CODE to non-zero and
* return SVN_NO_ERROR.
*/
static svn_error_t *
sub_main(int *exit_code, int argc, const char *argv[], apr_pool_t *pool)
{
enum run_mode run_mode = run_mode_unspecified;
svn_boolean_t foreground = FALSE;
apr_socket_t *sock;
apr_sockaddr_t *sa;
svn_error_t *err;
apr_getopt_t *os;
int opt;
serve_params_t params;
const char *arg;
apr_status_t status;
#ifndef WIN32
apr_proc_t proc;
#endif
svn_boolean_t is_multi_threaded;
enum connection_handling_mode handling_mode = CONNECTION_DEFAULT;
svn_boolean_t cache_fulltexts = TRUE;
svn_boolean_t cache_txdeltas = TRUE;
svn_boolean_t cache_revprops = FALSE;
svn_boolean_t use_block_read = FALSE;
apr_uint16_t port = SVN_RA_SVN_PORT;
const char *host = NULL;
int family = APR_INET;
apr_int32_t sockaddr_info_flags = 0;
#if APR_HAVE_IPV6
svn_boolean_t prefer_v6 = FALSE;
#endif
svn_boolean_t quiet = FALSE;
svn_boolean_t is_version = FALSE;
int mode_opt_count = 0;
int handling_opt_count = 0;
const char *config_filename = NULL;
const char *pid_filename = NULL;
const char *log_filename = NULL;
svn_node_kind_t kind;
apr_size_t min_thread_count = THREADPOOL_MIN_SIZE;
apr_size_t max_thread_count = THREADPOOL_MAX_SIZE;
#ifdef SVN_HAVE_SASL
SVN_ERR(cyrus_init(pool));
#endif
/* Check library versions */
SVN_ERR(check_lib_versions());
/* Initialize the FS library. */
SVN_ERR(svn_fs_initialize(pool));
SVN_ERR(svn_cmdline__getopt_init(&os, argc, argv, pool));
params.root = "/";
params.tunnel = FALSE;
params.tunnel_user = NULL;
params.read_only = FALSE;
params.base = NULL;
params.cfg = NULL;
params.compression_level = SVN_DELTA_COMPRESSION_LEVEL_DEFAULT;
params.logger = NULL;
params.config_pool = NULL;
params.authz_pool = NULL;
params.fs_config = NULL;
params.vhost = FALSE;
params.username_case = CASE_ASIS;
params.memory_cache_size = (apr_uint64_t)-1;
params.zero_copy_limit = 0;
params.error_check_interval = 4096;
while (1)
{
status = apr_getopt_long(os, svnserve__options, &opt, &arg);
if (APR_STATUS_IS_EOF(status))
break;
if (status != APR_SUCCESS)
{
usage(argv[0], pool);
*exit_code = EXIT_FAILURE;
return SVN_NO_ERROR;
}
switch (opt)
{
case '6':
#if APR_HAVE_IPV6
prefer_v6 = TRUE;
#endif
/* ### Maybe error here if we don't have IPV6 support? */
break;
case 'h':
help(pool);
return SVN_NO_ERROR;
case 'q':
quiet = TRUE;
break;
case SVNSERVE_OPT_VERSION:
is_version = TRUE;
break;
case 'd':
if (run_mode != run_mode_daemon)
{
run_mode = run_mode_daemon;
mode_opt_count++;
}
break;
case SVNSERVE_OPT_FOREGROUND:
foreground = TRUE;
break;
case SVNSERVE_OPT_SINGLE_CONN:
handling_mode = connection_mode_single;
handling_opt_count++;
break;
case 'i':
if (run_mode != run_mode_inetd)
{
run_mode = run_mode_inetd;
mode_opt_count++;
}
break;
case SVNSERVE_OPT_LISTEN_PORT:
{
apr_uint64_t val;
err = svn_cstring_strtoui64(&val, arg, 0, APR_UINT16_MAX, 10);
if (err)
return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, err,
_("Invalid port '%s'"), arg);
port = (apr_uint16_t)val;
}
break;
case SVNSERVE_OPT_LISTEN_HOST:
host = arg;
break;
case 't':
if (run_mode != run_mode_tunnel)
{
run_mode = run_mode_tunnel;
mode_opt_count++;
}
break;
case SVNSERVE_OPT_TUNNEL_USER:
params.tunnel_user = arg;
break;
case 'X':
if (run_mode != run_mode_listen_once)
{
run_mode = run_mode_listen_once;
mode_opt_count++;
}
break;
case 'r':
SVN_ERR(svn_utf_cstring_to_utf8(¶ms.root, arg, pool));
SVN_ERR(svn_io_check_resolved_path(params.root, &kind, pool));
if (kind != svn_node_dir)
{
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("Root path '%s' does not exist "
"or is not a directory"), params.root);
}
params.root = svn_dirent_internal_style(params.root, pool);
SVN_ERR(svn_dirent_get_absolute(¶ms.root, params.root, pool));
break;
case 'R':
params.read_only = TRUE;
break;
case 'T':
handling_mode = connection_mode_thread;
handling_opt_count++;
break;
case 'c':
params.compression_level = atoi(arg);
if (params.compression_level < SVN_DELTA_COMPRESSION_LEVEL_NONE)
params.compression_level = SVN_DELTA_COMPRESSION_LEVEL_NONE;
if (params.compression_level > SVN_DELTA_COMPRESSION_LEVEL_MAX)
params.compression_level = SVN_DELTA_COMPRESSION_LEVEL_MAX;
break;
case 'M':
params.memory_cache_size = 0x100000 * apr_strtoi64(arg, NULL, 0);
break;
case SVNSERVE_OPT_CACHE_TXDELTAS:
cache_txdeltas = svn_tristate__from_word(arg) == svn_tristate_true;
break;
case SVNSERVE_OPT_CACHE_FULLTEXTS:
cache_fulltexts = svn_tristate__from_word(arg) == svn_tristate_true;
break;
case SVNSERVE_OPT_CACHE_REVPROPS:
cache_revprops = svn_tristate__from_word(arg) == svn_tristate_true;
break;
case SVNSERVE_OPT_BLOCK_READ:
use_block_read = svn_tristate__from_word(arg) == svn_tristate_true;
break;
case SVNSERVE_OPT_CLIENT_SPEED:
{
apr_size_t bandwidth = (apr_size_t)apr_strtoi64(arg, NULL, 0);
/* for slower clients, don't try anything fancy */
if (bandwidth >= 1000)
{
/* block other clients for at most 1 ms (at full bandwidth).
Note that the send buffer is 16kB anyways. */
params.zero_copy_limit = bandwidth * 120;
/* check for aborted connections at the same rate */
params.error_check_interval = bandwidth * 120;
}
}
break;
case SVNSERVE_OPT_MIN_THREADS:
min_thread_count = (apr_size_t)apr_strtoi64(arg, NULL, 0);
break;
case SVNSERVE_OPT_MAX_THREADS:
max_thread_count = (apr_size_t)apr_strtoi64(arg, NULL, 0);
break;
#ifdef WIN32
case SVNSERVE_OPT_SERVICE:
if (run_mode != run_mode_service)
{
run_mode = run_mode_service;
mode_opt_count++;
}
break;
#endif
case SVNSERVE_OPT_CONFIG_FILE:
SVN_ERR(svn_utf_cstring_to_utf8(&config_filename, arg, pool));
config_filename = svn_dirent_internal_style(config_filename, pool);
SVN_ERR(svn_dirent_get_absolute(&config_filename, config_filename,
pool));
break;
case SVNSERVE_OPT_PID_FILE:
SVN_ERR(svn_utf_cstring_to_utf8(&pid_filename, arg, pool));
pid_filename = svn_dirent_internal_style(pid_filename, pool);
SVN_ERR(svn_dirent_get_absolute(&pid_filename, pid_filename, pool));
break;
case SVNSERVE_OPT_VIRTUAL_HOST:
params.vhost = TRUE;
break;
case SVNSERVE_OPT_LOG_FILE:
SVN_ERR(svn_utf_cstring_to_utf8(&log_filename, arg, pool));
log_filename = svn_dirent_internal_style(log_filename, pool);
SVN_ERR(svn_dirent_get_absolute(&log_filename, log_filename, pool));
break;
}
}
if (is_version)
{
SVN_ERR(version(quiet, pool));
return SVN_NO_ERROR;
}
if (os->ind != argc)
{
usage(argv[0], pool);
*exit_code = EXIT_FAILURE;
return SVN_NO_ERROR;
}
if (mode_opt_count != 1)
{
svn_error_clear(svn_cmdline_fputs(
#ifdef WIN32
_("You must specify exactly one of -d, -i, -t, "
"--service or -X.\n"),
#else
_("You must specify exactly one of -d, -i, -t or -X.\n"),
#endif
stderr, pool));
usage(argv[0], pool);
*exit_code = EXIT_FAILURE;
return SVN_NO_ERROR;
}
if (handling_opt_count > 1)
{
svn_error_clear(svn_cmdline_fputs(
_("You may only specify one of -T or --single-thread\n"),
stderr, pool));
usage(argv[0], pool);
*exit_code = EXIT_FAILURE;
return SVN_NO_ERROR;
}
/* construct object pools */
is_multi_threaded = handling_mode == connection_mode_thread;
params.fs_config = apr_hash_make(pool);
svn_hash_sets(params.fs_config, SVN_FS_CONFIG_FSFS_CACHE_DELTAS,
cache_txdeltas ? "1" :"0");
svn_hash_sets(params.fs_config, SVN_FS_CONFIG_FSFS_CACHE_FULLTEXTS,
cache_fulltexts ? "1" :"0");
svn_hash_sets(params.fs_config, SVN_FS_CONFIG_FSFS_CACHE_REVPROPS,
cache_revprops ? "2" :"0");
svn_hash_sets(params.fs_config, SVN_FS_CONFIG_FSFS_BLOCK_READ,
use_block_read ? "1" :"0");
SVN_ERR(svn_repos__config_pool_create(¶ms.config_pool,
is_multi_threaded,
pool));
SVN_ERR(svn_repos__authz_pool_create(¶ms.authz_pool,
params.config_pool,
is_multi_threaded,
pool));
/* If a configuration file is specified, load it and any referenced
* password and authorization files. */
if (config_filename)
{
params.base = svn_dirent_dirname(config_filename, pool);
SVN_ERR(svn_repos__config_pool_get(¶ms.cfg, NULL,
params.config_pool,
config_filename,
TRUE, /* must_exist */
FALSE, /* names_case_sensitive */
NULL,
pool));
}
if (log_filename)
SVN_ERR(logger__create(¶ms.logger, log_filename, pool));
else if (run_mode == run_mode_listen_once)
SVN_ERR(logger__create_for_stderr(¶ms.logger, pool));
if (params.tunnel_user && run_mode != run_mode_tunnel)
{
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Option --tunnel-user is only valid in tunnel mode"));
}
if (run_mode == run_mode_inetd || run_mode == run_mode_tunnel)
{
apr_pool_t *connection_pool;
svn_ra_svn_conn_t *conn;
svn_stream_t *stdin_stream;
svn_stream_t *stdout_stream;
params.tunnel = (run_mode == run_mode_tunnel);
apr_pool_cleanup_register(pool, pool, apr_pool_cleanup_null,
redirect_stdout);
SVN_ERR(svn_stream_for_stdin(&stdin_stream, pool));
SVN_ERR(svn_stream_for_stdout(&stdout_stream, pool));
/* Use a subpool for the connection to ensure that if SASL is used
* the pool cleanup handlers that call sasl_dispose() (connection_pool)
* and sasl_done() (pool) are run in the right order. See issue #3664. */
connection_pool = svn_pool_create(pool);
conn = svn_ra_svn_create_conn4(NULL, stdin_stream, stdout_stream,
params.compression_level,
params.zero_copy_limit,
params.error_check_interval,
connection_pool);
err = serve(conn, ¶ms, connection_pool);
svn_pool_destroy(connection_pool);
return err;
}
#ifdef WIN32
/* If svnserve needs to run as a Win32 service, then we need to
coordinate with the Service Control Manager (SCM) before
continuing. This function call registers the svnserve.exe
process with the SCM, waits for the "start" command from the SCM
(which will come very quickly), and confirms that those steps
succeeded.
After this call succeeds, the service is free to run. At some
point in the future, the SCM will send a message to the service,
requesting that it stop. This is translated into a call to
winservice_notify_stop(). The service is then responsible for
cleanly terminating.
We need to do this before actually starting the service logic
(opening files, sockets, etc.) because the SCM wants you to
connect *first*, then do your service-specific logic. If the
service process takes too long to connect to the SCM, then the
SCM will decide that the service is busted, and will give up on
it.
*/
if (run_mode == run_mode_service)
{
err = winservice_start();
if (err)
{
svn_handle_error2(err, stderr, FALSE, "svnserve: ");
/* This is the most common error. It means the user started
svnserve from a shell, and specified the --service
argument. svnserve cannot be started, as a service, in
this way. The --service argument is valid only valid if
svnserve is started by the SCM. */
if (err->apr_err ==
APR_FROM_OS_ERROR(ERROR_FAILED_SERVICE_CONTROLLER_CONNECT))
{
svn_error_clear(svn_cmdline_fprintf(stderr, pool,
_("svnserve: The --service flag is only valid if the"
" process is started by the Service Control Manager.\n")));
}
svn_error_clear(err);
*exit_code = EXIT_FAILURE;
return SVN_NO_ERROR;
}
/* The service is now in the "starting" state. Before the SCM will
consider the service "started", this thread must call the
winservice_running() function. */
}
#endif /* WIN32 */
/* Make sure we have IPV6 support first before giving apr_sockaddr_info_get
APR_UNSPEC, because it may give us back an IPV6 address even if we can't
create IPV6 sockets. */
#if APR_HAVE_IPV6
#ifdef MAX_SECS_TO_LINGER
/* ### old APR interface */
status = apr_socket_create(&sock, APR_INET6, SOCK_STREAM, pool);
#else
status = apr_socket_create(&sock, APR_INET6, SOCK_STREAM, APR_PROTO_TCP,
pool);
#endif
if (status == 0)
{
apr_socket_close(sock);
family = APR_UNSPEC;
if (prefer_v6)
{
if (host == NULL)
host = "::";
sockaddr_info_flags = APR_IPV6_ADDR_OK;
}
else
{
if (host == NULL)
host = "0.0.0.0";
sockaddr_info_flags = APR_IPV4_ADDR_OK;
}
}
#endif
status = apr_sockaddr_info_get(&sa, host, family, port,
sockaddr_info_flags, pool);
if (status)
{
return svn_error_wrap_apr(status, _("Can't get address info"));
}
#ifdef MAX_SECS_TO_LINGER
/* ### old APR interface */
status = apr_socket_create(&sock, sa->family, SOCK_STREAM, pool);
#else
status = apr_socket_create(&sock, sa->family, SOCK_STREAM, APR_PROTO_TCP,
pool);
#endif
if (status)
{
return svn_error_wrap_apr(status, _("Can't create server socket"));
}
/* Prevents "socket in use" errors when server is killed and quickly
* restarted. */
status = apr_socket_opt_set(sock, APR_SO_REUSEADDR, 1);
if (status)
{
return svn_error_wrap_apr(status, _("Can't set options on server socket"));
}
status = apr_socket_bind(sock, sa);
if (status)
{
return svn_error_wrap_apr(status, _("Can't bind server socket"));
}
status = apr_socket_listen(sock, ACCEPT_BACKLOG);
if (status)
{
return svn_error_wrap_apr(status, _("Can't listen on server socket"));
}
#if APR_HAS_FORK
if (run_mode != run_mode_listen_once && !foreground)
/* ### ignoring errors... */
apr_proc_detach(APR_PROC_DETACH_DAEMONIZE);
apr_signal(SIGCHLD, sigchld_handler);
#endif
#ifdef SIGPIPE
/* Disable SIGPIPE generation for the platforms that have it. */
apr_signal(SIGPIPE, SIG_IGN);
#endif
#ifdef SIGXFSZ
/* Disable SIGXFSZ generation for the platforms that have it, otherwise
* working with large files when compiled against an APR that doesn't have
* large file support will crash the program, which is uncool. */
apr_signal(SIGXFSZ, SIG_IGN);
#endif
if (pid_filename)
SVN_ERR(write_pid_file(pid_filename, pool));
#ifdef WIN32
status = apr_os_sock_get(&winservice_svnserve_accept_socket, sock);
if (status)
winservice_svnserve_accept_socket = INVALID_SOCKET;
/* At this point, the service is "running". Notify the SCM. */
if (run_mode == run_mode_service)
winservice_running();
#endif
/* Configure FS caches for maximum efficiency with svnserve.
* For pre-forked (i.e. multi-processed) mode of operation,
* keep the per-process caches smaller than the default.
* Also, apply the respective command line parameters, if given. */
{
svn_cache_config_t settings = *svn_cache_config_get();
if (params.memory_cache_size != -1)
settings.cache_size = params.memory_cache_size;
settings.single_threaded = TRUE;
if (handling_mode == connection_mode_thread)
{
#if APR_HAS_THREADS
settings.single_threaded = FALSE;
#else
/* No requests will be processed at all
* (see "switch (handling_mode)" code further down).
* But if they were, some other synchronization code
* would need to take care of securing integrity of
* APR-based structures. That would include our caches.
*/
#endif
}
svn_cache_config_set(&settings);
}
#if APR_HAS_THREADS
SVN_ERR(svn_root_pools__create(&connection_pools));
if (handling_mode == connection_mode_thread)
{
/* create the thread pool with a valid range of threads */
if (max_thread_count < 1)
max_thread_count = 1;
if (min_thread_count > max_thread_count)
min_thread_count = max_thread_count;
status = apr_thread_pool_create(&threads,
min_thread_count,
max_thread_count,
pool);
if (status)
{
return svn_error_wrap_apr(status, _("Can't create thread pool"));
}
/* let idle threads linger for a while in case more requests are
coming in */
apr_thread_pool_idle_wait_set(threads, THREADPOOL_THREAD_IDLE_LIMIT);
/* don't queue requests unless we reached the worker thread limit */
apr_thread_pool_threshold_set(threads, 0);
}
else
{
threads = NULL;
}
#endif
while (1)
{
connection_t *connection = NULL;
SVN_ERR(accept_connection(&connection, sock, ¶ms, handling_mode,
pool));
if (run_mode == run_mode_listen_once)
{
err = serve_socket(connection, connection->pool);
close_connection(connection);
return err;
}
switch (handling_mode)
{
case connection_mode_fork:
#if APR_HAS_FORK
status = apr_proc_fork(&proc, connection->pool);
if (status == APR_INCHILD)
{
/* the child would't listen to the main server's socket */
apr_socket_close(sock);
/* serve_socket() logs any error it returns, so ignore it. */
svn_error_clear(serve_socket(connection, connection->pool));
close_connection(connection);
return SVN_NO_ERROR;
}
else if (status != APR_INPARENT)
{
err = svn_error_wrap_apr(status, "apr_proc_fork");
logger__log_error(params.logger, err, NULL, NULL);
svn_error_clear(err);
}
#endif
break;
case connection_mode_thread:
/* Create a detached thread for each connection. That's not a
particularly sophisticated strategy for a threaded server, it's
little different from forking one process per connection. */
#if APR_HAS_THREADS
attach_connection(connection);
status = apr_thread_pool_push(threads, serve_thread, connection,
0, NULL);
if (status)
{
return svn_error_wrap_apr(status, _("Can't push task"));
}
#endif
break;
case connection_mode_single:
/* Serve one connection at a time. */
/* serve_socket() logs any error it returns, so ignore it. */
svn_error_clear(serve_socket(connection, connection->pool));
}
close_connection(connection);
}
/* NOTREACHED */
}
int main(int argc, char *argv[])
{
const char *OLDDB = NULL, *NEWDB = NULL;
const char *old_db, *new_db;
int i;
int opt;
char *alt_config = NULL;
while ((opt = getopt(argc, argv, "C:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
}
}
if ((argc - optind) != 4) {
strarray_t *backends = cyrusdb_backends();
char sep;
fprintf(stderr, "Usage: %s [-C altconfig] <old db> <old db backend> <new db> <new db backend>\n", argv[0]);
fprintf(stderr, "Usable Backends: ");
for(i=0, sep = ':'; i < backends->count; i++) {
fprintf(stderr, "%c %s", sep, strarray_nth(backends, i));
sep = ',';
}
strarray_free(backends);
fprintf(stderr, "\n");
exit(-1);
}
old_db = argv[optind];
new_db = argv[optind+2];
if (old_db[0] != '/' || new_db[0] != '/') {
printf("\nSorry, you cannot use this tool with relative path names.\n"
"This is because some database backends (mainly berkeley) do not\n"
"always do what you would expect with them.\n"
"\nPlease use absolute pathnames instead.\n\n");
exit(EC_OSERR);
}
OLDDB = argv[optind+1];
NEWDB = argv[optind+3];
if (NEWDB == OLDDB) {
fatal("no conversion required", EC_TEMPFAIL);
}
cyrus_init(alt_config, "cvt_cyrusdb", 0);
printf("Converting from %s (%s) to %s (%s)\n", old_db, OLDDB,
new_db, NEWDB);
cyrusdb_convert(old_db, new_db, OLDDB, NEWDB);
cyrus_done();
return 0;
}
int main(int argc, char **argv)
{
int opt, i, r;
char buf[MAX_MAILBOX_PATH+1];
char *alt_config = NULL;
int (*cb)(struct findall_data *, void *) = &do_examine;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:u:s:qc")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'u':
if(wantvalue) usage();
wantuid = 1;
wantvalue = atoi(optarg);
break;
case 's':
if(wantvalue) usage();
wantvalue = atoi(optarg);
break;
case 'q':
cb = &do_quota;
break;
case 'c':
cb = &do_compare;
break;
default:
usage();
}
}
cyrus_init(alt_config, "mbexamine", 0, 0);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&mbexamine_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
mboxlist_init(0);
mboxlist_open(NULL);
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
if (optind == argc) {
strlcpy(buf, "*", sizeof(buf));
mboxlist_findall(&mbexamine_namespace, buf, 1, 0, 0, cb, NULL);
}
for (i = optind; i < argc; i++) {
mboxlist_findall(&mbexamine_namespace, argv[i], 1, 0, 0, cb, NULL);
}
mboxlist_close();
mboxlist_done();
exit(0);
}
int main(int argc,char **argv)
{
int opt;
int i;
int fflag = 0;
int r, code = 0;
int do_report = 1;
char *alt_config = NULL, *domain = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:d:fqZ")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'q':
do_report = 0;
break;
case 'd':
domain = optarg;
break;
case 'f':
fflag = 1;
break;
/* deliberately undocumented option for testing */
case 'Z':
test_sync_mode = 1;
break;
default:
usage();
}
}
/* always report if not fixing, otherwise we do nothing */
if (!fflag)
do_report = 1;
cyrus_init(alt_config, "quota", 0, CONFIG_NEED_PARTITION_DATA);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace("a_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
if (config_getswitch(IMAPOPT_IMPROVED_MBOXLIST_SORT))
compar = bsearch_compare_mbox;
else
compar = strcmp;
/*
* Lock mailbox list to prevent mailbox creation/deletion
* during work
*/
mboxlist_init(0);
mboxlist_open(NULL);
quotadb_init(0);
quotadb_open(NULL);
quota_changelock();
if (!r)
r = buildquotalist(domain, argv+optind, argc-optind);
if (!r && fflag)
r = fixquotas(domain, argv+optind, argc-optind);
quota_changelockrelease();
if (r) code = convert_code(r);
else if (do_report) reportquota();
quotadb_close();
quotadb_done();
mboxlist_close();
mboxlist_done();
/* just for neatness */
for (i = 0; i < quota_num; i++)
free(quotaroots[i].name);
free(quotaroots);
cyrus_done();
return code;
}
int main(int argc, char *argv[])
{
extern char *optarg;
int opt;
char *alt_config = NULL, *port = "119";
const char *peer = NULL, *server = "localhost", *wildmat = "*";
char *authname = NULL, *password = NULL;
int psock = -1, ssock = -1;
struct protstream *pin, *pout, *sin, *sout;
char buf[BUFFERSIZE];
char sfile[1024] = "";
int fd = -1, i, offered, rejected, accepted, failed;
time_t stamp;
strarray_t resp = STRARRAY_INITIALIZER;
int newnews = 1;
char *datefmt = "%y%m%d %H%M%S";
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:s:w:f:a:p:ny")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 's': /* server */
server = xstrdup(optarg);
if ((port = strchr(server, ':')))
*port++ = '\0';
else
port = "119";
break;
case 'w': /* wildmat */
wildmat = optarg;
break;
case 'f': /* timestamp file */
snprintf(sfile, sizeof(sfile), "%s", optarg);
break;
case 'a': /* authname */
authname = optarg;
break;
case 'p': /* password */
password = optarg;
break;
case 'n': /* no newnews */
newnews = 0;
break;
case 'y': /* newsserver is y2k compliant */
datefmt = "%Y%m%d %H%M%S";
break;
default:
usage();
/* NOTREACHED */
}
}
if (argc - optind < 1) {
usage();
/* NOTREACHED */
}
peer = argv[optind++];
cyrus_init(alt_config, "fetchnews", 0, 0);
/* connect to the peer */
/* xxx configurable port number? */
if ((psock = init_net(peer, "119", &pin, &pout)) < 0) {
fprintf(stderr, "connection to %s failed\n", peer);
cyrus_done();
exit(-1);
}
/* read the initial greeting */
if (!prot_fgets(buf, sizeof(buf), pin) || strncmp("20", buf, 2)) {
syslog(LOG_ERR, "peer not available");
goto quit;
}
if (authname) {
/* authenticate to peer */
/* XXX this should be modified to support SASL and STARTTLS */
prot_printf(pout, "AUTHINFO USER %s\r\n", authname);
if (!prot_fgets(buf, sizeof(buf), pin)) {
syslog(LOG_ERR, "AUTHINFO USER terminated abnormally");
goto quit;
}
else if (!strncmp("381", buf, 3)) {
/* password required */
if (!password)
password = cyrus_getpass("Please enter the password: "******"failed to get password\n");
goto quit;
}
prot_printf(pout, "AUTHINFO PASS %s\r\n", password);
if (!prot_fgets(buf, sizeof(buf), pin)) {
syslog(LOG_ERR, "AUTHINFO PASS terminated abnormally");
goto quit;
}
}
if (strncmp("281", buf, 3)) {
/* auth failed */
goto quit;
}
}
/* change to reader mode - not always necessary, so ignore result */
prot_printf(pout, "MODE READER\r\n");
prot_fgets(buf, sizeof(buf), pin);
if (newnews) {
struct tm ctime, *ptime;
/* fetch the server's current time */
prot_printf(pout, "DATE\r\n");
if (!prot_fgets(buf, sizeof(buf), pin) || strncmp("111 ", buf, 4)) {
syslog(LOG_ERR, "error fetching DATE");
goto quit;
}
/* parse and normalize the server time */
memset(&ctime, 0, sizeof(struct tm));
sscanf(buf+4, "%4d%02d%02d%02d%02d%02d",
&ctime.tm_year, &ctime.tm_mon, &ctime.tm_mday,
&ctime.tm_hour, &ctime.tm_min, &ctime.tm_sec);
ctime.tm_year -= 1900;
ctime.tm_mon--;
ctime.tm_isdst = -1;
/* read the previous timestamp */
if (!sfile[0]) {
char oldfile[1024];
snprintf(sfile, sizeof(sfile), "%s/fetchnews.stamp", config_dir);
/* upgrade from the old stamp filename to the new */
snprintf(oldfile, sizeof(oldfile), "%s/newsstamp", config_dir);
rename(oldfile, sfile);
}
if ((fd = open(sfile, O_RDWR | O_CREAT, 0644)) == -1) {
syslog(LOG_ERR, "cannot open %s", sfile);
goto quit;
}
if (lock_nonblocking(fd) == -1) {
syslog(LOG_ERR, "cannot lock %s: %m", sfile);
goto quit;
}
if (read(fd, &stamp, sizeof(stamp)) < (int) sizeof(stamp)) {
/* XXX do something better here */
stamp = 0;
}
/* ask for new articles */
if (stamp) stamp -= 180; /* adjust back 3 minutes */
ptime = gmtime(&stamp);
ptime->tm_isdst = -1;
strftime(buf, sizeof(buf), datefmt, ptime);
prot_printf(pout, "NEWNEWS %s %s GMT\r\n", wildmat, buf);
if (!prot_fgets(buf, sizeof(buf), pin) || strncmp("230", buf, 3)) {
syslog(LOG_ERR, "peer doesn't support NEWNEWS");
newnews = 0;
}
/* prepare server's current time as new timestamp */
stamp = mktime(&ctime);
/* adjust for local timezone
XXX We need to do this because we use gmtime() above.
We can't change this, otherwise we'd be incompatible
with an old localtime timestamp.
*/
stamp += gmtoff_of(&ctime, stamp);
}
if (!newnews) {
prot_printf(pout, "LIST ACTIVE %s\r\n", wildmat);
if (!prot_fgets(buf, sizeof(buf), pin) || strncmp("215", buf, 3)) {
syslog(LOG_ERR, "peer doesn't support LIST ACTIVE");
goto quit;
}
}
/* process the NEWNEWS/LIST ACTIVE list */
while (prot_fgets(buf, sizeof(buf), pin)) {
if (buf[0] == '.') break;
strarray_append(&resp, buf);
}
if (buf[0] != '.') {
syslog(LOG_ERR, "%s terminated abnormally",
newnews ? "NEWNEWS" : "LIST ACTIVE");
goto quit;
}
if (!resp.count) {
/* nothing matches our wildmat */
goto quit;
}
/* connect to the server */
if ((ssock = init_net(server, port, &sin, &sout)) < 0) {
fprintf(stderr, "connection to %s failed\n", server);
goto quit;
}
/* read the initial greeting */
if (!prot_fgets(buf, sizeof(buf), sin) || strncmp("20", buf, 2)) {
syslog(LOG_ERR, "server not available");
goto quit;
}
/* fetch and store articles */
offered = rejected = accepted = failed = 0;
if (newnews) {
/* response is a list of msgids */
for (i = 0; i < resp.count; i++) {
/* find the end of the msgid */
*(strrchr(resp.data[i], '>') + 1) = '\0';
offered++;
if (fetch(resp.data[i], 1, pin, pout, sin, sout,
&rejected, &accepted, &failed)) {
goto quit;
}
}
/* write the current timestamp */
lseek(fd, 0, SEEK_SET);
if (write(fd, &stamp, sizeof(stamp)) < (int) sizeof(stamp))
syslog(LOG_ERR, "error writing %s", sfile);
lock_unlock(fd);
close(fd);
}
else {
char group[BUFFERSIZE], msgid[BUFFERSIZE], lastbuf[50];
const char *data;
unsigned long low, high, last, cur;
int start;
size_t datalen;
struct txn *tid = NULL;
newsrc_init(NULL, 0);
/*
* response is a list of groups.
* select each group, and STAT each article we haven't seen yet.
*/
for (i = 0; i < resp.count; i++) {
/* parse the LIST ACTIVE response */
sscanf(resp.data[i], "%s %lu %lu", group, &high, &low);
last = 0;
if (!cyrusdb_fetchlock(newsrc_db, group, strlen(group),
&data, &datalen, &tid)) {
last = strtoul(data, NULL, 10);
}
if (high <= last) continue;
/* select the group */
prot_printf(pout, "GROUP %s\r\n", group);
if (!prot_fgets(buf, sizeof(buf), pin)) {
syslog(LOG_ERR, "GROUP terminated abnormally");
continue;
}
else if (strncmp("211", buf, 3)) break;
for (start = 1, cur = low > last ? low : ++last;; cur++) {
if (start) {
/* STAT the first article we haven't seen */
prot_printf(pout, "STAT %lu\r\n", cur);
} else {
/* continue with the NEXT article */
prot_printf(pout, "NEXT\r\n");
}
if (!prot_fgets(buf, sizeof(buf), pin)) {
syslog(LOG_ERR, "STAT/NEXT terminated abnormally");
cur--;
break;
}
if (!strncmp("223", buf, 3)) {
/* parse the STAT/NEXT response */
sscanf(buf, "223 %lu %s", &cur, msgid);
/* find the end of the msgid */
*(strrchr(msgid, '>') + 1) = '\0';
if (fetch(msgid, 0, pin, pout, sin, sout,
&rejected, &accepted, &failed)) {
cur--;
break;
}
offered++;
start = 0;
}
/* have we reached the highwater mark? */
if (cur >= high) break;
}
snprintf(lastbuf, sizeof(lastbuf), "%lu", cur);
cyrusdb_store(newsrc_db, group, strlen(group),
lastbuf, strlen(lastbuf)+1, &tid);
}
if (tid) cyrusdb_commit(newsrc_db, tid);
newsrc_done();
}
syslog(LOG_NOTICE,
"fetchnews: %s offered %d; %s rejected %d, accepted %d, failed %d",
peer, offered, server, rejected, accepted, failed);
quit:
if (psock >= 0) {
prot_printf(pout, "QUIT\r\n");
prot_flush(pout);
/* Flush the incoming buffer */
prot_NONBLOCK(pin);
prot_fill(pin);
/* close/free socket & prot layer */
close(psock);
prot_free(pin);
prot_free(pout);
}
if (ssock >= 0) {
prot_printf(sout, "QUIT\r\n");
prot_flush(sout);
/* Flush the incoming buffer */
prot_NONBLOCK(sin);
prot_fill(sin);
/* close/free socket & prot layer */
close(psock);
prot_free(sin);
prot_free(sout);
}
cyrus_done();
return 0;
}
int main(int argc, char *argv[])
{
extern char *optarg;
int opt, r = 0;
char *alt_config = NULL, *intname = NULL, *extname = NULL;
struct mailbox *mailbox = NULL;
int mode = MODE_UNKNOWN;
unsigned numrestored = 0;
time_t time_since = time(NULL);
int len, secs = 0;
unsigned long *uids = NULL;
unsigned nuids = 0;
while ((opt = getopt(argc, argv, "C:laudt:f:v")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'l':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_LIST;
break;
case 'a':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_ALL;
break;
case 't':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_TIME;
secs = atoi(optarg);
len = strlen(optarg);
if ((secs > 0) && (len > 1)) {
switch (optarg[len-1]) {
case 'm':
secs *= 60;
break;
case 'h':
secs *= (60*60);
break;
case 'd':
secs *= (24*60*60);
break;
case 'w':
secs *= (7*24*60*60);
break;
}
}
time_since = time(NULL) - secs;
break;
case 'u':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_UID;
break;
case 'd':
unsetdeleted = 1;
break;
case 'f':
addflag = optarg;
break;
case 'v':
verbose = 1;
break;
default:
usage();
break;
}
}
/* sanity check */
if (mode == MODE_UNKNOWN ||
(optind + (mode == MODE_UID ? 1 : 0)) >= argc) usage();
cyrus_init(alt_config, "unexpunge", 0, 0);
sync_log_init();
if (addflag && addflag[0] == '\\') {
syslog(LOG_ERR, "can't set a system flag");
fatal("can't set a system flag", EX_SOFTWARE);
}
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&unex_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EX_CONFIG);
}
/* Translate mailboxname */
intname = mboxname_from_external(argv[optind], &unex_namespace, NULL);
if (mode == MODE_LIST) {
list_expunged(intname);
goto done;
}
/* Open/lock header */
r = mailbox_open_iwl(intname, &mailbox);
if (r) {
printf("Failed to open mailbox '%s'\n", intname);
goto done;
}
if (mode == MODE_UID) {
unsigned i;
nuids = argc - ++optind;
uids = (unsigned long *) xmalloc(nuids * sizeof(unsigned long));
for (i = 0; i < nuids; i++)
uids[i] = strtoul(argv[optind+i], NULL, 10);
/* Sort the UIDs so we can binary search */
qsort(uids, nuids, sizeof(unsigned long), compare_uid);
}
extname = mboxname_to_external(intname, &unex_namespace, NULL);
printf("restoring %sexpunged messages in mailbox '%s'\n",
mode == MODE_ALL ? "all " : "", extname);
r = restore_expunged(mailbox, mode, uids, nuids, time_since, &numrestored, extname);
if (!r) {
printf("restored %u expunged messages\n",
numrestored);
syslog(LOG_NOTICE,
"restored %u expunged messages in mailbox '%s'",
numrestored, extname);
}
mailbox_close(&mailbox);
done:
free(intname);
free(extname);
sync_log_done();
cyrus_done();
exit(r);
}
int main(int argc, char *argv[])
{
char *alt_config = NULL;
char cmd = '\0';
int opt;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:uUvmMacqnsb")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'u': /* User */
cmd = 'u';
break;
case 'U': /* UnUser */
cmd = 'U';
break;
case 'v': /* sieVe */
cmd = 'v';
break;
case 'm': /* Mailbox */
cmd = 'm';
break;
case 'M': /* UnMailbox */
cmd = 'M';
break;
case 'a': /* Append */
cmd = 'a';
break;
case 'c': /* aCl */
cmd = 'c';
break;
case 'q': /* Quota */
cmd = 'q';
break;
case 'n': /* aNnotation */
cmd = 'n';
break;
case 's': /* Seen */
cmd = 's';
break;
case 'b': /* suBscription */
cmd = 'b';
break;
}
}
/* need at least one value */
if ((argc - optind) < 1) usage(argv[0]);
/* and not an empty string */
if (!argv[optind][0]) usage(argv[0]);
if (cmd == 's' || cmd == 'b') {
/* need a second value */
if ((argc - optind) < 2) usage(argv[0]);
/* and not an empty string */
if (!argv[optind+1][0]) usage(argv[0]);
}
cyrus_init(alt_config, "cyr_synclog", 0, 0);
sync_log_init();
switch(cmd) {
case 'u': /* User */
sync_log_user(argv[optind]);
break;
case 'U': /* UnUser */
sync_log_unuser(argv[optind]);
break;
case 'v': /* sieVe */
sync_log_sieve(argv[optind]);
break;
case 'm': /* Mailbox */
sync_log_mailbox(argv[optind]);
break;
case 'M': /* UnMailbox */
sync_log_unmailbox(argv[optind]);
break;
case 'q': /* Quota */
sync_log_quota(argv[optind]);
break;
case 'n': /* aNnotation */
sync_log_annotation(argv[optind]);
break;
case 's': /* Seen */
sync_log_seen(argv[optind], argv[optind+1]);
break;
case 'b': /* suBscription */
sync_log_subscribe(argv[optind], argv[optind+1]);
break;
default:
/* just as is! */
sync_log(argv[optind]);
break;
}
sync_log_done();
cyrus_done();
return 0;
}
int main(int argc, char *argv[])
{
extern char *optarg;
int opt, r = 0;
char *alt_config = NULL;
char buf[MAX_MAILBOX_PATH+1];
struct mailbox *mailbox = NULL;
int mode = MODE_UNKNOWN;
unsigned numrestored = 0;
time_t time_since = time(NULL);
int len, secs = 0;
unsigned long *uids = NULL;
unsigned nuids = 0;
char *mboxname = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:laudt:v")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'l':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_LIST;
break;
case 'a':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_ALL;
break;
case 't':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_TIME;
secs = atoi(optarg);
len = strlen(optarg);
if ((secs > 0) && (len > 1)) {
switch (optarg[len-1]) {
case 'm':
secs *= 60;
break;
case 'h':
secs *= (60*60);
break;
case 'd':
secs *= (24*60*60);
break;
case 'w':
secs *= (7*24*60*60);
break;
}
}
time_since = time(NULL) - secs;
break;
case 'u':
if (mode != MODE_UNKNOWN) usage();
mode = MODE_UID;
break;
case 'd':
unsetdeleted = 1;
break;
case 'v':
verbose = 1;
break;
default:
usage();
break;
}
}
/* sanity check */
if (mode == MODE_UNKNOWN ||
(optind + (mode == MODE_UID ? 1 : 0)) >= argc) usage();
cyrus_init(alt_config, "unexpunge", 0, 0);
mboxlist_init(0);
mboxlist_open(NULL);
quotadb_init(0);
quotadb_open(NULL);
sync_log_init();
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&unex_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
/* Translate mailboxname */
(*unex_namespace.mboxname_tointernal)(&unex_namespace, argv[optind],
NULL, buf);
if (mode == MODE_LIST) {
list_expunged(buf);
goto done;
}
/* Open/lock header */
r = mailbox_open_iwl(buf, &mailbox);
if (r) {
printf("Failed to open mailbox '%s'\n", buf);
goto done;
}
if (mode == MODE_UID) {
unsigned i;
nuids = argc - ++optind;
uids = (unsigned long *) xmalloc(nuids * sizeof(unsigned long));
for (i = 0; i < nuids; i++)
uids[i] = strtoul(argv[optind+i], NULL, 10);
/* Sort the UIDs so we can binary search */
qsort(uids, nuids, sizeof(unsigned long), compare_uid);
}
mboxname = xstrdup(mailbox->name);
mboxname_hiersep_toexternal(&unex_namespace, mboxname, 0);
printf("restoring %sexpunged messages in mailbox '%s'\n",
mode == MODE_ALL ? "all " : "", mboxname);
r = restore_expunged(mailbox, mode, uids, nuids, time_since, &numrestored, mboxname);
if (!r) {
printf("restored %u expunged messages\n",
numrestored);
syslog(LOG_NOTICE,
"restored %u expunged messages in mailbox '%s'",
numrestored, mboxname);
}
mailbox_close(&mailbox);
done:
sync_log_done();
quotadb_close();
quotadb_done();
mboxlist_close();
mboxlist_done();
cyrus_done();
exit(r);
}
int main(int argc, char **argv)
{
int opt, i, r;
int dousers = 0;
int rflag = 0;
int mflag = 0;
int fflag = 0;
int xflag = 0;
char buf[MAX_MAILBOX_PATH+1];
strarray_t discovered = STRARRAY_INITIALIZER;
char *alt_config = NULL;
char *start_part = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
construct_hash_table(&unqid_table, 2047, 1);
while ((opt = getopt(argc, argv, "C:kp:rmfsxgGqRUMoOnV:u")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'p':
start_part = optarg;
break;
case 'r':
rflag = 1;
break;
case 'u':
dousers = 1;
break;
case 'm':
mflag = 1;
break;
case 'n':
reconstruct_flags &= ~RECONSTRUCT_MAKE_CHANGES;
break;
case 'g':
fprintf(stderr, "reconstruct: deprecated option -g ignored\n");
break;
case 'G':
reconstruct_flags |= RECONSTRUCT_ALWAYS_PARSE;
break;
case 'f':
fflag = 1;
break;
case 'x':
xflag = 1;
break;
case 'k':
fprintf(stderr, "reconstruct: deprecated option -k ignored\n");
break;
case 's':
reconstruct_flags &= ~RECONSTRUCT_DO_STAT;
break;
case 'q':
reconstruct_flags |= RECONSTRUCT_QUIET;
break;
case 'R':
reconstruct_flags |= RECONSTRUCT_GUID_REWRITE;
break;
case 'U':
reconstruct_flags |= RECONSTRUCT_GUID_UNLINK;
break;
case 'o':
reconstruct_flags |= RECONSTRUCT_IGNORE_ODDFILES;
break;
case 'O':
reconstruct_flags |= RECONSTRUCT_REMOVE_ODDFILES;
break;
case 'M':
reconstruct_flags |= RECONSTRUCT_PREFER_MBOXLIST;
break;
case 'V':
if (!strcasecmp(optarg, "max"))
setversion = MAILBOX_MINOR_VERSION;
else
setversion = atoi(optarg);
break;
default:
usage();
}
}
cyrus_init(alt_config, "reconstruct", 0, CONFIG_NEED_PARTITION_DATA);
global_sasl_init(1,0,NULL);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&recon_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
sync_log_init();
if (mflag) {
if (rflag || fflag || optind != argc) {
cyrus_done();
usage();
}
do_mboxlist();
}
mboxlist_init(0);
mboxlist_open(NULL);
quotadb_init(0);
quotadb_open(NULL);
#ifdef WITH_DAV
caldav_init();
carddav_init();
webdav_init();
#endif
/* Deal with nonexistent mailboxes */
if (start_part) {
/* We were handed a mailbox that does not exist currently */
if(optind == argc) {
fprintf(stderr,
"When using -p, you must specify a mailbox to attempt to reconstruct.");
exit(EC_USAGE);
}
/* do any of the mailboxes exist in mboxlist already? */
/* Do they look like mailboxes? */
for (i = optind; i < argc; i++) {
if (strchr(argv[i],'%') || strchr(argv[i],'*')) {
fprintf(stderr, "Using wildcards with -p is not supported.\n");
exit(EC_USAGE);
}
/* Translate mailboxname */
char *intname = mboxname_from_external(argv[i], &recon_namespace, NULL);
/* Does it exist */
do {
r = mboxlist_lookup(intname, NULL, NULL);
} while (r == IMAP_AGAIN);
if (r != IMAP_MAILBOX_NONEXISTENT) {
fprintf(stderr,
"Mailbox %s already exists. Cannot specify -p.\n",
argv[i]);
exit(EC_USAGE);
}
free(intname);
}
/* None of them exist. Create them. */
for (i = optind; i < argc; i++) {
/* Translate mailboxname */
char *intname = mboxname_from_external(argv[i], &recon_namespace, NULL);
/* don't notify mailbox creation here */
r = mboxlist_createmailbox(intname, 0, start_part, 1,
"cyrus", NULL, 0, 0, !xflag, 0, NULL);
if (r) {
fprintf(stderr, "could not create %s\n", argv[i]);
}
free(intname);
}
}
/* Normal Operation */
if (optind == argc) {
if (rflag || dousers) {
fprintf(stderr, "please specify a mailbox to recurse from\n");
cyrus_done();
exit(EC_USAGE);
}
assert(!rflag);
strlcpy(buf, "*", sizeof(buf));
mboxlist_findall(&recon_namespace, buf, 1, 0, 0,
do_reconstruct, NULL);
}
for (i = optind; i < argc; i++) {
if (dousers) {
mboxlist_usermboxtree(argv[i], do_reconstruct_p, NULL, MBOXTREE_TOMBSTONES|MBOXTREE_DELETED);
continue;
}
char *domain = NULL;
/* save domain */
if (config_virtdomains) domain = strchr(argv[i], '@');
strlcpy(buf, argv[i], sizeof(buf));
/* reconstruct the first mailbox/pattern */
mboxlist_findall(&recon_namespace, buf, 1, 0,
0, do_reconstruct,
fflag ? &discovered : NULL);
if (rflag) {
/* build a pattern for submailboxes */
char *p = strchr(buf, '@');
if (p) *p = '\0';
strlcat(buf, ".*", sizeof(buf));
/* append the domain */
if (domain) strlcat(buf, domain, sizeof(buf));
/* reconstruct the submailboxes */
mboxlist_findall(&recon_namespace, buf, 1, 0,
0, do_reconstruct,
fflag ? &discovered : NULL);
}
}
/* examine our list to see if we discovered anything */
while (discovered.count) {
char *name = strarray_shift(&discovered);
int r = 0;
/* create p (database only) and reconstruct it */
/* partition is defined by the parent mailbox */
/* don't notify mailbox creation here */
r = mboxlist_createmailbox(name, 0, NULL, 1,
"cyrus", NULL, 0, 0, !xflag, 0, NULL);
if (r) {
fprintf(stderr, "createmailbox %s: %s\n",
name, error_message(r));
} else {
mboxlist_findone(&recon_namespace, name, 1, 0,
0, do_reconstruct,
&discovered);
}
/* may have added more things into our list */
free(name);
}
free_hash_table(&unqid_table, free);
sync_log_done();
mboxlist_close();
mboxlist_done();
quotadb_close();
quotadb_done();
partlist_local_done();
#ifdef WITH_DAV
webdav_done();
carddav_done();
caldav_done();
#endif
cyrus_done();
strarray_fini(&discovered);
return 0;
}
int main(int argc, char *argv[])
{
extern char *optarg;
int opt, r = 0;
char *alt_file = NULL;
char *alt_config = NULL;
char *days = NULL;
int flag = 0;
enum { DUMP, PRUNE, NONE } op = NONE;
if (geteuid() == 0) fatal("must run as the Cyrus user", EC_USAGE);
while ((opt = getopt(argc, argv, "C:drE:f:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'd':
if (op == NONE) op = DUMP;
else usage();
break;
case 'f':
if (alt_file == NULL) alt_file = optarg;
else usage ();
break;
case 'E':
if (op == NONE) op = PRUNE;
else usage();
/* deprecated, but we still support it */
days = optarg;
break;
default:
usage();
break;
}
}
switch (op) {
case PRUNE: {
char buf[4096];
fprintf(stderr, "ctl_deliver -E is deprecated: "
"using cyr_expire -E instead\n");
r = snprintf(buf, sizeof(buf), "%s/cyr_expire", SERVICE_PATH);
if(r < 0 || r >= sizeof(buf)) {
fatal("cyr_expire command buffer not sufficiently big", EC_CONFIG);
}
if (alt_config)
execl(buf, buf, "-C", alt_config, "-E", days, NULL);
else
execl(buf, buf, "-E", days, NULL);
break;
}
case DUMP:
cyrus_init(alt_config, "ctl_deliver", 0);
if (duplicate_init(alt_file, flag) != 0) {
fprintf(stderr,
"ctl_deliver: unable to init duplicate delivery database\n");
exit(1);
}
printf("it is NOW: %d\n", (int) time(NULL));
printf("got %d entries\n", duplicate_dump(stdout));
r = 0;
duplicate_done();
cyrus_done();
break;
case NONE:
r = 2;
usage();
break;
}
return r;
}
int main(int argc, char *argv[])
{
const char *alt_config = NULL;
unsigned maxval = 0;
int flags = SEQ_MERGE;
struct seqset *seq = NULL;
int opt;
unsigned num;
char *res;
const char *origlist = NULL;
while ((opt = getopt(argc, argv, "C:m:o:s")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'm': /* maxval */
parseuint32(optarg, NULL, &maxval);
break;
case 'o':
origlist = optarg;
break;
case 's':
flags = SEQ_SPARSE;
}
}
if ((argc - optind) < 1) usage(argv[0]);
cyrus_init(alt_config, "cyr_sequence", 0);
/* special case */
if (!strcmp(argv[optind], "create")) {
int i;
seq = seqset_init(maxval, flags);
for (i = optind + 1; i < argc; i++) {
char *ptr = argv[i];
int isadd = 1;
if (*ptr == '~') {
isadd = 0;
ptr++;
}
if (parseuint32(ptr, NULL, &num))
printf("%s NAN\n", argv[i]);
else
seqset_add(seq, num, isadd);
}
if (origlist) {
unsigned oldmax = seq_lastnum(origlist, NULL);
if (oldmax > maxval) {
struct seqset *origseq = seqset_parse(origlist, NULL, oldmax);
unsigned val;
for (val = maxval + 1; val <= oldmax; val++)
seqset_add(seq, val, seqset_ismember(origseq, val));
seqset_free(origseq);
}
}
res = seqset_cstring(seq);
printf("%s\n", res);
free(res);
}
else if (!strcmp(argv[optind], "parsed")) {
unsigned i;
seq = seqset_parse(argv[optind+1], NULL, maxval);
printf("Sections: " SIZE_T_FMT "\n", seq->len);
for (i = 0; i < seq->len; i++) {
if (seq->set[i].high == UINT_MAX)
printf(" [%u, *]\n", seq->set[i].low);
else
printf(" [%u, %u]\n", seq->set[i].low, seq->set[i].high);
}
}
else if (!strcmp(argv[optind], "compress")) {
seq = seqset_parse(argv[optind+1], NULL, maxval);
res = seqset_cstring(seq);
printf("%s\n", res);
free(res);
}
else if (!strcmp(argv[optind], "members")) {
seq = seqset_parse(argv[optind+1], NULL, maxval);
while ((num = seqset_getnext(seq))) {
printf("%u\n", num);
}
}
else if (!strcmp(argv[optind], "join")) {
struct seqset *seq2;
seq = seqset_parse(argv[optind+1], NULL, maxval);
seq2 = seqset_parse(argv[optind+2], NULL, maxval);
seqset_join(seq, seq2);
res = seqset_cstring(seq);
printf("%s\n", res);
free(res);
}
else if (!strcmp(argv[optind], "ismember")) {
int i;
seq = seqset_parse(argv[optind+1], NULL, maxval);
for (i = optind + 2; i < argc; i++) {
if (parseuint32(argv[i], NULL, &num))
printf("%s NAN\n", argv[i]);
else
printf("%d %s\n", num, seqset_ismember(seq, num) ? "Yes" : "No");
}
}
else {
printf("Unknown command %s", argv[optind]);
}
seqset_free(seq);
cyrus_done();
return 0;
}
int main(int argc, char **argv)
{
int opt, r = 0;
char *alt_config = NULL, *pub = NULL, *ver = NULL, *winfile = NULL;
char prefix[2048];
enum { REBUILD, WINZONES, NONE } op = NONE;
if ((geteuid()) == 0 && (become_cyrus(/*ismaster*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:r:vw:")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'r':
if (op == NONE) {
op = REBUILD;
pub = optarg;
ver = strchr(optarg, ':');
if (ver) *ver++ = '\0';
else usage();
}
else usage();
break;
case 'v':
verbose = 1;
break;
case 'w':
if (op == NONE) {
op = WINZONES;
winfile = optarg;
}
else usage();
break;
default:
usage();
}
}
cyrus_init(alt_config, "ctl_zoneinfo", 0, 0);
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
snprintf(prefix, sizeof(prefix), "%s%s", config_dir, FNAME_ZONEINFODIR);
switch (op) {
case REBUILD: {
struct hash_table tzentries;
struct zoneinfo *info;
struct txn *tid = NULL;
char buf[1024];
FILE *fp;
construct_hash_table(&tzentries, 500, 1);
/* Add INFO record (overall lastmod and TZ DB source version) */
info = xzmalloc(sizeof(struct zoneinfo));
info->type = ZI_INFO;
appendstrlist(&info->data, pub);
appendstrlist(&info->data, ver);
hash_insert(INFO_TZID, info, &tzentries);
/* Add LEAP record (last updated and hash) */
snprintf(buf, sizeof(buf), "%s%s", prefix, FNAME_LEAPSECFILE);
if (verbose) printf("Processing leap seconds file %s\n", buf);
if (!(fp = fopen(buf, "r"))) {
fprintf(stderr, "Could not open leap seconds file %s\n", buf);
}
else {
struct zoneinfo *leap = xzmalloc(sizeof(struct zoneinfo));
leap->type = ZI_INFO;
while(fgets(buf, sizeof(buf), fp)) {
if (buf[0] == '#') {
/* comment line */
if (buf[1] == '$') {
/* last updated */
unsigned long last;
sscanf(buf+2, "\t%lu", &last);
leap->dtstamp = last - NIST_EPOCH_OFFSET;
}
else if (buf[1] == 'h') {
/* hash */
char *p, *hash = buf+3 /* skip "#h\t" */;
/* trim trailing whitespace */
for (p = hash + strlen(hash); isspace(*--p); *p = '\0');
appendstrlist(&leap->data, hash);
}
}
}
fclose(fp);
hash_insert(LEAP_TZID, leap, &tzentries);
info->dtstamp = leap->dtstamp;
}
/* Add ZONE/LINK records */
do_zonedir(prefix, &tzentries, info);
zoneinfo_open(NULL);
/* Store records */
hash_enumerate(&tzentries, &store_zoneinfo, &tid);
zoneinfo_close(tid);
free_hash_table(&tzentries, &free_zoneinfo);
break;
}
case WINZONES: {
xmlParserCtxtPtr ctxt;
xmlDocPtr doc;
xmlNodePtr node;
struct buf tzidbuf = BUF_INITIALIZER;
struct buf aliasbuf = BUF_INITIALIZER;
if (verbose) printf("Processing Windows Zone file %s\n", winfile);
/* Parse the XML file */
ctxt = xmlNewParserCtxt();
if (!ctxt) {
fprintf(stderr, "Failed to create XML parser context\n");
break;
}
doc = xmlCtxtReadFile(ctxt, winfile, NULL, 0);
xmlFreeParserCtxt(ctxt);
if (!doc) {
fprintf(stderr, "Failed to parse XML document\n");
break;
}
node = xmlDocGetRootElement(doc);
if (!node || xmlStrcmp(node->name, BAD_CAST "supplementalData")) {
fprintf(stderr, "Incorrect root node\n");
goto done;
}
for (node = xmlFirstElementChild(node);
node && xmlStrcmp(node->name, BAD_CAST "windowsZones");
node = xmlNextElementSibling(node));
if (!node) {
fprintf(stderr, "Missing windowsZones node\n");
goto done;
}
node = xmlFirstElementChild(node);
if (!node || xmlStrcmp(node->name, BAD_CAST "mapTimezones")) {
fprintf(stderr, "Missing mapTimezones node\n");
goto done;
}
if (chdir(prefix)) {
fprintf(stderr, "chdir(%s) failed\n", prefix);
goto done;
}
for (node = xmlFirstElementChild(node);
node;
node = xmlNextElementSibling(node)) {
if (!xmlStrcmp(node->name, BAD_CAST "mapZone") &&
!xmlStrcmp(xmlGetProp(node, BAD_CAST "territory"),
BAD_CAST "001")) {
const char *tzid, *alias;
buf_setcstr(&tzidbuf,
(const char *) xmlGetProp(node, BAD_CAST "type"));
buf_appendcstr(&tzidbuf, ".ics");
tzid = buf_cstring(&tzidbuf);
buf_setcstr(&aliasbuf,
(const char *) xmlGetProp(node, BAD_CAST "other"));
buf_appendcstr(&aliasbuf, ".ics");
alias = buf_cstring(&aliasbuf);
if (verbose) printf("\tLINK: %s -> %s\n", alias, tzid);
if (symlink(tzid, alias)) {
if (errno == EEXIST) {
struct stat sbuf;
if (stat(alias, &sbuf)) {
fprintf(stderr, "stat(%s) failed: %s\n",
alias, strerror(errno));
errno = EEXIST;
}
else if (sbuf.st_mode & S_IFLNK) {
char link[MAX_MAILBOX_PATH+1];
int n = readlink(alias, link, MAX_MAILBOX_PATH);
if (n == -1) {
fprintf(stderr, "readlink(%s) failed: %s\n",
alias, strerror(errno));
errno = EEXIST;
}
else if (n == (int) strlen(tzid) &&
!strncmp(tzid, link, n)) {
errno = 0;
}
}
}
if (errno) {
fprintf(stderr, "symlink(%s, %s) failed: %s\n",
tzid, alias, strerror(errno));
}
}
}
}
done:
buf_free(&aliasbuf);
buf_free(&tzidbuf);
xmlFreeDoc(doc);
break;
}
case NONE:
r = 2;
usage();
break;
}
cyrus_done();
return r;
}
int main(int argc, char **argv)
{
int opt, i, r;
char buf[MAX_MAILBOX_PATH+1];
char *alt_config = NULL;
int quotachk = 0;
if ((geteuid()) == 0 && (become_cyrus() != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
/* Ensure we're up-to-date on the index file format */
assert(INDEX_HEADER_SIZE == (OFFSET_HEADER_CRC+4));
assert(INDEX_RECORD_SIZE == (OFFSET_RECORD_CRC+4));
while ((opt = getopt(argc, argv, "C:u:s:q")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'u':
if(wantvalue) usage();
wantuid = 1;
wantvalue = atoi(optarg);
break;
case 's':
if(wantvalue) usage();
wantvalue = atoi(optarg);
break;
case 'q':
quotachk = 1;
break;
default:
usage();
}
}
cyrus_init(alt_config, "mbexamine", 0);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&recon_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
mboxlist_init(0);
mboxlist_open(NULL);
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
if (optind == argc) {
strlcpy(buf, "*", sizeof(buf));
(*recon_namespace.mboxlist_findall)(&recon_namespace, buf, 1, 0, 0,
quotachk ? do_quota : do_examine,
NULL);
}
for (i = optind; i < argc; i++) {
/* Handle virtdomains and separators in mailboxname */
(*recon_namespace.mboxname_tointernal)(&recon_namespace, argv[i],
NULL, buf);
(*recon_namespace.mboxlist_findall)(&recon_namespace, buf, 1, 0, 0,
quotachk ? do_quota : do_examine,
NULL);
}
mboxlist_close();
mboxlist_done();
exit(code);
}
int main(int argc, char **argv)
{
int opt;
pid_t pid;
char *alt_config = NULL;
time_t runattime = 0;
int upgrade = 0;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((opt = getopt(argc, argv, "C:dt:U")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'd': /* don't fork. debugging mode */
debugmode = 1;
break;
case 't': /* run a single scan at this time */
runattime = atoi(optarg);
break;
case 'U':
upgrade = 1;
break;
default:
fprintf(stderr, "invalid argument\n");
exit(EC_USAGE);
break;
}
}
cyrus_init(alt_config, "calalarmd", 0, 0);
mboxlist_init(0);
mboxlist_open(NULL);
quotadb_init(0);
quotadb_open(NULL);
annotatemore_open();
caldav_init();
mboxevent_init();
if (upgrade) {
caldav_alarm_upgrade();
shut_down(0);
}
if (runattime) {
caldav_alarm_process(runattime);
shut_down(0);
}
signals_set_shutdown(shut_down);
signals_add_handlers(0);
/* fork unless we were given the -d option or we're running as a daemon */
if (debugmode == 0 && !getenv("CYRUS_ISDAEMON")) {
pid = fork();
if (pid == -1) {
perror("fork");
exit(1);
}
if (pid != 0) { /* parent */
exit(0);
}
}
/* child */
for (;;) {
struct timeval start, end;
double totaltime;
int tosleep;
signals_poll();
gettimeofday(&start, 0);
caldav_alarm_process(0);
gettimeofday(&end, 0);
signals_poll();
totaltime = timesub(&start, &end);
tosleep = 10 - (int) (totaltime + 0.5); /* round to nearest int */
if (tosleep > 0)
sleep(tosleep);
}
/* NOTREACHED */
shut_down(1);
}
int main (int argc, char *argv[]) {
int option; /* getopt() returns an int */
char buf[MAX_MAILBOX_PATH+1];
char *alt_config = NULL;
int r;
if ((geteuid()) == 0 && (become_cyrus() != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((option = getopt(argc, argv, "C:rn")) != EOF) {
switch (option) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'r':
disinfect = 1;
break;
case 'n':
notify = 1;
break;
case 'h':
default: usage(argv[0]);
}
}
cyrus_init(alt_config, "cyr_virusscan", 0);
if (!engine.name) {
fatal("no virus scanner configured", EC_SOFTWARE);
} else {
if (verbose) printf("Using %s virus scanner\n", engine.name);
}
engine.state = engine.init();
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&scan_namespace, 1)) != 0) {
syslog(LOG_ERR, "%s", error_message(r));
fatal(error_message(r), EC_CONFIG);
}
mboxlist_init(0);
mboxlist_open(NULL);
/* open the quota db, we'll need it for expunge */
quotadb_init(0);
quotadb_open(NULL);
sync_log_init();
if (optind == argc) { /* do the whole partition */
strcpy(buf, "*");
(*scan_namespace.mboxlist_findall)(&scan_namespace, buf, 1, 0, 0,
scan_me, NULL);
} else {
for (; optind < argc; optind++) {
strncpy(buf, argv[optind], MAX_MAILBOX_BUFFER);
/* Translate any separators in mailboxname */
mboxname_hiersep_tointernal(&scan_namespace, buf,
config_virtdomains ?
strcspn(buf, "@") : 0);
(*scan_namespace.mboxlist_findall)(&scan_namespace, buf, 1, 0, 0,
scan_me, NULL);
}
}
if (notify) append_notifications();
sync_log_done();
quotadb_close();
quotadb_done();
mboxlist_close();
mboxlist_done();
engine.destroy(engine.state);
cyrus_done();
return 0;
}
int main(int argc, char **argv)
{
int r = 0;
int opt;
int lmtpflag = 0;
int ignorequota = 0;
char *mailboxname = NULL;
char *authuser = NULL;
char *return_path = NULL;
char buf[1024];
char *alt_config = NULL;
while ((opt = getopt(argc, argv, "C:df:r:m:a:F:eE:lqD")) != EOF) {
switch(opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'd':
/* Ignore -- /bin/mail compatibility flags */
break;
case 'D':
logdebug = 1;
break;
case 'r':
case 'f':
return_path = optarg;
break;
case 'm':
if (mailboxname) {
fprintf(stderr, "deliver: multiple -m options\n");
usage();
/* NOTREACHED */
}
if (*optarg) mailboxname = optarg;
break;
case 'a':
if (authuser) {
fprintf(stderr, "deliver: multiple -a options\n");
usage();
/* NOTREACHED */
}
authuser = optarg;
break;
case 'F': /* set IMAP flag. we no longer support this */
fprintf(stderr,"deliver: 'F' option no longer supported\n");
usage();
break;
case 'e':
/* duplicate delivery. ignore */
break;
case 'E':
fprintf(stderr,"deliver: 'E' option no longer supported\n");
usage();
break;
case 'l':
lmtpflag = 1;
break;
case 'q':
ignorequota = 1;
break;
default:
usage();
/* NOTREACHED */
}
}
deliver_in = prot_new(0, 0);
deliver_out = prot_new(1, 1);
prot_setflushonread(deliver_in, deliver_out);
prot_settimeout(deliver_in, 300);
cyrus_init(alt_config, "deliver", CYRUSINIT_NODB);
sockaddr = config_getstring(IMAPOPT_LMTPSOCKET);
if (!sockaddr) {
strlcpy(buf, config_dir, sizeof(buf));
strlcat(buf, "/socket/lmtp", sizeof(buf));
sockaddr = buf;
}
if (lmtpflag == 1) {
struct backend *conn = init_net(sockaddr);
pipe_through(conn);
backend_disconnect(conn);
free(conn);
}
else {
if (return_path == NULL) {
uid_t me = getuid();
struct passwd *p = getpwuid(me);
return_path = p->pw_name;
}
/* deliver to users or global mailbox */
r = deliver_msg(return_path,authuser, ignorequota,
argv+optind, argc - optind, mailboxname);
}
cyrus_done();
return r;
}
int
main(int argc, char **argv)
{
char *path, *mpath;
int rc, i, quiet = 0, stop_on_error=0, metadata=0;
int opt; /* getopt() returns an int */
char *alt_config = NULL;
char buf[MAX_MAILBOX_PATH+1];
if (geteuid() == 0) fatal("must run as the Cyrus user", EC_USAGE);
while ((opt = getopt(argc, argv, "C:qsm")) != EOF) {
switch(opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'q':
quiet = 1;
break;
case 's':
stop_on_error = 1;
break;
case 'm':
metadata = 1;
break;
default:
usage();
}
}
cyrus_init(alt_config, "mbpath", 0);
if ((rc = mboxname_init_namespace(&mbpath_namespace, 1)) != 0) {
fatal(error_message(rc), -1);
}
mboxlist_init(0);
mboxlist_open(NULL);
for (i = optind; i < argc; i++) {
(void)memset(&path, 0, sizeof(path));
/* Translate mailboxname */
(*mbpath_namespace.mboxname_tointernal)(&mbpath_namespace, argv[i], NULL, buf);
if ((rc = mboxlist_detail(buf, NULL, &path, &mpath,
NULL, NULL, NULL)) == 0) {
if (metadata && mpath) printf("%s\n", mpath);
else printf("%s\n", path);
} else {
if (!quiet && (rc == IMAP_MAILBOX_NONEXISTENT)) {
fprintf(stderr, "Invalid mailbox name: %s\n", argv[i]);
}
if (stop_on_error) {
if (quiet) {
fatal("", -1);
} else {
fatal("Error in processing mailbox. Stopping\n", -1);
}
}
}
}
mboxlist_close();
mboxlist_done();
cyrus_done();
return 0;
}
int main(int argc, char **argv)
{
int opt;
char *alt_config = NULL;
int r = IMAP_NOTFOUND;
strarray_t mboxnames = STRARRAY_INITIALIZER;
const char *query = NULL;
int background = 1;
const char *channel = "squatter";
const char *synclogfile = NULL;
int init_flags = CYRUSINIT_PERROR;
int multi_folder = 0;
int user_mode = 0;
int compact_flags = 0;
const char *fromfile = NULL;
strarray_t *srctiers = NULL;
const char *desttier = NULL;
enum { UNKNOWN, INDEXER, INDEXFROM, SEARCH, ROLLING, SYNCLOG,
START_DAEMON, STOP_DAEMON, RUN_DAEMON, COMPACT } mode = UNKNOWN;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
setbuf(stdout, NULL);
while ((opt = getopt(argc, argv, "C:I:N:RAXT:S:Fc:de:f:mn:rsiavz:t:ou")) != EOF) {
switch (opt) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'A':
compact_flags |= SEARCH_COMPACT_AUDIT;
break;
case 'F':
compact_flags |= SEARCH_COMPACT_FILTER;
break;
case 'X':
compact_flags |= SEARCH_COMPACT_REINDEX;
break;
case 'N':
name_starts_from = optarg;
break;
case 'I': /* indexer, using specified mbox/uids in file */
if (mode != UNKNOWN && mode != INDEXFROM) usage(argv[0]);
fromfile = optarg;
mode = INDEXFROM;
break;
case 'R': /* rolling indexer */
if (mode != UNKNOWN) usage(argv[0]);
mode = ROLLING;
incremental_mode = 1; /* always incremental if rolling */
break;
case 'S': /* sleep time in seconds */
sleepmicroseconds = (atof(optarg) * 1000000);
break;
case 'T': /* temporary root directory for search */
temp_root_dir = optarg;
break;
/* This option is deliberately undocumented, for testing only */
case 'c': /* daemon control mode */
if (mode != UNKNOWN) usage(argv[0]);
if (!strcmp(optarg, "start"))
mode = START_DAEMON;
else if (!strcmp(optarg, "stop"))
mode = STOP_DAEMON;
else if (!strcmp(optarg, "run"))
mode = RUN_DAEMON;
else
usage(argv[0]);
break;
case 'd': /* foreground (with -R) */
background = 0;
break;
/* This option is deliberately undocumented, for testing only */
case 'e': /* add a search term */
if (mode != UNKNOWN && mode != SEARCH) usage(argv[0]);
query = optarg;
mode = SEARCH;
break;
case 'f': /* alternate synclogfile used in SYNCLOG mode */
synclogfile = optarg;
mode = SYNCLOG;
break;
/* This option is deliberately undocumented, for testing only */
case 'm': /* multi-folder in SEARCH mode */
if (mode != UNKNOWN && mode != SEARCH) usage(argv[0]);
multi_folder = 1;
mode = SEARCH;
break;
case 'n': /* sync channel name (with -R) */
channel = optarg;
break;
case 'o': /* copy one DB rather than compressing */
compact_flags |= SEARCH_COMPACT_COPYONE;
break;
case 'v': /* verbose */
verbose++;
break;
case 'r': /* recurse */
if (mode != UNKNOWN && mode != INDEXER) usage(argv[0]);
recursive_flag = 1;
mode = INDEXER;
break;
case 'i': /* incremental mode */
incremental_mode = 1;
break;
case 'a': /* use /squat annotation */
if (mode != UNKNOWN && mode != INDEXER) usage(argv[0]);
annotation_flag = 1;
mode = INDEXER;
break;
case 'z':
if (mode != UNKNOWN && mode != COMPACT) usage(argv[0]);
desttier = optarg;
mode = COMPACT;
break;
case 't':
if (mode != UNKNOWN && mode != COMPACT) usage(argv[0]);
srctiers = strarray_split(optarg, ",", 0);
mode = COMPACT;
break;
case 'u':
user_mode = 1;
break;
default:
usage("squatter");
}
}
compact_flags |= SEARCH_VERBOSE(verbose);
if (mode == UNKNOWN)
mode = INDEXER;
/* fork and close fds if required */
if (mode == ROLLING && background) {
become_daemon();
init_flags &= ~CYRUSINIT_PERROR;
}
if (mode == COMPACT && (!desttier || !srctiers)) {
/* need both src and dest for compact */
usage("squatter");
}
cyrus_init(alt_config, "squatter", init_flags, CONFIG_NEED_PARTITION_DATA);
/* Set namespace -- force standard (internal) */
if ((r = mboxname_init_namespace(&squat_namespace, 1)) != 0) {
fatal(error_message(r), EC_CONFIG);
}
annotate_init(NULL, NULL);
annotatemore_open();
mboxlist_init(0);
mboxlist_open(NULL);
if (mode == ROLLING || mode == SYNCLOG) {
signals_set_shutdown(&shut_down);
signals_add_handlers(0);
}
switch (mode) {
case UNKNOWN:
break;
case INDEXER:
/* -r requires at least one mailbox */
if (recursive_flag && optind == argc) usage(argv[0]);
expand_mboxnames(&mboxnames, argc-optind, (const char **)argv+optind, user_mode);
syslog(LOG_NOTICE, "indexing mailboxes");
r = do_indexer(&mboxnames);
syslog(LOG_NOTICE, "done indexing mailboxes");
break;
case INDEXFROM:
syslog(LOG_NOTICE, "indexing messages");
r = do_indexfrom(fromfile);
syslog(LOG_NOTICE, "done indexing messages");
break;
case SEARCH:
if (recursive_flag && optind == argc) usage(argv[0]);
expand_mboxnames(&mboxnames, argc-optind, (const char **)argv+optind, user_mode);
r = do_search(query, !multi_folder, &mboxnames);
break;
case ROLLING:
do_rolling(channel);
/* never returns */
break;
case SYNCLOG:
r = do_synclogfile(synclogfile);
break;
case START_DAEMON:
if (optind != argc) usage("squatter");
search_start_daemon(verbose);
break;
case STOP_DAEMON:
if (optind != argc) usage("squatter");
search_stop_daemon(verbose);
break;
case RUN_DAEMON:
if (optind != argc) usage("squatter");
do_run_daemon();
break;
case COMPACT:
if (recursive_flag && optind == argc) usage(argv[0]);
expand_mboxnames(&mboxnames, argc-optind, (const char **)argv+optind, user_mode);
r = do_compact(&mboxnames, srctiers, desttier, compact_flags);
break;
}
strarray_fini(&mboxnames);
shut_down(r ? EC_TEMPFAIL : 0);
}
int main (int argc, char *argv[]) {
int option; /* getopt() returns an int */
char *alt_config = NULL;
if ((geteuid()) == 0 && (become_cyrus(/*is_master*/0) != 0)) {
fatal("must run as the Cyrus user", EC_USAGE);
}
while ((option = getopt(argc, argv, "C:rn")) != EOF) {
switch (option) {
case 'C': /* alt config file */
alt_config = optarg;
break;
case 'r':
disinfect = 1;
break;
case 'n':
notify = 1;
break;
case 'h':
default: usage(argv[0]);
}
}
cyrus_init(alt_config, "cyr_virusscan", 0, CONFIG_NEED_PARTITION_DATA);
if (!engine.name) {
fatal("no virus scanner configured", EC_SOFTWARE);
} else {
if (verbose) printf("Using %s virus scanner\n", engine.name);
}
engine.state = engine.init();
mboxlist_init(0);
mboxlist_open(NULL);
/* open the quota db, we'll need it for expunge */
quotadb_init(0);
quotadb_open(NULL);
sync_log_init();
/* setup for mailbox event notifications */
mboxevent_init();
if (optind == argc) { /* do the whole partition */
mboxlist_findall(NULL, "*", 1, 0, 0, scan_me, NULL);
} else {
strarray_t *array = strarray_new();
for (; optind < argc; optind++) {
strarray_append(array, argv[optind]);
}
mboxlist_findallmulti(NULL, array, 1, 0, 0, scan_me, NULL);
strarray_free(array);
}
if (notify) append_notifications();
sync_log_done();
quotadb_close();
quotadb_done();
mboxlist_close();
mboxlist_done();
engine.destroy(engine.state);
cyrus_done();
return 0;
}
