sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-27 22:50:26 +03:00
Code

Remove more pstring. Unify talloc_sub functions to make

Browse Source 
them a better match for replacing string_sub. Remove
more unused code.
Jeremy.
(This used to be commit ae7885711f504f1442335f09088cbe149a7e00f9)
This commit is contained in:
Jeremy Allison 2007-11-19 18:56:22 -08:00
parent cf31bb7532
commit 4c6b01b0ef
3 changed files with 99 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
source3/lib/util_str.c
View File

@ -1274,11 +1274,15 @@ char *realloc_string_sub(char *string,
/*
* Internal guts of talloc_string_sub and talloc_all_string_sub.
* 'filter' differentiates between them.
* talloc version of string_sub2.
*/
static char *talloc_string_sub_internal(TALLOC_CTX *mem_ctx, const char *src,
const char *pattern, const char *insert, bool filter)
char *talloc_string_sub2(TALLOC_CTX *mem_ctx, const char *src,
const char *pattern,
const char *insert,
bool remove_unsafe_characters,
bool replace_once,
bool allow_trailing_dollar)
{
char *p, *in;
char *s;
@ -1291,7 +1295,7 @@ static char *talloc_string_sub_internal(TALLOC_CTX *mem_ctx, const char *src,
string = talloc_strdup(mem_ctx, src);
if (string == NULL) {
DEBUG(0, ("talloc_string_sub_internal: "
DEBUG(0, ("talloc_string_sub2: "
"talloc_strdup failed\n"));
return NULL;
}
@ -1300,7 +1304,7 @@ static char *talloc_string_sub_internal(TALLOC_CTX *mem_ctx, const char *src,
in = SMB_STRDUP(insert);
if (!in) {
DEBUG(0, ("talloc_string_sub_internal: ENOMEM\n"));
DEBUG(0, ("talloc_string_sub2: ENOMEM\n"));
return NULL;
}
ls = (ssize_t)strlen(s);
@ -1308,22 +1312,28 @@ static char *talloc_string_sub_internal(TALLOC_CTX *mem_ctx, const char *src,
li = (ssize_t)strlen(insert);
ld = li - lp;
if (filter) {
for (i=0;i<li;i++) {
switch (in[i]) {
case '`':
case '"':
case '\'':
case ';':
case '$':
case '%':
case '\r':
case '\n':
in[i] = '_';
default:
/* ok */
for (i=0;i<li;i++) {
switch (in[i]) {
case '`':
case '"':
case '\'':
case ';':
case '$':
/* allow a trailing $
* (as in machine accounts) */
if (allow_trailing_dollar && (i == li - 1 )) {
break;
}
}
case '%':
case '\r':
case '\n':
if (remove_unsafe_characters) {
in[i] = '_';
break;
}
default:
/* ok */
break;
}
}
@ -1346,6 +1356,10 @@ static char *talloc_string_sub_internal(TALLOC_CTX *mem_ctx, const char *src,
memcpy(p, in, li);
s = p + li;
ls += ld;
if (replace_once) {
break;
}
}
SAFE_FREE(in);
return string;
@ -1353,10 +1367,13 @@ static char *talloc_string_sub_internal(TALLOC_CTX *mem_ctx, const char *src,
/* Same as string_sub, but returns a talloc'ed string */
char *talloc_string_sub(TALLOC_CTX *mem_ctx, const char *src,
const char *pattern, const char *insert)
char *talloc_string_sub(TALLOC_CTX *mem_ctx,
const char *src,
const char *pattern,
const char *insert)
{
return talloc_string_sub_internal(mem_ctx, src, pattern, insert, true);
return talloc_string_sub2(mem_ctx, src, pattern, insert,
true, false, false);
}
/**
@ -1406,73 +1423,8 @@ char *talloc_all_string_sub(TALLOC_CTX *ctx,
const char *pattern,
const char *insert)
{
return talloc_string_sub_internal(ctx, src, pattern, insert, false);
}
/**
Similar to all_string_sub but for unicode strings.
Return a new allocated unicode string.
similar to string_sub() but allows for any character to be substituted.
Use with caution!
**/
static smb_ucs2_t *all_string_sub_w(const smb_ucs2_t *s,
const smb_ucs2_t *pattern,
const smb_ucs2_t *insert)
{
smb_ucs2_t *r, *rp;
const smb_ucs2_t *sp;
size_t lr, lp, li, lt;
if (!insert || !pattern || !*pattern || !s)
return NULL;
lt = (size_t)strlen_w(s);
lp = (size_t)strlen_w(pattern);
li = (size_t)strlen_w(insert);
if (li > lp) {
const smb_ucs2_t *st = s;
int ld = li - lp;
while ((sp = strstr_w(st, pattern))) {
st = sp + lp;
lt += ld;
}
}
r = rp = SMB_MALLOC_ARRAY(smb_ucs2_t, lt + 1);
if (!r) {
DEBUG(0, ("all_string_sub_w: out of memory!\n"));
return NULL;
}
while ((sp = strstr_w(s, pattern))) {
memcpy(rp, s, (sp - s));
rp += ((sp - s) / sizeof(smb_ucs2_t));
memcpy(rp, insert, (li * sizeof(smb_ucs2_t)));
s = sp + lp;
rp += li;
}
lr = ((rp - r) / sizeof(smb_ucs2_t));
if (lr < lt) {
memcpy(rp, s, ((lt - lr) * sizeof(smb_ucs2_t)));
rp += (lt - lr);
}
*rp = 0;
return r;
}
smb_ucs2_t *all_string_sub_wa(smb_ucs2_t *s, const char *pattern,
const char *insert)
{
wpstring p, i;
if (!insert || !pattern || !s)
return NULL;
push_ucs2(NULL, p, pattern, sizeof(wpstring) - 1, STR_TERMINATE);
push_ucs2(NULL, i, insert, sizeof(wpstring) - 1, STR_TERMINATE);
return all_string_sub_w(s, p, i);
return talloc_string_sub2(ctx, src, pattern, insert,
false, false, false);
}
#if 0

8
source3/printing/lpq_parse.c
View File

@ -125,9 +125,13 @@ static bool parse_lpq_bsd(char *line,print_queue_struct *buf,bool first)
char *tok[MAXTOK];
int count = 0;
pstring line2;
TALLOC_CTX *ctx = talloc_tos();
char *line2 = NULL;
pstrcpy(line2,line);
line2 = talloc_strdup(ctx, line);
if (!line2) {
return false;
}
#ifdef OSF1
{

81
source3/printing/printing.c
View File

@ -180,13 +180,11 @@ static int get_queue_status(const char* sharename, print_status_struct *);
bool print_backend_init(struct messaging_context *msg_ctx)
{
const char *sversion = "INFO/version";
pstring printing_path;
int services = lp_numservices();
int snum;
unlink(lock_path("printing.tdb"));
pstrcpy(printing_path,lock_path("printing"));
mkdir(printing_path,0755);
mkdir(lock_path("printing"),0755);
/* handle a Samba upgrade */
@ -1443,43 +1441,66 @@ static void print_queue_update(int snum, bool force)
{
fstring key;
fstring sharename;
pstring lpqcommand, lprmcommand;
char *lpqcommand = NULL;
char *lprmcommand = NULL;
uint8 *buffer = NULL;
size_t len = 0;
size_t newlen;
struct tdb_print_db *pdb;
int type;
struct printif *current_printif;
TALLOC_CTX *ctx = talloc_tos();
fstrcpy( sharename, lp_const_servicename(snum));
/* don't strip out characters like '$' from the printername */
pstrcpy( lpqcommand, lp_lpqcommand(snum));
string_sub2( lpqcommand, "%p", PRINTERNAME(snum), sizeof(lpqcommand),
False, False, False );
standard_sub_advanced(lp_servicename(snum),
current_user_info.unix_name, "",
current_user.ut.gid,
get_current_username(),
current_user_info.domain,
lpqcommand, sizeof(lpqcommand) );
lpqcommand = talloc_string_sub2(ctx,
lp_lpqcommand(snum),
"%p",
PRINTERNAME(snum),
false, false, false);
if (!lpqcommand) {
return;
}
lpqcommand = talloc_sub_advanced(ctx,
lp_servicename(snum),
current_user_info.unix_name,
"",
current_user.ut.gid,
get_current_username(),
current_user_info.domain,
lpqcommand);
if (!lpqcommand) {
return;
}
pstrcpy( lprmcommand, lp_lprmcommand(snum));
string_sub2( lprmcommand, "%p", PRINTERNAME(snum), sizeof(lprmcommand),
False, False, False );
standard_sub_advanced(lp_servicename(snum),
current_user_info.unix_name, "",
current_user.ut.gid,
get_current_username(),
current_user_info.domain,
lprmcommand, sizeof(lprmcommand) );
/*
* Make sure that the background queue process exists.
* Otherwise just do the update ourselves
lprmcommand = talloc_string_sub2(ctx,
lp_lprmcommand(snum),
"%p",
PRINTERNAME(snum),
false, false, false);
if (!lprmcommand) {
return;
}
lprmcommand = talloc_sub_advanced(ctx,
lp_servicename(snum),
current_user_info.unix_name,
"",
current_user.ut.gid,
get_current_username(),
current_user_info.domain,
lprmcommand);
if (!lprmcommand) {
return;
}
/*
* Make sure that the background queue process exists.
* Otherwise just do the update ourselves
*/
if ( force || background_lpq_updater_pid == -1 ) {
DEBUG(4,("print_queue_update: updating queue [%s] myself\n", sharename));
current_printif = get_printer_fns( snum );
@ -1489,13 +1510,13 @@ static void print_queue_update(int snum, bool force)
}
type = lp_printing(snum);
/* get the length */
len = tdb_pack( NULL, 0, "fdPP",
sharename,
type,
lpqcommand,
lpqcommand,
lprmcommand );
buffer = SMB_XMALLOC_ARRAY( uint8, len );