uint16_t cipher;
uint16_t signing;
uint8_t signing_flags;
- const struct smbXsrv_session_global0 *global;
+ const struct smbXsrv_session_global *global;
};
void *private_data;
};
-static int sessionid_traverse_read_fn(struct smbXsrv_session_global0 *global,
+static int sessionid_traverse_read_fn(struct smbXsrv_session_global *global,
void *private_data)
{
struct sessionid_traverse_read_state *state =
*/
typedef [public, v1_enum] enum {
/*
- * NOTE: Version 0 is designed to be unstable and the format
+ * NOTE: Version 0 was designed to be unstable and the format
* may change during development.
*/
- SMBXSRV_VERSION_0 = 0x00000000
+ SMBXSRV_VERSION_1 = 0x00000001
} smbXsrv_version_values;
- const uint32 SMBXSRV_VERSION_CURRENT = SMBXSRV_VERSION_0;
+ const uint32 SMBXSRV_VERSION_CURRENT = SMBXSRV_VERSION_1;
typedef struct {
server_id server_id;
smbXsrv_version_values min_version;
smbXsrv_version_values max_version;
smbXsrv_version_values current_version;
- } smbXsrv_version_node0;
+ } smbXsrv_version_node;
typedef struct {
[range(1, 1024)] uint32 num_nodes;
- smbXsrv_version_node0 nodes[num_nodes];
- } smbXsrv_version_global0;
+ smbXsrv_version_node nodes[num_nodes];
+ } smbXsrv_version_global;
typedef union {
- [case(0)] smbXsrv_version_global0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_version_global *info1;
+ [default] ;
} smbXsrv_version_globalU;
typedef [public] struct {
NTTIME initial_connect_time;
GUID client_guid;
boolean8 stored;
- } smbXsrv_client_global0;
+ } smbXsrv_client_global;
typedef union {
- [case(0)] smbXsrv_client_global0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_client_global *info1;
+ [default] ;
} smbXsrv_client_globalU;
typedef [public] struct {
[ignore] struct tevent_context *raw_ev_ctx;
[ignore] struct messaging_context *msg_ctx;
- [ref] smbXsrv_client_global0 *global;
+ [ref] smbXsrv_client_global *global;
/*
* There's just one 'sconn' per client.
} smbXsrv_client;
typedef union {
- [case(0)] smbXsrv_client *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_client *info1;
+ [default] ;
} smbXsrv_clientU;
typedef [public] struct {
NTTIME client_connect_time;
uint8 transport_type;
DATA_BLOB negotiate_request;
- } smbXsrv_connection_pass0;
+ } smbXsrv_connection_pass;
typedef union {
- [case(0)] smbXsrv_connection_pass0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_connection_pass *info1;
+ [default] ;
} smbXsrv_connection_passU;
typedef [public] struct {
NTTIME xconn_connect_time;
server_id dst_server_id;
NTTIME client_connect_time;
- } smbXsrv_connection_drop0;
+ } smbXsrv_connection_drop;
typedef union {
- [case(0)] smbXsrv_connection_drop0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_connection_drop *info1;
+ [default] ;
} smbXsrv_connection_dropU;
typedef [public] struct {
uint16 signing_algo;
uint16 encryption_cipher;
uint8 transport_type;
- } smbXsrv_channel_global0;
+ } smbXsrv_channel_global;
typedef struct {
[ignore] db_record *db_rec;
[noprint] DATA_BLOB application_key_blob;
[ignore] smb2_signing_key *application_key;
[range(1, 1024)] uint32 num_channels;
- smbXsrv_channel_global0 channels[num_channels];
- } smbXsrv_session_global0;
+ smbXsrv_channel_global channels[num_channels];
+ } smbXsrv_session_global;
typedef union {
- [case(0)] smbXsrv_session_global0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_session_global *info1;
+ [default] ;
} smbXsrv_session_globalU;
typedef [public] struct {
/*
* The main server code should just work with
* 'struct smbXsrv_session' and never use
- * smbXsrv_session0, smbXsrv_sessionU
+ * smbXsrv_session1, smbXsrv_sessionU
* and smbXsrv_sessionB directly.
*
* If we need to change the smbXsrv_session,
* we can just rename smbXsrv_session
- * to smbXsrv_session0 and add a new
+ * to smbXsrv_session1 and add a new
* smbXsrv_session for version 1
* and could implement transparent mapping.
*/
typedef struct {
- [ignore] smbXsrv_session_auth0 *prev;
- [max_recursion(20000)] smbXsrv_session_auth0 *next;
+ [ignore] smbXsrv_session_auth *prev;
+ [max_recursion(20000)] smbXsrv_session_auth *next;
[ignore] smbXsrv_session *session;
[ignore] smbXsrv_connection *connection;
[ignore] gensec_security *gensec;
NTTIME creation_time;
NTTIME idle_time;
hyper channel_id;
- } smbXsrv_session_auth0;
+ } smbXsrv_session_auth;
typedef struct {
[ignore] smbXsrv_session_table *table;
[ignore] db_record *db_rec;
[ignore] smbXsrv_client *client;
uint32 local_id;
- [ref] smbXsrv_session_global0 *global;
+ [ref] smbXsrv_session_global *global;
NTSTATUS status;
NTTIME idle_time;
hyper nonce_high_random;
hyper nonce_low;
[ignore] smbXsrv_tcon_table *tcon_table;
[ignore] uint32 homes_snum;
- smbXsrv_session_auth0 *pending_auth;
+ smbXsrv_session_auth *pending_auth;
} smbXsrv_session;
typedef union {
- [case(0)] smbXsrv_session *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_session *info1;
+ [default] ;
} smbXsrv_sessionU;
typedef [public] struct {
hyper old_session_wire_id;
NTTIME old_creation_time;
hyper new_session_wire_id;
- } smbXsrv_session_close0;
+ } smbXsrv_session_close;
typedef union {
- [case(0)] smbXsrv_session_close0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_session_close *info1;
+ [default] ;
} smbXsrv_session_closeU;
typedef [public] struct {
*/
uint32 session_global_id;
smbXsrv_signing_flags signing_flags;
- } smbXsrv_tcon_global0;
+ } smbXsrv_tcon_global;
typedef union {
- [case(0)] smbXsrv_tcon_global0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_tcon_global *info1;
+ [default] ;
} smbXsrv_tcon_globalU;
typedef [public] struct {
/*
* The main server code should just work with
* 'struct smbXsrv_tcon' and never use
- * smbXsrv_tcon0, smbXsrv_tconU
+ * smbXsrv_tcon1, smbXsrv_tconU
* and smbXsrv_tconB directly.
*
* If we need to change the smbXsrv_tcon,
* we can just rename smbXsrv_tcon
- * to smbXsrv_tcon0 and add a new
+ * to smbXsrv_tcon1 and add a new
* smbXsrv_tcon for version 1
* and could implement transparent mapping.
*/
[ignore] smbXsrv_tcon_table *table;
[ignore] db_record *db_rec;
uint32 local_id;
- [ref] smbXsrv_tcon_global0 *global;
+ [ref] smbXsrv_tcon_global *global;
NTSTATUS status;
NTTIME idle_time;
uint8 share_type;
} smbXsrv_tcon;
typedef union {
- [case(0)] smbXsrv_tcon *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_tcon *info1;
+ [default] ;
} smbXsrv_tconU;
typedef [public] struct {
uint16 channel_sequence;
hyper channel_generation;
[flag(NDR_PAHEX)] uint8 lock_sequence_array[64];
- } smbXsrv_open_global0;
+ } smbXsrv_open_global;
typedef union {
- [case(0)] smbXsrv_open_global0 *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_open_global *info1;
+ [default] ;
} smbXsrv_open_globalU;
typedef [public] struct {
/*
* The main server code should just work with
* 'struct smbXsrv_open' and never use
- * smbXsrv_open0, smbXsrv_openU
+ * smbXsrv_open1, smbXsrv_openU
* and smbXsrv_openB directly.
*
* If we need to change the smbXsrv_open,
* we can just rename smbXsrv_open
- * to smbXsrv_open0 and add a new
+ * to smbXsrv_open1 and add a new
* smbXsrv_open for version 1
* and could implement transparent mapping.
*/
typedef struct {
[ignore] smbXsrv_open_table *table;
uint32 local_id;
- [ref] smbXsrv_open_global0 *global;
+ [ref] smbXsrv_open_global *global;
smbXsrv_session *session;
smbXsrv_tcon *tcon;
NTSTATUS status;
} smbXsrv_open;
typedef union {
- [case(0)] smbXsrv_open *info0;
- [default] hyper *dummy;
+ [case(1),ref] smbXsrv_open *info1;
+ [default] ;
} smbXsrv_openU;
typedef [public] struct {
Count an entry against the respective service.
****************************************************************************/
-static int count_for_all_fn(struct smbXsrv_tcon_global0 *tcon, void *udp)
+static int count_for_all_fn(struct smbXsrv_tcon_global *tcon, void *udp)
{
union srvsvc_NetShareCtr *ctr = udp;
process an entry from the connection db.
****************************************************************************/
-static int share_conn_fn(struct smbXsrv_tcon_global0 *tcon,
+static int share_conn_fn(struct smbXsrv_tcon_global *tcon,
void *data)
{
struct share_conn_stat *scs = data;
Count the entries belonging to a service in the connection db.
****************************************************************************/
-static int count_fn(struct smbXsrv_tcon_global0 *tcon,
+static int count_fn(struct smbXsrv_tcon_global *tcon,
void *udp)
{
struct count_stat *cs = (struct count_stat *)udp;
void *private_data)
{
struct durable_reconnect_state *state = private_data;
- struct smbXsrv_open_global0 *global = state->op->global;
+ struct smbXsrv_open_global *global = state->op->global;
uint64_t id = global->open_persistent_id;
if (e->share_file_id != id) {
uint32_t tree_id, NTTIME now,
struct smbXsrv_tcon **tcon);
NTSTATUS smb2srv_tcon_disconnect_all(struct smbXsrv_session *session);
-struct smbXsrv_tcon_global0;
+struct smbXsrv_tcon_global;
NTSTATUS smbXsrv_tcon_global_traverse(
- int (*fn)(struct smbXsrv_tcon_global0 *, void *),
+ int (*fn)(struct smbXsrv_tcon_global *, void *),
void *private_data);
TALLOC_CTX *frame = talloc_stackframe();
struct tevent_timer *te;
struct scavenger_timer_context *ctx;
- const struct smbXsrv_open_global0 *global = NULL;
+ const struct smbXsrv_open_global *global = NULL;
struct timeval until;
struct file_id_buf idbuf;
NTTIME disconnect_time = 0;
struct smbXsrv_session *session = NULL;
uint16_t smb_bufsize = SVAL(req->vwv+2, 0);
uint32_t client_caps = IVAL(req->vwv+10, 0);
- struct smbXsrv_session_auth0 *auth;
+ struct smbXsrv_session_auth *auth = NULL;
DEBUG(3,("Doing spnego session setup\n"));
struct messaging_context *msg_ctx;
};
-static int shutdown_other_smbds(struct smbXsrv_session_global0 *session,
+static int shutdown_other_smbds(struct smbXsrv_session_global *session,
void *private_data)
{
struct shutdown_state *state = (struct shutdown_state *)private_data;
struct smbXsrv_connection *xconn,
bool *_has_channel)
{
- struct smbXsrv_channel_global0 *c = NULL;
+ struct smbXsrv_channel_global *c = NULL;
NTSTATUS status;
struct smb2_signing_key *key = NULL;
bool has_channel = false;
}
if (session != NULL) {
- struct smbXsrv_channel_global0 *c = NULL;
+ struct smbXsrv_channel_global *c = NULL;
/*
* Having a session means we're handling
}
static NTSTATUS smbd_smb2_auth_generic_return(struct smbXsrv_session *session,
- struct smbXsrv_session_auth0 **_auth,
+ struct smbXsrv_session_auth **_auth,
struct smbd_smb2_request *smb2req,
uint8_t in_security_mode,
struct auth_session_info *session_info,
NTSTATUS status;
bool guest = false;
struct smbXsrv_session *x = session;
- struct smbXsrv_session_auth0 *auth = *_auth;
+ struct smbXsrv_session_auth *auth = *_auth;
struct smbXsrv_connection *xconn = smb2req->xconn;
size_t i;
struct smb2_signing_derivations derivations = {
&session_info);
session->global->auth_session_info_seqnum += 1;
for (i=0; i < session->global->num_channels; i++) {
- struct smbXsrv_channel_global0 *_c =
+ struct smbXsrv_channel_global *_c =
&session->global->channels[i];
_c->auth_session_info_seqnum =
}
static NTSTATUS smbd_smb2_reauth_generic_return(struct smbXsrv_session *session,
- struct smbXsrv_session_auth0 **_auth,
+ struct smbXsrv_session_auth **_auth,
struct smbd_smb2_request *smb2req,
struct auth_session_info *session_info,
uint16_t *out_session_flags,
{
NTSTATUS status;
struct smbXsrv_session *x = session;
- struct smbXsrv_session_auth0 *auth = *_auth;
+ struct smbXsrv_session_auth *auth = *_auth;
struct smbXsrv_connection *xconn = smb2req->xconn;
size_t i;
&session_info);
session->global->auth_session_info_seqnum += 1;
for (i=0; i < session->global->num_channels; i++) {
- struct smbXsrv_channel_global0 *_c =
+ struct smbXsrv_channel_global *_c =
&session->global->channels[i];
_c->auth_session_info_seqnum =
}
static NTSTATUS smbd_smb2_bind_auth_return(struct smbXsrv_session *session,
- struct smbXsrv_session_auth0 **_auth,
+ struct smbXsrv_session_auth **_auth,
struct smbd_smb2_request *smb2req,
struct auth_session_info *session_info,
uint16_t *out_session_flags,
{
NTSTATUS status;
struct smbXsrv_session *x = session;
- struct smbXsrv_session_auth0 *auth = *_auth;
+ struct smbXsrv_session_auth *auth = *_auth;
struct smbXsrv_connection *xconn = smb2req->xconn;
- struct smbXsrv_channel_global0 *c = NULL;
+ struct smbXsrv_channel_global *c = NULL;
size_t i;
struct smb2_signing_derivations derivations = {
.signing = NULL,
uint64_t in_previous_session_id;
DATA_BLOB in_security_buffer;
struct smbXsrv_session *session;
- struct smbXsrv_session_auth0 *auth;
+ struct smbXsrv_session_auth *auth;
struct auth_session_info *session_info;
uint16_t out_session_flags;
DATA_BLOB out_security_buffer;
NTSTATUS status;
NTTIME now = timeval_to_nttime(&smb2req->request_time);
struct tevent_req *subreq;
- struct smbXsrv_channel_global0 *c = NULL;
+ struct smbXsrv_channel_global *c = NULL;
enum security_user_level seclvl;
req = tevent_req_create(mem_ctx, &state,
return NT_STATUS_OK;
}
-static int smbXsrv_client_global_destructor(struct smbXsrv_client_global0 *global)
+static int smbXsrv_client_global_destructor(struct smbXsrv_client_global *global)
{
return 0;
}
bool *was_free,
TALLOC_CTX *mem_ctx,
const struct server_id *dead_server_id,
- struct smbXsrv_client_global0 **_g,
+ struct smbXsrv_client_global **_g,
uint32_t *pseqnum)
{
TDB_DATA key;
DATA_BLOB blob;
struct smbXsrv_client_globalB global_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_client_global0 *global = NULL;
+ struct smbXsrv_client_global *global = NULL;
bool dead = false;
bool exists;
TALLOC_CTX *frame = talloc_stackframe();
NDR_PRINT_DEBUG(smbXsrv_client_globalB, &global_blob);
}
- if (global_blob.version != SMBXSRV_VERSION_0) {
+ if (global_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("key '%s' uses unsupported version %u\n",
tdb_data_dbg(key),
global_blob.version);
return;
}
- global = global_blob.info.info0;
+ global = global_blob.info.info1;
dead = server_id_equal(dead_server_id, &global->server_id);
if (dead) {
}
static NTSTATUS smb2srv_client_connection_pass(struct smbd_smb2_request *smb2req,
- struct smbXsrv_client_global0 *global)
+ struct smbXsrv_client_global *global)
{
DATA_BLOB blob;
enum ndr_err_code ndr_err;
NTSTATUS status;
- struct smbXsrv_connection_pass0 pass_info0;
+ struct smbXsrv_connection_pass pass_info;
struct smbXsrv_connection_passB pass_blob;
ssize_t reqlen;
struct iovec iov;
- pass_info0 = (struct smbXsrv_connection_pass0) {
+ pass_info = (struct smbXsrv_connection_pass) {
.client_guid = global->client_guid,
.src_server_id = smb2req->xconn->client->global->server_id,
.xconn_connect_time = smb2req->xconn->client->global->initial_connect_time,
return NT_STATUS_INVALID_BUFFER_SIZE;
}
- pass_info0.negotiate_request.length = reqlen;
- pass_info0.negotiate_request.data = talloc_array(talloc_tos(), uint8_t,
- reqlen);
- if (pass_info0.negotiate_request.data == NULL) {
+ pass_info.negotiate_request.length = reqlen;
+ pass_info.negotiate_request.data = talloc_array(talloc_tos(), uint8_t,
+ reqlen);
+ if (pass_info.negotiate_request.data == NULL) {
return NT_STATUS_NO_MEMORY;
}
iov_buf(smb2req->in.vector, smb2req->in.vector_count,
- pass_info0.negotiate_request.data,
- pass_info0.negotiate_request.length);
+ pass_info.negotiate_request.data,
+ pass_info.negotiate_request.length);
ZERO_STRUCT(pass_blob);
pass_blob.version = smbXsrv_version_global_current();
- pass_blob.info.info0 = &pass_info0;
+ pass_blob.info.info1 = &pass_info;
if (DEBUGLVL(DBGLVL_DEBUG)) {
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &pass_blob);
ndr_err = ndr_push_struct_blob(&blob, talloc_tos(), &pass_blob,
(ndr_push_flags_fn_t)ndr_push_smbXsrv_connection_passB);
- data_blob_free(&pass_info0.negotiate_request);
+ data_blob_free(&pass_info.negotiate_request);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
status = ndr_map_error2ntstatus(ndr_err);
return status;
}
static NTSTATUS smb2srv_client_connection_drop(struct smbd_smb2_request *smb2req,
- struct smbXsrv_client_global0 *global)
+ struct smbXsrv_client_global *global)
{
DATA_BLOB blob;
enum ndr_err_code ndr_err;
NTSTATUS status;
- struct smbXsrv_connection_drop0 drop_info0;
+ struct smbXsrv_connection_drop drop_info;
struct smbXsrv_connection_dropB drop_blob;
struct iovec iov;
- drop_info0 = (struct smbXsrv_connection_drop0) {
+ drop_info = (struct smbXsrv_connection_drop) {
.client_guid = global->client_guid,
.src_server_id = smb2req->xconn->client->global->server_id,
.xconn_connect_time = smb2req->xconn->client->global->initial_connect_time,
ZERO_STRUCT(drop_blob);
drop_blob.version = smbXsrv_version_global_current();
- drop_blob.info.info0 = &drop_info0;
+ drop_blob.info.info1 = &drop_info;
if (DEBUGLVL(DBGLVL_DEBUG)) {
NDR_PRINT_DEBUG(smbXsrv_connection_dropB, &drop_blob);
return NT_STATUS_OK;
}
-static NTSTATUS smbXsrv_client_global_store(struct smbXsrv_client_global0 *global)
+static NTSTATUS smbXsrv_client_global_store(struct smbXsrv_client_global *global)
{
struct smbXsrv_client_globalB global_blob;
DATA_BLOB blob = data_blob_null;
bool saved_stored = global->stored;
/*
- * TODO: if we use other versions than '0'
+ * TODO: if we use other versions than '1'
* we would add glue code here, that would be able to
* store the information in the old format.
*/
global_blob = (struct smbXsrv_client_globalB) {
.version = smbXsrv_version_global_current(),
- .info.info0 = global,
+ .info.info1 = global,
};
if (val.dsize >= 8) {
global_blob.seqnum = IVAL(val.dptr, 4);
struct smbXsrv_client *client = xconn->client;
struct smbXsrv_client_table *table = client->table;
struct GUID client_guid = xconn->smb2.client.guid;
- struct smbXsrv_client_global0 *global = NULL;
+ struct smbXsrv_client_global *global = NULL;
bool is_free = false;
struct tevent_req *subreq = NULL;
NTSTATUS status;
if (DEBUGLVL(DBGLVL_DEBUG)) {
struct smbXsrv_clientB client_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = client,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = client,
};
struct GUID_txt_buf buf;
struct messaging_rec *rec = NULL;
struct smbXsrv_connection_passB passed_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_connection_pass0 *passed_info0 = NULL;
+ struct smbXsrv_connection_pass *passed_info = NULL;
NTSTATUS status;
int ret;
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &passed_blob);
}
- if (passed_blob.version != SMBXSRV_VERSION_0) {
+ if (passed_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("ignore invalid version %u\n", passed_blob.version);
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &passed_blob);
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
- passed_info0 = passed_blob.info.info0;
- if (passed_info0 == NULL) {
+ passed_info = passed_blob.info.info1;
+ if (passed_info == NULL) {
DBG_ERR("ignore NULL info %u\n", passed_blob.version);
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &passed_blob);
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
- if (!GUID_equal(&xconn->smb2.client.guid, &passed_info0->client_guid)) {
+ if (!GUID_equal(&xconn->smb2.client.guid, &passed_info->client_guid)) {
struct GUID_txt_buf buf1, buf2;
DBG_ERR("client's client_guid [%s] != passed guid [%s]\n",
GUID_buf_string(&xconn->smb2.client.guid,
&buf1),
- GUID_buf_string(&passed_info0->client_guid,
+ GUID_buf_string(&passed_info->client_guid,
&buf2));
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &passed_blob);
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
}
if (client->global->initial_connect_time !=
- passed_info0->xconn_connect_time)
+ passed_info->xconn_connect_time)
{
DBG_ERR("client's initial connect time [%s] (%llu) != "
"passed xconn connect time [%s] (%llu)\n",
client->global->initial_connect_time),
(unsigned long long)client->global->initial_connect_time,
nt_time_string(talloc_tos(),
- passed_info0->xconn_connect_time),
- (unsigned long long)passed_info0->xconn_connect_time);
+ passed_info->xconn_connect_time),
+ (unsigned long long)passed_info->xconn_connect_time);
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &passed_blob);
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
- if (passed_info0->negotiate_request.length != 0) {
+ if (passed_info->negotiate_request.length != 0) {
DBG_ERR("negotiate_request.length[%zu]\n",
- passed_info0->negotiate_request.length);
+ passed_info->negotiate_request.length);
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &passed_blob);
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
return tevent_req_simple_recv_ntstatus(req);
}
-static NTSTATUS smbXsrv_client_global_remove(struct smbXsrv_client_global0 *global)
+static NTSTATUS smbXsrv_client_global_remove(struct smbXsrv_client_global *global)
{
TDB_DATA key;
NTSTATUS status;
{
struct smbXsrv_client_table *table;
struct smbXsrv_client *client = NULL;
- struct smbXsrv_client_global0 *global = NULL;
+ struct smbXsrv_client_global *global = NULL;
NTSTATUS status;
struct tevent_req *subreq = NULL;
client->table = talloc_move(client, &table);
table = client->table;
- global = talloc_zero(client, struct smbXsrv_client_global0);
+ global = talloc_zero(client, struct smbXsrv_client_global);
if (global == NULL) {
TALLOC_FREE(client);
return NT_STATUS_NO_MEMORY;
if (DEBUGLVL(DBGLVL_DEBUG)) {
struct smbXsrv_clientB client_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = client,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = client,
};
struct GUID_txt_buf buf;
}
static NTSTATUS smb2srv_client_connection_passed(struct smbXsrv_client *client,
- const struct smbXsrv_connection_pass0 *recv_info0)
+ const struct smbXsrv_connection_pass *recv_info)
{
DATA_BLOB blob;
enum ndr_err_code ndr_err;
NTSTATUS status;
- struct smbXsrv_connection_pass0 passed_info0;
+ struct smbXsrv_connection_pass passed_info;
struct smbXsrv_connection_passB passed_blob;
struct iovec iov;
/*
* We echo back the message with a cleared negotiate_request
*/
- passed_info0 = *recv_info0;
- passed_info0.negotiate_request = data_blob_null;
+ passed_info = *recv_info;
+ passed_info.negotiate_request = data_blob_null;
ZERO_STRUCT(passed_blob);
passed_blob.version = smbXsrv_version_global_current();
- passed_blob.info.info0 = &passed_info0;
+ passed_blob.info.info1 = &passed_info;
if (DEBUGLVL(DBGLVL_DEBUG)) {
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &passed_blob);
iov.iov_len = blob.length;
status = messaging_send_iov(client->msg_ctx,
- recv_info0->src_server_id,
+ recv_info->src_server_id,
MSG_SMBXSRV_CONNECTION_PASSED,
&iov, 1,
NULL, 0);
struct messaging_rec *rec = NULL;
struct smbXsrv_connection_passB pass_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_connection_pass0 *pass_info0 = NULL;
+ struct smbXsrv_connection_pass *pass_info = NULL;
NTSTATUS status;
int sock_fd = -1;
uint64_t seq_low;
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &pass_blob);
}
- if (pass_blob.version != SMBXSRV_VERSION_0) {
+ if (pass_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("ignore invalid version %u\n", pass_blob.version);
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &pass_blob);
goto next;
}
- pass_info0 = pass_blob.info.info0;
- if (pass_info0 == NULL) {
+ pass_info = pass_blob.info.info1;
+ if (pass_info == NULL) {
DBG_ERR("ignore NULL info %u\n", pass_blob.version);
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &pass_blob);
goto next;
}
- if (!GUID_equal(&client->global->client_guid, &pass_info0->client_guid))
+ if (!GUID_equal(&client->global->client_guid, &pass_info->client_guid))
{
struct GUID_txt_buf buf1, buf2;
DBG_WARNING("client's client_guid [%s] != passed guid [%s]\n",
GUID_buf_string(&client->global->client_guid,
&buf1),
- GUID_buf_string(&pass_info0->client_guid,
+ GUID_buf_string(&pass_info->client_guid,
&buf2));
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &pass_blob);
}
if (client->global->initial_connect_time !=
- pass_info0->client_connect_time)
+ pass_info->client_connect_time)
{
DBG_WARNING("client's initial connect time [%s] (%llu) != "
"passed initial connect time [%s] (%llu)\n",
client->global->initial_connect_time),
(unsigned long long)client->global->initial_connect_time,
nt_time_string(talloc_tos(),
- pass_info0->client_connect_time),
- (unsigned long long)pass_info0->client_connect_time);
+ pass_info->client_connect_time),
+ (unsigned long long)pass_info->client_connect_time);
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &pass_blob);
}
goto next;
}
- if (pass_info0->negotiate_request.length < SMB2_HDR_BODY) {
+ if (pass_info->negotiate_request.length < SMB2_HDR_BODY) {
DBG_WARNING("negotiate_request.length[%zu]\n",
- pass_info0->negotiate_request.length);
+ pass_info->negotiate_request.length);
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_connection_passB, &pass_blob);
}
goto next;
}
- status = smb2srv_client_connection_passed(client, pass_info0);
+ status = smb2srv_client_connection_passed(client, pass_info);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
/*
* We hit a race where, the client dropped the connection
status = smbd_add_connection(client,
sock_fd,
- pass_info0->transport_type,
- pass_info0->xconn_connect_time,
+ pass_info->transport_type,
+ pass_info->xconn_connect_time,
&xconn);
if (NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_ACCESS_DENIED)) {
rec->num_fds = 0;
/*
* Set seq_low to mid received in negprot
*/
- seq_low = BVAL(pass_info0->negotiate_request.data,
+ seq_low = BVAL(pass_info->negotiate_request.data,
SMB2_HDR_MESSAGE_ID);
xconn->smb2.client.guid_verified = true;
smbd_smb2_process_negprot(xconn, seq_low,
- pass_info0->negotiate_request.data,
- pass_info0->negotiate_request.length);
+ pass_info->negotiate_request.data,
+ pass_info->negotiate_request.length);
next:
if (rec != NULL) {
struct messaging_rec *rec = NULL;
struct smbXsrv_connection_dropB drop_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_connection_drop0 *drop_info0 = NULL;
+ struct smbXsrv_connection_drop *drop_info = NULL;
struct server_id_buf src_server_id_buf = {};
NTSTATUS status;
NDR_PRINT_DEBUG(smbXsrv_connection_dropB, &drop_blob);
}
- if (drop_blob.version != SMBXSRV_VERSION_0) {
+ if (drop_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("ignore invalid version %u\n", drop_blob.version);
NDR_PRINT_DEBUG(smbXsrv_connection_dropB, &drop_blob);
goto next;
}
- drop_info0 = drop_blob.info.info0;
- if (drop_info0 == NULL) {
+ drop_info = drop_blob.info.info1;
+ if (drop_info == NULL) {
DBG_ERR("ignore NULL info %u\n", drop_blob.version);
NDR_PRINT_DEBUG(smbXsrv_connection_dropB, &drop_blob);
goto next;
}
- if (!GUID_equal(&client->global->client_guid, &drop_info0->client_guid))
+ if (!GUID_equal(&client->global->client_guid, &drop_info->client_guid))
{
struct GUID_txt_buf buf1, buf2;
DBG_WARNING("client's client_guid [%s] != dropped guid [%s]\n",
GUID_buf_string(&client->global->client_guid,
&buf1),
- GUID_buf_string(&drop_info0->client_guid,
+ GUID_buf_string(&drop_info->client_guid,
&buf2));
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_connection_dropB, &drop_blob);
}
if (client->global->initial_connect_time !=
- drop_info0->client_connect_time)
+ drop_info->client_connect_time)
{
DBG_WARNING("client's initial connect time [%s] (%llu) != "
"dropped initial connect time [%s] (%llu)\n",
client->global->initial_connect_time),
(unsigned long long)client->global->initial_connect_time,
nt_time_string(talloc_tos(),
- drop_info0->client_connect_time),
- (unsigned long long)drop_info0->client_connect_time);
+ drop_info->client_connect_time),
+ (unsigned long long)drop_info->client_connect_time);
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_connection_dropB, &drop_blob);
}
* The client will have to reopen all sessions, tcons and durable opens.
*/
smbd_server_disconnect_client(client,
- server_id_str_buf(drop_info0->src_server_id, &src_server_id_buf));
+ server_id_str_buf(drop_info->src_server_id, &src_server_id_buf));
return;
next:
if (DEBUGLVL(DBGLVL_DEBUG)) {
struct smbXsrv_clientB client_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = client,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = client,
};
struct GUID_txt_buf buf;
TALLOC_CTX *mem_ctx,
TDB_DATA key,
TDB_DATA val,
- struct smbXsrv_open_global0 **global)
+ struct smbXsrv_open_global **global)
{
DATA_BLOB blob = data_blob_const(val.dptr, val.dsize);
struct smbXsrv_open_globalB global_blob;
NDR_PRINT_DEBUG(smbXsrv_open_globalB, &global_blob);
}
- if (global_blob.version != SMBXSRV_VERSION_0) {
+ if (global_blob.version != SMBXSRV_VERSION_1) {
status = NT_STATUS_INTERNAL_DB_CORRUPTION;
DEBUG(1,("Invalid record in smbXsrv_open_global.tdb:"
"key '%s' unsupported version - %d - %s\n",
goto done;
}
- if (global_blob.info.info0 == NULL) {
+ if (global_blob.info.info1 == NULL) {
status = NT_STATUS_INTERNAL_DB_CORRUPTION;
DEBUG(1,("Invalid record in smbXsrv_open_global.tdb:"
"key '%s' info0 NULL pointer - %s\n",
goto done;
}
- *global = talloc_move(mem_ctx, &global_blob.info.info0);
+ *global = talloc_move(mem_ctx, &global_blob.info.info1);
status = NT_STATUS_OK;
done:
talloc_free(frame);
TDB_DATA key,
TDB_DATA val,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_open_global0 **_global0)
+ struct smbXsrv_open_global **_global)
{
- struct smbXsrv_open_global0 *global0 = NULL;
+ struct smbXsrv_open_global *global = NULL;
struct server_id_buf buf;
NTSTATUS status;
return NT_STATUS_NOT_FOUND;
}
- status = smbXsrv_open_global_parse_record(mem_ctx, key, val, &global0);
+ status = smbXsrv_open_global_parse_record(mem_ctx, key, val, &global);
if (!NT_STATUS_IS_OK(status)) {
DBG_WARNING("smbXsrv_open_global_parse_record for %s failed: "
"%s\n",
nt_errstr(status));
return status;
}
- *_global0 = global0;
+ *_global = global;
- if (server_id_is_disconnected(&global0->server_id)) {
+ if (server_id_is_disconnected(&global->server_id)) {
return NT_STATUS_REMOTE_DISCONNECT;
}
- if (serverid_exists(&global0->server_id)) {
+ if (serverid_exists(&global->server_id)) {
return NT_STATUS_OBJECTID_EXISTS;
}
- if (global0->persistent) {
+ if (global->persistent) {
return NT_STATUS_REMOTE_DISCONNECT;
}
DBG_WARNING("smbd %s did not clean up record %s\n",
- server_id_str_buf(global0->server_id, &buf),
+ server_id_str_buf(global->server_id, &buf),
tdb_data_dbg(key));
return NT_STATUS_FATAL_APP_EXIT;
struct smbXsrv_open_global_lookup_state {
TALLOC_CTX *mem_ctx;
- struct smbXsrv_open_global0 *global;
+ struct smbXsrv_open_global *global;
NTSTATUS status;
};
NTSTATUS smbXsrv_open_global_lookup(
TALLOC_CTX *mem_ctx,
uint32_t open_global_id,
- const struct smbXsrv_open_global0 **_global)
+ const struct smbXsrv_open_global **_global)
{
struct smbXsrv_open_global_key_buf key_buf;
TDB_DATA key = smbXsrv_open_global_id_to_key(open_global_id, &key_buf);
struct db_record *rec,
TDB_DATA key,
TDB_DATA oldval,
- struct smbXsrv_open_global0 *global)
+ struct smbXsrv_open_global *global)
{
struct smbXsrv_open_globalB global_blob;
DATA_BLOB blob = data_blob_null;
int dbwrap_flags = DBWRAP_REPLACE;
/*
- * TODO: if we use other versions than '0'
+ * TODO: if we use other versions than '1'
* we would add glue code here, that would be able to
* store the information in the old format.
*/
global_blob.seqnum = IVAL(oldval.dptr, 4);
}
global_blob.seqnum += 1;
- global_blob.info.info0 = global;
+ global_blob.info.info1 = global;
ndr_err = ndr_push_struct_blob(&blob, talloc_tos(), &global_blob,
(ndr_push_flags_fn_t)ndr_push_smbXsrv_open_globalB);
struct smbXsrv_open_global_allocate_state {
uint32_t id;
- struct smbXsrv_open_global0 *global;
+ struct smbXsrv_open_global *global;
NTSTATUS status;
};
struct db_record *rec, TDB_DATA oldval, void *private_data)
{
struct smbXsrv_open_global_allocate_state *state = private_data;
- struct smbXsrv_open_global0 *global = state->global;
- struct smbXsrv_open_global0 *tmp_global0 = NULL;
+ struct smbXsrv_open_global *global = state->global;
+ struct smbXsrv_open_global *tmp_global = NULL;
TDB_DATA key = dbwrap_record_get_key(rec);
state->status = smbXsrv_open_global_verify_record(
- key, oldval, talloc_tos(), &tmp_global0);
+ key, oldval, talloc_tos(), &tmp_global);
if (!NT_STATUS_EQUAL(state->status, NT_STATUS_NOT_FOUND)) {
/*
* Found an existing record
*/
- TALLOC_FREE(tmp_global0);
+ TALLOC_FREE(tmp_global);
state->status = NT_STATUS_RETRY;
return;
}
if (NT_STATUS_EQUAL(state->status, NT_STATUS_FATAL_APP_EXIT)) {
NTSTATUS status;
- TALLOC_FREE(tmp_global0);
+ TALLOC_FREE(tmp_global);
/*
* smbd crashed
}
static NTSTATUS smbXsrv_open_global_allocate(
- struct db_context *db, struct smbXsrv_open_global0 *global)
+ struct db_context *db, struct smbXsrv_open_global *global)
{
struct smbXsrv_open_global_allocate_state state = {
.global = global,
struct smbXsrv_open_table *table = conn->client->open_table;
struct auth_session_info *session_info = NULL;
struct smbXsrv_open *op = NULL;
- struct smbXsrv_open_global0 *global = NULL;
+ struct smbXsrv_open_global *global = NULL;
NTSTATUS status;
struct dom_sid *current_sid = NULL;
struct security_token *current_token = NULL;
op->session = session;
op->tcon = tcon;
- global = talloc_zero(op, struct smbXsrv_open_global0);
+ global = talloc_zero(op, struct smbXsrv_open_global);
if (global == NULL) {
TALLOC_FREE(op);
return NT_STATUS_NO_MEMORY;
if (CHECK_DEBUGLVL(10)) {
struct smbXsrv_openB open_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = op,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = op,
};
DEBUG(10,("smbXsrv_open_create: global_id (0x%08x) stored\n",
}
struct smbXsrv_open_update_state {
- struct smbXsrv_open_global0 *global;
+ struct smbXsrv_open_global *global;
NTSTATUS status;
};
if (CHECK_DEBUGLVL(10)) {
struct smbXsrv_openB open_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = op,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = op,
};
DEBUG(10,("smbXsrv_open_update: global_id (0x%08x) stored\n",
struct db_record *rec, TDB_DATA oldval, void *private_data)
{
struct smbXsrv_open_close_state *state = private_data;
- struct smbXsrv_open_global0 *global = state->op->global;
+ struct smbXsrv_open_global *global = state->op->global;
TDB_DATA key = dbwrap_record_get_key(rec);
if (global->durable) {
if (CHECK_DEBUGLVL(10)) {
struct smbXsrv_openB open_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = state->op,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = state->op,
};
DBG_DEBUG("(0x%08x) stored disconnect\n",
NTSTATUS smbXsrv_open_close(struct smbXsrv_open *op, NTTIME now)
{
struct smbXsrv_open_close_state state = { .op = op, };
- struct smbXsrv_open_global0 *global = op->global;
+ struct smbXsrv_open_global *global = op->global;
struct smbXsrv_open_table *table;
NTSTATUS status;
NTSTATUS error = NT_STATUS_OK;
struct GUID_txt_buf _create_guid_buf;
const char *create_guid_str = GUID_buf_string(&create_guid, &_create_guid_buf);
struct db_record *db_rec = NULL;
- const struct smbXsrv_open_global0 *global = NULL;
+ const struct smbXsrv_open_global *global = NULL;
struct smbXsrv_open *op = NULL;
uint32_t open_global_id;
struct smbXsrv_open_replay_cache_key_buf key_buf;
}
if (CHECK_DEBUGLVL(DBGLVL_DEBUG)) {
- NDR_PRINT_DEBUG(smbXsrv_open_global0, global);
+ NDR_PRINT_DEBUG(smbXsrv_open_global, global);
}
status = smbXsrv_open_local_lookup(table,
{
struct smb2srv_open_recreate_state *state = private_data;
TDB_DATA key = dbwrap_record_get_key(rec);
- struct smbXsrv_open_global0 *global = NULL;
+ struct smbXsrv_open_global *global = NULL;
struct GUID_txt_buf buf1, buf2;
state->status = smbXsrv_open_global_verify_record(
if (CHECK_DEBUGLVL(10)) {
struct smbXsrv_openB open_blob = {
- .info.info0 = state.op,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = state.op,
};
DBG_DEBUG("global_id (0x%08x) stored\n",
state.op->global->open_global_id);
struct smbXsrv_open_global_traverse_state {
int (*fn)(struct db_record *rec,
- struct smbXsrv_open_global0 *global,
+ struct smbXsrv_open_global *global,
TDB_DATA *rc_open_global_key,
void *private_data);
void *private_data;
{
struct smbXsrv_open_global_traverse_state *state =
(struct smbXsrv_open_global_traverse_state*)data;
- struct smbXsrv_open_global0 *global = NULL;
+ struct smbXsrv_open_global *global = NULL;
TDB_DATA key = dbwrap_record_get_key(rec);
TDB_DATA val = dbwrap_record_get_value(rec);
NTSTATUS status;
NTSTATUS smbXsrv_open_global_traverse(
int (*fn)(struct db_record *rec,
- struct smbXsrv_open_global0 *global,
+ struct smbXsrv_open_global *global,
TDB_DATA *rc_open_global_key,
void *private_data),
void *private_data)
struct db_record *rec, TDB_DATA oldval, void *private_data)
{
struct smbXsrv_open_cleanup_state *state = private_data;
- struct smbXsrv_open_global0 *global = NULL;
+ struct smbXsrv_open_global *global = NULL;
TDB_DATA key = dbwrap_record_get_key(rec);
bool delete_open = false;
NTSTATUS smbXsrv_open_global_traverse_per_rec_persistent_read(
int (*fn)(struct db_record *rec,
- struct smbXsrv_open_global0 *global,
+ struct smbXsrv_open_global *global,
TDB_DATA *rc_open_global_key,
void *private_data),
void *private_data)
struct smbXsrv_connection;
struct auth_session_info;
struct smbXsrv_open;
-struct smbXsrv_open_global0;
+struct smbXsrv_open_global;
struct smbXsrv_client;
NTSTATUS smbXsrv_open_global_init(void);
struct smbXsrv_open **_open);
NTSTATUS smbXsrv_open_global_lookup(TALLOC_CTX *mem_ctx,
uint32_t open_global_id,
- const struct smbXsrv_open_global0 **global);
+ const struct smbXsrv_open_global **global);
NTSTATUS smbXsrv_open_global_parse_record(TALLOC_CTX *mem_ctx,
TDB_DATA key,
TDB_DATA val,
- struct smbXsrv_open_global0 **global);
+ struct smbXsrv_open_global **global);
NTSTATUS smbXsrv_open_purge_replay_cache(struct smbXsrv_client *client,
const struct GUID *create_guid);
struct db_record;
NTSTATUS smbXsrv_open_global_traverse(
int (*fn)(struct db_record *rec,
- struct smbXsrv_open_global0 *global,
+ struct smbXsrv_open_global *global,
TDB_DATA *rc_open_global_key,
void *private_data),
void *private_data);
NTSTATUS smbXsrv_open_global_traverse_per_rec_persistent_read(
int (*fn)(struct db_record *rec,
- struct smbXsrv_open_global0 *global,
+ struct smbXsrv_open_global *global,
TDB_DATA *rc_open_global_key,
void *private_data),
void *private_data);
struct messaging_rec *rec = NULL;
struct smbXsrv_session_closeB close_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_session_close0 *close_info0 = NULL;
+ struct smbXsrv_session_close *close_info = NULL;
struct smbXsrv_session *session = NULL;
NTSTATUS status;
struct timeval tv = timeval_current();
NDR_PRINT_DEBUG(smbXsrv_session_closeB, &close_blob);
}
- if (close_blob.version != SMBXSRV_VERSION_0) {
+ if (close_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("ignore invalid version %u\n", close_blob.version);
NDR_PRINT_DEBUG(smbXsrv_session_closeB, &close_blob);
goto next;
}
- close_info0 = close_blob.info.info0;
- if (close_info0 == NULL) {
+ close_info = close_blob.info.info1;
+ if (close_info == NULL) {
DBG_ERR("ignore NULL info %u\n", close_blob.version);
NDR_PRINT_DEBUG(smbXsrv_session_closeB, &close_blob);
goto next;
}
status = smb2srv_session_lookup_client(client,
- close_info0->old_session_wire_id,
+ close_info->old_session_wire_id,
now, &session);
if (NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
DBG_INFO("old_session_wire_id %" PRIu64 " not found\n",
- close_info0->old_session_wire_id);
+ close_info->old_session_wire_id);
if (DEBUGLVL(DBGLVL_INFO)) {
NDR_PRINT_DEBUG(smbXsrv_session_closeB, &close_blob);
}
!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_SESSION_EXPIRED)) {
DBG_WARNING("old_session_wire_id %" PRIu64 " - %s\n",
- close_info0->old_session_wire_id,
+ close_info->old_session_wire_id,
nt_errstr(status));
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_session_closeB, &close_blob);
goto next;
}
- if (session->global->session_global_id != close_info0->old_session_global_id) {
+ if (session->global->session_global_id != close_info->old_session_global_id) {
DBG_WARNING("old_session_wire_id %" PRIu64 " - "
"global %" PRIu32 " != %" PRIu32 "\n",
- close_info0->old_session_wire_id,
+ close_info->old_session_wire_id,
session->global->session_global_id,
- close_info0->old_session_global_id);
+ close_info->old_session_global_id);
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_session_closeB, &close_blob);
}
goto next;
}
- if (session->global->creation_time != close_info0->old_creation_time) {
+ if (session->global->creation_time != close_info->old_creation_time) {
DBG_WARNING("old_session_wire_id %" PRIu64 " - "
"creation %s (%" PRIu64 ") != %s (%" PRIu64 ")\n",
- close_info0->old_session_wire_id,
+ close_info->old_session_wire_id,
nt_time_string(rec,
session->global->creation_time),
session->global->creation_time,
nt_time_string(rec,
- close_info0->old_creation_time),
- close_info0->old_creation_time);
+ close_info->old_creation_time),
+ close_info->old_creation_time);
if (DEBUGLVL(DBGLVL_WARNING)) {
NDR_PRINT_DEBUG(smbXsrv_session_closeB, &close_blob);
}
* valid on the channel.
*/
if (conn != NULL) {
- struct smbXsrv_channel_global0 *c = NULL;
+ struct smbXsrv_channel_global *c = NULL;
status = smbXsrv_session_find_channel(state.session, conn, &c);
if (!NT_STATUS_IS_OK(status)) {
return state.session->status;
}
-static int smbXsrv_session_global_destructor(struct smbXsrv_session_global0 *global)
+static int smbXsrv_session_global_destructor(struct smbXsrv_session_global *global)
{
return 0;
}
bool *is_free,
bool *was_free,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_session_global0 **_g,
+ struct smbXsrv_session_global **_g,
uint32_t *pseqnum);
static NTSTATUS smbXsrv_session_global_allocate(struct db_context *db,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_session_global0 **_global)
+ struct smbXsrv_session_global **_global)
{
uint32_t i;
- struct smbXsrv_session_global0 *global = NULL;
+ struct smbXsrv_session_global *global = NULL;
uint32_t last_free = 0;
const uint32_t min_tries = 3;
*_global = NULL;
- global = talloc_zero(mem_ctx, struct smbXsrv_session_global0);
+ global = talloc_zero(mem_ctx, struct smbXsrv_session_global);
if (global == NULL) {
return NT_STATUS_NO_MEMORY;
}
bool *is_free,
bool *was_free,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_session_global0 **_g,
+ struct smbXsrv_session_global **_g,
uint32_t *pseqnum)
{
TDB_DATA key;
DATA_BLOB blob;
struct smbXsrv_session_globalB global_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_session_global0 *global = NULL;
+ struct smbXsrv_session_global *global = NULL;
bool exists;
TALLOC_CTX *frame = talloc_stackframe();
NDR_PRINT_DEBUG(smbXsrv_session_globalB, &global_blob);
}
- if (global_blob.version != SMBXSRV_VERSION_0) {
+ if (global_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("key '%s' use unsupported version %u\n",
tdb_data_dbg(key),
global_blob.version);
return;
}
- global = global_blob.info.info0;
+ global = global_blob.info.info1;
#define __BLOB_KEEP_SECRET(__blob) do { \
if ((__blob).length != 0) { \
TALLOC_FREE(frame);
}
-static NTSTATUS smbXsrv_session_global_store(struct smbXsrv_session_global0 *global)
+static NTSTATUS smbXsrv_session_global_store(struct smbXsrv_session_global *global)
{
struct smbXsrv_session_globalB global_blob;
DATA_BLOB blob = data_blob_null;
enum ndr_err_code ndr_err;
/*
- * TODO: if we use other versions than '0'
+ * TODO: if we use other versions than '1'
* we would add glue code here, that would be able to
* store the information in the old format.
*/
global_blob = (struct smbXsrv_session_globalB){
.version = smbXsrv_version_global_current(),
- .info.info0 = global,
+ .info.info1 = global,
};
if (val.dsize >= 8) {
struct smbXsrv_connection *conn = state->connection;
DATA_BLOB blob;
struct security_token *previous_token = NULL;
- struct smbXsrv_session_global0 *global = NULL;
+ struct smbXsrv_session_global *global = NULL;
enum ndr_err_code ndr_err;
- struct smbXsrv_session_close0 close_info0;
+ struct smbXsrv_session_close close_info;
struct smbXsrv_session_closeB close_blob;
struct tevent_req *subreq = NULL;
NTSTATUS status;
smb2srv_session_close_previous_modified,
req);
- close_info0 = (struct smbXsrv_session_close0){
+ close_info = (struct smbXsrv_session_close) {
.old_session_global_id = global->session_global_id,
.old_session_wire_id = global->session_wire_id,
.old_creation_time = global->creation_time,
close_blob = (struct smbXsrv_session_closeB){
.version = smbXsrv_version_global_current(),
- .info.info0 = &close_info0,
+ .info.info1 = &close_info,
};
ndr_err = ndr_push_struct_blob(&blob, state, &close_blob,
status = ndr_map_error2ntstatus(ndr_err);
DBG_WARNING("old_session[%" PRIu64 "] "
"new_session[%" PRIu64 "] ndr_push - %s\n",
- close_info0.old_session_wire_id,
- close_info0.new_session_wire_id,
+ close_info.old_session_wire_id,
+ close_info.new_session_wire_id,
nt_errstr(status));
tevent_req_nterror(req, status);
return;
struct smbXsrv_session *session = NULL;
void *ptr = NULL;
TDB_DATA val;
- struct smbXsrv_session_global0 *global = NULL;
- struct smbXsrv_channel_global0 *channel = NULL;
+ struct smbXsrv_session_global *global = NULL;
+ struct smbXsrv_channel_global *channel = NULL;
NTSTATUS status;
if (table->local.num_sessions >= table->local.max_sessions) {
if (DEBUGLVL(DBGLVL_DEBUG)) {
struct smbXsrv_sessionB session_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = session,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = session,
};
DBG_DEBUG("global_id (0x%08x) stored\n",
NTSTATUS smbXsrv_session_add_channel(struct smbXsrv_session *session,
struct smbXsrv_connection *conn,
NTTIME now,
- struct smbXsrv_channel_global0 **_c)
+ struct smbXsrv_channel_global **_c)
{
- struct smbXsrv_session_global0 *global = session->global;
- struct smbXsrv_channel_global0 *c = NULL;
+ struct smbXsrv_session_global *global = session->global;
+ struct smbXsrv_channel_global *c = NULL;
if (global->num_channels > 31) {
/*
c = talloc_realloc(global,
global->channels,
- struct smbXsrv_channel_global0,
+ struct smbXsrv_channel_global,
global->num_channels + 1);
if (c == NULL) {
return NT_STATUS_NO_MEMORY;
c = &global->channels[global->num_channels];
- *c = (struct smbXsrv_channel_global0){
+ *c = (struct smbXsrv_channel_global) {
.server_id = messaging_server_id(conn->client->msg_ctx),
.channel_id = conn->channel_id,
.creation_time = now,
if (DEBUGLVL(DBGLVL_DEBUG)) {
struct smbXsrv_sessionB session_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = session,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = session,
};
DBG_DEBUG("global_id (0x%08x) stored\n",
NTSTATUS smbXsrv_session_find_channel(const struct smbXsrv_session *session,
const struct smbXsrv_connection *conn,
- struct smbXsrv_channel_global0 **_c)
+ struct smbXsrv_channel_global **_c)
{
uint32_t i;
for (i=0; i < session->global->num_channels; i++) {
- struct smbXsrv_channel_global0 *c = &session->global->channels[i];
+ struct smbXsrv_channel_global *c = &session->global->channels[i];
if (c->channel_id != conn->channel_id) {
continue;
NTSTATUS smbXsrv_session_find_auth(const struct smbXsrv_session *session,
const struct smbXsrv_connection *conn,
NTTIME now,
- struct smbXsrv_session_auth0 **_a)
+ struct smbXsrv_session_auth **_a)
{
- struct smbXsrv_session_auth0 *a;
+ struct smbXsrv_session_auth *a = NULL;
for (a = session->pending_auth; a != NULL; a = a->next) {
if (a->channel_id != conn->channel_id) {
return NT_STATUS_USER_SESSION_DELETED;
}
-static int smbXsrv_session_auth0_destructor(struct smbXsrv_session_auth0 *a)
+static int smbXsrv_session_auth_destructor(struct smbXsrv_session_auth *a)
{
if (a->session == NULL) {
return 0;
NTTIME now,
uint8_t in_flags,
uint8_t in_security_mode,
- struct smbXsrv_session_auth0 **_a)
+ struct smbXsrv_session_auth **_a)
{
- struct smbXsrv_session_auth0 *a;
+ struct smbXsrv_session_auth *a = NULL;
NTSTATUS status;
status = smbXsrv_session_find_auth(session, conn, 0, &a);
return NT_STATUS_INTERNAL_ERROR;
}
- a = talloc(session, struct smbXsrv_session_auth0);
+ a = talloc(session, struct smbXsrv_session_auth);
if (a == NULL) {
return NT_STATUS_NO_MEMORY;
}
- *a = (struct smbXsrv_session_auth0){
+ *a = (struct smbXsrv_session_auth) {
.session = session,
.connection = conn,
.in_flags = in_flags,
*a->preauth = conn->smb2.preauth;
}
- talloc_set_destructor(a, smbXsrv_session_auth0_destructor);
+ talloc_set_destructor(a, smbXsrv_session_auth_destructor);
DLIST_ADD_END(session->pending_auth, a);
*_a = a;
NTSTATUS smbXsrv_session_remove_channel(struct smbXsrv_session *session,
struct smbXsrv_connection *xconn)
{
- struct smbXsrv_session_auth0 *a = NULL;
- struct smbXsrv_channel_global0 *c = NULL;
+ struct smbXsrv_session_auth *a = NULL;
+ struct smbXsrv_channel_global *c = NULL;
NTSTATUS status;
bool need_update = false;
}
if (a != NULL) {
- smbXsrv_session_auth0_destructor(a);
+ smbXsrv_session_auth_destructor(a);
a->connection = NULL;
need_update = true;
}
if (c != NULL) {
- struct smbXsrv_session_global0 *global = session->global;
+ struct smbXsrv_session_global *global = session->global;
ptrdiff_t n;
n = (c - global->channels);
}
struct smbXsrv_session_global_traverse_state {
- int (*fn)(struct smbXsrv_session_global0 *, void *);
+ int (*fn)(struct smbXsrv_session_global *, void *);
void *private_data;
};
goto done;
}
- if (global_blob.version != SMBXSRV_VERSION_0) {
+ if (global_blob.version != SMBXSRV_VERSION_1) {
DBG_WARNING("Invalid record in smbXsrv_session_global.tdb:"
"key '%s' unsupported version - %d\n",
tdb_data_dbg(key),
goto done;
}
- if (global_blob.info.info0 == NULL) {
+ if (global_blob.info.info1 == NULL) {
DBG_WARNING("Invalid record in smbXsrv_tcon_global.tdb:"
"key '%s' info0 NULL pointer\n",
tdb_data_dbg(key));
goto done;
}
- global_blob.info.info0->db_rec = rec;
- ret = state->fn(global_blob.info.info0, state->private_data);
+ global_blob.info.info1->db_rec = rec;
+ ret = state->fn(global_blob.info.info1, state->private_data);
done:
TALLOC_FREE(frame);
return ret;
}
NTSTATUS smbXsrv_session_global_traverse(
- int (*fn)(struct smbXsrv_session_global0 *, void *),
+ int (*fn)(struct smbXsrv_session_global *, void *),
void *private_data)
{
struct smbXsrv_client;
struct smbXsrv_connection;
struct smbXsrv_session;
-struct smbXsrv_session_global0;
-struct smbXsrv_channel_global0;
-struct smbXsrv_session_auth0;
+struct smbXsrv_session_global;
+struct smbXsrv_channel_global;
+struct smbXsrv_session_auth;
NTSTATUS smbXsrv_session_global_init(struct messaging_context *msg_ctx);
NTSTATUS smbXsrv_session_create(struct smbXsrv_connection *conn,
NTSTATUS smbXsrv_session_add_channel(struct smbXsrv_session *session,
struct smbXsrv_connection *conn,
NTTIME now,
- struct smbXsrv_channel_global0 **_c);
+ struct smbXsrv_channel_global **_c);
NTSTATUS smbXsrv_session_remove_channel(struct smbXsrv_session *session,
struct smbXsrv_connection *xconn);
NTSTATUS smbXsrv_session_disconnect_xconn(struct smbXsrv_connection *xconn);
NTSTATUS smbXsrv_session_update(struct smbXsrv_session *session);
NTSTATUS smbXsrv_session_find_channel(const struct smbXsrv_session *session,
const struct smbXsrv_connection *conn,
- struct smbXsrv_channel_global0 **_c);
+ struct smbXsrv_channel_global **_c);
NTSTATUS smbXsrv_session_find_auth(const struct smbXsrv_session *session,
const struct smbXsrv_connection *conn,
NTTIME now,
- struct smbXsrv_session_auth0 **_a);
+ struct smbXsrv_session_auth **_a);
NTSTATUS smbXsrv_session_create_auth(struct smbXsrv_session *session,
struct smbXsrv_connection *conn,
NTTIME now,
uint8_t in_flags,
uint8_t in_security_mode,
- struct smbXsrv_session_auth0 **_a);
+ struct smbXsrv_session_auth **_a);
struct tevent_req *smb2srv_session_shutdown_send(
TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
int (*caller_cb)(struct smbXsrv_session *session, void *caller_data),
void *caller_data);
NTSTATUS smbXsrv_session_global_traverse(
- int (*fn)(struct smbXsrv_session_global0 *, void *),
+ int (*fn)(struct smbXsrv_session_global *, void *),
void *private_data);
struct tevent_req *smb2srv_session_close_previous_send(
TALLOC_CTX *mem_ctx,
return state.tcon->status;
}
-static int smbXsrv_tcon_global_destructor(struct smbXsrv_tcon_global0 *global)
+static int smbXsrv_tcon_global_destructor(struct smbXsrv_tcon_global *global)
{
return 0;
}
bool *is_free,
bool *was_free,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_tcon_global0 **_g);
+ struct smbXsrv_tcon_global **_g);
static NTSTATUS smbXsrv_tcon_global_allocate(struct db_context *db,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_tcon_global0 **_global)
+ struct smbXsrv_tcon_global **_global)
{
uint32_t i;
- struct smbXsrv_tcon_global0 *global = NULL;
+ struct smbXsrv_tcon_global *global = NULL;
uint32_t last_free = 0;
const uint32_t min_tries = 3;
*_global = NULL;
- global = talloc_zero(mem_ctx, struct smbXsrv_tcon_global0);
+ global = talloc_zero(mem_ctx, struct smbXsrv_tcon_global);
if (global == NULL) {
return NT_STATUS_NO_MEMORY;
}
bool *is_free,
bool *was_free,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_tcon_global0 **_g)
+ struct smbXsrv_tcon_global **_g)
{
TDB_DATA key;
TDB_DATA val;
DATA_BLOB blob;
struct smbXsrv_tcon_globalB global_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_tcon_global0 *global = NULL;
+ struct smbXsrv_tcon_global *global = NULL;
bool exists;
TALLOC_CTX *frame = talloc_stackframe();
NDR_PRINT_DEBUG(smbXsrv_tcon_globalB, &global_blob);
}
- if (global_blob.version != SMBXSRV_VERSION_0) {
+ if (global_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("key '%s' uses unsupported version %u\n",
tdb_data_dbg(key),
global_blob.version);
return;
}
- global = global_blob.info.info0;
+ global = global_blob.info.info1;
exists = serverid_exists(&global->server_id);
if (!exists) {
TALLOC_FREE(frame);
}
-static NTSTATUS smbXsrv_tcon_global_store(struct smbXsrv_tcon_global0 *global)
+static NTSTATUS smbXsrv_tcon_global_store(struct smbXsrv_tcon_global *global)
{
struct smbXsrv_tcon_globalB global_blob;
DATA_BLOB blob = data_blob_null;
enum ndr_err_code ndr_err;
/*
- * TODO: if we use other versions than '0'
+ * TODO: if we use other versions than '1'
* we would add glue code here, that would be able to
* store the information in the old format.
*/
global_blob.seqnum = IVAL(val.dptr, 4);
}
global_blob.seqnum += 1;
- global_blob.info.info0 = global;
+ global_blob.info.info1 = global;
ndr_err = ndr_push_struct_blob(&blob, global->db_rec, &global_blob,
(ndr_push_flags_fn_t)ndr_push_smbXsrv_tcon_globalB);
struct smbXsrv_tcon *tcon = NULL;
void *ptr = NULL;
TDB_DATA val;
- struct smbXsrv_tcon_global0 *global = NULL;
+ struct smbXsrv_tcon_global *global = NULL;
NTSTATUS status;
if (table->local.num_tcons >= table->local.max_tcons) {
if (DEBUGLVL(DBGLVL_DEBUG)) {
struct smbXsrv_tconB tcon_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = tcon,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = tcon,
};
DBG_DEBUG("global_id (0x%08x) stored\n",
if (DEBUGLVL(DBGLVL_DEBUG)) {
struct smbXsrv_tconB tcon_blob = {
- .version = SMBXSRV_VERSION_0,
- .info.info0 = tcon,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = tcon,
};
DBG_DEBUG("global_id (0x%08x) stored\n",
}
struct smbXsrv_tcon_global_traverse_state {
- int (*fn)(struct smbXsrv_tcon_global0 *, void *);
+ int (*fn)(struct smbXsrv_tcon_global *, void *);
void *private_data;
};
goto done;
}
- if (global_blob.version != SMBXSRV_VERSION_0) {
+ if (global_blob.version != SMBXSRV_VERSION_1) {
DBG_WARNING("Invalid record in smbXsrv_tcon_global.tdb:"
"key '%s' unsupported version - %d\n",
tdb_data_dbg(key),
goto done;
}
- if (global_blob.info.info0 == NULL) {
+ if (global_blob.info.info1 == NULL) {
DBG_WARNING("Invalid record in smbXsrv_tcon_global.tdb:"
"key '%s' info0 NULL pointer\n",
tdb_data_dbg(key));
goto done;
}
- global_blob.info.info0->db_rec = rec;
- ret = state->fn(global_blob.info.info0, state->private_data);
+ global_blob.info.info1->db_rec = rec;
+ ret = state->fn(global_blob.info.info1, state->private_data);
done:
TALLOC_FREE(frame);
return ret;
}
NTSTATUS smbXsrv_tcon_global_traverse(
- int (*fn)(struct smbXsrv_tcon_global0 *, void *),
+ int (*fn)(struct smbXsrv_tcon_global *, void *),
void *private_data)
{
NTSTATUS status;
DATA_BLOB blob;
struct smbXsrv_version_globalB global_blob;
enum ndr_err_code ndr_err;
- struct smbXsrv_version_global0 *global = NULL;
+ struct smbXsrv_version_global *global = NULL;
uint32_t i;
uint32_t num_valid = 0;
- struct smbXsrv_version_node0 *valid = NULL;
- struct smbXsrv_version_node0 *local_node = NULL;
+ struct smbXsrv_version_node *valid = NULL;
+ struct smbXsrv_version_node *local_node = NULL;
bool exists;
NTSTATUS status;
const char *key_string = "smbXsrv_version_global";
val = dbwrap_record_get_value(db_rec);
if (val.dsize == 0) {
- global = talloc_zero(frame, struct smbXsrv_version_global0);
+ global = talloc_zero(frame, struct smbXsrv_version_global);
if (global == NULL) {
DBG_ERR("talloc_zero failed - %s\n", __location__);
TALLOC_FREE(frame);
return NT_STATUS_NO_MEMORY;
}
global_blob = (struct smbXsrv_version_globalB) {
- .version = SMBXSRV_VERSION_CURRENT,
- .info.info0 = global,
+ .version = SMBXSRV_VERSION_1,
+ .info.info1 = global,
};
} else {
blob = data_blob_const(val.dptr, val.dsize);
}
switch (global_blob.version) {
- case SMBXSRV_VERSION_0:
- global = global_blob.info.info0;
+ case SMBXSRV_VERSION_1:
+ global = global_blob.info.info1;
if (global == NULL) {
status = NT_STATUS_INTERNAL_DB_CORRUPTION;
break;
}
valid = talloc_zero_array(global,
- struct smbXsrv_version_node0,
+ struct smbXsrv_version_node,
global->num_nodes + 1);
if (valid == NULL) {
DBG_ERR("talloc_zero_array failed - %s\n", __location__);
num_valid = 0;
for (i=0; i < global->num_nodes; i++) {
- struct smbXsrv_version_node0 *n = &global->nodes[i];
+ struct smbXsrv_version_node *n = &global->nodes[i];
exists = serverid_exists(&n->server_id);
if (!exists) {
num_valid++;
}
- *local_node = (struct smbXsrv_version_node0){
+ *local_node = (struct smbXsrv_version_node) {
.server_id = *server_id,
- .min_version = SMBXSRV_VERSION_0,
+ .min_version = SMBXSRV_VERSION_1,
.max_version = SMBXSRV_VERSION_CURRENT,
.current_version = global_blob.version,
};
global->nodes = valid;
global_blob.seqnum += 1;
- global_blob.info.info0 = global;
+ global_blob.info.info1 = global;
ndr_err = ndr_push_struct_blob(&blob, db_rec, &global_blob,
(ndr_push_flags_fn_t)ndr_push_smbXsrv_version_globalB);
}
static int cleanup_ph_fn(struct db_record *dbrec,
- struct smbXsrv_open_global0 *global,
+ struct smbXsrv_open_global *global,
TDB_DATA *rc_open_global_key,
void *private_data)
{
bool authenticated;
};
-static int collect_sessions_fn(struct smbXsrv_session_global0 *global,
+static int collect_sessions_fn(struct smbXsrv_session_global *global,
void *connections_forall_state)
{
NTSTATUS status;
return 0;
}
-static int traverse_tcon_fn(struct smbXsrv_tcon_global0 *global,
+static int traverse_tcon_fn(struct smbXsrv_tcon_global *global,
void *connections_forall_state)
{
NTSTATUS status;
return ret;
}
-static int wipedbs_traverse_sessions(struct smbXsrv_session_global0 *session,
+static int wipedbs_traverse_sessions(struct smbXsrv_session_global *session,
void *wipedbs_state)
{
struct wipedbs_state *state =
return ret;
}
-static int wipedbs_traverse_tcon(struct smbXsrv_tcon_global0 *tcon,
+static int wipedbs_traverse_tcon(struct smbXsrv_tcon_global *tcon,
void *wipedbs_state)
{
struct wipedbs_state *state =
}
static int wipedbs_traverse_open(struct db_record *db_rec,
- struct smbXsrv_open_global0 *open,
+ struct smbXsrv_open_global *open,
TDB_DATA *rc_open_global_key,
void *wipedbs_state)
{
struct wipedbs_delete_state *delete_state)
{
struct wipedbs_record_marker *cur = delete_state->cur;
- struct smbXsrv_open_global0 *global = NULL;
+ struct smbXsrv_open_global *global = NULL;
NTSTATUS status;
bool ok;
return;
}
- if (global_blob.version != SMBXSRV_VERSION_0) {
+ if (global_blob.version != SMBXSRV_VERSION_1) {
DBG_ERR("Unsupported open record version %u\n",
global_blob.version);
TALLOC_FREE(mem_ctx);
return;
}
- status = smbXsrv_replay_cleanup(&global_blob.info.info0->client_guid,
- &global_blob.info.info0->create_guid);
+ status = smbXsrv_replay_cleanup(&global_blob.info.info1->client_guid,
+ &global_blob.info.info1->create_guid);
TALLOC_FREE(mem_ctx);
if (!NT_STATUS_IS_OK(status)) {
DBG_ERR("Replay record cleanup failed\n");
}
static int add_channel_to_json(struct json_object *parent_json,
- const struct smbXsrv_channel_global0 *channel)
+ const struct smbXsrv_channel_global *channel)
{
TALLOC_CTX *frame = talloc_stackframe();
struct json_object sub_json;
}
static int add_channels_to_json(struct json_object *parent_json,
- const struct smbXsrv_session_global0 *global)
+ const struct smbXsrv_session_global *global)
{
struct json_object sub_json;
uint32_t i;
}
for (i = 0; i < global->num_channels; i++) {
- const struct smbXsrv_channel_global0 *c = &global->channels[i];
+ const struct smbXsrv_channel_global *c = &global->channels[i];
result = add_channel_to_json(&sub_json, c);
if (result < 0) {
projects / thirdparty / samba.git / commitdiff
