Copyright (C) Gerald Carter 2003-2007
Copyright (C) Volker Lendecke 2005
Copyright (C) Guenther Deschner 2005
+ Copyright (C) Michael Adam 2007
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
Validate functions for all possible cache tdb keys.
***********************************************************************/
-static BOOL bad_cache_entry;
+struct validation_status {
+ BOOL tdb_error;
+ BOOL bad_freelist;
+ BOOL bad_entry;
+ BOOL unknown_key;
+ BOOL success;
+};
-static struct cache_entry *create_centry_validate(const char *kstr, TDB_DATA data)
+static struct cache_entry *create_centry_validate(const char *kstr, TDB_DATA data,
+ struct validation_status *state)
{
struct cache_entry *centry;
if (centry->len < 8) {
/* huh? corrupt cache? */
- DEBUG(0,("validate_create_centry: Corrupt cache for key %s (len < 8) ?\n", kstr));
+ DEBUG(0,("create_centry_validate: Corrupt cache for key %s (len < 8) ?\n", kstr));
centry_free(centry);
- bad_cache_entry = True;
+ state->bad_entry = True;
+ state->success = False;
return NULL;
}
return centry;
}
-static int validate_seqnum(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_seqnum(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
if (dbuf.dsize != 8) {
DEBUG(0,("validate_seqnum: Corrupt cache for key %s (len %u != 8) ?\n",
keystr, (unsigned int)dbuf.dsize ));
- bad_cache_entry = True;
+ state->bad_entry = True;
return 1;
}
return 0;
}
-static int validate_ns(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_ns(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
if (!centry) {
return 1;
}
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_ns: %s ok\n", keystr));
return 0;
}
-static int validate_sn(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_sn(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
if (!centry) {
return 1;
}
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_sn: %s ok\n", keystr));
return 0;
}
-static int validate_u(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_u(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
DOM_SID sid;
if (!centry) {
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_u: %s ok\n", keystr));
return 0;
}
-static int validate_loc_pol(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_loc_pol(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
if (!centry) {
return 1;
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_loc_pol: %s ok\n", keystr));
return 0;
}
-static int validate_pwd_pol(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_pwd_pol(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
if (!centry) {
return 1;
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_pwd_pol: %s ok\n", keystr));
return 0;
}
-static int validate_cred(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_cred(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
if (!centry) {
return 1;
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_cred: %s ok\n", keystr));
return 0;
}
-static int validate_ul(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_ul(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
int32 num_entries, i;
if (!centry) {
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_ul: %s ok\n", keystr));
return 0;
}
-static int validate_gl(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_gl(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
int32 num_entries, i;
if (!centry) {
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_gl: %s ok\n", keystr));
return 0;
}
-static int validate_ug(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_ug(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
int32 num_groups, i;
if (!centry) {
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_ug: %s ok\n", keystr));
return 0;
}
-static int validate_ua(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_ua(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
int32 num_aliases, i;
if (!centry) {
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_ua: %s ok\n", keystr));
return 0;
}
-static int validate_gm(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_gm(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
int32 num_names, i;
if (!centry) {
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_gm: %s ok\n", keystr));
return 0;
}
-static int validate_dr(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_dr(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
/* Can't say anything about this other than must be nonzero. */
if (dbuf.dsize == 0) {
DEBUG(0,("validate_dr: Corrupt cache for key %s (len == 0) ?\n",
keystr));
- bad_cache_entry = True;
+ state->bad_entry = True;
+ state->success = False;
return 1;
}
return 0;
}
-static int validate_de(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_de(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
/* Can't say anything about this other than must be nonzero. */
if (dbuf.dsize == 0) {
DEBUG(0,("validate_de: Corrupt cache for key %s (len == 0) ?\n",
keystr));
- bad_cache_entry = True;
+ state->bad_entry = True;
+ state->success = False;
return 1;
}
return 0;
}
-static int validate_trustdoms(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_trustdoms(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
- struct cache_entry *centry = create_centry_validate(keystr, dbuf);
+ struct cache_entry *centry = create_centry_validate(keystr, dbuf, state);
int32 num_domains, i;
if (!centry) {
centry_free(centry);
- if (bad_cache_entry) {
+ if (!(state->success)) {
return 1;
}
DEBUG(10,("validate_trustdoms: %s ok\n", keystr));
return 0;
}
-static int validate_offline(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf)
+static int validate_trustdomcache(TALLOC_CTX *mem_ctx, const char *keystr,
+ TDB_DATA dbuf,
+ struct validation_status *state)
+{
+ if (dbuf.dsize == 0) {
+ DEBUG(0, ("validate_trustdomcache: Corrupt cache for "
+ "key %s (len ==0) ?\n", keystr));
+ state->bad_entry = True;
+ state->success = False;
+ return 1;
+ }
+
+ DEBUG(10, ("validate_trustdomcache: %s ok\n", keystr));
+ DEBUGADD(10, (" Don't trust me, I am a DUMMY!\n"));
+ return 0;
+}
+
+static int validate_offline(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
{
if (dbuf.dsize != 4) {
DEBUG(0,("validate_offline: Corrupt cache for key %s (len %u != 4) ?\n",
keystr, (unsigned int)dbuf.dsize ));
- bad_cache_entry = True;
+ state->bad_entry = True;
+ state->success = False;
return 1;
}
DEBUG(10,("validate_offline: %s ok\n", keystr));
return 0;
}
+static int validate_cache_version(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf,
+ struct validation_status *state)
+{
+ if (dbuf.dsize != 4) {
+ DEBUG(0, ("validate_cache_version: Corrupt cache for "
+ "key %s (len %u != 4) ?\n",
+ keystr, (unsigned int)dbuf.dsize));
+ state->bad_entry = True;
+ state->success = False;
+ return 1;
+ }
+
+ DEBUG(10, ("validate_cache_version: %s ok\n", keystr));
+ return 0;
+}
+
/***********************************************************************
A list of all possible cache tdb keys with associated validation
functions.
struct key_val_struct {
const char *keyname;
- int (*validate_data_fn)(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf);
+ int (*validate_data_fn)(TALLOC_CTX *mem_ctx, const char *keystr, TDB_DATA dbuf, struct validation_status* state);
} key_val[] = {
{"SEQNUM/", validate_seqnum},
{"NS/", validate_ns},
{"DR/", validate_dr},
{"DE/", validate_de},
{"TRUSTDOMS/", validate_trustdoms},
+ {"TRUSTDOMCACHE/", validate_trustdomcache},
{"WINBINDD_OFFLINE", validate_offline},
+ {WINBINDD_CACHE_VERSION_KEYSTR, validate_cache_version},
{NULL, NULL}
};
static int cache_traverse_validate_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, void *state)
{
int i;
+ struct validation_status *v_state = (struct validation_status *)state;
/* Paranoia check. */
if (kbuf.dsize > 1024) {
return 1;
}
- ret = key_val[i].validate_data_fn(mem_ctx, keystr, dbuf);
+ ret = key_val[i].validate_data_fn(mem_ctx, keystr, dbuf,
+ v_state);
SAFE_FREE(keystr);
talloc_destroy(mem_ctx);
dump_data(0, (uint8 *)kbuf.dptr, kbuf.dsize);
DEBUG(0,("data :\n"));
dump_data(0, (uint8 *)dbuf.dptr, dbuf.dsize);
+ v_state->unknown_key = True;
+ v_state->success = False;
return 1; /* terminate. */
}
static void validate_panic(const char *const why)
{
- DEBUG(0,("validating cache: would panic %s\n", why ));
- bad_cache_entry = True;
-}
-
-/* Handle any signals generated when validating a possibly
- bad cache tdb. */
-
-static jmp_buf jmpbuf;
-
-#ifdef SIGSEGV
-static void sig_segv(int sig)
-{
- longjmp(jmpbuf, SIGSEGV);
-}
-#endif
-
-#ifdef SIGBUS
-static void sig_bus(int sig)
-{
- longjmp(jmpbuf, SIGBUS);
-}
-#endif
-
-#ifdef SIGABRT
-static void sig_abrt(int sig)
-{
- longjmp(jmpbuf, SIGABRT);
+ DEBUG(0,("validating cache: would panic %s\n", why ));
+ DEBUGADD(0, ("exiting instead (cache validation mode)\n"));
+ exit(47);
}
-#endif
/***********************************************************************
Try and validate every entry in the winbindd cache. If we fail here,
function) will restart us as we don't know if we crashed or not.
***********************************************************************/
-int winbindd_validate_cache(void)
+/*
+ * internal validation function, executed by the child.
+ */
+static int winbindd_validate_cache_child(const char *cache_path, int pfd)
{
- BOOL ret = -1;
- int fd = -1;
+ int ret = -1;
+ int tfd = -1;
int num_entries = 0;
TDB_CONTEXT *tdb = NULL;
- const char *cache_path = lock_path("winbindd_cache.tdb");
-
-#ifdef SIGSEGV
- void (*old_segv_handler)(int) = CatchSignal(SIGSEGV,SIGNAL_CAST sig_segv);
-#endif
-#ifdef SIGBUS
- void (*old_bus_handler)(int) = CatchSignal(SIGBUS,SIGNAL_CAST sig_bus);
-#endif
-#ifdef SIGABRT
- void (*old_abrt_handler)(int) = CatchSignal(SIGABRT,SIGNAL_CAST sig_abrt);
-#endif
-
- switch((ret = setjmp(jmpbuf))) {
- case 0:
- ret = -1;
- break;
- case SIGSEGV:
- case SIGBUS:
- case SIGABRT:
- default:
- goto out;
- }
-
- /* Doh ! Volker is very smart :-). Use TDB_NOMMAP to prevent
- * any wild pointer references when reading a corrupt tdb file. */
+ struct validation_status v_status;
+
+ v_status.tdb_error = False;
+ v_status.bad_freelist = False;
+ v_status.bad_entry = False;
+ v_status.unknown_key = False;
+ v_status.success = True;
tdb = tdb_open_log(cache_path,
WINBINDD_CACHE_TDB_DEFAULT_HASH_SIZE,
- lp_winbind_offline_logon() ? TDB_NOMMAP : (TDB_NOMMAP | TDB_CLEAR_IF_FIRST),
+ lp_winbind_offline_logon()
+ ? TDB_DEFAULT
+ : (TDB_DEFAULT | TDB_CLEAR_IF_FIRST),
O_RDWR|O_CREAT, 0600);
if (!tdb) {
+ v_status.tdb_error = True;
+ v_status.success = False;
goto out;
}
- fd = tdb_fd(tdb);
+ tfd = tdb_fd(tdb);
/* Check the cache freelist is good. */
if (tdb_validate_freelist(tdb, &num_entries) == -1) {
- DEBUG(0,("winbindd_validate_cache: bad freelist in cache %s\n",
+ DEBUG(0,("winbindd_validate_cache_child: bad freelist in cache %s\n",
cache_path));
+ v_status.bad_freelist = True;
+ v_status.success = False;
goto out;
}
- DEBUG(10,("winbindd_validate_cache: cache %s freelist has %d entries\n",
+ DEBUG(10,("winbindd_validate_cache_child: cache %s freelist has %d entries\n",
cache_path, num_entries));
- smb_panic_fn = validate_panic;
-
/* Now traverse the cache to validate it. */
- num_entries = tdb_traverse(tdb, cache_traverse_validate_fn, NULL);
- if (num_entries == -1 || bad_cache_entry) {
- DEBUG(0,("winbindd_validate_cache: cache %s traverse failed\n",
+ num_entries = tdb_traverse(tdb, cache_traverse_validate_fn, (void *)&v_status);
+ if (num_entries == -1 || !(v_status.success)) {
+ DEBUG(0,("winbindd_validate_cache_child: cache %s traverse failed\n",
cache_path));
+ if (!(v_status.success)) {
+ if (v_status.bad_entry) {
+ DEBUGADD(0, (" -> bad entry found\n"));
+ }
+ if (v_status.unknown_key) {
+ DEBUGADD(0, (" -> unknown key encountered\n"));
+ }
+ }
goto out;
}
- DEBUG(10,("winbindd_validate_cache: cache %s is good "
+ DEBUG(10,("winbindd_validate_cache_child: cache %s is good "
"with %d entries\n", cache_path, num_entries));
ret = 0; /* Cache is good. */
- out:
-
- bad_cache_entry = False;
- smb_panic_fn = smb_panic;
-
- /* Ensure if we segv on exit we use the original
- handlers to avoid a loop. */
-
-#ifdef SIGSEGV
- CatchSignal(SIGSEGV,SIGNAL_CAST old_segv_handler);
-#endif
-#ifdef SIGBUS
- CatchSignal(SIGBUS,SIGNAL_CAST old_bus_handler);
-#endif
-#ifdef SIGABRT
- CatchSignal(SIGABRT,SIGNAL_CAST old_abrt_handler);
-#endif
-
+out:
if (tdb) {
if (ret == 0) {
tdb_close(tdb);
- } else if (fd != -1) {
- close(fd);
+ }
+ else if (tfd != -1) {
+ close(tfd);
}
}
- if (ret) {
+ DEBUG(10, ("winbindd_validate_cache_child: writing status to pipe\n"));
+ write (pfd, (const char *)&v_status, sizeof(v_status));
+ close(pfd);
+
+ return ret;
+}
+
+int winbindd_validate_cache(void)
+{
+ pid_t child_pid = -1;
+ int child_status = 0;
+ int wait_pid = 0;
+ int ret = -1;
+ int pipe_fds[2];
+ struct validation_status v_status;
+ int bytes_read = 0;
+ const char *cache_path = lock_path("winbindd_cache.tdb");
+
+ DEBUG(10, ("winbindd_validate_cache: replacing panic function\n"));
+ smb_panic_fn = validate_panic;
+
+ /* fork and let the child do the validation.
+ * benefit: no need to twist signal handlers and panic functions.
+ * just let the child panic. we catch the signal.
+ * communicate the extended status struct over a pipe. */
+
+ if (pipe(pipe_fds) != 0) {
+ DEBUG(0, ("winbindd_validate_cache: unable to create pipe, "
+ "error %s", strerror(errno)));
+ smb_panic("winbind_validate_cache: unable to create pipe.");
+ }
+
+ DEBUG(10, ("winbindd_validate_cache: forking to let child do validation.\n"));
+ child_pid = sys_fork();
+ if (child_pid == 0) {
+ DEBUG(10, ("winbindd_validate_cache (validation child): created\n"));
+ close(pipe_fds[0]); /* close reading fd */
+ DEBUG(10, ("winbindd_validate_cache (validation child): "
+ "calling winbindd_validate_cache_child\n"));
+ exit(winbindd_validate_cache_child(cache_path, pipe_fds[1]));
+ }
+ else if (child_pid < 0) {
+ smb_panic("winbindd_validate_cache: fork for validation failed.");
+ }
+
+ /* parent */
+
+ DEBUG(10, ("winbindd_validate_cache: fork succeeded, child PID = %d\n",
+ child_pid));
+ close(pipe_fds[1]); /* close writing fd */
+
+ v_status.success = True;
+ v_status.bad_entry = False;
+ v_status.unknown_key = False;
+
+ DEBUG(10, ("winbindd_validate_cache: reading from pipe.\n"));
+ bytes_read = read(pipe_fds[0], (void *)&v_status, sizeof(v_status));
+ close(pipe_fds[0]);
+
+ if (bytes_read != sizeof(v_status)) {
+ DEBUG(10, ("winbindd_validate_cache: read %d bytes from pipe "
+ "but expected %d", bytes_read, sizeof(v_status)));
+ DEBUGADD(10, (" -> assuming child crashed\n"));
+ v_status.success = False;
+ }
+ else {
+ DEBUG(10, ("winbindd_validate_cache: read status from child\n"));
+ DEBUGADD(10, (" * tdb error: %s\n", v_status.tdb_error ? "yes" : "no"));
+ DEBUGADD(10, (" * bad freelist: %s\n", v_status.bad_freelist ? "yes" : "no"));
+ DEBUGADD(10, (" * bad entry: %s\n", v_status.bad_entry ? "yes" : "no"));
+ DEBUGADD(10, (" * unknown key: %s\n", v_status.unknown_key ? "yes" : "no"));
+ DEBUGADD(10, (" => overall success: %s\n", v_status.success ? "yes" : "no"));
+ }
+
+ if (!v_status.success) {
+ DEBUG(10, ("winbindd_validate_cache: validation not successful.\n"));
+ DEBUGADD(10, ("removing tdb %s.\n", cache_path));
unlink(cache_path);
}
+ DEBUG(10, ("winbindd_validate_cache: waiting for child to finish...\n"));
+ while ((wait_pid = sys_waitpid(child_pid, &child_status, 0)) < 0) {
+ if (errno == EINTR) {
+ DEBUG(10, ("winbindd_validate_cache: got signal during "
+ "waitpid, retrying\n"));
+ errno = 0;
+ continue;
+ }
+ DEBUG(0, ("winbindd_validate_cache: waitpid failed with "
+ "errno %s\n", strerror(errno)));
+ smb_panic("winbindd_validate_cache: waitpid failed.");
+ }
+ if (wait_pid != child_pid) {
+ DEBUG(0, ("winbindd_validate_cache: waitpid returned pid %d, "
+ "but %d was expexted\n", wait_pid, child_pid));
+ smb_panic("winbindd_validate_cache: waitpid returned "
+ "unexpected PID.");
+ }
+
+
+ DEBUG(10, ("winbindd_validate_cache: validating child returned.\n"));
+ if (WIFEXITED(child_status)) {
+ DEBUG(10, ("winbindd_validate_cache: child exited, code %d.\n",
+ WEXITSTATUS(child_status)));
+ ret = WEXITSTATUS(child_status);
+ }
+ if (WIFSIGNALED(child_status)) {
+ DEBUG(10, ("winbindd_validate_cache: child terminated "
+ "by signal %d%s\n",
+ WTERMSIG(child_status),
+#if defined(WCOREDUMP)
+ WCOREDUMP(child_status)?" (core dumped)":""
+#else
+ ""
+#endif
+ ));
+ ret = WTERMSIG(child_status);
+ }
+ if (WIFSTOPPED(child_status)) {
+ DEBUG(10, ("winbindd_validate_cache: child was stopped "
+ "by signal %d\n",
+ WSTOPSIG(child_status)));
+ ret = WSTOPSIG(child_status);
+ }
+
+ DEBUG(10, ("winbindd_validate_cache: restoring panic function\n"));
+ smb_panic_fn = smb_panic;
return ret;
}
git.samba.org / obnox / samba / samba-obnox.git / commitdiff