sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-01-10 01:18:15 +03:00
Code

Share data_blob implementation.

Browse Source
This commit is contained in:
Jelmer Vernooij 2008-10-12 01:46:15 +02:00
parent 218f482fbf
commit 348be5f1e4
11 changed files with 20 additions and 218 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/util/data_blob.c
View File

@ -20,6 +20,8 @@
#include "includes.h"
const DATA_BLOB data_blob_null = { NULL, 0 };
/**
* @file
* @brief Manipulation of arbitrary data blobs

2
lib/util/data_blob.h
View File

@ -120,4 +120,6 @@ _PUBLIC_ bool data_blob_realloc(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, size_t len
_PUBLIC_ bool data_blob_append(TALLOC_CTX *mem_ctx, DATA_BLOB *blob,
const void *p, size_t length);
extern const DATA_BLOB data_blob_null;
#endif /* _SAMBA_DATABLOB_H_ */

2
source3/Makefile.in
View File

@ -326,7 +326,7 @@ LIB_OBJ = $(LIBSAMBAUTIL_OBJ) \
lib/bitmap.o ../lib/crypto/crc32.o lib/dprintf.o $(UTIL_REG_OBJ) \
../lib/util/xfile.o ../lib/util/util_strlist.o lib/wins_srv.o \
lib/util_str.o lib/clobber.o lib/util_sid.o lib/util_uuid.o \
lib/util_unistr.o lib/util_file.o lib/data_blob.o \
lib/util_unistr.o lib/util_file.o ../lib/util/data_blob.o \
lib/util.o lib/util_sock.o lib/sock_exec.o lib/util_sec.o \
lib/substitute.o lib/fsusage.o lib/dbwrap_util.o \
lib/ms_fnmatch.o lib/select.o lib/errmap_unix.o \

1
source3/include/includes.h
View File

@ -654,6 +654,7 @@ typedef char fstring[FSTRING_LEN];
#include "../talloc/talloc.h"
#include "../lib/util/data_blob.h"
#include "../lib/util/time.h"
/* And a little extension. Abort on type mismatch */
#define talloc_get_type_abort(ptr, type) \

7
source3/include/messages.h
View File

