#include "includes.h"
#include "system/passwd.h"
#include "system/filesys.h"
+#include "lib/util/server_id.h"
#include "util_tdb.h"
#include "ctdbd_conn.h"
#include "../lib/util/util_pw.h"
#include "lib/util/sys_rw.h"
#include "lib/util/sys_rw_data.h"
#include "lib/util/util_process.h"
+#include "lib/dbwrap/dbwrap_ctdb.h"
+#include "lib/gencache.h"
#ifdef HAVE_SYS_PRCTL_H
#include <sys/prctl.h>
#define MAX_ALLOC_SIZE (1024*1024*256)
#if (defined(HAVE_NETGROUP) && defined (WITH_AUTOMOUNT))
+/* rpc/xdr.h uses TRUE and FALSE */
+#ifdef TRUE
+#undef TRUE
+#endif
+
+#ifdef FALSE
+#undef FALSE
+#endif
+
+#include "system/nis.h"
+
#ifdef WITH_NISPLUS_HOME
#ifdef BROKEN_NISPLUS_INCLUDE_FILES
/*
* we have reached EOF on stdin, which means the
* parent has exited. Shutdown the server
*/
+ TALLOC_FREE(fde);
(void)kill(getpid(), SIGTERM);
}
}
const char *comment)
{
NTSTATUS status = NT_STATUS_OK;
+ int ret;
+
+ /*
+ * The main process thread should never
+ * allow per_thread_cwd_enable() to be
+ * called.
+ */
+ per_thread_cwd_disable();
if (reinit_after_fork_pipe[1] != -1) {
close(reinit_after_fork_pipe[1]);
DEBUG(0,("messaging_reinit() failed: %s\n",
nt_errstr(status)));
}
+
+ if (lp_clustering()) {
+ ret = ctdb_async_ctx_reinit(
+ NULL, messaging_tevent_context(msg_ctx));
+ if (ret != 0) {
+ DBG_ERR("db_ctdb_async_ctx_reinit failed: %s\n",
+ strerror(errno));
+ return map_nt_error_from_unix(ret);
+ }
+ }
}
if (comment) {
dump_core();
}
-/*******************************************************************
- Print a backtrace of the stack to the debug log. This function
- DELIBERATELY LEAKS MEMORY. The expectation is that you should
- exit shortly after calling it.
-********************************************************************/
-
-#ifdef HAVE_LIBUNWIND_H
-#include <libunwind.h>
-#endif
-
-#ifdef HAVE_EXECINFO_H
-#include <execinfo.h>
-#endif
-
-#ifdef HAVE_LIBEXC_H
-#include <libexc.h>
-#endif
-
-void log_stack_trace(void)
-{
-#ifdef HAVE_LIBUNWIND
- /* Try to use libunwind before any other technique since on ia64
- * libunwind correctly walks the stack in more circumstances than
- * backtrace.
- */
- unw_cursor_t cursor;
- unw_context_t uc;
- unsigned i = 0;
-
- char procname[256];
- unw_word_t ip, sp, off;
-
- procname[sizeof(procname) - 1] = '\0';
-
- if (unw_getcontext(&uc) != 0) {
- goto libunwind_failed;
- }
-
- if (unw_init_local(&cursor, &uc) != 0) {
- goto libunwind_failed;
- }
-
- DEBUG(0, ("BACKTRACE:\n"));
-
- do {
- ip = sp = 0;
- unw_get_reg(&cursor, UNW_REG_IP, &ip);
- unw_get_reg(&cursor, UNW_REG_SP, &sp);
-
- switch (unw_get_proc_name(&cursor,
- procname, sizeof(procname) - 1, &off) ) {
- case 0:
- /* Name found. */
- case -UNW_ENOMEM:
- /* Name truncated. */
- DEBUGADD(0, (" #%u %s + %#llx [ip=%#llx] [sp=%#llx]\n",
- i, procname, (long long)off,
- (long long)ip, (long long) sp));
- break;
- default:
- /* case -UNW_ENOINFO: */
- /* case -UNW_EUNSPEC: */
- /* No symbol name found. */
- DEBUGADD(0, (" #%u %s [ip=%#llx] [sp=%#llx]\n",
- i, "<unknown symbol>",
- (long long)ip, (long long) sp));
- }
- ++i;
- } while (unw_step(&cursor) > 0);
-
- return;
-
-libunwind_failed:
- DEBUG(0, ("unable to produce a stack trace with libunwind\n"));
-
-#elif HAVE_BACKTRACE_SYMBOLS
- void *backtrace_stack[BACKTRACE_STACK_SIZE];
- size_t backtrace_size;
- char **backtrace_strings;
-
- /* get the backtrace (stack frames) */
- backtrace_size = backtrace(backtrace_stack,BACKTRACE_STACK_SIZE);
- backtrace_strings = backtrace_symbols(backtrace_stack, backtrace_size);
-
- DEBUG(0, ("BACKTRACE: %lu stack frames:\n",
- (unsigned long)backtrace_size));
-
- if (backtrace_strings) {
- int i;
-
- for (i = 0; i < backtrace_size; i++)
- DEBUGADD(0, (" #%u %s\n", i, backtrace_strings[i]));
-
- /* Leak the backtrace_strings, rather than risk what free() might do */
- }
-
-#elif HAVE_LIBEXC
-
- /* The IRIX libexc library provides an API for unwinding the stack. See
- * libexc(3) for details. Apparantly trace_back_stack leaks memory, but
- * since we are about to abort anyway, it hardly matters.
- */
-
-#define NAMESIZE 32 /* Arbitrary */
-
- __uint64_t addrs[BACKTRACE_STACK_SIZE];
- char * names[BACKTRACE_STACK_SIZE];
- char namebuf[BACKTRACE_STACK_SIZE * NAMESIZE];
-
- int i;
- int levels;
-
- ZERO_ARRAY(addrs);
- ZERO_ARRAY(names);
- ZERO_ARRAY(namebuf);
-
- /* We need to be root so we can open our /proc entry to walk
- * our stack. It also helps when we want to dump core.
- */
- become_root();
-
- for (i = 0; i < BACKTRACE_STACK_SIZE; i++) {
- names[i] = namebuf + (i * NAMESIZE);
- }
-
- levels = trace_back_stack(0, addrs, names,
- BACKTRACE_STACK_SIZE, NAMESIZE - 1);
-
- DEBUG(0, ("BACKTRACE: %d stack frames:\n", levels));
- for (i = 0; i < levels; i++) {
- DEBUGADD(0, (" #%d 0x%llx %s\n", i, addrs[i], names[i]));
- }
-#undef NAMESIZE
-
-#else
- DEBUG(0, ("unable to produce a stack trace on this platform\n"));
-#endif
-}
-
/*******************************************************************
A readdir wrapper which just returns the file name.
********************************************************************/
enum remote_arch_types ra;
};
-static void ra_parser(time_t timeout, DATA_BLOB blob, void *priv_data)
+static void ra_parser(const struct gencache_timeout *t,
+ DATA_BLOB blob,
+ void *priv_data)
{
struct ra_parser_state *state = (struct ra_parser_state *)priv_data;
const char *ra_str = NULL;
- if (timeout <= time(NULL)) {
+ if (gencache_timeout_expired(t)) {
return;
}
if (ISDOT(pattern))
return False;
- return ms_fnmatch(pattern, string, Protocol <= PROTOCOL_LANMAN2, is_case_sensitive) == 0;
+ return ms_fnmatch_protocol(pattern, string, Protocol, is_case_sensitive) == 0;
}
/*******************************************************************
return False;
}
-/*********************************************************
- Recursive routine that is called by unix_wild_match.
-*********************************************************/
-
-static bool unix_do_match(const char *regexp, const char *str)
-{
- const char *p;
-
- for( p = regexp; *p && *str; ) {
-
- switch(*p) {
- case '?':
- str++;
- p++;
- break;
-
- case '*':
-
- /*
- * Look for a character matching
- * the one after the '*'.
- */
- p++;
- if(!*p)
- return true; /* Automatic match */
- while(*str) {
-
- while(*str && (*p != *str))
- str++;
-
- /*
- * Patch from weidel@multichart.de. In the case of the regexp
- * '*XX*' we want to ensure there are at least 2 'X' characters
- * in the string after the '*' for a match to be made.
- */
-
- {
- int matchcount=0;
-
- /*
- * Eat all the characters that match, but count how many there were.
- */
-
- while(*str && (*p == *str)) {
- str++;
- matchcount++;
- }
-
- /*
- * Now check that if the regexp had n identical characters that
- * matchcount had at least that many matches.
- */
-
- while ( *(p+1) && (*(p+1) == *p)) {
- p++;
- matchcount--;
- }
-
- if ( matchcount <= 0 )
- return false;
- }
-
- str--; /* We've eaten the match char after the '*' */
-
- if(unix_do_match(p, str))
- return true;
-
- if(!*str)
- return false;
- else
- str++;
- }
- return false;
-
- default:
- if(*str != *p)
- return false;
- str++;
- p++;
- break;
- }
- }
-
- if(!*p && !*str)
- return true;
-
- if (!*p && str[0] == '.' && str[1] == 0)
- return true;
-
- if (!*str && *p == '?') {
- while (*p == '?')
- p++;
- return(!*p);
- }
-
- if(!*str && (*p == '*' && p[1] == '\0'))
- return true;
-
- return false;
-}
-
-/*******************************************************************
- Simple case insensitive interface to a UNIX wildcard matcher.
- Returns True if match, False if not.
-*******************************************************************/
-
-bool unix_wild_match(const char *pattern, const char *string)
-{
- TALLOC_CTX *ctx = talloc_stackframe();
- char *p2;
- char *s2;
- char *p;
- bool ret = false;
-
- p2 = talloc_strdup(ctx,pattern);
- s2 = talloc_strdup(ctx,string);
- if (!p2 || !s2) {
- TALLOC_FREE(ctx);
- return false;
- }
- if (!strlower_m(p2)) {
- TALLOC_FREE(ctx);
- return false;
- }
- if (!strlower_m(s2)) {
- TALLOC_FREE(ctx);
- return false;
- }
-
- /* Remove any *? and ** from the pattern as they are meaningless */
- for(p = p2; *p; p++) {
- while( *p == '*' && (p[1] == '?' ||p[1] == '*')) {
- memmove(&p[1], &p[2], strlen(&p[2])+1);
- }
- }
-
- if (strequal(p2,"*")) {
- TALLOC_FREE(ctx);
- return true;
- }
-
- ret = unix_do_match(p2, s2);
- TALLOC_FREE(ctx);
- return ret;
-}
-
/**********************************************************************
Converts a name to a fully qualified domain name.
Returns true if lookup succeeded, false if not (then fqdn is set to name)
return cpy;
}
+/****************************************************************************
+ Return a root token
+****************************************************************************/
+
+struct security_unix_token *root_unix_token(TALLOC_CTX *mem_ctx)
+{
+ struct security_unix_token *t = NULL;
+
+ t = talloc_zero(mem_ctx, struct security_unix_token);
+ if (t == NULL) {
+ return NULL;
+ }
+
+ /*
+ * This is not needed, but lets make it explicit, not implicit.
+ */
+ *t = (struct security_unix_token) {
+ .uid = 0,
+ .gid = 0,
+ .ngroups = 0,
+ .groups = NULL
+ };
+
+ return t;
+}
+
/****************************************************************************
Check that a file matches a particular file type.
****************************************************************************/