bool db_is_local(const char *name)
{
#ifdef CLUSTER_SUPPORT
const char *sockname = lp_ctdbd_socket();
if(!sockname || !*sockname) {
sockname = CTDB_PATH;
}
if (lp_clustering() && socket_exist(sockname)) {
const char *partname;
/* ctdb only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "ctdb", partname, True)) {
return false;
}
}
#endif
return true;
}
/**
* open a database
*/
struct db_context *db_open(TALLOC_CTX *mem_ctx,
const char *name,
int hash_size, int tdb_flags,
int open_flags, mode_t mode)
{
struct db_context *result = NULL;
#ifdef CLUSTER_SUPPORT
const char *sockname = lp_ctdbd_socket();
if(!sockname || !*sockname) {
sockname = CTDB_PATH;
}
if (lp_clustering()) {
const char *partname;
if (!socket_exist(sockname)) {
DEBUG(1, ("ctdb socket does not exist - is ctdb not "
"running?\n"));
return NULL;
}
/* ctdb only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "ctdb", partname, True)) {
result = db_open_ctdb(mem_ctx, partname, hash_size,
tdb_flags, open_flags, mode);
if (result == NULL) {
DEBUG(0,("failed to attach to ctdb %s\n",
partname));
if (errno == 0) {
errno = EIO;
}
return NULL;
}
}
}
#endif
if (result == NULL) {
result = db_open_tdb(mem_ctx, name, hash_size,
tdb_flags, open_flags, mode);
}
if ((result != NULL) && (result->fetch == NULL)) {
result->fetch = dbwrap_fallback_fetch;
}
if ((result != NULL) && (result->parse_record == NULL)) {
result->parse_record = dbwrap_fallback_parse_record;
}
return result;
}
static bool smbconf_reg_requires_messaging(struct smbconf_ctx *ctx)
{
#ifdef CLUSTER_SUPPORT
if (lp_clustering() && lp_parm_bool(-1, "ctdb", "registry.tdb", true)) {
return true;
}
#endif
return false;
}
struct tevent_req *ctdb_conn_init_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
const char *sock)
{
struct tevent_req *req, *subreq;
struct ctdb_conn_init_state *state;
req = tevent_req_create(mem_ctx, &state, struct ctdb_conn_init_state);
if (req == NULL) {
return NULL;
}
if (!lp_clustering()) {
tevent_req_error(req, ENOSYS);
return tevent_req_post(req, ev);
}
if (strlen(sock) >= sizeof(state->addr.sun_path)) {
tevent_req_error(req, ENAMETOOLONG);
return tevent_req_post(req, ev);
}
state->conn = talloc(state, struct ctdb_conn);
if (tevent_req_nomem(state->conn, req)) {
return tevent_req_post(req, ev);
}
state->conn->outqueue = tevent_queue_create(
state->conn, "ctdb outqueue");
if (tevent_req_nomem(state->conn->outqueue, req)) {
return tevent_req_post(req, ev);
}
state->conn->fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (state->conn->fd == -1) {
tevent_req_error(req, errno);
return tevent_req_post(req, ev);
}
talloc_set_destructor(state->conn, ctdb_conn_destructor);
state->addr.sun_family = AF_UNIX;
strncpy(state->addr.sun_path, sock, sizeof(state->addr.sun_path));
subreq = async_connect_send(state, ev, state->conn->fd,
(struct sockaddr *)&state->addr,
sizeof(state->addr), before_connect_cb,
after_connect_cb, NULL);
if (tevent_req_nomem(subreq, req)) {
return tevent_req_post(req, ev);
}
tevent_req_set_callback(subreq, ctdb_conn_init_done, req);
return req;
}
bool serverid_exists(const struct server_id *id)
{
if (procid_is_local(id)) {
return serverid_exists_local(id);
}
if (lp_clustering()) {
return ctdbd_process_exists(messaging_ctdb_connection(),
id->vnn, id->pid, id->unique_id);
}
return false;
}
bool cluster_probe_ok(void)
{
if (lp_clustering()) {
int ret;
ret = ctdbd_probe(lp_ctdbd_socket(), lp_ctdb_timeout());
if (ret != 0) {
DEBUG(0, ("clustering=yes but ctdbd connect failed: "
"%s\n", strerror(ret)));
return false;
}
}
return true;
}
bool serverid_register(const struct server_id id, uint32_t msg_flags)
{
struct db_context *db;
struct serverid_key key;
struct serverid_data data;
struct db_record *rec;
TDB_DATA tdbkey, tdbdata;
NTSTATUS status;
bool ret = false;
db = serverid_db();
if (db == NULL) {
return false;
}
serverid_fill_key(&id, &key);
tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
rec = dbwrap_fetch_locked(db, talloc_tos(), tdbkey);
if (rec == NULL) {
DEBUG(1, ("Could not fetch_lock serverid.tdb record\n"));
return false;
}
ZERO_STRUCT(data);
data.unique_id = id.unique_id;
data.msg_flags = msg_flags;
tdbdata = make_tdb_data((uint8_t *)&data, sizeof(data));
status = dbwrap_record_store(rec, tdbdata, 0);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("Storing serverid.tdb record failed: %s\n",
nt_errstr(status)));
goto done;
}
if (lp_clustering() &&
ctdb_serverids_exist_supported(messaging_ctdbd_connection()))
{
register_with_ctdbd(messaging_ctdbd_connection(), id.unique_id,
NULL, NULL);
}
ret = true;
done:
TALLOC_FREE(rec);
return ret;
}
bool serverids_exist(const struct server_id *ids, int num_ids, bool *results)
{
struct db_context *db;
int i;
#ifdef HAVE_CTDB_CONTROL_CHECK_SRVIDS_DECL
if (lp_clustering()) {
return ctdb_serverids_exist(messaging_ctdbd_connection(),
ids, num_ids, results);
}
#endif
if (!processes_exist(ids, num_ids, results)) {
return false;
}
db = serverid_db();
if (db == NULL) {
return false;
}
for (i=0; i<num_ids; i++) {
struct serverid_exists_state state;
struct serverid_key key;
TDB_DATA tdbkey;
if (ids[i].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
results[i] = true;
continue;
}
if (!results[i]) {
continue;
}
serverid_fill_key(&ids[i], &key);
tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
state.id = &ids[i];
state.exists = false;
dbwrap_parse_record(db, tdbkey, server_exists_parse, &state);
results[i] = state.exists;
}
return true;
}
bool notify_internal_parent_init(TALLOC_CTX *mem_ctx)
{
struct tdb_wrap *db1, *db2;
struct loadparm_context *lp_ctx;
if (lp_clustering()) {
return true;
}
lp_ctx = loadparm_init_s3(mem_ctx, loadparm_s3_context());
if (lp_ctx == NULL) {
DEBUG(0, ("loadparm_init_s3 failed\n"));
return false;
}
/*
* Open the tdbs in the parent process (smbd) so that our
* CLEAR_IF_FIRST optimization in tdb_reopen_all can properly
* work.
*/
db1 = tdb_wrap_open(mem_ctx, lock_path("notify.tdb"),
0, TDB_SEQNUM|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
O_RDWR|O_CREAT, 0644, lp_ctx);
if (db1 == NULL) {
talloc_unlink(mem_ctx, lp_ctx);
DEBUG(1, ("could not open notify.tdb: %s\n", strerror(errno)));
return false;
}
db2 = tdb_wrap_open(mem_ctx, lock_path("notify_onelevel.tdb"),
0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDWR|O_CREAT, 0644, lp_ctx);
talloc_unlink(mem_ctx, lp_ctx);
if (db2 == NULL) {
DEBUG(1, ("could not open notify_onelevel.tdb: %s\n",
strerror(errno)));
TALLOC_FREE(db1);
return false;
}
return true;
}
static void smbd_accept_connection(struct tevent_context *ev,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
struct smbd_open_socket *s = talloc_get_type_abort(private_data,
struct smbd_open_socket);
struct messaging_context *msg_ctx = s->msg_ctx;
struct smbd_server_connection *sconn = msg_ctx_to_sconn(msg_ctx);
struct sockaddr_storage addr;
socklen_t in_addrlen = sizeof(addr);
int fd;
pid_t pid = 0;
uint64_t unique_id;
fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
sconn->sock = fd;
if (fd == -1 && errno == EINTR)
return;
if (fd == -1) {
DEBUG(0,("open_sockets_smbd: accept: %s\n",
strerror(errno)));
return;
}
if (s->parent->interactive) {
smbd_process(ev, sconn);
exit_server_cleanly("end of interactive mode");
return;
}
if (!allowable_number_of_smbd_processes()) {
close(fd);
sconn->sock = -1;
return;
}
/*
* Generate a unique id in the parent process so that we use
* the global random state in the parent.
*/
generate_random_buffer((uint8_t *)&unique_id, sizeof(unique_id));
pid = sys_fork();
if (pid == 0) {
NTSTATUS status = NT_STATUS_OK;
/* Child code ... */
am_parent = 0;
set_my_unique_id(unique_id);
/* Stop zombies, the parent explicitly handles
* them, counting worker smbds. */
CatchChild();
/* close our standard file
descriptors */
if (!debug_get_output_is_stdout()) {
close_low_fds(False); /* Don't close stderr */
}
/*
* Can't use TALLOC_FREE here. Nulling out the argument to it
* would overwrite memory we've just freed.
*/
talloc_free(s->parent);
s = NULL;
status = reinit_after_fork(msg_ctx,
ev,
procid_self(),
true);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,
NT_STATUS_TOO_MANY_OPENED_FILES)) {
DEBUG(0,("child process cannot initialize "
"because too many files are open\n"));
goto exit;
}
if (lp_clustering() &&
NT_STATUS_EQUAL(status,
NT_STATUS_INTERNAL_DB_ERROR)) {
DEBUG(1,("child process cannot initialize "
"because connection to CTDB "
"has failed\n"));
goto exit;
}
DEBUG(0,("reinit_after_fork() failed\n"));
smb_panic("reinit_after_fork() failed");
}
smbd_setup_sig_term_handler();
smbd_setup_sig_hup_handler(ev,
msg_ctx);
if (!serverid_register(procid_self(),
FLAG_MSG_GENERAL|FLAG_MSG_SMBD
|FLAG_MSG_DBWRAP
|FLAG_MSG_PRINT_GENERAL)) {
exit_server_cleanly("Could not register myself in "
"serverid.tdb");
}
smbd_process(ev, sconn);
exit:
exit_server_cleanly("end of child");
return;
}
if (pid < 0) {
DEBUG(0,("smbd_accept_connection: sys_fork() failed: %s\n",
strerror(errno)));
}
/* The parent doesn't need this socket */
close(fd);
/* Sun May 6 18:56:14 2001 [email protected]:
Clear the closed fd info out of server_fd --
and more importantly, out of client_fd in
util_sock.c, to avoid a possible
getpeername failure if we reopen the logs
and use %I in the filename.
*/
sconn->sock = -1;
if (pid != 0) {
add_child_pid(pid);
}
/* Force parent to check log size after
* spawning child. Fix from
* [email protected]. The
* parent smbd will log to logserver.smb. It
* writes only two messages for each child
* started/finished. But each child writes,
* say, 50 messages also in logserver.smb,
* begining with the debug_count of the
* parent, before the child opens its own log
* file logserver.client. In a worst case
* scenario the size of logserver.smb would be
* checked after about 50*50=2500 messages
* (ca. 100kb).
* */
force_check_log_size();
}
/**
* open a database
*/
struct db_context *db_open(TALLOC_CTX *mem_ctx,
const char *name,
int hash_size, int tdb_flags,
int open_flags, mode_t mode,
enum dbwrap_lock_order lock_order,
uint64_t dbwrap_flags)
{
struct db_context *result = NULL;
const char *sockname;
if (!DBWRAP_LOCK_ORDER_VALID(lock_order)) {
errno = EINVAL;
return NULL;
}
if (tdb_flags & TDB_CLEAR_IF_FIRST) {
const char *base;
bool try_readonly = false;
base = strrchr_m(name, '/');
if (base != NULL) {
base += 1;
} else {
base = name;
}
if (dbwrap_flags & DBWRAP_FLAG_OPTIMIZE_READONLY_ACCESS) {
try_readonly = true;
}
try_readonly = lp_parm_bool(-1, "dbwrap_optimize_readonly", "*", try_readonly);
try_readonly = lp_parm_bool(-1, "dbwrap_optimize_readonly", base, try_readonly);
if (try_readonly) {
dbwrap_flags |= DBWRAP_FLAG_OPTIMIZE_READONLY_ACCESS;
} else {
dbwrap_flags &= ~DBWRAP_FLAG_OPTIMIZE_READONLY_ACCESS;
}
}
if (tdb_flags & TDB_CLEAR_IF_FIRST) {
const char *base;
bool try_mutex = true;
bool require_mutex = false;
base = strrchr_m(name, '/');
if (base != NULL) {
base += 1;
} else {
base = name;
}
try_mutex = lp_parm_bool(-1, "dbwrap_tdb_mutexes", "*", try_mutex);
try_mutex = lp_parm_bool(-1, "dbwrap_tdb_mutexes", base, try_mutex);
if (!lp_use_mmap()) {
/*
* Mutexes require mmap. "use mmap = no" can
* be a debugging tool, so let it override the
* mutex parameters
*/
try_mutex = false;
}
if (try_mutex && tdb_runtime_check_for_robust_mutexes()) {
tdb_flags |= TDB_MUTEX_LOCKING;
}
require_mutex = lp_parm_bool(-1, "dbwrap_tdb_require_mutexes",
"*", require_mutex);
require_mutex = lp_parm_bool(-1, "dbwrap_tdb_require_mutexes",
base, require_mutex);
if (require_mutex) {
tdb_flags |= TDB_MUTEX_LOCKING;
}
}
sockname = lp_ctdbd_socket();
if (lp_clustering()) {
const char *partname;
if (!socket_exist(sockname)) {
DEBUG(1, ("ctdb socket does not exist - is ctdb not "
"running?\n"));
return NULL;
}
/* ctdb only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "ctdb", partname, True)) {
struct messaging_context *msg_ctx;
struct ctdbd_connection *conn;
conn = messaging_ctdb_connection();
if (conn == NULL) {
DBG_WARNING("No ctdb connection\n");
errno = EIO;
return NULL;
}
msg_ctx = server_messaging_context();
result = db_open_ctdb(mem_ctx, msg_ctx, partname,
hash_size,
tdb_flags, open_flags, mode,
lock_order, dbwrap_flags);
if (result == NULL) {
DEBUG(0,("failed to attach to ctdb %s\n",
partname));
if (errno == 0) {
errno = EIO;
}
return NULL;
}
}
}
if (result == NULL) {
struct loadparm_context *lp_ctx = loadparm_init_s3(mem_ctx, loadparm_s3_helpers());
if (hash_size == 0) {
hash_size = lpcfg_tdb_hash_size(lp_ctx, name);
}
tdb_flags = lpcfg_tdb_flags(lp_ctx, tdb_flags);
result = dbwrap_local_open(
mem_ctx,
name,
hash_size,
tdb_flags,
open_flags,
mode,
lock_order,
dbwrap_flags);
talloc_unlink(mem_ctx, lp_ctx);
}
return result;
}
static bool open_sockets_smbd(struct smbd_parent_context *parent,
struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
const char *smb_ports)
{
int num_interfaces = iface_count();
int i,j;
const char **ports;
unsigned dns_port = 0;
#ifdef HAVE_ATEXIT
atexit(killkids);
#endif
/* Stop zombies */
smbd_setup_sig_chld_handler(parent);
ports = lp_smb_ports();
/* use a reasonable default set of ports - listing on 445 and 139 */
if (smb_ports) {
char **l;
l = str_list_make_v3(talloc_tos(), smb_ports, NULL);
ports = discard_const_p(const char *, l);
}
for (j = 0; ports && ports[j]; j++) {
unsigned port = atoi(ports[j]);
if (port == 0 || port > 0xffff) {
exit_server_cleanly("Invalid port in the config or on "
"the commandline specified!");
}
}
if (lp_interfaces() && lp_bind_interfaces_only()) {
/* We have been given an interfaces line, and been
told to only bind to those interfaces. Create a
socket per interface and bind to only these.
*/
/* Now open a listen socket for each of the
interfaces. */
for(i = 0; i < num_interfaces; i++) {
const struct sockaddr_storage *ifss =
iface_n_sockaddr_storage(i);
if (ifss == NULL) {
DEBUG(0,("open_sockets_smbd: "
"interface %d has NULL IP address !\n",
i));
continue;
}
for (j = 0; ports && ports[j]; j++) {
unsigned port = atoi(ports[j]);
/* Keep the first port for mDNS service
* registration.
*/
if (dns_port == 0) {
dns_port = port;
}
if (!smbd_open_one_socket(parent,
ev_ctx,
ifss,
port)) {
return false;
}
}
}
} else {
/* Just bind to 0.0.0.0 - accept connections
from anywhere. */
const char *sock_addr;
char *sock_tok;
const char *sock_ptr;
#if HAVE_IPV6
sock_addr = "::,0.0.0.0";
#else
sock_addr = "0.0.0.0";
#endif
for (sock_ptr=sock_addr;
next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
for (j = 0; ports && ports[j]; j++) {
struct sockaddr_storage ss;
unsigned port = atoi(ports[j]);
/* Keep the first port for mDNS service
* registration.
*/
if (dns_port == 0) {
dns_port = port;
}
/* open an incoming socket */
if (!interpret_string_addr(&ss, sock_tok,
AI_NUMERICHOST|AI_PASSIVE)) {
continue;
}
/*
* If we fail to open any sockets
* in this loop the parent-sockets == NULL
* case below will prevent us from starting.
*/
(void)smbd_open_one_socket(parent,
ev_ctx,
&ss,
port);
}
}
}
if (parent->sockets == NULL) {
DEBUG(0,("open_sockets_smbd: No "
"sockets available to bind to.\n"));
return false;
}
/* Setup the main smbd so that we can get messages. Note that
do this after starting listening. This is needed as when in
clustered mode, ctdb won't allow us to start doing database
operations until it has gone thru a full startup, which
includes checking to see that smbd is listening. */
if (!serverid_register(messaging_server_id(msg_ctx),
FLAG_MSG_GENERAL|FLAG_MSG_SMBD
|FLAG_MSG_PRINT_GENERAL
|FLAG_MSG_DBWRAP)) {
DEBUG(0, ("open_sockets_smbd: Failed to register "
"myself in serverid.tdb\n"));
return false;
}
/* Listen to messages */
messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
smbd_parent_conf_updated);
messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
smb_stat_cache_delete);
messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
messaging_register(msg_ctx, NULL, MSG_SMB_BRL_VALIDATE,
brl_revalidate);
messaging_register(msg_ctx, NULL, MSG_SMB_FORCE_TDIS,
smb_parent_send_to_children);
messaging_register(msg_ctx, NULL, MSG_SMB_KILL_CLIENT_IP,
smb_parent_send_to_children);
messaging_register(msg_ctx, NULL, MSG_SMB_TELL_NUM_CHILDREN,
smb_tell_num_children);
messaging_register(msg_ctx, NULL,
ID_CACHE_DELETE, smbd_parent_id_cache_delete);
messaging_register(msg_ctx, NULL,
ID_CACHE_KILL, smbd_parent_id_cache_kill);
if (lp_clustering()) {
struct ctdbd_connection *conn = messaging_ctdbd_connection();
register_with_ctdbd(conn, CTDB_SRVID_RECONFIGURE,
smbd_parent_ctdb_reconfigured, msg_ctx);
register_with_ctdbd(conn, CTDB_SRVID_SAMBA_NOTIFY,
smbd_parent_ctdb_reconfigured, msg_ctx);
}
#ifdef DEVELOPER
messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
msg_inject_fault);
#endif
if (lp_multicast_dns_register() && (dns_port != 0)) {
#ifdef WITH_DNSSD_SUPPORT
smbd_setup_mdns_registration(ev_ctx,
parent, dns_port);
#endif
#ifdef WITH_AVAHI_SUPPORT
void *avahi_conn;
avahi_conn = avahi_start_register(ev_ctx,
ev_ctx,
dns_port);
if (avahi_conn == NULL) {
DEBUG(10, ("avahi_start_register failed\n"));
}
#endif
}
return true;
}
static void smbd_accept_connection(struct tevent_context *ev,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
struct smbd_open_socket *s = talloc_get_type_abort(private_data,
struct smbd_open_socket);
struct messaging_context *msg_ctx = s->parent->msg_ctx;
struct sockaddr_storage addr;
socklen_t in_addrlen = sizeof(addr);
int fd;
pid_t pid = 0;
fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
if (fd == -1 && errno == EINTR)
return;
if (fd == -1) {
DEBUG(0,("accept: %s\n",
strerror(errno)));
return;
}
if (s->parent->interactive) {
reinit_after_fork(msg_ctx, ev, true, NULL);
smbd_process(ev, msg_ctx, fd, true);
exit_server_cleanly("end of interactive mode");
return;
}
if (!allowable_number_of_smbd_processes(s->parent)) {
close(fd);
return;
}
pid = fork();
if (pid == 0) {
NTSTATUS status = NT_STATUS_OK;
/*
* Can't use TALLOC_FREE here. Nulling out the argument to it
* would overwrite memory we've just freed.
*/
talloc_free(s->parent);
s = NULL;
/* Stop zombies, the parent explicitly handles
* them, counting worker smbds. */
CatchChild();
status = smbd_reinit_after_fork(msg_ctx, ev, true, NULL);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,
NT_STATUS_TOO_MANY_OPENED_FILES)) {
DEBUG(0,("child process cannot initialize "
"because too many files are open\n"));
goto exit;
}
if (lp_clustering() &&
NT_STATUS_EQUAL(status,
NT_STATUS_INTERNAL_DB_ERROR)) {
DEBUG(1,("child process cannot initialize "
"because connection to CTDB "
"has failed\n"));
goto exit;
}
DEBUG(0,("reinit_after_fork() failed\n"));
smb_panic("reinit_after_fork() failed");
}
smbd_process(ev, msg_ctx, fd, false);
exit:
exit_server_cleanly("end of child");
return;
}
if (pid < 0) {
DEBUG(0,("smbd_accept_connection: fork() failed: %s\n",
strerror(errno)));
}
/* The parent doesn't need this socket */
close(fd);
/* Sun May 6 18:56:14 2001 [email protected]:
Clear the closed fd info out of server_fd --
and more importantly, out of client_fd in
util_sock.c, to avoid a possible
getpeername failure if we reopen the logs
and use %I in the filename.
*/
if (pid != 0) {
add_child_pid(s->parent, pid);
}
/* Force parent to check log size after
* spawning child. Fix from
* [email protected]. The
* parent smbd will log to logserver.smb. It
* writes only two messages for each child
* started/finished. But each child writes,
* say, 50 messages also in logserver.smb,
* begining with the debug_count of the
* parent, before the child opens its own log
* file logserver.client. In a worst case
* scenario the size of logserver.smb would be
* checked after about 50*50=2500 messages
* (ca. 100kb).
* */
force_check_log_size();
}
bool serverids_exist(const struct server_id *ids, int num_ids, bool *results)
{
int *todo_idx = NULL;
struct server_id *todo_ids = NULL;
bool *todo_results = NULL;
int todo_num = 0;
int *remote_idx = NULL;
int remote_num = 0;
int *verify_idx = NULL;
int verify_num = 0;
int t, idx;
bool result = false;
struct db_context *db;
db = serverid_db();
if (db == NULL) {
return false;
}
todo_idx = talloc_array(talloc_tos(), int, num_ids);
if (todo_idx == NULL) {
goto fail;
}
todo_ids = talloc_array(talloc_tos(), struct server_id, num_ids);
if (todo_ids == NULL) {
goto fail;
}
todo_results = talloc_array(talloc_tos(), bool, num_ids);
if (todo_results == NULL) {
goto fail;
}
remote_idx = talloc_array(talloc_tos(), int, num_ids);
if (remote_idx == NULL) {
goto fail;
}
verify_idx = talloc_array(talloc_tos(), int, num_ids);
if (verify_idx == NULL) {
goto fail;
}
for (idx=0; idx<num_ids; idx++) {
results[idx] = false;
if (server_id_is_disconnected(&ids[idx])) {
continue;
}
if (procid_is_me(&ids[idx])) {
results[idx] = true;
continue;
}
if (procid_is_local(&ids[idx])) {
bool exists = process_exists_by_pid(ids[idx].pid);
if (!exists) {
continue;
}
if (ids[idx].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
results[idx] = true;
continue;
}
verify_idx[verify_num] = idx;
verify_num += 1;
continue;
}
if (!lp_clustering()) {
continue;
}
remote_idx[remote_num] = idx;
remote_num += 1;
}
if (remote_num != 0 &&
ctdb_serverids_exist_supported(messaging_ctdbd_connection()))
{
int old_remote_num = remote_num;
remote_num = 0;
todo_num = 0;
for (t=0; t<old_remote_num; t++) {
idx = remote_idx[t];
if (ids[idx].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
remote_idx[remote_num] = idx;
remote_num += 1;
continue;
}
todo_idx[todo_num] = idx;
todo_ids[todo_num] = ids[idx];
todo_results[todo_num] = false;
todo_num += 1;
}
/*
* Note: this only uses CTDB_CONTROL_CHECK_SRVIDS
* to verify that the server_id still exists,
* which means only the server_id.unique_id and
* server_id.vnn are verified, while server_id.pid
* is not verified at all.
*
* TODO: do we want to verify server_id.pid somehow?
*/
if (!ctdb_serverids_exist(messaging_ctdbd_connection(),
todo_ids, todo_num, todo_results))
{
goto fail;
}
for (t=0; t<todo_num; t++) {
idx = todo_idx[t];
results[idx] = todo_results[t];
}
}
if (remote_num != 0) {
todo_num = 0;
for (t=0; t<remote_num; t++) {
idx = remote_idx[t];
todo_idx[todo_num] = idx;
todo_ids[todo_num] = ids[idx];
todo_results[todo_num] = false;
todo_num += 1;
}
if (!ctdb_processes_exist(messaging_ctdbd_connection(),
todo_ids, todo_num,
todo_results)) {
goto fail;
}
for (t=0; t<todo_num; t++) {
idx = todo_idx[t];
if (!todo_results[t]) {
continue;
}
if (ids[idx].unique_id == SERVERID_UNIQUE_ID_NOT_TO_VERIFY) {
results[idx] = true;
continue;
}
verify_idx[verify_num] = idx;
verify_num += 1;
}
}
for (t=0; t<verify_num; t++) {
struct serverid_exists_state state;
struct serverid_key key;
TDB_DATA tdbkey;
NTSTATUS status;
idx = verify_idx[t];
serverid_fill_key(&ids[idx], &key);
tdbkey = make_tdb_data((uint8_t *)&key, sizeof(key));
state.id = &ids[idx];
state.exists = false;
status = dbwrap_parse_record(db, tdbkey, server_exists_parse, &state);
if (!NT_STATUS_IS_OK(status)) {
results[idx] = false;
continue;
}
results[idx] = state.exists;
}
result = true;
fail:
TALLOC_FREE(verify_idx);
TALLOC_FREE(remote_idx);
TALLOC_FREE(todo_results);
TALLOC_FREE(todo_ids);
TALLOC_FREE(todo_idx);
return result;
}
static bool open_sockets_smbd(struct smbd_parent_context *parent,
struct tevent_context *ev_ctx,
struct messaging_context *msg_ctx,
const char *smb_ports)
{
int num_interfaces = iface_count();
int i;
const char *ports;
unsigned dns_port = 0;
#ifdef HAVE_ATEXIT
atexit(killkids);
#endif
/* Stop zombies */
smbd_setup_sig_chld_handler(ev_ctx);
/* use a reasonable default set of ports - listing on 445 and 139 */
if (!smb_ports) {
ports = lp_smb_ports();
if (!ports || !*ports) {
ports = talloc_strdup(talloc_tos(), SMB_PORTS);
} else {
ports = talloc_strdup(talloc_tos(), ports);
}
} else {
ports = talloc_strdup(talloc_tos(), smb_ports);
}
if (lp_interfaces() && lp_bind_interfaces_only()) {
/* We have been given an interfaces line, and been
told to only bind to those interfaces. Create a
socket per interface and bind to only these.
*/
/* Now open a listen socket for each of the
interfaces. */
for(i = 0; i < num_interfaces; i++) {
const struct sockaddr_storage *ifss =
iface_n_sockaddr_storage(i);
char *tok;
const char *ptr;
if (ifss == NULL) {
DEBUG(0,("open_sockets_smbd: "
"interface %d has NULL IP address !\n",
i));
continue;
}
for (ptr=ports;
next_token_talloc(talloc_tos(),&ptr, &tok, " \t,");) {
unsigned port = atoi(tok);
if (port == 0 || port > 0xffff) {
continue;
}
/* Keep the first port for mDNS service
* registration.
*/
if (dns_port == 0) {
dns_port = port;
}
if (!smbd_open_one_socket(parent,
ev_ctx,
msg_ctx,
ifss,
port)) {
return false;
}
}
}
} else {
/* Just bind to 0.0.0.0 - accept connections
from anywhere. */
char *tok;
const char *ptr;
const char *sock_addr = lp_socket_address();
char *sock_tok;
const char *sock_ptr;
if (strequal(sock_addr, "0.0.0.0") ||
strequal(sock_addr, "::")) {
#if HAVE_IPV6
sock_addr = "::,0.0.0.0";
#else
sock_addr = "0.0.0.0";
#endif
}
for (sock_ptr=sock_addr;
next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
for (ptr=ports; next_token_talloc(talloc_tos(), &ptr, &tok, " \t,"); ) {
struct sockaddr_storage ss;
unsigned port = atoi(tok);
if (port == 0 || port > 0xffff) {
continue;
}
/* Keep the first port for mDNS service
* registration.
*/
if (dns_port == 0) {
dns_port = port;
}
/* open an incoming socket */
if (!interpret_string_addr(&ss, sock_tok,
AI_NUMERICHOST|AI_PASSIVE)) {
continue;
}
if (!smbd_open_one_socket(parent,
ev_ctx,
msg_ctx,
&ss,
port)) {
return false;
}
}
}
}
if (parent->sockets == NULL) {
DEBUG(0,("open_sockets_smbd: No "
"sockets available to bind to.\n"));
return false;
}
/* Setup the main smbd so that we can get messages. Note that
do this after starting listening. This is needed as when in
clustered mode, ctdb won't allow us to start doing database
operations until it has gone thru a full startup, which
includes checking to see that smbd is listening. */
if (!serverid_register(procid_self(),
FLAG_MSG_GENERAL|FLAG_MSG_SMBD
|FLAG_MSG_PRINT_GENERAL
|FLAG_MSG_DBWRAP)) {
DEBUG(0, ("open_sockets_smbd: Failed to register "
"myself in serverid.tdb\n"));
return false;
}
/* Listen to messages */
messaging_register(msg_ctx, NULL, MSG_SMB_SAM_SYNC, msg_sam_sync);
messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
messaging_register(msg_ctx, NULL, MSG_SMB_FILE_RENAME,
msg_file_was_renamed);
messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
smb_conf_updated);
messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
smb_stat_cache_delete);
messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
messaging_register(msg_ctx, ev_ctx, MSG_PRINTER_PCAP,
smb_pcap_updated);
brl_register_msgs(msg_ctx);
msg_idmap_register_msg(msg_ctx);
#ifdef CLUSTER_SUPPORT
if (lp_clustering()) {
ctdbd_register_reconfigure(messaging_ctdbd_connection());
}
#endif
#ifdef DEVELOPER
messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
msg_inject_fault);
#endif
if (lp_multicast_dns_register() && (dns_port != 0)) {
#ifdef WITH_DNSSD_SUPPORT
smbd_setup_mdns_registration(ev_ctx,
parent, dns_port);
#endif
#ifdef WITH_AVAHI_SUPPORT
void *avahi_conn;
avahi_conn = avahi_start_register(ev_ctx,
ev_ctx,
dns_port);
if (avahi_conn == NULL) {
DEBUG(10, ("avahi_start_register failed\n"));
}
#endif
}
return true;
}
int main(int argc, char *argv[])
{
int c;
int profile_only = 0;
bool show_processes, show_locks, show_shares;
poptContext pc;
struct poptOption long_options[] = {
POPT_AUTOHELP
{"processes", 'p', POPT_ARG_NONE, NULL, 'p', "Show processes only" },
{"verbose", 'v', POPT_ARG_NONE, NULL, 'v', "Be verbose" },
{"locks", 'L', POPT_ARG_NONE, NULL, 'L', "Show locks only" },
{"shares", 'S', POPT_ARG_NONE, NULL, 'S', "Show shares only" },
{"user", 'u', POPT_ARG_STRING, &username, 'u', "Switch to user" },
{"brief", 'b', POPT_ARG_NONE, NULL, 'b', "Be brief" },
{"profile", 'P', POPT_ARG_NONE, NULL, 'P', "Do profiling" },
{"profile-rates", 'R', POPT_ARG_NONE, NULL, 'R', "Show call rates" },
{"byterange", 'B', POPT_ARG_NONE, NULL, 'B', "Include byte range locks"},
{"numeric", 'n', POPT_ARG_NONE, NULL, 'n', "Numeric uid/gid"},
POPT_COMMON_SAMBA
POPT_TABLEEND
};
TALLOC_CTX *frame = talloc_stackframe();
int ret = 0;
struct messaging_context *msg_ctx;
sec_init();
load_case_tables();
setup_logging(argv[0], DEBUG_STDERR);
if (getuid() != geteuid()) {
d_printf("smbstatus should not be run setuid\n");
ret = 1;
goto done;
}
pc = poptGetContext(NULL, argc, (const char **) argv, long_options,
POPT_CONTEXT_KEEP_FIRST);
while ((c = poptGetNextOpt(pc)) != -1) {
switch (c) {
case 'p':
processes_only = true;
break;
case 'v':
verbose = true;
break;
case 'L':
locks_only = true;
break;
case 'S':
shares_only = true;
break;
case 'b':
brief = true;
break;
case 'u':
Ucrit_addUid(nametouid(poptGetOptArg(pc)));
break;
case 'P':
case 'R':
profile_only = c;
break;
case 'B':
show_brl = true;
break;
case 'n':
numeric_only = true;
break;
}
}
/* setup the flags based on the possible combincations */
show_processes = !(shares_only || locks_only || profile_only) || processes_only;
show_locks = !(shares_only || processes_only || profile_only) || locks_only;
show_shares = !(processes_only || locks_only || profile_only) || shares_only;
if ( username )
Ucrit_addUid( nametouid(username) );
if (verbose) {
d_printf("using configfile = %s\n", get_dyn_CONFIGFILE());
}
if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n",
get_dyn_CONFIGFILE());
ret = -1;
goto done;
}
if (lp_clustering()) {
/*
* This implicitly initializes the global ctdbd
* connection, usable by the db_open() calls further
* down.
*/
msg_ctx = messaging_init(NULL, event_context_init(NULL));
if (msg_ctx == NULL) {
fprintf(stderr, "messaging_init failed\n");
ret = -1;
goto done;
}
}
if (!lp_load_global(get_dyn_CONFIGFILE())) {
fprintf(stderr, "Can't load %s - run testparm to debug it\n",
get_dyn_CONFIGFILE());
ret = -1;
goto done;
}
switch (profile_only) {
case 'P':
/* Dump profile data */
return status_profile_dump(verbose);
case 'R':
/* Continuously display rate-converted data */
return status_profile_rates(verbose);
default:
break;
}
if ( show_processes ) {
d_printf("\nSamba version %s\n",samba_version_string());
d_printf("PID Username Group Machine \n");
d_printf("-------------------------------------------------------------------\n");
if (lp_security() == SEC_SHARE) {
d_printf(" <processes do not show up in "
"anonymous mode>\n");
}
sessionid_traverse_read(traverse_sessionid, NULL);
if (processes_only) {
goto done;
}
}
if ( show_shares ) {
if (verbose) {
d_printf("Opened %s\n", lock_path("connections.tdb"));
}
if (brief) {
goto done;
}
d_printf("\nService pid machine Connected at\n");
d_printf("-------------------------------------------------------\n");
connections_forall_read(traverse_fn1, NULL);
d_printf("\n");
if ( shares_only ) {
goto done;
}
}
if ( show_locks ) {
int result;
struct db_context *db;
db = db_open(NULL, lock_path("locking.tdb"), 0,
TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, O_RDONLY, 0,
DBWRAP_LOCK_ORDER_1);
if (!db) {
d_printf("%s not initialised\n",
lock_path("locking.tdb"));
d_printf("This is normal if an SMB client has never "
"connected to your server.\n");
exit(0);
} else {
TALLOC_FREE(db);
}
if (!locking_init_readonly()) {
d_printf("Can't initialise locking module - exiting\n");
ret = 1;
goto done;
}
result = share_mode_forall(print_share_mode, NULL);
if (result == 0) {
d_printf("No locked files\n");
} else if (result < 0) {
d_printf("locked file list truncated\n");
}
d_printf("\n");
if (show_brl) {
brl_forall(print_brl, NULL);
}
locking_end();
}
done:
TALLOC_FREE(frame);
return ret;
}
/**
* If you use this you can only modify with a transaction
*/
struct db_context *db_open_trans(TALLOC_CTX *mem_ctx,
const char *name,
int hash_size, int tdb_flags,
int open_flags, mode_t mode)
{
bool use_tdb2 = lp_parm_bool(-1, "dbwrap", "use_tdb2", false);
#ifdef CLUSTER_SUPPORT
const char *sockname = lp_ctdbd_socket();
#endif
if (tdb_flags & TDB_CLEAR_IF_FIRST) {
DEBUG(0,("db_open_trans: called with TDB_CLEAR_IF_FIRST: %s\n",
name));
smb_panic("db_open_trans: called with TDB_CLEAR_IF_FIRST");
}
#ifdef CLUSTER_SUPPORT
if(!sockname || !*sockname) {
sockname = CTDB_PATH;
}
if (lp_clustering() && socket_exist(sockname)) {
const char *partname;
/* ctdb only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "ctdb", partname, true)) {
struct db_context *result = NULL;
result = db_open_ctdb(mem_ctx, partname, hash_size,
tdb_flags, open_flags, mode);
if (result == NULL) {
DEBUG(0,("failed to attach to ctdb %s\n",
partname));
smb_panic("failed to attach to a ctdb "
"database");
}
return result;
}
}
#endif
if (use_tdb2) {
const char *partname;
/* tdb2 only wants the file part of the name */
partname = strrchr(name, '/');
if (partname) {
partname++;
} else {
partname = name;
}
/* allow ctdb for individual databases to be disabled */
if (lp_parm_bool(-1, "tdb2", partname, true)) {
return db_open_tdb2(mem_ctx, partname, hash_size,
tdb_flags, open_flags, mode);
}
}
return db_open_tdb(mem_ctx, name, hash_size,
tdb_flags, open_flags, mode);
}
