Remove more pstring. Unify talloc_sub functions to make

them a better match for replacing string_sub. Remove
more unused code.
Jeremy.
(This used to be commit ae7885711f504f1442335f09088cbe149a7e00f9)

diff --git a/source3/lib/util_str.c b/source3/lib/util_str.c
index 68b06a6d9013274f3ecdbac97259effbbf854261..f5a50b360e5afa3934c4c4487cff8a3d21816c06 100644 (file)
--- a/source3/lib/util_str.c
+++ b/source3/lib/util_str.c
@@ -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':
+       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] = '_';
-                               default:
-                                       /* ok */
                                        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

diff --git a/source3/printing/lpq_parse.c b/source3/printing/lpq_parse.c
index 50fad6f946cdad7ba9101ff07992529d2fe496a3..09f630e464b83e1bbb63626a21536140610ad9b3 100644 (file)
--- a/source3/printing/lpq_parse.c
+++ b/source3/printing/lpq_parse.c
@@ -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
        {

diff --git a/source3/printing/printing.c b/source3/printing/printing.c
index af87b8f2c293da3d862316d7b406cef52f9916b3..48ac54d7970c04f82b5971844c977994ded7e3e3 100644 (file)
--- a/source3/printing/printing.c
+++ b/source3/printing/printing.c
@@ -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 );