]>
git.ipfire.org Git - thirdparty/squid.git/blob - src/SquidString.h
2 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
4 * Squid software is distributed under GPLv2+ license and includes
5 * contributions from numerous individuals and organizations.
6 * Please see the COPYING and CONTRIBUTORS files for details.
9 /* DEBUG: section 67 String */
11 #ifndef SQUID_SRC_SQUIDSTRING_H
12 #define SQUID_SRC_SQUIDSTRING_H
14 #include "base/TextException.h"
15 #include "debug/Stream.h"
19 /* squid string placeholder (for printf) */
21 #define SQUIDSTRINGPH "%.*s"
22 #define SQUIDSTRINGPRINT(s) (s).psize(),(s).rawBuf()
23 #endif /* SQUIDSTRINGPH */
31 String(String
const &);
32 String(String
&& S
) : size_(S
.size_
), len_(S
.len_
), buf_(S
.buf_
) {
33 S
.buf_
= nullptr; // S is about to be destructed
38 typedef size_t size_type
; //storage size intentionally unspecified
39 const static size_type npos
= static_cast<size_type
>(-1);
41 String
&operator =(char const *);
42 String
&operator =(String
const &);
43 String
&operator =(String
&& S
) {
51 S
.buf_
= nullptr; // S is about to be destructed
56 bool operator ==(String
const &) const;
57 bool operator !=(String
const &) const;
60 * Retrieve a single character in the string.
61 \param aPos Position of character to retrieve.
63 char operator [](unsigned int aPos
) const {
68 /// The absolute size limit on data held in a String.
69 /// Since Strings can be nil-terminated implicitly it is best to ensure
70 /// the useful content length is strictly less than this limit.
71 static size_type
SizeMaxXXX() { return SizeMax_
; }
73 size_type
size() const { return len_
; }
75 /// variant of size() suited to be used for printf-alikes.
76 /// throws when size() >= INT_MAX
78 Must(size() < INT_MAX
);
83 * Returns a raw pointer to the underlying backing store. The caller has been
84 * verified not to make any assumptions about null-termination
86 char const * rawBuf() const { return buf_
; }
89 * Returns a raw pointer to the underlying backing store.
90 * The caller requires it to be null-terminated.
92 char const * termedBuf() const { return buf_
; }
94 void assign(const char *str
, int len
);
96 void reset(char const *str
);
97 void append(char const *buf
, int len
);
98 void append(char const *buf
);
99 void append(char const);
100 void append(String
const &);
101 void absorb(String
&old
);
102 const char * pos(char const *aString
) const;
103 const char * pos(char const ch
) const;
104 ///offset from string start of the first occurrence of ch
105 /// returns String::npos if ch is not found
106 size_type
find(char const ch
) const;
107 size_type
find(char const *aString
) const;
108 const char * rpos(char const ch
) const;
109 size_type
rfind(char const ch
) const;
110 int cmp(char const *) const;
111 int cmp(char const *, size_type count
) const;
112 int cmp(String
const &) const;
113 int caseCmp(char const *) const;
114 int caseCmp(char const *, size_type count
) const;
115 int caseCmp(String
const &str
) const {
116 return caseCmp(str
.rawBuf(),str
.size());
119 /// Whether creating a totalLen-character string is safe (i.e., unlikely to assert).
120 /// Optional extras can be used for overflow-safe length addition.
121 /// Implementation has to add 1 because many String allocation methods do.
122 static bool CanGrowTo(size_type totalLen
, const size_type extras
= 0) { return SafeAdd(totalLen
, extras
) && SafeAdd(totalLen
, 1); }
123 /// whether appending growthLen characters is safe (i.e., unlikely to assert)
124 bool canGrowBy(const size_type growthLen
) const { return CanGrowTo(size(), growthLen
); }
126 String
substr(size_type from
, size_type to
) const;
128 void cut(size_type newLength
);
131 void allocAndFill(const char *str
, int len
);
132 void allocBuffer(size_type sz
);
133 void setBuffer(char *buf
, size_type sz
);
135 bool defined() const {return buf_
!=nullptr;}
136 bool undefined() const {return !defined();}
138 /* never reference these directly! */
139 size_type size_
= 0; /* buffer size; limited by SizeMax_ */
141 size_type len_
= 0; /* current length */
143 /// An earlier 64KB limit was meant to protect some fixed-size buffers, but
144 /// (a) we do not know where those buffers are (or whether they still exist)
145 /// (b) too many String users unknowingly exceeded that limit and asserted.
146 /// We are now using a larger limit to reduce the number of (b) cases,
147 /// especially cases where "compact" lists of items grow 50% in size when we
148 /// convert them to canonical form. The new limit is selected to withstand
149 /// concatenation and ~50% expansion of two HTTP headers limited by default
150 /// request_header_max_size and reply_header_max_size settings.
151 static const size_type SizeMax_
= 3*64*1024 - 1;
153 /// returns true after increasing the first argument by extra if the sum does not exceed SizeMax_
154 static bool SafeAdd(size_type
&base
, size_type extra
) { if (extra
<= SizeMax_
&& base
<= SizeMax_
- extra
) { base
+= extra
; return true; } return false; }
156 char *buf_
= nullptr;
158 void set(char const *loc
, char const ch
) {
159 if (loc
< buf_
|| loc
> (buf_
+ size_
))
164 void cutPointer(char const *loc
) {
165 if (loc
< buf_
|| loc
> (buf_
+ size_
))
172 inline std::ostream
& operator<<(std::ostream
&os
, String
const &aString
)
174 os
.write(aString
.rawBuf(),aString
.size());
178 inline bool operator<(const String
&a
, const String
&b
)
183 const char *checkNullString(const char *p
);
184 int stringHasWhitespace(const char *);
185 int stringHasCntl(const char *);
186 char *strwordtok(char *buf
, char **t
);
188 #endif /* SQUID_SRC_SQUIDSTRING_H */