--- /dev/null
+/*
+ Unix SMB/CIFS implementation.
+ Samba utility functions
+ Copyright (C) Andrew Bartlett 2011
+
+ 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 "librpc/gen_ndr/server_id.h"
+
+char *server_id_str(TALLOC_CTX *mem_ctx, const struct server_id *id)
+{
+ if (id->vnn == NONCLUSTER_VNN && id->task_id == 0) {
+ return talloc_asprintf(mem_ctx,
+ "%llu",
+ (unsigned long long)id->pid);
+ } else {
+ return talloc_asprintf(mem_ctx,
+ "%u:%llu:%u",
+ (unsigned)id->vnn,
+ (unsigned long long)id->pid,
+ (unsigned)id->task_id);
+ }
+}
**/
const char *shlib_ext(void);
+struct server_id;
+char *server_id_str(TALLOC_CTX *mem_ctx, const struct server_id *id);
#endif /* _SAMBA_UTIL_H_ */
genrand.c fsusage.c blocking.c become_daemon.c
signal.c system.c params.c util.c util_id.c util_net.c
util_strlist.c util_paths.c idtree.c debug.c fault.c base64.c
- util_str.c util_str_common.c substitute.c ms_fnmatch.c'''
+ util_str.c util_str_common.c substitute.c ms_fnmatch.c
+ server_id.c'''
common_util_headers = 'debug.h'
common_util_public_deps = 'talloc pthread LIBCRYPTO CHARSET'
interface server_id
{
+ /*
+ * Virtual Node Numbers are identifying a node within a cluster.
+ * Ctdbd sets this, we retrieve our vnn from it.
+ */
+
+ const int NONCLUSTER_VNN = 0xFFFFFFFF;
+
/* used to look like the following, note that unique_id was not
* marshalled at all...
../lib/util/tevent_werror.o \
../lib/util/smb_threads.o ../lib/util/util_id.o \
../lib/util/blocking.o ../lib/util/rfc1738.o \
- ../lib/util/select.o ../lib/util/util_pw.o
+ ../lib/util/select.o ../lib/util/util_pw.o ../lib/util/server_id.o
CRYPTO_OBJ = ../lib/crypto/crc32.o ../lib/crypto/md5.o \
../lib/crypto/hmacmd5.o ../lib/crypto/arcfour.o \
#define FLAG_MSG_DBWRAP 0x0020
-/*
- * Virtual Node Numbers are identifying a node within a cluster. Ctdbd sets
- * this, we retrieve our vnn from it.
- */
-
-#define NONCLUSTER_VNN (0xFFFFFFFF)
-
/*
* ctdb gives us 64-bit server ids for messaging_send. This is done to avoid
* pid clashes and to be able to register for special messages like "all
const struct server_id *id2);
bool procid_is_me(const struct server_id *pid);
struct server_id interpret_pid(const char *pid_string);
-char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid);
char *procid_str_static(const struct server_id *pid);
bool procid_valid(const struct server_id *pid);
bool procid_is_local(const struct server_id *pid);
DEBUG(10, ("locks:\n"));
for (i=0; i<num_locks; i++) {
DEBUGADD(10, ("%s: %s %s\n",
- procid_str(talloc_tos(), &locks[i].pid),
+ server_id_str(talloc_tos(), &locks[i].pid),
((locks[i].lock_type & 1) == G_LOCK_READ) ?
"read" : "write",
(locks[i].lock_type & G_LOCK_PENDING) ?
&& !process_exists(locks[i].pid)) {
DEBUGADD(10, ("lock owner %s died -- discarding\n",
- procid_str(talloc_tos(),
+ server_id_str(talloc_tos(),
&locks[i].pid)));
if (i < (num_locks-1)) {
continue;
}
DEBUGADD(10, ("%s does not exist -- discarding\n",
- procid_str(talloc_tos(), &locks[i].pid)));
+ server_id_str(talloc_tos(), &locks[i].pid)));
if (i < (num_locks-1)) {
locks[i] = locks[num_locks-1];
bool *pretry = (bool *)private_data;
DEBUG(10, ("Got retry message from pid %s\n",
- procid_str(talloc_tos(), &server_id)));
+ server_id_str(talloc_tos(), &server_id)));
*pretry = true;
}
&data_blob_null);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("sending retry to %s failed: %s\n",
- procid_str(talloc_tos(),
+ server_id_str(talloc_tos(),
&locks[i].pid),
nt_errstr(status)));
} else {
return result;
}
-char *procid_str(TALLOC_CTX *mem_ctx, const struct server_id *pid)
-{
- if (pid->vnn == NONCLUSTER_VNN && pid->task_id == 0) {
- return talloc_asprintf(mem_ctx,
- "%llu",
- (unsigned long long)pid->pid);
- }
- else {
- return talloc_asprintf(mem_ctx,
- "%u:%llu:%u",
- (unsigned)pid->vnn,
- (unsigned long long)pid->pid,
- (unsigned)pid->task_id);
- }
-}
-
char *procid_str_static(const struct server_id *pid)
{
- return procid_str(talloc_tos(), pid);
+ return server_id_str(talloc_tos(), pid);
}
bool procid_valid(const struct server_id *pid)
i,
(unsigned long long)pls->context.smblctx,
(unsigned int)pls->context.tid,
- procid_str(talloc_tos(), &pls->context.pid) ));
+ server_id_str(talloc_tos(), &pls->context.pid) ));
DEBUG(10,("start = %.0f, size = %.0f, fnum = %d, %s %s\n",
(double)pls->start,
message_to_share_mode_entry(&msg, (char *)data->data);
DEBUG(10, ("Got oplock async level 2 break message from pid %s: "
- "%s/%lu\n", procid_str(talloc_tos(), &src),
+ "%s/%lu\n", server_id_str(talloc_tos(), &src),
file_id_string_tos(&msg.id), msg.share_file_id));
fsp = initial_break_processing(sconn, msg.id, msg.share_file_id);
message_to_share_mode_entry(&msg, (char *)data->data);
DEBUG(10, ("Got oplock break message from pid %s: %s/%lu\n",
- procid_str(talloc_tos(), &src), file_id_string_tos(&msg.id),
+ server_id_str(talloc_tos(), &src), file_id_string_tos(&msg.id),
msg.share_file_id));
fsp = initial_break_processing(sconn, msg.id, msg.share_file_id);
file_id = (unsigned long)IVAL(data->data, 24);
DEBUG(10, ("Got kernel oplock break message from pid %s: %s/%u\n",
- procid_str(talloc_tos(), &src), file_id_string_tos(&id),
+ server_id_str(talloc_tos(), &src), file_id_string_tos(&id),
(unsigned int)file_id));
fsp = initial_break_processing(sconn, id, file_id);
message_to_share_mode_entry(&msg, (char *)data->data);
DEBUG(10, ("Got oplock break response from pid %s: %s/%lu mid %llu\n",
- procid_str(talloc_tos(), &src), file_id_string_tos(&msg.id),
+ server_id_str(talloc_tos(), &src), file_id_string_tos(&msg.id),
msg.share_file_id, (unsigned long long)msg.op_mid));
schedule_deferred_open_message_smb(msg.op_mid);
message_to_share_mode_entry(&msg, (char *)data->data);
DEBUG(10, ("Got open retry msg from pid %s: %s mid %llu\n",
- procid_str(talloc_tos(), &src), file_id_string_tos(&msg.id),
+ server_id_str(talloc_tos(), &src), file_id_string_tos(&msg.id),
(unsigned long long)msg.op_mid));
schedule_deferred_open_message_smb(msg.op_mid);
struct shutdown_state *state = (struct shutdown_state *)private_data;
DEBUG(10, ("shutdown_other_smbds: %s, %s\n",
- procid_str(talloc_tos(), &crec->pid), crec->addr));
+ server_id_str(talloc_tos(), &crec->pid), crec->addr));
if (!process_exists(crec->pid)) {
DEBUG(10, ("process does not exist\n"));
{
char *pidstr;
- pidstr = procid_str(talloc_tos(), &pid);
+ pidstr = server_id_str(talloc_tos(), &pid);
d_printf("%s: %s (%s)\n", pidstr,
(lock_type & 1) ? "WRITE" : "READ",
(lock_type & G_LOCK_PENDING) ? "pending" : "holder");
static int net_serverid_list_fn(const struct server_id *id,
uint32_t msg_flags, void *priv)
{
- char *str = procid_str(talloc_tos(), id);
+ char *str = server_id_str(talloc_tos(), id);
d_printf("%s %llu 0x%x\n", str, (unsigned long long)id->unique_id,
(unsigned int)msg_flags);
TALLOC_FREE(str);
}
status = rec->delete_rec(rec);
if (!NT_STATUS_IS_OK(status)) {
- char *str = procid_str(talloc_tos(), id);
+ char *str = server_id_str(talloc_tos(), id);
DEBUG(1, ("Could not delete serverid.tdb record %s: %s\n",
str, nt_errstr(status)));
TALLOC_FREE(str);
NTSTATUS status;
DEBUG(10, ("Deleting connections.tdb record for pid %s\n",
- procid_str(talloc_tos(), &key->pid)));
+ server_id_str(talloc_tos(), &key->pid)));
status = rec->delete_rec(rec);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("Could not delete connections.tdb record "
"for pid %s: %s\n",
- procid_str(talloc_tos(), &key->pid),
+ server_id_str(talloc_tos(), &key->pid),
nt_errstr(status)));
}
}
NTSTATUS status;
DEBUG(10, ("Deleting sessionid.tdb record for pid %s\n",
- procid_str(talloc_tos(), &session->pid)));
+ server_id_str(talloc_tos(), &session->pid)));
status = rec->delete_rec(rec);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("Could not delete session.tdb record "
"for pid %s: %s\n",
- procid_str(talloc_tos(), &session->pid),
+ server_id_str(talloc_tos(), &session->pid),
nt_errstr(status)));
}
}
{
char *pidstr;
- pidstr = procid_str(talloc_tos(), &pid);
+ pidstr = server_id_str(talloc_tos(), &pid);
printf("PID %s: %.*s", pidstr, (int)data->length,
(const char *)data->data);
TALLOC_FREE(pidstr);
struct server_id pid,
DATA_BLOB *data)
{
- char *src_string = procid_str(NULL, &pid);
+ char *src_string = server_id_str(NULL, &pid);
printf("PONG from pid %s\n", src_string);
TALLOC_FREE(src_string);
num_replies++;
struct server_id pid,
DATA_BLOB *data)
{
- char *src_string = procid_str(NULL, &pid);
+ char *src_string = server_id_str(NULL, &pid);
printf("Winbindd cache is %svalid. (answer from pid %s)\n",
(*(data->data) == 0 ? "" : "NOT "), src_string);
TALLOC_FREE(src_string);
return ops->cluster_id(ops, pid, task_id);
}
-
-/*
- return a server_id as a string
-*/
-char *cluster_id_string(TALLOC_CTX *mem_ctx, struct server_id id)
-{
- cluster_init();
- return ops->cluster_id_string(ops, mem_ctx, id);
-}
-
-
/*
open a temporary tdb in a cluster friendly manner
*/
/* prototypes */
struct server_id cluster_id(uint64_t id, uint32_t task_id);
-char *cluster_id_string(TALLOC_CTX *mem_ctx, struct server_id id);
struct tdb_wrap *cluster_tdb_tmp_open(TALLOC_CTX *mem_ctx, struct loadparm_context *lp_ctx, const char *dbname, int flags);
void *cluster_backend_handle(void);
struct cluster_ops {
struct server_id (*cluster_id)(struct cluster_ops *ops, uint64_t id, uint32_t id2);
- char *(*cluster_id_string)(struct cluster_ops *ops,
- TALLOC_CTX *, struct server_id );
struct tdb_wrap *(*cluster_tdb_tmp_open)(struct cluster_ops *,
TALLOC_CTX *,
struct loadparm_context *,
}
-/*
- return a server_id as a string
-*/
-static char *local_id_string(struct cluster_ops *ops,
- TALLOC_CTX *mem_ctx, struct server_id id)
-{
- return talloc_asprintf(mem_ctx, "%u.%llu.%u", id.vnn, (unsigned long long)id.pid, id.task_id);
-}
-
-
/*
open a tmp tdb for the local node. By using smbd_tmp_path() we don't need
TDB_CLEAR_IF_FIRST as the tmp path is wiped at startup
static struct cluster_ops cluster_local_ops = {
.cluster_id = local_id,
- .cluster_id_string = local_id_string,
.cluster_tdb_tmp_open = local_tdb_tmp_open,
.backend_handle = local_backend_handle,
.message_init = local_message_init,
static void ping_message(struct imessaging_context *msg, void *private_data,
uint32_t msg_type, struct server_id src, DATA_BLOB *data)
{
- char *task_id = cluster_id_string(NULL, src);
+ char *task_id = server_id_str(NULL, &src);
DEBUG(1,("INFO: Received PING message from server %s [%.*s]\n",
task_id, (int)data->length,
data->data?(const char *)data->data:""));
static char *imessaging_path(struct imessaging_context *msg, struct server_id server_id)
{
TALLOC_CTX *tmp_ctx = talloc_new(msg);
- const char *id = cluster_id_string(tmp_ctx, server_id);
+ const char *id = server_id_str(tmp_ctx, &server_id);
char *s;
if (id == NULL) {
return NULL;
if (!NT_STATUS_IS_OK(status)) {
TALLOC_CTX *tmp_ctx = talloc_new(msg);
DEBUG(1,("messaging: Lost message from %s to %s of type %u - %s\n",
- cluster_id_string(tmp_ctx, rec->header->from),
- cluster_id_string(tmp_ctx, rec->header->to),
+ server_id_str(tmp_ctx, &rec->header->from),
+ server_id_str(tmp_ctx, &rec->header->to),
rec->header->msg_type,
nt_errstr(status)));
talloc_free(tmp_ctx);
}
}
- task_id = cluster_id_string(NULL, req->smb_conn->connection->server_id);
+ task_id = server_id_str(NULL, &req->smb_conn->connection->server_id);
DEBUG(5,("switch message %s (task_id %s)\n",
smb_fn_name(type), task_id));
talloc_free(task_id);
stream_socket->ops->name,
tsocket_address_string(srv_conn->remote_address, tmp_ctx),
tsocket_address_string(srv_conn->local_address, tmp_ctx),
- cluster_id_string(tmp_ctx, server_id));
+ server_id_str(tmp_ctx, &server_id));
if (title) {
stream_connection_set_title(srv_conn, title);
}