const char* sys_data_path()
{
unsigned int i;
static char *search_dirs[] = {
#if defined(DATA_DIR)
DATA_DIR,
#else
"data",
#if !defined(PLATFORM_WINDOWS)
"/usr/share/" CONFIG_APPNAME "/data",
"/usr/share/games/" CONFIG_APPNAME "/data",
"/usr/local/share/" CONFIG_APPNAME "/data",
"/usr/local/games/" CONFIG_APPNAME "/data",
"/usr/local/share/games/" CONFIG_APPNAME "/data",
"/opt/" CONFIG_APPNAME "/data",
#endif
#endif /* defined(DATA_DIR) */
};
const unsigned int count = sizeof(search_dirs) / sizeof(search_dirs[0]);
for (i=0; i < count; i++)
{
// FIXME: ~/data could be found if run from $HOME.
// add an additional check for present file/dir in data-dir
if (sys_isdir(search_dirs[i]))
return search_dirs[i];
}
return 0;
}
int trap_IsDirectory(lua_State *s)
{
const char *path;
trap_args(s, "IsDirectory", "s", &path);
lua_pushboolean(s, sys_isdir(datapath(path)));
return 1;
}
static void
syscall_handler (struct intr_frame *f )
{
/* VALUE */
int syscall_num;
int arg[5];
void *esp = f->esp;
/* VALUE */
check_address(esp);
syscall_num = *(int *)esp;
switch(syscall_num)
{
case SYS_HALT:
halt();
break;
case SYS_EXIT:
get_argument(esp,arg,1);
exit(arg[0]);
break;
case SYS_EXEC:
get_argument(esp,arg,1);
check_address((void *)arg[0]);
f->eax = exec((const char *)arg[0]);
break;
case SYS_WAIT:
get_argument(esp,arg,1);
f->eax = wait(arg[0]);
break;
case SYS_CREATE:
get_argument(esp,arg,2);
check_address((void *)arg[0]);
f->eax = create((const char *)arg[0],(unsigned)arg[1]);
break;
case SYS_REMOVE:
get_argument(esp,arg,1);
check_address((void *)arg[0]);
f->eax=remove((const char *)arg[0]);
break;
case SYS_OPEN:
get_argument(esp,arg,1);
check_address((void *)arg[0]);
f->eax = open((const char *)arg[0]);
break;
case SYS_FILESIZE:
get_argument(esp,arg,1);
f->eax = filesize(arg[0]);
break;
case SYS_READ:
get_argument(esp,arg,3);
check_address((void *)arg[1]);
f->eax = read(arg[0],(void *)arg[1],(unsigned)arg[2]);
break;
case SYS_WRITE:
get_argument(esp,arg,3);
check_address((void *)arg[1]);
f->eax = write(arg[0],(void *)arg[1],(unsigned)arg[2]);
break;
case SYS_SEEK:
get_argument(esp,arg,2);
seek(arg[0],(unsigned)arg[1]);
break;
case SYS_TELL:
get_argument(esp,arg,1);
f->eax = tell(arg[0]);
break;
case SYS_CLOSE:
get_argument(esp,arg,1);
close(arg[0]);
break;
case SYS_ISDIR:
get_argument(esp,arg,1);
sys_isdir(arg[0]);
break;
case SYS_MKDIR:
get_argument(esp, arg, 1);
check_address((void *)arg[0]);
f->eax = sys_mkdir((const char *)arg[0]);
break;
case SYS_READDIR:
get_argument(esp, arg, 2);
check_address((char *)arg[1]);
f->eax = sys_readdir(arg[0], (char *)arg[1]);
break;
case SYS_CHDIR:
get_argument(esp, arg, 1);
check_address((void *)arg[0]);
f->eax = sys_chdir((const char *)arg[0]);
break;
}
}
static void
syscall_handler (struct intr_frame *f)
{
int syscall_number;
ASSERT( sizeof(syscall_number) == 4 ); // assuming x86
// The system call number is in the 32-bit word at the caller's stack pointer.
memread_user(f->esp, &syscall_number, sizeof(syscall_number));
_DEBUG_PRINTF ("[DEBUG] system call, number = %d!\n", syscall_number);
// Store the esp, which is needed in the page fault handler.
// refer to exception.c:page_fault() (see manual 4.3.3)
thread_current()->current_esp = f->esp;
// Dispatch w.r.t system call number
// SYS_*** constants are defined in syscall-nr.h
switch (syscall_number) {
case SYS_HALT: // 0
{
sys_halt();
NOT_REACHED();
break;
}
case SYS_EXIT: // 1
{
int exitcode;
memread_user(f->esp + 4, &exitcode, sizeof(exitcode));
sys_exit(exitcode);
NOT_REACHED();
break;
}
case SYS_EXEC: // 2
{
void* cmdline;
memread_user(f->esp + 4, &cmdline, sizeof(cmdline));
int return_code = sys_exec((const char*) cmdline);
f->eax = (uint32_t) return_code;
break;
}
case SYS_WAIT: // 3
{
pid_t pid;
memread_user(f->esp + 4, &pid, sizeof(pid_t));
int ret = sys_wait(pid);
f->eax = (uint32_t) ret;
break;
}
case SYS_CREATE: // 4
{
const char* filename;
unsigned initial_size;
bool return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
memread_user(f->esp + 8, &initial_size, sizeof(initial_size));
return_code = sys_create(filename, initial_size);
f->eax = return_code;
break;
}
case SYS_REMOVE: // 5
{
const char* filename;
bool return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_remove(filename);
f->eax = return_code;
break;
}
case SYS_OPEN: // 6
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_open(filename);
f->eax = return_code;
break;
}
case SYS_FILESIZE: // 7
{
int fd, return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_filesize(fd);
f->eax = return_code;
break;
}
case SYS_READ: // 8
{
int fd, return_code;
void *buffer;
unsigned size;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &buffer, sizeof(buffer));
memread_user(f->esp + 12, &size, sizeof(size));
return_code = sys_read(fd, buffer, size);
f->eax = (uint32_t) return_code;
break;
}
case SYS_WRITE: // 9
{
int fd, return_code;
const void *buffer;
unsigned size;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &buffer, sizeof(buffer));
memread_user(f->esp + 12, &size, sizeof(size));
return_code = sys_write(fd, buffer, size);
f->eax = (uint32_t) return_code;
break;
}
case SYS_SEEK: // 10
{
int fd;
unsigned position;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &position, sizeof(position));
sys_seek(fd, position);
break;
}
case SYS_TELL: // 11
{
int fd;
unsigned return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_tell(fd);
f->eax = (uint32_t) return_code;
break;
}
case SYS_CLOSE: // 12
{
int fd;
memread_user(f->esp + 4, &fd, sizeof(fd));
sys_close(fd);
break;
}
#ifdef VM
case SYS_MMAP: // 13
{
int fd;
void *addr;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &addr, sizeof(addr));
mmapid_t ret = sys_mmap (fd, addr);
f->eax = ret;
break;
}
case SYS_MUNMAP: // 14
{
mmapid_t mid;
memread_user(f->esp + 4, &mid, sizeof(mid));
sys_munmap(mid);
break;
}
#endif
#ifdef FILESYS
case SYS_CHDIR: // 15
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_chdir(filename);
f->eax = return_code;
break;
}
case SYS_MKDIR: // 16
{
const char* filename;
int return_code;
memread_user(f->esp + 4, &filename, sizeof(filename));
return_code = sys_mkdir(filename);
f->eax = return_code;
break;
}
case SYS_READDIR: // 17
{
int fd;
char *name;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
memread_user(f->esp + 8, &name, sizeof(name));
return_code = sys_readdir(fd, name);
f->eax = return_code;
break;
}
case SYS_ISDIR: // 18
{
int fd;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_isdir(fd);
f->eax = return_code;
break;
}
case SYS_INUMBER: // 19
{
int fd;
int return_code;
memread_user(f->esp + 4, &fd, sizeof(fd));
return_code = sys_inumber(fd);
f->eax = return_code;
break;
}
#endif
/* unhandled case */
default:
printf("[ERROR] system call %d is unimplemented!\n", syscall_number);
// ensure that waiting (parent) process should wake up and terminate.
sys_exit(-1);
break;
}
}
/*
* Main entry point.
*/
int
main(int argc, char *argv[])
{
const char *argv0;
int ch;
opts_t *opts;
char *natengine;
int pidfd = -1;
int rv = EXIT_FAILURE;
argv0 = argv[0];
opts = opts_new();
natengine = strdup(nat_getdefaultname());
while ((ch = getopt(argc, argv, OPT_g OPT_G OPT_Z
"k:c:C:K:t:OPs:e:Eu:j:p:l:L:S:dDVh")) != -1) {
switch (ch) {
case 'c':
if (opts->cacrt)
X509_free(opts->cacrt);
opts->cacrt = ssl_x509_load(optarg);
if (!opts->cacrt) {
fprintf(stderr, "%s: error loading CA "
"cert from '%s':\n",
argv0, optarg);
if (errno) {
fprintf(stderr, "%s\n",
strerror(errno));
} else {
ERR_print_errors_fp(stderr);
}
exit(EXIT_FAILURE);
}
ssl_x509_refcount_inc(opts->cacrt);
sk_X509_insert(opts->chain, opts->cacrt, 0);
if (!opts->cakey) {
opts->cakey = ssl_key_load(optarg);
}
#ifndef OPENSSL_NO_DH
if (!opts->dh) {
opts->dh = ssl_dh_load(optarg);
}
#endif /* !OPENSSL_NO_DH */
break;
case 'k':
if (opts->cakey)
EVP_PKEY_free(opts->cakey);
opts->cakey = ssl_key_load(optarg);
if (!opts->cakey) {
fprintf(stderr, "%s: error loading CA "
"key from '%s':\n",
argv0, optarg);
if (errno) {
fprintf(stderr, "%s\n",
strerror(errno));
} else {
ERR_print_errors_fp(stderr);
}
exit(EXIT_FAILURE);
}
if (!opts->cacrt) {
opts->cacrt = ssl_x509_load(optarg);
if (opts->cacrt) {
ssl_x509_refcount_inc(
opts->cacrt);
sk_X509_insert(opts->chain,
opts->cacrt, 0);
}
}
#ifndef OPENSSL_NO_DH
if (!opts->dh) {
opts->dh = ssl_dh_load(optarg);
}
#endif /* !OPENSSL_NO_DH */
break;
case 'C':
if (ssl_x509chain_load(NULL, &opts->chain,
optarg) == -1) {
fprintf(stderr, "%s: error loading "
"chain from '%s':\n",
argv0, optarg);
if (errno) {
fprintf(stderr, "%s\n",
strerror(errno));
} else {
ERR_print_errors_fp(stderr);
}
exit(EXIT_FAILURE);
}
break;
case 'K':
if (opts->key)
EVP_PKEY_free(opts->key);
opts->key = ssl_key_load(optarg);
if (!opts->key) {
fprintf(stderr, "%s: error loading lea"
"f key from '%s':\n",
argv0, optarg);
if (errno) {
fprintf(stderr, "%s\n",
strerror(errno));
} else {
ERR_print_errors_fp(stderr);
}
exit(EXIT_FAILURE);
}
#ifndef OPENSSL_NO_DH
if (!opts->dh) {
opts->dh = ssl_dh_load(optarg);
}
#endif /* !OPENSSL_NO_DH */
break;
case 't':
if (!sys_isdir(optarg)) {
fprintf(stderr, "%s: '%s' is not a "
"directory\n",
argv0, optarg);
exit(EXIT_FAILURE);
}
if (opts->tgcrtdir)
free(opts->tgcrtdir);
opts->tgcrtdir = strdup(optarg);
break;
case 'O':
opts->deny_ocsp = 1;
break;
case 'P':
opts->passthrough = 1;
break;
#ifndef OPENSSL_NO_DH
case 'g':
if (opts->dh)
DH_free(opts->dh);
opts->dh = ssl_dh_load(optarg);
if (!opts->dh) {
fprintf(stderr, "%s: error loading DH "
"params from '%s':\n",
argv0, optarg);
if (errno) {
fprintf(stderr, "%s\n",
strerror(errno));
} else {
ERR_print_errors_fp(stderr);
}
exit(EXIT_FAILURE);
}
break;
#endif /* !OPENSSL_NO_DH */
#ifndef OPENSSL_NO_ECDH
case 'G':
{
EC_KEY *ec;
if (opts->ecdhcurve)
free(opts->ecdhcurve);
if (!(ec = ssl_ec_by_name(optarg))) {
fprintf(stderr, "%s: unknown curve "
"'%s'\n",
argv0, optarg);
exit(EXIT_FAILURE);
}
EC_KEY_free(ec);
opts->ecdhcurve = strdup(optarg);
break;
}
#endif /* !OPENSSL_NO_ECDH */
#ifdef SSL_OP_NO_COMPRESSION
case 'Z':
opts->sslcomp = 0;
break;
#endif /* SSL_OP_NO_COMPRESSION */
case 's':
if (opts->ciphers)
free(opts->ciphers);
opts->ciphers = strdup(optarg);
break;
case 'e':
free(natengine);
natengine = strdup(optarg);
break;
case 'E':
nat_list_engines();
exit(EXIT_SUCCESS);
break;
case 'u':
if (opts->dropuser)
free(opts->dropuser);
opts->dropuser = strdup(optarg);
break;
case 'p':
if (opts->pidfile)
free(opts->pidfile);
opts->pidfile = strdup(optarg);
break;
case 'j':
if (opts->jaildir)
free(opts->jaildir);
opts->jaildir = strdup(optarg);
break;
case 'l':
if (opts->connectlog)
free(opts->connectlog);
opts->connectlog = strdup(optarg);
break;
case 'L':
if (opts->contentlog)
free(opts->contentlog);
opts->contentlog = strdup(optarg);
opts->contentlogdir = 0;
break;
case 'S':
if (opts->contentlog)
free(opts->contentlog);
opts->contentlog = strdup(optarg);
opts->contentlogdir = 1;
break;
case 'd':
opts->detach = 1;
break;
case 'D':
log_dbg_mode(LOG_DBG_MODE_ERRLOG);
opts->debug = 1;
break;
case 'V':
main_version();
exit(EXIT_SUCCESS);
case 'h':
main_usage();
exit(EXIT_SUCCESS);
case '?':
exit(EXIT_FAILURE);
default:
main_usage();
exit(EXIT_FAILURE);
}
}
argc -= optind;
argv += optind;
opts->spec = proxyspec_parse(&argc, &argv, natengine);
/* usage checks */
if (opts->detach && OPTS_DEBUG(opts)) {
fprintf(stderr, "%s: -d and -D are mutually exclusive.\n",
argv0);
exit(EXIT_FAILURE);
}
if (!opts->spec) {
fprintf(stderr, "%s: no proxyspec specified.\n", argv0);
exit(EXIT_FAILURE);
}
for (proxyspec_t *spec = opts->spec; spec; spec = spec->next) {
if (spec->connect_addrlen || spec->sni_port)
continue;
if (!spec->natengine) {
fprintf(stderr, "%s: no supported NAT engines "
"on this platform.\n"
"Only static addr and SNI proxyspecs "
"supported.\n", argv0);
exit(EXIT_FAILURE);
}
if (spec->listen_addr.ss_family == AF_INET6 &&
!nat_ipv6ready(spec->natengine)) {
fprintf(stderr, "%s: IPv6 not supported by '%s'\n",
argv0, spec->natengine);
exit(EXIT_FAILURE);
}
spec->natlookup = nat_getlookupcb(spec->natengine);
spec->natsocket = nat_getsocketcb(spec->natengine);
}
if (opts_has_ssl_spec(opts)) {
if ((opts->cacrt || !opts->tgcrtdir) && !opts->cakey) {
fprintf(stderr, "%s: no CA key specified (-k).\n",
argv0);
exit(EXIT_FAILURE);
}
if (opts->cakey && !opts->cacrt) {
fprintf(stderr, "%s: no CA cert specified (-c).\n",
argv0);
exit(EXIT_FAILURE);
}
if (opts->cakey && opts->cacrt &&
(X509_check_private_key(opts->cacrt, opts->cakey) != 1)) {
fprintf(stderr, "%s: CA cert does not match key.\n",
argv0);
ERR_print_errors_fp(stderr);
exit(EXIT_FAILURE);
}
}
/* prevent multiple instances running */
if (opts->pidfile) {
pidfd = sys_pidf_open(opts->pidfile);
if (pidfd == -1) {
fprintf(stderr, "%s: cannot open PID file '%s' "
"- process already running?\n",
argv0, opts->pidfile);
exit(EXIT_FAILURE);
}
}
/* dynamic defaults */
if (!opts->ciphers) {
opts->ciphers = strdup("ALL:-aNULL");
if (!opts->ciphers) {
fprintf(stderr, "%s: out of memory.\n", argv0);
exit(EXIT_FAILURE);
}
}
if (!opts->jaildir && (geteuid() == 0) && !opts->contentlogdir) {
opts->jaildir = strdup("/var/empty");
}
if (!opts->dropuser && !geteuid() && !getuid() &&
!opts->contentlogdir) {
opts->dropuser = strdup("nobody");
}
if (opts_has_ssl_spec(opts) && !opts->key) {
opts->key = ssl_key_genrsa(1024);
if (!opts->key) {
fprintf(stderr, "%s: error generating RSA key:\n",
argv0);
ERR_print_errors_fp(stderr);
exit(EXIT_FAILURE);
}
if (OPTS_DEBUG(opts)) {
log_dbg_printf("Generated RSA key for leaf certs.\n");
}
}
/* debugging */
if (OPTS_DEBUG(opts)) {
main_version();
log_dbg_printf("proxyspecs:\n");
for (proxyspec_t *spec = opts->spec; spec; spec = spec->next) {
char *lbuf, *cbuf = NULL;
lbuf = sys_sockaddr_str((struct sockaddr *)
&spec->listen_addr,
spec->listen_addrlen);
if (spec->connect_addrlen) {
cbuf = sys_sockaddr_str((struct sockaddr *)
&spec->connect_addr,
spec->connect_addrlen);
}
if (spec->sni_port) {
asprintf(&cbuf, "sni %i", spec->sni_port);
}
log_dbg_printf("- %s %s %s %s\n", lbuf,
(spec->ssl ? "ssl" : "tcp"),
(spec->http ? "http" : "plain"),
(spec->natengine ? spec->natengine
: cbuf));
if (lbuf)
free(lbuf);
if (cbuf)
free(cbuf);
}
if (opts->cacrt) {
char *subj = ssl_x509_subject(opts->cacrt);
log_dbg_printf("Loaded CA: '%s'\n", subj);
free(subj);
#ifdef DEBUG_CERTIFICATE
log_dbg_print_free(ssl_x509_to_str(opts->cacrt));
log_dbg_print_free(ssl_x509_to_pem(opts->cacrt));
#endif /* DEBUG_CERTIFICATE */
} else {
log_dbg_printf("No CA loaded.\n");
}
}
/*
* Initialize as much as possible before daemon() in order to be
* able to provide direct feedback to the user when failing.
*/
if (cachemgr_preinit() == -1) {
fprintf(stderr, "%s: failed to preinit cachemgr.\n", argv0);
exit(EXIT_FAILURE);
}
if (log_preinit(opts) == -1) {
fprintf(stderr, "%s: failed to preinit logging.\n", argv0);
exit(EXIT_FAILURE);
}
if (nat_preinit() == -1) {
fprintf(stderr, "%s: failed to preinit NAT lookup.\n", argv0);
exit(EXIT_FAILURE);
}
/* Bind listeners before dropping privileges */
proxy_ctx_t *proxy = proxy_new(opts);
if (!proxy) {
fprintf(stderr, "%s: failed to initialize proxy.\n", argv0);
exit(EXIT_FAILURE);
}
/* Drop privs, chroot, detach from TTY */
if (sys_privdrop(opts->dropuser, opts->jaildir) == -1) {
fprintf(stderr, "%s: failed to drop privileges: %s\n",
argv0, strerror(errno));
exit(EXIT_FAILURE);
}
if (opts->detach) {
if (OPTS_DEBUG(opts)) {
log_dbg_printf("Detaching from TTY, see syslog for "
"errors after this point\n");
}
if (daemon(1, 0) == -1) {
fprintf(stderr, "%s: failed to detach from TTY: %s\n",
argv0, strerror(errno));
exit(EXIT_FAILURE);
}
log_err_mode(LOG_ERR_MODE_SYSLOG);
ssl_reinit();
}
/* Post-privdrop/chroot/detach initialization, thread spawning */
if (log_init(opts) == -1) {
fprintf(stderr, "%s: failed to init log facility.\n", argv0);
goto out_log_failed;
}
if (opts->pidfile && (sys_pidf_write(pidfd) == -1)) {
log_err_printf("Failed to write PID to PID file '%s': %s\n",
opts->pidfile, strerror(errno));
goto out_pidwrite_failed;
}
if (cachemgr_init() == -1) {
log_err_printf("Failed to init cache manager.\n");
goto out_cachemgr_failed;
}
if (nat_init() == -1) {
log_err_printf("Failed to init NAT state table lookup.\n");
goto out_nat_failed;
}
if (opts->tgcrtdir) {
sys_dir_eachfile(opts->tgcrtdir, main_loadtgcrt, opts);
}
rv = EXIT_SUCCESS;
proxy_run(proxy);
proxy_free(proxy);
nat_fini();
out_nat_failed:
cachemgr_fini();
out_cachemgr_failed:
if (opts->pidfile) {
sys_pidf_close(pidfd, opts->pidfile);
}
out_pidwrite_failed:
log_fini();
out_log_failed:
opts_free(opts);
ssl_fini();
return rv;
}
END_TEST
START_TEST(sys_isdir_04)
{
fail_unless(!sys_isdir(file), "File isdir");
}
END_TEST
START_TEST(sys_isdir_03)
{
fail_unless(!sys_isdir(notexist), "Not-exist isdir");
}
END_TEST
START_TEST(sys_isdir_02)
{
fail_unless(sys_isdir(ldir), "Symlink dir !isdir");
}
END_TEST
START_TEST(sys_isdir_05)
{
fail_unless(!sys_isdir(lfile), "Symlink file isdir");
}
int load_config() {
string tmp;
vector<string> splited;
int tmpSize, tmpPort;
if(configFilePath[0] == '\0') {
strcpy(configFilePath, DEFAULT_CONFIG_FILE_PATH);
}
if(!options.read_options_file(configFilePath)) {
log_message(ERROR_LOG, "Couldn't read configuration file %s.", configFilePath);
return 1;
}
tmp = options["logLevel"];
config.logLevel = atoi(tmp.c_str());
tmp = options["maxClients"];
config.maxClients = atoi(tmp.c_str());
config.logFilePath = options["logFilePath"];
tmp = options["bindPort"];
config.bindPort = atoi(tmp.c_str());
tmp = options["sslPorts"];
splited = split(tmp, ',');
tmpSize = splited.size();
for(int i=0; i<tmpSize; i++) {
tmpPort = atoi(splited.at(i).c_str());
if((tmpPort >= 0) && (tmpPort <= 65535)) {
config.sslPorts.push_back(tmpPort);
}
}
/* load certificate */
tmp = options["cacrt"];
config.cacrt = ssl_x509_load(tmp.c_str());
if(!config.cacrt) {
log_message(ERROR_LOG, "Could not loading ca crt %s.", tmp.c_str());
return 1;
}
config.chain = sk_X509_new_null();
ssl_x509_refcount_inc(config.cacrt);
sk_X509_insert(config.chain, config.cacrt, 0);
tmp = options["cakey"];
config.cakey = ssl_key_load(tmp.c_str());
if (!config.cakey) {
log_message(ERROR_LOG, "Could not loading ca key %s.", tmp.c_str());
return 1;
}
tmp = options["leafkey"];
config.key = ssl_key_load(tmp.c_str());
if (!config.key) {
log_message(ERROR_LOG, "Could not loading leaf key %s.", tmp.c_str());
return 1;
}
config.ciphers = strdup("ALL:-aNULL");
if (!config.ciphers) {
log_message(ERROR_LOG, "Could not malloc ciphers.");
return 1;
}
tmp = options["contentLogDir"];
config.contentLogDir = strdup(tmp.c_str());
if (!config.contentLogDir) {
log_message(ERROR_LOG, "Could not malloc contentLogDir.");
return 1;
}
if (!sys_isdir(config.contentLogDir)) {
log_message(ERROR_LOG, "%s is not a directory.", config.contentLogDir);
return 1;
}
return 0;
}