1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-23 17:34:34 +03:00
samba-mirror/source4/samba/server.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

1001 lines
24 KiB
C
Raw Normal View History

/*
Unix SMB/CIFS implementation.
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
Main SMB server routines
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
Copyright (C) Andrew Tridgell 1992-2005
Copyright (C) Martin Pool 2002
Copyright (C) Jelmer Vernooij 2002
Copyright (C) James J Myers 2003 <myersjj@samba.org>
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
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "lib/events/events.h"
#include "version.h"
#include "lib/cmdline/cmdline.h"
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
#include "system/dir.h"
#include "system/filesys.h"
#include "auth/gensec/gensec.h"
#include "libcli/auth/schannel.h"
#include "samba/process_model.h"
#include "param/secrets.h"
#include "lib/util/pidfile.h"
#include "param/param.h"
#include "dsdb/samdb/samdb.h"
#include "auth/session.h"
#include "lib/messaging/irpc.h"
#include "librpc/gen_ndr/ndr_irpc.h"
#include "cluster/cluster.h"
#include "dynconfig/dynconfig.h"
#include "nsswitch/winbind_client.h"
#include "libds/common/roles.h"
#include "lib/util/tfork.h"
#include "dsdb/samdb/ldb_modules/util.h"
#include "lib/util/server_id.h"
#include "server_util.h"
#ifdef HAVE_PTHREAD
#include <pthread.h>
#endif
struct server_state {
struct tevent_context *event_ctx;
const char *binary_name;
};
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
/*
recursively delete a directory tree
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
*/
static void recursive_delete(const char *path)
{
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
DIR *dir;
struct dirent *de;
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
dir = opendir(path);
if (!dir) {
return;
}
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
for (de=readdir(dir);de;de=readdir(dir)) {
char *fname;
struct stat st;
if (ISDOT(de->d_name) || ISDOTDOT(de->d_name)) {
continue;
}
fname = talloc_asprintf(path, "%s/%s", path, de->d_name);
if (stat(fname, &st) != 0) {
continue;
}
if (S_ISDIR(st.st_mode)) {
recursive_delete(fname);
talloc_free(fname);
continue;
}
if (unlink(fname) != 0) {
DBG_ERR("Unabled to delete '%s' - %s\n",
fname, strerror(errno));
smb_panic("unable to cleanup tmp files");
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
}
talloc_free(fname);
}
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
closedir(dir);
}
/*
cleanup temporary files. This is the new alternative to
TDB_CLEAR_IF_FIRST. Unfortunately TDB_CLEAR_IF_FIRST is not
efficient on unix systems due to the lack of scaling of the byte
range locking system. So instead of putting the burden on tdb to
cleanup tmp files, this function deletes them.
*/
static void cleanup_tmp_files(struct loadparm_context *lp_ctx)
{
char *path;
TALLOC_CTX *mem_ctx = talloc_new(NULL);
if (mem_ctx == NULL) {
exit_daemon("Failed to create memory context",
ENOMEM);
}
path = smbd_tmp_path(mem_ctx, lp_ctx, NULL);
if (path == NULL) {
exit_daemon("Failed to cleanup temporary files",
EINVAL);
}
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
recursive_delete(path);
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
talloc_free(mem_ctx);
}
static void sig_hup(int sig)
{
debug_schedule_reopen_logs();
}
static void sig_term(int sig)
{
#ifdef HAVE_GETPGRP
if (getpgrp() == getpid()) {
/*
* We're the process group leader, send
* SIGTERM to our process group.
*/
kill(-getpgrp(), SIGTERM);
}
#endif
_exit(127);
}
static void sigterm_signal_handler(struct tevent_context *ev,
struct tevent_signal *se,
int signum, int count, void *siginfo,
void *private_data)
{
struct server_state *state = talloc_get_type_abort(
private_data, struct server_state);
DBG_DEBUG("Process %s got SIGTERM\n", state->binary_name);
TALLOC_FREE(state);
sig_term(SIGTERM);
}
static void sighup_signal_handler(struct tevent_context *ev,
struct tevent_signal *se,
int signum, int count, void *siginfo,
void *private_data)
{
struct server_state *state = talloc_get_type_abort(
private_data, struct server_state);
DBG_DEBUG("Process %s got SIGHUP\n", state->binary_name);
reopen_logs_internal();
}
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
/*
setup signal masks
*/
static void setup_signals(void)
{
/* we are never interested in SIGPIPE */
BlockSignals(true,SIGPIPE);
#if defined(SIGFPE)
/* we are never interested in SIGFPE */
BlockSignals(true,SIGFPE);
#endif
/* We are no longer interested in USR1 */
BlockSignals(true, SIGUSR1);
#if defined(SIGUSR2)
/* We are no longer interested in USR2 */
BlockSignals(true,SIGUSR2);
#endif
/* POSIX demands that signals are inherited. If the invoking process has
* these signals masked, we will have problems,
* as we won't receive them. */
BlockSignals(false, SIGHUP);
BlockSignals(false, SIGTERM);
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
CatchSignal(SIGHUP, sig_hup);
CatchSignal(SIGTERM, sig_term);
}
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
/*
handle io on stdin
*/
static void server_stdin_handler(struct tevent_context *event_ctx,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
struct server_state *state = talloc_get_type_abort(
private_data, struct server_state);
uint8_t c;
if (read(0, &c, 1) == 0) {
DBG_ERR("%s: EOF on stdin - PID %d terminating\n",
state->binary_name, (int)getpid());
#ifdef HAVE_GETPGRP
if (getpgrp() == getpid()) {
DBG_ERR("Sending SIGTERM from pid %d\n",
(int)getpid());
kill(-getpgrp(), SIGTERM);
}
#endif
TALLOC_FREE(state);
exit(0);
}
}
/*
die if the user selected maximum runtime is exceeded
*/
_NORETURN_ static void max_runtime_handler(struct tevent_context *ev,
struct tevent_timer *te,
2009-02-02 10:41:28 +03:00
struct timeval t, void *private_data)
{
struct server_state *state = talloc_get_type_abort(
private_data, struct server_state);
DBG_ERR("%s: maximum runtime exceeded - "
"terminating PID %d at %llu, current ts: %llu\n",
state->binary_name,
(int)getpid(),
(unsigned long long)t.tv_sec,
(unsigned long long)time(NULL));
TALLOC_FREE(state);
exit(0);
}
/*
* When doing an in-place upgrade of Samba, the database format may have
* changed between versions. E.g. between 4.7 and 4.8 the DB changed from
* DN-based indexes to GUID-based indexes, so we have to re-index the DB after
* upgrading.
* This function handles migrating an older samba DB to a new Samba release.
* Note that we have to maintain DB compatibility between *all* older versions
* of Samba, not just the ones still under maintenance support.
*
* Finally, while the transaction is open, check if we support the set
* domain functional level, if the DC functional level on our object
* is correct and if not to update it (except on the RODC)
*/
static int handle_inplace_db_upgrade_check_and_update_fl(struct ldb_context *ldb_ctx,
struct loadparm_context *lp_ctx)
{
int ret;
/*
* The DSDB stack will handle reindexing the DB (if needed) upon the first
* DB write. Open and close a transaction on the DB now to trigger a
* reindex if required, rather than waiting for the first write.
* We do this here to guarantee that the DB will have been re-indexed by
* the time the main samba code runs.
* Refer to dsdb_schema_set_indices_and_attributes() for the actual reindexing
* code, called from
* source4/dsdb/samdb/ldb_modules/schema_load.c:schema_load_start_transaction()
*/
ret = ldb_transaction_start(ldb_ctx);
if (ret != LDB_SUCCESS) {
return ret;
}
ret = dsdb_check_and_update_fl(ldb_ctx, lp_ctx);
if (ret != LDB_SUCCESS) {
ldb_transaction_cancel(ldb_ctx);
return ret;
}
ret = ldb_transaction_commit(ldb_ctx);
if (ret != LDB_SUCCESS) {
return ret;
}
return LDB_SUCCESS;
}
/*
pre-open the key databases. This saves a lot of time in child
processes
*/
static int prime_ldb_databases(struct tevent_context *event_ctx, bool *am_backup)
{
struct ldb_result *res = NULL;
struct ldb_dn *samba_dsdb_dn = NULL;
struct ldb_context *ldb_ctx = NULL;
struct ldb_context *pdb = NULL;
static const char *attrs[] = { "backupDate", NULL };
struct loadparm_context *lp_ctx = samba_cmdline_get_lp_ctx();
const char *msg = NULL;
int ret;
TALLOC_CTX *db_context = talloc_new(event_ctx);
if (db_context == NULL) {
return LDB_ERR_OPERATIONS_ERROR;
}
*am_backup = false;
/* note we deliberately leave these open, which allows them to be
* re-used in ldb_wrap_connect() */
ldb_ctx = samdb_connect(db_context,
event_ctx,
lp_ctx,
system_session(lp_ctx),
NULL,
0);
if (ldb_ctx == NULL) {
talloc_free(db_context);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = handle_inplace_db_upgrade_check_and_update_fl(ldb_ctx,
lp_ctx);
if (ret != LDB_SUCCESS) {
talloc_free(db_context);
return ret;
}
pdb = privilege_connect(db_context, lp_ctx);
if (pdb == NULL) {
talloc_free(db_context);
return LDB_ERR_OPERATIONS_ERROR;
}
/* check the root DB object to see if it's marked as a backup */
samba_dsdb_dn = ldb_dn_new(db_context, ldb_ctx, "@SAMBA_DSDB");
if (!samba_dsdb_dn) {
talloc_free(db_context);
return LDB_ERR_OPERATIONS_ERROR;
}
ret = dsdb_search_dn(ldb_ctx, db_context, &res, samba_dsdb_dn, attrs,
DSDB_FLAG_AS_SYSTEM);
if (ret != LDB_SUCCESS) {
talloc_free(db_context);
return ret;
}
if (res->count > 0) {
msg = ldb_msg_find_attr_as_string(res->msgs[0], "backupDate",
NULL);
if (msg != NULL) {
*am_backup = true;
}
}
return LDB_SUCCESS;
}
/*
called from 'smbcontrol samba shutdown'
*/
static void samba_parent_shutdown(struct imessaging_context *msg,
void *private_data,
uint32_t msg_type,
struct server_id src,
size_t num_fds,
int *fds,
DATA_BLOB *data)
{
struct server_state *state =
talloc_get_type_abort(private_data,
struct server_state);
struct server_id_buf src_buf;
struct server_id dst = imessaging_get_server_id(msg);
struct server_id_buf dst_buf;
if (num_fds != 0) {
DBG_WARNING("Received %zu fds, ignoring message\n", num_fds);
return;
}
DBG_ERR("samba_shutdown of %s %s: from %s\n",
state->binary_name,
server_id_str_buf(dst, &dst_buf),
server_id_str_buf(src, &src_buf));
TALLOC_FREE(state);
exit(0);
}
/*
called when a fatal condition occurs in a child task
*/
static NTSTATUS samba_terminate(struct irpc_message *msg,
struct samba_terminate *r)
{
struct server_state *state = talloc_get_type(msg->private_data,
struct server_state);
DBG_ERR("samba_terminate of %s %d: %s\n",
state->binary_name, (int)getpid(), r->in.reason);
TALLOC_FREE(state);
exit(1);
}
/*
setup messaging for the top level samba (parent) task
*/
static NTSTATUS setup_parent_messaging(struct server_state *state,
struct loadparm_context *lp_ctx)
{
struct imessaging_context *msg;
NTSTATUS status;
if (state == NULL) {
return NT_STATUS_UNSUCCESSFUL;
}
msg = imessaging_init(state->event_ctx,
lp_ctx,
cluster_id(getpid(), SAMBA_PARENT_TASKID),
state->event_ctx);
NT_STATUS_HAVE_NO_MEMORY(msg);
status = irpc_add_name(msg, "samba");
if (!NT_STATUS_IS_OK(status)) {
return status;
}
status = imessaging_register(msg, state, MSG_SHUTDOWN,
samba_parent_shutdown);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
status = IRPC_REGISTER(msg, irpc, SAMBA_TERMINATE,
samba_terminate, state);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return NT_STATUS_OK;
}
/*
show build info
*/
static void show_build(void)
{
#define CONFIG_OPTION(n) { #n, dyn_ ## n }
struct {
const char *name;
const char *value;
} config_options[] = {
CONFIG_OPTION(BINDIR),
CONFIG_OPTION(SBINDIR),
CONFIG_OPTION(CONFIGFILE),
CONFIG_OPTION(NCALRPCDIR),
CONFIG_OPTION(LOGFILEBASE),
CONFIG_OPTION(LMHOSTSFILE),
CONFIG_OPTION(DATADIR),
CONFIG_OPTION(MODULESDIR),
CONFIG_OPTION(LOCKDIR),
CONFIG_OPTION(STATEDIR),
CONFIG_OPTION(CACHEDIR),
CONFIG_OPTION(PIDDIR),
CONFIG_OPTION(PRIVATE_DIR),
CONFIG_OPTION(CODEPAGEDIR),
CONFIG_OPTION(SETUPDIR),
CONFIG_OPTION(WINBINDD_SOCKET_DIR),
CONFIG_OPTION(NTP_SIGND_SOCKET_DIR),
{ NULL, NULL}
};
int i;
printf("Samba version: %s\n", SAMBA_VERSION_STRING);
printf("Build environment:\n");
printf("Paths:\n");
for (i=0; config_options[i].name; i++) {
printf(" %s: %s\n",
config_options[i].name,
config_options[i].value);
}
exit(0);
}
static int event_ctx_destructor(struct tevent_context *event_ctx)
{
imessaging_dgm_unref_ev(event_ctx);
return 0;
}
#ifdef HAVE_PTHREAD
static int to_children_fd = -1;
static void atfork_prepare(void) {
}
static void atfork_parent(void) {
}
static void atfork_child(void) {
if (to_children_fd != -1) {
close(to_children_fd);
to_children_fd = -1;
}
}
#endif
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
/*
main server.
*/
static int binary_smbd_main(TALLOC_CTX *mem_ctx,
const char *binary_name,
int argc,
const char *argv[])
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
{
struct samba_cmdline_daemon_cfg *cmdline_daemon_cfg = NULL;
bool db_is_backup = false;
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
int opt;
int ret;
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
poptContext pc;
uint16_t stdin_event_flags;
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
NTSTATUS status;
const char *model = "prefork";
int max_runtime = 0;
struct stat st;
enum {
OPT_PROCESS_MODEL = 1000,
OPT_SHOW_BUILD,
};
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
struct poptOption long_options[] = {
POPT_AUTOHELP
{
.longName = "model",
.shortName = 'M',
.argInfo = POPT_ARG_STRING,
.val = OPT_PROCESS_MODEL,
.descrip = "Select process model",
.argDescrip = "MODEL",
},
{
.longName = "maximum-runtime",
.argInfo = POPT_ARG_INT,
.arg = &max_runtime,
.descrip = "set maximum runtime of the server process, "
"till autotermination",
.argDescrip = "seconds"
},
{
.longName = "show-build",
.shortName = 'b',
.argInfo = POPT_ARG_NONE,
.val = OPT_SHOW_BUILD,
.descrip = "show build info",
},
POPT_COMMON_SAMBA
POPT_COMMON_DAEMON
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
POPT_COMMON_VERSION
POPT_TABLEEND
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
};
struct server_state *state = NULL;
struct tevent_signal *se = NULL;
struct samba_tevent_trace_state *samba_tevent_trace_state = NULL;
struct loadparm_context *lp_ctx = NULL;
bool ok;
setproctitle("root process");
ok = samba_cmdline_init(mem_ctx,
SAMBA_CMDLINE_CONFIG_SERVER,
true /* require_smbconf */);
if (!ok) {
DBG_ERR("Failed to init cmdline parser!\n");
TALLOC_FREE(mem_ctx);
exit(1);
}
cmdline_daemon_cfg = samba_cmdline_get_daemon_cfg();
pc = samba_popt_get_context(binary_name,
argc,
argv,
long_options,
0);
if (pc == NULL) {
DBG_ERR("Failed to setup popt context!\n");
TALLOC_FREE(mem_ctx);
exit(1);
}
while((opt = poptGetNextOpt(pc)) != -1) {
switch(opt) {
case OPT_PROCESS_MODEL:
model = poptGetOptArg(pc);
break;
case OPT_SHOW_BUILD:
show_build();
break;
default:
fprintf(stderr, "\nInvalid option %s: %s\n\n",
poptBadOption(pc, 0), poptStrerror(opt));
poptPrintUsage(pc, stderr, 0);
return 1;
}
}
if (cmdline_daemon_cfg->daemon && cmdline_daemon_cfg->interactive) {
fprintf(stderr,"\nERROR: "
"Option -i|--interactive is "
"not allowed together with -D|--daemon\n\n");
poptPrintUsage(pc, stderr, 0);
return 1;
} else if (!cmdline_daemon_cfg->interactive &&
cmdline_daemon_cfg->fork) {
/* default is --daemon */
cmdline_daemon_cfg->daemon = true;
}
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
poptFreeContext(pc);
lp_ctx = samba_cmdline_get_lp_ctx();
talloc_enable_null_tracking();
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
setup_signals();
/* we want total control over the permissions on created files,
so set our umask to 0 */
umask(0);
DBG_STARTUP_NOTICE("%s version %s started.\n"
COPYRIGHT_STARTUP_MESSAGE "\n",
binary_name,
SAMBA_VERSION_STRING);
if (sizeof(uint16_t) < 2 ||
sizeof(uint32_t) < 4 ||
sizeof(uint64_t) < 8) {
DEBUG(0,("ERROR: Samba is not configured correctly "
"for the word size on your machine\n"));
DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, "
"sizeof(uint64_t) = %u\n",
(unsigned int)sizeof(uint16_t),
(unsigned int)sizeof(uint32_t),
(unsigned int)sizeof(uint64_t)));
return 1;
}
if (cmdline_daemon_cfg->daemon) {
DBG_NOTICE("Becoming a daemon.\n");
become_daemon(cmdline_daemon_cfg->fork,
cmdline_daemon_cfg->no_process_group,
false);
} else if (!cmdline_daemon_cfg->interactive) {
daemon_status("samba", "Starting process...");
}
/* Create the memory context to hang everything off. */
state = talloc_zero(mem_ctx, struct server_state);
if (state == NULL) {
exit_daemon("Samba cannot create server state", ENOMEM);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
};
state->binary_name = binary_name;
cleanup_tmp_files(lp_ctx);
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
if (!directory_exist(lpcfg_lock_directory(lp_ctx))) {
mkdir(lpcfg_lock_directory(lp_ctx), 0755);
}
if (!directory_exist(lpcfg_pid_directory(lp_ctx))) {
mkdir(lpcfg_pid_directory(lp_ctx), 0755);
}
pidfile_create(lpcfg_pid_directory(lp_ctx), binary_name);
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
if (lpcfg_server_role(lp_ctx) == ROLE_ACTIVE_DIRECTORY_DC) {
if (!open_schannel_session_store(state,
lp_ctx)) {
TALLOC_FREE(state);
exit_daemon("Samba cannot open schannel store "
"for secured NETLOGON operations.", EACCES);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
}
/* make sure we won't go through nss_winbind */
if (!winbind_off()) {
TALLOC_FREE(state);
exit_daemon("Samba failed to disable recursive "
"winbindd calls.", EACCES);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
gensec_init(); /* FIXME: */
process_model_init(lp_ctx);
samba_service_init();
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
/* the event context is the top level structure in smbd. Everything else
should hang off that */
state->event_ctx = s4_event_context_init(state);
if (state->event_ctx == NULL) {
TALLOC_FREE(state);
exit_daemon("Initializing event context failed", EACCES);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
talloc_set_destructor(state->event_ctx, event_ctx_destructor);
samba_tevent_trace_state = create_samba_tevent_trace_state(state);
if (samba_tevent_trace_state == NULL) {
exit_daemon("Samba failed to setup tevent tracing state",
ENOTTY);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
tevent_set_trace_callback(state->event_ctx,
samba_tevent_trace_callback,
samba_tevent_trace_state);
if (cmdline_daemon_cfg->interactive) {
/* terminate when stdin goes away */
2009-01-03 17:24:31 +03:00
stdin_event_flags = TEVENT_FD_READ;
} else {
/* stay alive forever */
stdin_event_flags = 0;
}
#ifdef HAVE_SETPGID
/*
* If we're interactive we want to set our own process group for
* signal management, unless --no-process-group specified.
*/
if (cmdline_daemon_cfg->interactive &&
!cmdline_daemon_cfg->no_process_group)
{
setpgid((pid_t)0, (pid_t)0);
}
#endif
/* catch EOF on stdin */
#ifdef SIGTTIN
signal(SIGTTIN, SIG_IGN);
#endif
if (fstat(0, &st) != 0) {
TALLOC_FREE(state);
exit_daemon("Samba failed to set standard input handler",
ENOTTY);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
struct tevent_fd *fde = tevent_add_fd(state->event_ctx,
state->event_ctx,
0,
stdin_event_flags,
server_stdin_handler,
state);
if (fde == NULL) {
TALLOC_FREE(state);
exit_daemon("Initializing stdin failed", ENOMEM);
/*
* return is never reached but is here to
* satisfy static checkers
*/
return 1;
}
}
if (max_runtime) {
struct tevent_timer *te;
DBG_ERR("%s PID %d was called with maxruntime %d - "
"current ts %llu\n",
binary_name, (int)getpid(),
max_runtime, (unsigned long long) time(NULL));
te = tevent_add_timer(state->event_ctx, state->event_ctx,
2009-01-03 17:24:31 +03:00
timeval_current_ofs(max_runtime, 0),
max_runtime_handler,
state);
if (te == NULL) {
TALLOC_FREE(state);
exit_daemon("Maxruntime handler failed", ENOMEM);
/*
* return is never reached but is here to
* satisfy static checkers
*/
return 1;
}
}
se = tevent_add_signal(state->event_ctx,
state->event_ctx,
SIGTERM,
0,
sigterm_signal_handler,
state);
if (se == NULL) {
TALLOC_FREE(state);
exit_daemon("Initialize SIGTERM handler failed", ENOMEM);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
se = tevent_add_signal(state->event_ctx,
state->event_ctx,
SIGHUP,
0,
sighup_signal_handler,
state);
if (se == NULL) {
TALLOC_FREE(state);
exit_daemon("Initialize SIGHUP handler failed", ENOMEM);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
if (lpcfg_server_role(lp_ctx) != ROLE_ACTIVE_DIRECTORY_DC
&& !lpcfg_parm_bool(lp_ctx, NULL,
"server role check", "inhibit", false)
&& !str_list_check_ci(lpcfg_server_services(lp_ctx), "smb")
&& !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(lp_ctx),
"remote")
&& !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(lp_ctx),
"mapiproxy")) {
DEBUG(0, ("At this time the 'samba' binary should only be used "
"for either:\n"));
DEBUGADD(0, ("'server role = active directory domain "
"controller' or the rpc proxy "
"with 'dcerpc endpoint servers = remote'\n"));
DEBUGADD(0, ("You should start smbd/nmbd/winbindd instead for "
"domain member and standalone file server tasks\n"));
exit_daemon("Samba detected misconfigured 'server role' "
"and exited. Check logs for details", EINVAL);
};
ret = prime_ldb_databases(state->event_ctx, &db_is_backup);
if (ret != LDB_SUCCESS) {
TALLOC_FREE(state);
exit_daemon("Samba failed to prime database", EINVAL);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
if (db_is_backup) {
TALLOC_FREE(state);
exit_daemon("Database is a backup. Please run samba-tool domain"
" backup restore", EINVAL);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
status = setup_parent_messaging(state, lp_ctx);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(state);
exit_daemon("Samba failed to setup parent messaging",
NT_STATUS_V(status));
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
DBG_ERR("%s: using '%s' process model\n", binary_name, model);
{
int child_pipe[2];
int rc;
bool start_services = false;
rc = pipe(child_pipe);
if (rc < 0) {
TALLOC_FREE(state);
exit_daemon("Samba failed to open process control pipe",
errno);
/*
* return is never reached but is here to satisfy static
* checkers
*/
return 1;
}
smb_set_close_on_exec(child_pipe[0]);
smb_set_close_on_exec(child_pipe[1]);
#ifdef HAVE_PTHREAD
to_children_fd = child_pipe[1];
pthread_atfork(atfork_prepare, atfork_parent,
atfork_child);
start_services = true;
#else
pid_t pid;
struct tfork *t = NULL;
t = tfork_create();
if (t == NULL) {
exit_daemon(
"Samba unable to fork master process",
0);
}
pid = tfork_child_pid(t);
if (pid == 0) {
start_services = false;
} else {
/* In the child process */
start_services = true;
close(child_pipe[1]);
}
#endif
if (start_services) {
status = server_service_startup(
state->event_ctx, lp_ctx, model,
lpcfg_server_services(lp_ctx),
child_pipe[0]);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(state);
exit_daemon("Samba failed to start services",
NT_STATUS_V(status));
/*
* return is never reached but is here to
* satisfy static checkers
*/
return 1;
}
}
}
if (!cmdline_daemon_cfg->interactive) {
daemon_ready("samba");
}
r5102: This is a major simplification of the logic for controlling top level servers in smbd. The old code still contained a fairly bit of legacy from the time when smbd was only handling SMB connection. The new code gets rid of all of the smb_server specific code in smbd/, and creates a much simpler infrastructures for new server code. Major changes include: - simplified the process model code a lot. - got rid of the top level server and service structures completely. The top level context is now the event_context. This got rid of service.h and server.h completely (they were the most confusing parts of the old code) - added service_stream.[ch] for the helper functions that are specific to stream type services (services that handle streams, and use a logically separate process per connection) - got rid of the builtin idle_handler code in the service logic, as none of the servers were using it, and it can easily be handled by a server in future by adding its own timed_event to the event context. - fixed some major memory leaks in the rpc server code. - added registration of servers, rather than hard coding our list of possible servers. This allows for servers as modules in the future. - temporarily disabled the winbind code until I add the helper functions for that type of server - added error checking on service startup. If a configured server fails to startup then smbd doesn't startup. - cleaned up the command line handling in smbd, removing unused options (This used to be commit cf6a46c3cbde7b1eb1b86bd3882b953a2de3a42e)
2005-01-30 03:54:57 +03:00
/* wait for events - this is where smbd sits for most of its
life */
tevent_loop_wait(state->event_ctx);
/* as everything hangs off this state->event context, freeing state
will initiate a clean shutdown of all services */
TALLOC_FREE(state);
return 0;
}
int main(int argc, const char *argv[])
{
TALLOC_CTX *mem_ctx = NULL;
int rc;
mem_ctx = talloc_init("samba/server.c#main");
if (mem_ctx == NULL) {
exit(ENOMEM);
}
setproctitle_init(argc, discard_const(argv), environ);
rc = binary_smbd_main(mem_ctx, "samba", argc, argv);
TALLOC_FREE(mem_ctx);
return rc;
}