@ -82,7 +82,6 @@ struct server_id {
struct messaging_context;
struct messaging_rec;
struct data_blob;
/*
* struct messaging_context belongs to messages.c, but because we still have
@ -102,7 +101,7 @@ struct messaging_context {
struct messaging_backend {
NTSTATUS (*send_fn)(struct messaging_context *msg_ctx,
struct server_id pid, int msg_type,
const struct data_blob *data,
const DATA_BLOB *data,
struct messaging_backend *backend);
void *private_data;
};
@ -138,12 +137,12 @@ NTSTATUS messaging_register(struct messaging_context *msg_ctx,
void *private_data,
uint32_t msg_type,
struct server_id server_id,
struct data_blob *data));
DATA_BLOB *data));
void messaging_deregister(struct messaging_context *ctx, uint32_t msg_type,
void *private_data);
NTSTATUS messaging_send(struct messaging_context *msg_ctx,
struct server_id server,
uint32_t msg_type, const struct data_blob *data);
uint32_t msg_type, const DATA_BLOB *data);
NTSTATUS messaging_send_buf(struct messaging_context *msg_ctx,
struct server_id server, uint32_t msg_type,
const uint8 *buf, size_t len);

4
source3/include/packet.h
View File

@ -46,10 +46,10 @@ NTSTATUS packet_fd_read_sync(struct packet_context *ctx);
* Otherwise return True and store the callback result in *status
*/
bool packet_handler(struct packet_context *ctx,
bool (*full_req)(const struct data_blob *data,
bool (*full_req)(const DATA_BLOB *data,
size_t *length,
void *private_data),
NTSTATUS (*callback)(const struct data_blob *data,
NTSTATUS (*callback)(const DATA_BLOB *data,
void *private_data),
void *private_data,
NTSTATUS *status);

12
source3/include/proto.h
View File

@ -435,18 +435,6 @@ int connections_forall(int (*fn)(struct db_record *rec,
void *private_data);
bool connections_init(bool rw);
/* The following definitions come from lib/data_blob.c */
DATA_BLOB data_blob(const void *p, size_t length);
DATA_BLOB data_blob_talloc(TALLOC_CTX *mem_ctx, const void *p, size_t length);
void data_blob_free(DATA_BLOB *d);
void data_blob_clear(DATA_BLOB *d);
void data_blob_clear_free(DATA_BLOB *d);
DATA_BLOB data_blob_string_const(const char *str);
DATA_BLOB data_blob_const(const void *p, size_t length);
DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length);
_PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob);
/* The following definitions come from lib/dbwrap_util.c */
int32_t dbwrap_fetch_int32(struct db_context *db, const char *keystr);

9
source3/include/smb.h
View File

@ -246,15 +246,6 @@ struct id_map {
enum id_mapping status;
};
/* used to hold an arbitrary blob of data */
typedef struct data_blob {
uint8 *data;
size_t length;
void (*free)(struct data_blob *data_blob);
} DATA_BLOB;
extern const DATA_BLOB data_blob_null;
#include "librpc/gen_ndr/misc.h"
#include "librpc/gen_ndr/security.h"
#include "librpc/ndr/libndr.h"

180
source3/lib/data_blob.c
View File

@ -1,180 +0,0 @@
/*
Unix SMB/CIFS implementation.
Easy management of byte-length data
Copyright (C) Andrew Tridgell 2001
Copyright (C) Andrew Bartlett 2001
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"
const DATA_BLOB data_blob_null = { NULL, 0, NULL };
/*******************************************************************
Free() a data blob.
*******************************************************************/
static void free_data_blob(DATA_BLOB *d)
{
if ((d) && (d->free)) {
SAFE_FREE(d->data);
}
}
/*******************************************************************
Construct a data blob, must be freed with data_blob_free().
You can pass NULL for p and get a blank data blob
*******************************************************************/
DATA_BLOB data_blob(const void *p, size_t length)
{
DATA_BLOB ret;
if (!length) {
ZERO_STRUCT(ret);
return ret;
}
if (p) {
ret.data = (uint8 *)smb_xmemdup(p, length);
} else {
ret.data = SMB_XMALLOC_ARRAY(uint8, length);
}
ret.length = length;
ret.free = free_data_blob;
return ret;
}
/*******************************************************************
Construct a data blob, using supplied TALLOC_CTX.
*******************************************************************/
DATA_BLOB data_blob_talloc(TALLOC_CTX *mem_ctx, const void *p, size_t length)
{
DATA_BLOB ret;
if (!length) {
ZERO_STRUCT(ret);
return ret;
}
if (p) {
ret.data = (uint8 *)TALLOC_MEMDUP(mem_ctx, p, length);
if (ret.data == NULL)
smb_panic("data_blob_talloc: TALLOC_MEMDUP failed");
} else {
ret.data = (uint8 *)TALLOC(mem_ctx, length);
if (ret.data == NULL)
smb_panic("data_blob_talloc: TALLOC failed");
}
ret.length = length;
ret.free = NULL;
return ret;
}
/*******************************************************************
Free a data blob.
*******************************************************************/
void data_blob_free(DATA_BLOB *d)
{
if (d) {
if (d->free) {
(d->free)(d);
}
d->length = 0;
}
}
/*******************************************************************
Clear a DATA_BLOB's contents
*******************************************************************/
void data_blob_clear(DATA_BLOB *d)
{
if (d->data) {
memset(d->data, 0, d->length);
}
}
/*******************************************************************
Free a data blob and clear its contents
*******************************************************************/
void data_blob_clear_free(DATA_BLOB *d)
{
data_blob_clear(d);
data_blob_free(d);
}
/**
useful for constructing data blobs in test suites, while
avoiding const warnings
**/
DATA_BLOB data_blob_string_const(const char *str)
{
DATA_BLOB blob;
blob.data = CONST_DISCARD(uint8 *, str);
blob.length = strlen(str) + 1;
blob.free = NULL;
return blob;
}
/**
* Create a new data blob from const data
*/
DATA_BLOB data_blob_const(const void *p, size_t length)
{
DATA_BLOB blob;
blob.data = CONST_DISCARD(uint8 *, p);
blob.length = length;
blob.free = NULL;
return blob;
}
/**
construct a zero data blob, using supplied TALLOC_CTX.
use this sparingly as it initialises data - better to initialise
yourself if you want specific data in the blob
**/
DATA_BLOB data_blob_talloc_zero(TALLOC_CTX *mem_ctx, size_t length)
{
DATA_BLOB blob = data_blob_talloc(mem_ctx, NULL, length);
data_blob_clear(&blob);
return blob;
}
/**
print the data_blob as hex string
**/
_PUBLIC_ char *data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
{
int i;
char *hex_string;
hex_string = talloc_array(mem_ctx, char, (blob->length*2)+1);
if (!hex_string) {
return NULL;
}
for (i = 0; i < blob->length; i++)
slprintf(&hex_string[i*2], 3, "%02X", blob->data[i]);
hex_string[(blob->length*2)] = '\0';
return hex_string;
}

12
source3/lib/packet.c
View File

@ -21,7 +21,7 @@
struct packet_context {
int fd;
struct data_blob in, out;
DATA_BLOB in, out;
};
/*
@ -120,16 +120,16 @@ NTSTATUS packet_fd_read_sync(struct packet_context *ctx)
}
bool packet_handler(struct packet_context *ctx,
bool (*full_req)(const struct data_blob *data,
bool (*full_req)(const DATA_BLOB *data,
size_t *length,
void *private_data),
NTSTATUS (*callback)(const struct data_blob *data,
NTSTATUS (*callback)(const DATA_BLOB *data,
void *private_data),
void *private_data,
NTSTATUS *status)
{
size_t length;
struct data_blob data;
DATA_BLOB data;
if (!full_req(&ctx->in, &length, private_data)) {
return False;
@ -211,7 +211,7 @@ NTSTATUS packet_send(struct packet_context *ctx, int num_blobs, ...)
va_start(ap, num_blobs);
for (i=0; i<num_blobs; i++) {
size_t tmp;
struct data_blob blob = va_arg(ap, struct data_blob);
DATA_BLOB blob = va_arg(ap, DATA_BLOB);
tmp = len + blob.length;
if (tmp < len) {
@ -236,7 +236,7 @@ NTSTATUS packet_send(struct packet_context *ctx, int num_blobs, ...)
va_start(ap, num_blobs);
for (i=0; i<num_blobs; i++) {
struct data_blob blob = va_arg(ap, struct data_blob);
DATA_BLOB blob = va_arg(ap, DATA_BLOB);
memcpy(ctx->out.data+ctx->out.length, blob.data, blob.length);
ctx->out.length += blob.length;

7
source3/param/loadparm.c
View File

@ -6529,7 +6529,7 @@ static void copy_service(struct service *pserviceDest, struct service *pserviceS
break;
case P_LIST:
TALLOC_FREE(*((char ***)dest_ptr));
str_list_copy(NULL, (char ***)dest_ptr,
*((char ***)dest_ptr) = str_list_copy(NULL,
*(const char ***)src_ptr);
break;
default:
@ -7927,9 +7927,8 @@ static void lp_save_defaults(void)
continue;
switch (parm_table[i].type) {
case P_LIST:
str_list_copy(
NULL, &(parm_table[i].def.lvalue),
*(const char ***)parm_table[i].ptr);
parm_table[i].def.lvalue = str_list_copy(
NULL, *(const char ***)parm_table[i].ptr);
break;
case P_STRING:
case P_USTRING: