void
ns_os_init(const char *progname) {
ns_paths_init();
setup_syslog(progname);
ntservice_init();
version_check(progname);
}
static gboolean
plugin_check_version(GModule *module)
{
gint (*version_check)(gint) = NULL;
g_module_symbol(module, "plugin_version_check", (void *) &version_check);
if (G_UNLIKELY(! version_check))
{
geany_debug("Plugin \"%s\" has no plugin_version_check() function - ignoring plugin!",
g_module_name(module));
return FALSE;
}
else
{
gint result = version_check(GEANY_ABI_VERSION);
if (result < 0)
{
msgwin_status_add(_("The plugin \"%s\" is not binary compatible with this "
"release of Geany - please recompile it."), g_module_name(module));
geany_debug("Plugin \"%s\" is not binary compatible with this "
"release of Geany - recompile it.", g_module_name(module));
return FALSE;
}
if (result > GEANY_API_VERSION)
{
geany_debug("Plugin \"%s\" requires a newer version of Geany (API >= v%d).",
g_module_name(module), result);
return FALSE;
}
}
return TRUE;
}
static int copy_file_with_version_check(const char *from, const char *to, bool force) {
_cleanup_close_ int fd_from = -1, fd_to = -1;
_cleanup_free_ char *t = NULL;
int r;
fd_from = open(from, O_RDONLY|O_CLOEXEC|O_NOCTTY);
if (fd_from < 0)
return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", from);
if (!force) {
fd_to = open(to, O_RDONLY|O_CLOEXEC|O_NOCTTY);
if (fd_to < 0) {
if (errno != -ENOENT)
return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", to);
} else {
r = version_check(fd_from, from, fd_to, to);
if (r < 0)
return r;
if (lseek(fd_from, 0, SEEK_SET) == (off_t) -1)
return log_error_errno(errno, "Failed to seek in \%s\": %m", from);
fd_to = safe_close(fd_to);
}
}
static int
pkg_is_installed(Plisthead *plisthead, char *pkgname)
{
Pkglist *pkglist;
int cmplen;
char *dashp;
if ((dashp = strrchr(pkgname, '-')) == NULL)
return -1;
cmplen = dashp - pkgname;
SLIST_FOREACH(pkglist, plisthead, next) {
dashp = strrchr(pkglist->pkgname, '-');
if (dashp == NULL)
err(EXIT_FAILURE, "oops");
/* make sure foo-1 does not match foo-bin-1 */
if ((dashp - pkglist->pkgname) != cmplen)
continue;
if (strncmp(pkgname, pkglist->pkgname, cmplen) != 0)
continue;
if (strcmp(dashp, pkgname + cmplen) == 0)
return 0;
return version_check(pkglist->pkgname, pkgname);
}
/* Callback for JVMTI_EVENT_VM_INIT */
static void JNICALL
vm_init(jvmtiEnv *jvmti, JNIEnv *env, jthread thread)
{
jvmtiError err;
jint runtime_version;
/* The exact JVMTI version doesn't have to match, however this
* code demonstrates how you can check that the JVMTI version seen
* in the jvmti.h include file matches that being supplied at runtime
* by the VM.
*/
err = (*jvmti)->GetVersionNumber(jvmti, &runtime_version);
check_jvmti_error(jvmti, err, "get version number");
version_check(JVMTI_VERSION, runtime_version);
}
void
ns_os_init(const char *progname) {
ns_paths_init();
setup_syslog(progname);
/*
* XXXMPA. We may need to split ntservice_init() in two and
* just mark as running in ns_os_started(). If we do that
* this is where the first part of ntservice_init() should be
* called from.
*
* XXX970 Remove comment if no problems by 9.7.0.
*
* ntservice_init();
*/
version_check(progname);
}
/* Callback for JVMTI_EVENT_VM_INIT */
static void JNICALL
vm_init(jvmtiEnv *jvmti, JNIEnv *env, jthread thread)
{
jvmtiError err;
jint runtime_version;
/* The exact JVMTI version doesn't have to match, however this
* code demonstrates how you can check that the JVMTI version seen
* in the jvmti.h include file matches that being supplied at runtime
* by the VM.
*/
err = (*jvmti)->GetVersionNumber(jvmti, &runtime_version);
if (err != JVMTI_ERROR_NONE) {
fprintf(stderr, "ERROR: GetVersionNumber failed, err=%d\n", err);
exit(1);
} else {
version_check(JVMTI_VERSION, runtime_version);
}
}
static int copy_file(const char *from, const char *to, bool force) {
_cleanup_fclose_ FILE *f = NULL, *g = NULL;
char *p;
int r;
struct timespec t[2];
struct stat st;
assert(from);
assert(to);
f = fopen(from, "re");
if (!f)
return log_error_errno(errno, "Failed to open \"%s\" for reading: %m", from);
if (!force) {
/* If this is an update, then let's compare versions first */
r = version_check(fileno(f), from, to);
if (r < 0)
return r;
}
p = strjoina(to, "~");
g = fopen(p, "wxe");
if (!g) {
/* Directory doesn't exist yet? Then let's skip this... */
if (!force && errno == ENOENT)
return 0;
return log_error_errno(errno, "Failed to open \"%s\" for writing: %m", to);
}
rewind(f);
do {
size_t k;
uint8_t buf[32*1024];
k = fread(buf, 1, sizeof(buf), f);
if (ferror(f)) {
r = log_error_errno(EIO, "Failed to read \"%s\": %m", from);
goto error;
}
if (k == 0)
break;
fwrite(buf, 1, k, g);
if (ferror(g)) {
r = log_error_errno(EIO, "Failed to write \"%s\": %m", to);
goto error;
}
} while (!feof(f));
r = fflush_and_check(g);
if (r < 0) {
log_error_errno(r, "Failed to write \"%s\": %m", to);
goto error;
}
r = fstat(fileno(f), &st);
if (r < 0) {
r = log_error_errno(errno, "Failed to get file timestamps of \"%s\": %m", from);
goto error;
}
t[0] = st.st_atim;
t[1] = st.st_mtim;
r = futimens(fileno(g), t);
if (r < 0) {
r = log_error_errno(errno, "Failed to set file timestamps on \"%s\": %m", p);
goto error;
}
if (rename(p, to) < 0) {
r = log_error_errno(errno, "Failed to rename \"%s\" to \"%s\": %m", p, to);
goto error;
}
log_info("Copied \"%s\" to \"%s\".", from, to);
return 0;
error:
(void) unlink(p);
return r;
}
static int copy_file(const char *from, const char *to, bool force) {
FILE *f = NULL, *g = NULL;
char *p = NULL;
int r;
struct timespec t[2];
struct stat st;
assert(from);
assert(to);
f = fopen(from, "re");
if (!f) {
fprintf(stderr, "Failed to open %s for reading: %m\n", from);
return -errno;
}
if (!force) {
/* If this is an update, then let's compare versions first */
r = version_check(f, from, to);
if (r < 0)
goto finish;
}
if (asprintf(&p, "%s~", to) < 0) {
fprintf(stderr, "Out of memory.\n");
r = -ENOMEM;
goto finish;
}
g = fopen(p, "wxe");
if (!g) {
/* Directory doesn't exist yet? Then let's skip this... */
if (!force && errno == ENOENT) {
r = 0;
goto finish;
}
fprintf(stderr, "Failed to open %s for writing: %m\n", to);
r = -errno;
goto finish;
}
rewind(f);
do {
size_t k;
uint8_t buf[32*1024];
k = fread(buf, 1, sizeof(buf), f);
if (ferror(f)) {
fprintf(stderr, "Failed to read %s: %m\n", from);
r = -errno;
goto finish;
}
if (k == 0)
break;
fwrite(buf, 1, k, g);
if (ferror(g)) {
fprintf(stderr, "Failed to write %s: %m\n", to);
r = -errno;
goto finish;
}
} while (!feof(f));
fflush(g);
if (ferror(g)) {
fprintf(stderr, "Failed to write %s: %m\n", to);
r = -errno;
goto finish;
}
r = fstat(fileno(f), &st);
if (r < 0) {
fprintf(stderr, "Failed to get file timestamps of %s: %m", from);
r = -errno;
goto finish;
}
t[0] = st.st_atim;
t[1] = st.st_mtim;
r = futimens(fileno(g), t);
if (r < 0) {
fprintf(stderr, "Failed to change file timestamps for %s: %m", p);
r = -errno;
goto finish;
}
if (rename(p, to) < 0) {
fprintf(stderr, "Failed to rename %s to %s: %m\n", p, to);
r = -errno;
goto finish;
}
fprintf(stderr, "Copied %s to %s.\n", from, to);
free(p);
p = NULL;
r = 0;
finish:
if (f)
fclose(f);
if (g)
fclose(g);
if (p) {
unlink(p);
free(p);
}
return r;
}
int
main(
int argc,
char **argv)
{
extern char *optarg;
CLIENT *cl;
int ch, ret;
char *passwd;
prog = argv[0];
version_check();
/*
* Check whether another server is running or not. There
* is a race condition where two servers could be racing to
* register with the portmapper. The goal of this check is to
* forbid running additional servers (like those started from
* the test suite) if the user is already running one.
*
* XXX
* This does not solve nor prevent two servers from being
* started at the same time and running recovery at the same
* time on the same environments.
*/
if ((cl = clnt_create("localhost",
DB_RPC_SERVERPROG, DB_RPC_SERVERVERS, "tcp")) != NULL) {
fprintf(stderr,
"%s: Berkeley DB RPC server already running.\n", prog);
clnt_destroy(cl);
return (EXIT_FAILURE);
}
LIST_INIT(&__dbsrv_home);
while ((ch = getopt(argc, argv, "h:I:L:P:t:T:Vv")) != EOF)
switch (ch) {
case 'h':
(void)add_home(optarg);
break;
case 'I':
if (__db_getlong(NULL, prog,
optarg, 1, LONG_MAX, &__dbsrv_idleto))
return (EXIT_FAILURE);
break;
case 'L':
logfile = optarg;
break;
case 'P':
passwd = strdup(optarg);
memset(optarg, 0, strlen(optarg));
if (passwd == NULL) {
fprintf(stderr, "%s: strdup: %s\n",
prog, strerror(errno));
return (EXIT_FAILURE);
}
if ((ret = add_passwd(passwd)) != 0) {
fprintf(stderr, "%s: strdup: %s\n",
prog, strerror(ret));
return (EXIT_FAILURE);
}
break;
case 't':
if (__db_getlong(NULL, prog,
optarg, 1, LONG_MAX, &__dbsrv_defto))
return (EXIT_FAILURE);
break;
case 'T':
if (__db_getlong(NULL, prog,
optarg, 1, LONG_MAX, &__dbsrv_maxto))
return (EXIT_FAILURE);
break;
case 'V':
printf("%s\n", db_version(NULL, NULL, NULL));
return (EXIT_SUCCESS);
case 'v':
__dbsrv_verbose = 1;
break;
default:
usage(prog);
}
/*
* Check default timeout against maximum timeout
*/
if (__dbsrv_defto > __dbsrv_maxto)
__dbsrv_defto = __dbsrv_maxto;
/*
* Check default timeout against idle timeout
* It would be bad to timeout environments sooner than txns.
*/
if (__dbsrv_defto > __dbsrv_idleto)
fprintf(stderr,
"%s: WARNING: Idle timeout %ld is less than resource timeout %ld\n",
prog, __dbsrv_idleto, __dbsrv_defto);
LIST_INIT(&__dbsrv_head);
/*
* If a client crashes during an RPC, our reply to it
* generates a SIGPIPE. Ignore SIGPIPE so we don't exit unnecessarily.
*/
#ifdef SIGPIPE
signal(SIGPIPE, SIG_IGN);
#endif
if (logfile != NULL && __db_util_logset("berkeley_db_svc", logfile))
return (EXIT_FAILURE);
/*
* Now that we are ready to start, run recovery on all the
* environments specified.
*/
if (env_recover(prog) != 0)
return (EXIT_FAILURE);
/*
* We've done our setup, now call the generated server loop
*/
if (__dbsrv_verbose)
printf("%s: Ready to receive requests\n", prog);
__dbsrv_main();
/* NOTREACHED */
abort();
}