Converted more String.unsafeBuf users

String.operator[] now returns a copy of a char rather than a reference.
Implemented StringNg-alike String.find() method. Eventual aim is to get rid of users of String.pos()

diff --git a/src/HttpRequest.cc b/src/HttpRequest.cc
index 82aeea5cf2b88ff043da73cbf5531abd777ee3e2..399659f2a08b43488d6ac71cf2d2483cb9112dd5 100644 (file)
--- a/src/HttpRequest.cc
+++ b/src/HttpRequest.cc
@@ -150,7 +150,7 @@ HttpRequest::reset()
 HttpRequest *
 HttpRequest::clone() const
 {
-    HttpRequest *copy = new HttpRequest(method, protocol, urlpath.unsafeBuf());
+    HttpRequest *copy = new HttpRequest(method, protocol, urlpath.termedBuf());
     // TODO: move common cloning clone to Msg::copyTo() or copy ctor
     copy->header.append(&header);
     copy->hdrCacheInit();
@@ -298,8 +298,8 @@ HttpRequest::pack(Packer * p)
 {
     assert(p);
     /* pack request-line */
-    packerPrintf(p, "%s %s HTTP/1.0\r\n",
-                 RequestMethodStr(method), urlpath.unsafeBuf());
+    packerPrintf(p, "%s %.*s HTTP/1.0\r\n",
+                 RequestMethodStr(method), urlpath.size(), urlpath.rawBuf());
     /* headers */
     header.packInto(p);
     /* trailer */
@@ -336,7 +336,7 @@ httpRequestHdrAllowed(const HttpHeaderEntry * e, String * strConn)
     assert(e);
     /* check connection header */
 
-    if (strConn && strListIsMember(strConn, e->name.unsafeBuf(), ','))
+    if (strConn && strListIsMember(strConn, e->name.termedBuf(), ','))
         return 0;
 
     return 1;
@@ -411,7 +411,7 @@ const char *HttpRequest::packableURI(bool full_uri) const
         return urlCanonical((HttpRequest*)this);
 
     if (urlpath.size())
-        return urlpath.unsafeBuf();
+        return urlpath.termedBuf();
 
     return "/";
 }

diff --git a/src/HttpRequestMethod.cc b/src/HttpRequestMethod.cc
index 02b035f117b689e8f4e70aef510e5565fd5be722..8f4c9d19017ed9aa8b97b3e7f1d5d7073af88eb5 100644 (file)
--- a/src/HttpRequestMethod.cc
+++ b/src/HttpRequestMethod.cc
@@ -177,7 +177,7 @@ HttpRequestMethod::image() const
         return RequestMethodStr[theMethod];
     } else {
         if (theImage.size()>0) {
-            return theImage.unsafeBuf();
+            return theImage.termedBuf();
         } else {
             return "METHOD_OTHER";
         }

diff --git a/src/LoadableModule.cc b/src/LoadableModule.cc
index 7209771669df501a98cbdc54a44ac155e9396db8..d491da191c9cbb558c141bab95fa91612f2d266b 100644 (file)
--- a/src/LoadableModule.cc
+++ b/src/LoadableModule.cc
@@ -67,7 +67,7 @@ void LoadableModule::unload()
 void *LoadableModule::openModule(int mode)
 {
 #      if XSTD_USE_LIBLTDL
-    return lt_dlopen(theName.unsafeBuf());
+    return lt_dlopen(theName.termedBuf());
 #      else
     return dlopen(theName.c_str(),
                   mode == lmNow ? RTLD_NOW : RTLD_LAZY);

diff --git a/src/SquidString.h b/src/SquidString.h
index 845a5f5a56683480d8a6bbc5baf25d5400d52cbf..d97f37b83c4576cc3b86ce5678f4350afe73dee1 100644 (file)
--- a/src/SquidString.h
+++ b/src/SquidString.h
@@ -95,7 +95,7 @@ public:
      * Retrieve a single character in the string.
      \param pos        Position of character to retrieve.
      */
-    _SQUID_INLINE_ char &operator [](unsigned int pos);
+    _SQUID_INLINE_ char operator [](unsigned int pos);
 
     _SQUID_INLINE_ int size() const;
     _SQUID_INLINE_ char const * unsafeBuf() const;
@@ -128,6 +128,9 @@ public:
     void absorb(String &old);
     _SQUID_INLINE_ const char * pos(char const *) const;
     _SQUID_INLINE_ const char * pos(char const ch) const;
+    ///offset from string start of the first occurrence of ch
+    /// returns std::string::npos if ch is not found
+    _SQUID_INLINE_ size_t find(char const ch) const;
     _SQUID_INLINE_ const char * rpos(char const ch) const;
     _SQUID_INLINE_ int cmp (char const *) const;
     _SQUID_INLINE_ int cmp (char const *, size_t count) const;

diff --git a/src/String.cc b/src/String.cc
index 4f6bcba94930a7e02ad0e0aeff5a3f83332fa2e3..f90168ace64b03c6873996a2b2b64ac4e96b8314 100644 (file)
--- a/src/String.cc
+++ b/src/String.cc
@@ -188,7 +188,7 @@ String::append(const char *str, int len)
         snew.allocBuffer(snew.len_ + 1);
 
         if (len_)
-            xmemcpy(snew.buf_, unsafeBuf(), len_);
+            xmemcpy(snew.buf_, rawBuf(), len_);
 
         if (len)
             xmemcpy(snew.buf_ + len_, str, len);

diff --git a/src/String.cci b/src/String.cci
index a3a133e98da577af3382ce4413c6f0c88693aebe..e6f02fc5687446f6c28036e062867a2209413035 100644 (file)
--- a/src/String.cci
+++ b/src/String.cci
@@ -76,7 +76,7 @@ String::termedBuf() const
     return buf_;
 }
 
-char&
+char
 String::operator [](unsigned int pos)
 {
     assert(pos < size_);
@@ -96,6 +96,16 @@ String::pos(char const ch) const
     return strchr(termedBuf(), ch);
 }
 
+size_t
+String::find(char const ch) const
+{
+    const char *c;
+    c=pos(ch);
+    if (c==NULL)
+        return std::string::npos;
+    return c-rawBuf();
+}
+
 const char *
 String::rpos(char const ch) const
 {

diff --git a/src/internal.cc b/src/internal.cc
index e3aec551dfba18669c4cc3968189d82e99326fff..51d20d80bd0a2d5d4165530d9c6dbd08eb127b2b 100644 (file)
--- a/src/internal.cc
+++ b/src/internal.cc
@@ -51,7 +51,7 @@ void
 internalStart(HttpRequest * request, StoreEntry * entry)
 {
     ErrorState *err;
-    const char *upath = request->urlpath.unsafeBuf();
+    const char *upath = request->urlpath.termedBuf();
     debugs(76, 3, "internalStart: " << request->client_addr << " requesting '" << upath << "'");
 
     if (0 == strcmp(upath, "/squid-internal-dynamic/netdb")) {

diff --git a/src/redirect.cc b/src/redirect.cc
index ab9e6a65eb25cd064eaa8ce875e14cd95693f6b6..6d9ad53ac951f412d40e879ff9c205dca6d33821 100644 (file)
--- a/src/redirect.cc
+++ b/src/redirect.cc
@@ -137,8 +137,8 @@ redirectStart(ClientHttpRequest * http, RH * handler, void *data)
 
     if (http->request->auth_user_request)
         r->client_ident = http->request->auth_user_request->username();
-    else if (http->request->extacl_user.unsafeBuf() != NULL) {
-        r->client_ident = http->request->extacl_user.unsafeBuf();
+    else if (http->request->extacl_user.defined()) {
+        r->client_ident = http->request->extacl_user.termedBuf();
     }
 
     if (!r->client_ident && (conn != NULL && conn->rfc931[0]))

diff --git a/src/stat.cc b/src/stat.cc
index ef423864d4e938a6df54aa04ef215948e90300e0..e7e608577985972c81592ad69720befe251736a1 100644 (file)
--- a/src/stat.cc
+++ b/src/stat.cc
@@ -1653,8 +1653,8 @@ statClientRequests(StoreEntry * s)
 
         if (http->request->auth_user_request)
             p = http->request->auth_user_request->username();
-        else if (http->request->extacl_user.unsafeBuf() != NULL) {
-            p = http->request->extacl_user.unsafeBuf();
+        else if (http->request->extacl_user.defined()) {
+            p = http->request->extacl_user.termedBuf();
         }
 
         if (!p && (conn != NULL && conn->rfc931[0]))

diff --git a/src/store.cc b/src/store.cc
index 7317376273e94a50ecb4fd152080170ab27d7b72..14f1a9f4016581661a6fd3d22ed7a5d103a9c4ad 100644 (file)
--- a/src/store.cc
+++ b/src/store.cc
@@ -689,7 +689,7 @@ StoreEntry::setPublicKey()
 
             if (vary.size()) {
                 /* Again, we own this structure layout */
-                rep->header.putStr(HDR_VARY, vary.unsafeBuf());
+                rep->header.putStr(HDR_VARY, vary.termedBuf());
                 vary.clean();
             }
 

diff --git a/src/url.cc b/src/url.cc
index dccad18851db063e491760f6ecd813d1a059e23c..13b62b19047692c5d4f3db7e5ef974a713a6be06 100644 (file)
--- a/src/url.cc
+++ b/src/url.cc
@@ -439,7 +439,9 @@ urlCanonical(HttpRequest * request)
         return request->canonical;
 
     if (request->protocol == PROTO_URN) {
-        snprintf(urlbuf, MAX_URL, "urn:%s", request->urlpath.unsafeBuf());
+        snprintf(urlbuf, MAX_URL, "urn:%.*s",
+            request->urlpath.size(),
+            request->urlpath.rawBuf());
     } else {
 /// \todo AYJ: this could use "if..else and method == METHOD_CONNECT" easier.
         switch (request->method.id()) {
@@ -454,13 +456,14 @@ urlCanonical(HttpRequest * request)
             if (request->port != urlDefaultPort(request->protocol))
                 snprintf(portbuf, 32, ":%d", request->port);
 
-            snprintf(urlbuf, MAX_URL, "%s://%s%s%s%s%s",
+            snprintf(urlbuf, MAX_URL, "%s://%s%s%s%s%.*s",
                      ProtocolStr[request->protocol],
                      request->login,
                      *request->login ? "@" : null_string,
                      request->GetHost(),
                      portbuf,
-                     request->urlpath.unsafeBuf());
+                     request->urlpath.size(),
+                     request->urlpath.rawBuf());
 
             break;
         }
@@ -482,7 +485,8 @@ urlCanonicalClean(const HttpRequest * request)
     char *t;
 
     if (request->protocol == PROTO_URN) {
-        snprintf(buf, MAX_URL, "urn:%s", request->urlpath.unsafeBuf());
+        snprintf(buf, MAX_URL, "urn:%.*s",
+            request->urlpath.size(), request->urlpath.rawBuf());
     } else {
 /// \todo AYJ: this could use "if..else and method == METHOD_CONNECT" easier.
         switch (request->method.id()) {
@@ -510,12 +514,13 @@ urlCanonicalClean(const HttpRequest * request)
                 strcat(loginbuf, "@");
             }
 
-            snprintf(buf, MAX_URL, "%s://%s%s%s%s",
+            snprintf(buf, MAX_URL, "%s://%s%s%s%.*s",
                      ProtocolStr[request->protocol],
                      loginbuf,
                      request->GetHost(),
                      portbuf,
-                     request->urlpath.unsafeBuf());
+                     request->urlpath.size(),
+                     request->urlpath.rawBuf());
             /*
              * strip arguments AFTER a question-mark
              */
@@ -584,7 +589,9 @@ urlMakeAbsolute(const HttpRequest * req, const char *relUrl)
     char *urlbuf = (char *)xmalloc(MAX_URL * sizeof(char));
 
     if (req->protocol == PROTO_URN) {
-        snprintf(urlbuf, MAX_URL, "urn:%s", req->urlpath.unsafeBuf());
+        snprintf(urlbuf, MAX_URL, "urn:%.*s",
+            req->urlpath.size(),
+            req->urlpath.rawBuf());
         return (urlbuf);
     }
 
@@ -610,7 +617,7 @@ urlMakeAbsolute(const HttpRequest * req, const char *relUrl)
     if (relUrl[0] == '/') {
         strncpy(&urlbuf[urllen], relUrl, MAX_URL - urllen - 1);
     } else {
-        const char *path = req->urlpath.unsafeBuf();
+        const char *path = req->urlpath.termedBuf();
         const char *last_slash = strrchr(path, '/');
 
         if (last_slash == NULL) {

diff --git a/src/urn.cc b/src/urn.cc
index 55f113113ea10694877bf2d58b45b438ea96013c..b180aca99ed6b420b7128c5ec9d6866adda189c1 100644 (file)
--- a/src/urn.cc
+++ b/src/urn.cc
@@ -167,19 +167,15 @@ char *
 UrnState::getHost (String &urlpath)
 {
     char * result;
-    char const *t;
+    size_t p;
 
-    /* FIXME: this appears to be parsing the URL. *very* badly. */
-    /* FIXME: a proper encapsulated URI/URL type needs to clear this up. */
-
-    if ((t = urlpath.pos(':')) != NULL) {
-        urlpath.set(t, '\0');
-        result = xstrdup(urlpath.unsafeBuf());
-        urlpath.set(t, ':');
+    /** FIXME: this appears to be parsing the URL. *very* badly. */
+    /*   a proper encapsulated URI/URL type needs to clear this up. */
+    if ((p=urlpath.find(':')) != std::string::npos) {
+        result=xstrndup(urlpath.rawBuf(),p-1);
     } else {
-        result = xstrdup(urlpath.unsafeBuf());
+        result = xstrndup(urlpath.rawBuf(),urlpath.size());
     }
-
     return result;
 }