{
MemBuf mb;
wordlist **W = static_cast<wordlist **>(state);
- memBufDefInit(&mb);
- memBufPrintf(&mb, "%s", inet_ntoa(ip->addr1));
+ mb.init();
+ mb.Printf("%s", inet_ntoa(ip->addr1));
if (ip->addr2.s_addr != any_addr.s_addr)
- memBufPrintf(&mb, "-%s", inet_ntoa(ip->addr2));
+ mb.Printf("-%s", inet_ntoa(ip->addr2));
if (ip->mask.s_addr != no_addr.s_addr)
- memBufPrintf(&mb, "/%s", inet_ntoa(ip->mask));
+ mb.Printf("/%s", inet_ntoa(ip->mask));
wordlistAdd(W, mb.buf);
- memBufClean(&mb);
+ mb.clean();
}
/*
/*
- * $Id: HttpBody.cc,v 1.23 2005/09/17 04:53:44 wessels Exp $
+ * $Id: HttpBody.cc,v 1.24 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 56 HTTP Message Body
* AUTHOR: Alex Rousskov
{
assert(body);
- if (!memBufIsNull(body->mb))
- memBufClean(body->mb);
+ if (!body->mb->isNull())
+ body->mb->clean();
delete body->mb;
httpBodySet(HttpBody * body, MemBuf * mb)
{
assert(body);
- assert(memBufIsNull(body->mb));
+ assert(body->mb->isNull());
delete body->mb;
body->mb = mb; /* absorb */
}
/*
- * $Id: HttpHeader.cc,v 1.107 2005/09/17 04:53:44 wessels Exp $
+ * $Id: HttpHeader.cc,v 1.108 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 55 HTTP Header
* AUTHOR: Alex Rousskov
/* remove old directives if any */
httpHeaderDelById(hdr, HDR_CACHE_CONTROL);
/* pack into mb */
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
httpHdrCcPackInto(cc, &p);
/* put */
httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_CACHE_CONTROL, NULL, mb.buf));
/* cleanup */
packerClean(&p);
- memBufClean(&mb);
+ mb.clean();
}
void
/* remove old directives if any */
httpHeaderDelById(hdr, HDR_CONTENT_RANGE);
/* pack into mb */
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
httpHdrContRangePackInto(cr, &p);
/* put */
httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_CONTENT_RANGE, NULL, mb.buf));
/* cleanup */
packerClean(&p);
- memBufClean(&mb);
+ mb.clean();
}
void
/* remove old directives if any */
httpHeaderDelById(hdr, HDR_RANGE);
/* pack into mb */
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
range->packInto(&p);
/* put */
httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_RANGE, NULL, mb.buf));
/* cleanup */
packerClean(&p);
- memBufClean(&mb);
+ mb.clean();
}
void
/* remove old directives if any */
httpHeaderDelById(hdr, HDR_RANGE);
/* pack into mb */
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
httpHdrScPackInto(sc, &p);
/* put */
httpHeaderAddEntry(hdr, httpHeaderEntryCreate(HDR_SURROGATE_CONTROL, NULL, mb.buf));
/* cleanup */
packerClean(&p);
- memBufClean(&mb);
+ mb.clean();
}
/* add extension header (these fields are not parsed/analyzed/joined, etc.) */
/*
- * $Id: HttpHeaderTools.cc,v 1.49 2005/09/17 04:53:44 wessels Exp $
+ * $Id: HttpHeaderTools.cc,v 1.50 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 66 HTTP Header Tools
* AUTHOR: Alex Rousskov
httpHeaderPutStrvf(HttpHeader * hdr, http_hdr_type id, const char *fmt, va_list vargs)
{
MemBuf mb;
- memBufDefInit(&mb);
- memBufVPrintf(&mb, fmt, vargs);
+ mb.init();
+ mb.vPrintf(fmt, vargs);
httpHeaderPutStr(hdr, id, mb.buf);
- memBufClean(&mb);
+ mb.clean();
}
}
/* we think that we parsed it, veryfy */
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
httpHeaderClean(&hdr);
packerClean(&p);
- memBufClean(&mb);
+ mb.clean();
}
#endif
/*
- * $Id: HttpReply.cc,v 1.76 2005/09/17 04:53:44 wessels Exp $
+ * $Id: HttpReply.cc,v 1.77 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 58 HTTP Reply (Response)
* AUTHOR: Alex Rousskov
httpReplyReset(rep);
/* put a string terminator. s is how many bytes to touch in
* 'buf' including the terminating NULL. */
- memBufDefInit(&mb);
- memBufAppend(&mb, buf, end);
- memBufAppend(&mb, "\0", 1);
+ mb.init();
+ mb.append(buf, end);
+ mb.append("\0", 1);
success = rep->httpMsgParseStep(mb.buf, 0);
- memBufClean(&mb);
+ mb.clean();
return success == 1;
}
Packer p;
assert(rep);
- memBufDefInit(mb);
+ mb->init();
packerToMemInit(&p, mb);
httpReplyPackInto(rep, &p);
packerClean(&p);
/*
- * $Id: MemBuf.cc,v 1.40 2005/09/17 05:05:08 wessels Exp $
+ * $Id: MemBuf.cc,v 1.41 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 59 auto-growing Memory Buffer with printf
* AUTHOR: Alex Rousskov
* MemBuf buf;
*
* -- required init with optional size tuning (see #defines for defaults)
- * memBufInit(&buf, initial-size, absolute-maximum);
+ * buf.init(initial-size, absolute-maximum);
*
* -- "pack" (no need to handle offsets or check for overflows)
- * memBufPrintf(&buf, ...);
+ * buf.Printf(...);
* ...
*
* -- write
* comm_write_mbuf(fd, buf, handler, data);
*
* -- *iff* you did not give the buffer away, free it yourself
- * -- memBufClean(&buf);
+ * -- buf.clean();
* }
*/
/* if you have configure you can use this */
#define MEM_BUF_INIT_SIZE (2*1024)
#define MEM_BUF_MAX_SIZE (2*1000*1024*1024)
-
-/* local routines */
-static void memBufGrow(MemBuf * mb, mb_size_t min_cap);
-
CBDATA_CLASS_INIT(MemBuf);
/* init with defaults */
void
-memBufDefInit(MemBuf * mb)
+MemBuf::init()
{
- memBufInit(mb, MEM_BUF_INIT_SIZE, MEM_BUF_MAX_SIZE);
+ init(MEM_BUF_INIT_SIZE, MEM_BUF_MAX_SIZE);
}
/* init with specific sizes */
void
-memBufInit(MemBuf * mb, mb_size_t szInit, mb_size_t szMax)
+MemBuf::init(mb_size_t szInit, mb_size_t szMax)
{
- assert(mb);
assert(szInit > 0 && szMax > 0);
-
- mb->buf = NULL;
- mb->size = 0;
- mb->max_capacity = szMax;
- mb->capacity = 0;
- mb->stolen = 0;
-
- memBufGrow(mb, szInit);
+ buf = NULL;
+ size = 0;
+ max_capacity = szMax;
+ capacity = 0;
+ stolen = 0;
+ grow(szInit);
}
/*
* memBufFreeFunc
*/
void
-memBufClean(MemBuf * mb)
+MemBuf::clean()
{
- assert(mb);
-
- if (memBufIsNull(mb)) {
+ if (isNull()) {
// nothing to do
} else {
- assert(mb->buf);
- assert(!mb->stolen); /* not frozen */
+ assert(buf);
+ assert(!stolen); /* not frozen */
- memFreeBuf(mb->capacity, mb->buf);
- mb->buf = NULL;
- mb->size = mb->capacity = mb->max_capacity = 0;
+ memFreeBuf(capacity, buf);
+ buf = NULL;
+ size = capacity = max_capacity = 0;
}
}
/* cleans the buffer without changing its capacity
* if called with a Null buffer, calls memBufDefInit() */
void
-memBufReset(MemBuf * mb)
+MemBuf::reset()
{
- assert(mb);
-
- if (memBufIsNull(mb)) {
- memBufDefInit(mb);
+ if (isNull()) {
+ init();
} else {
- assert(!mb->stolen); /* not frozen */
+ assert(!stolen); /* not frozen */
/* reset */
- memset(mb->buf, 0, mb->capacity);
- mb->size = 0;
+ memset(buf, 0, capacity);
+ size = 0;
}
}
/* unfortunate hack to test if the buffer has been Init()ialized */
int
-memBufIsNull(MemBuf * mb)
+MemBuf::isNull()
{
- assert(mb);
-
- if (!mb->buf && !mb->max_capacity && !mb->capacity && !mb->size)
+ if (!buf && !max_capacity && !capacity && !size)
return 1; /* is null (not initialized) */
- assert(mb->buf && mb->max_capacity && mb->capacity); /* paranoid */
+ assert(buf && max_capacity && capacity); /* paranoid */
return 0;
}
if (sz > 0) {
if (size + sz + 1 > capacity)
- memBufGrow(this, size + sz + 1);
+ grow(size + sz + 1);
assert(size + sz <= capacity); /* paranoid */
*space() = '\0';
}
-void
-memBufAppend(MemBuf * mb, const char *buf, mb_size_t sz)
-{
- assert(mb);
- mb->append(buf, sz);
-}
-
/* calls memBufVPrintf */
#if STDC_HEADERS
void
-memBufPrintf(MemBuf * mb, const char *fmt,...)
+MemBuf::Printf(const char *fmt,...)
{
va_list args;
va_start(args, fmt);
#else
void
-memBufPrintf(va_alist)
+MemBuf::Printf(va_alist)
va_dcl
{
va_list args;
- MemBuf *mb = NULL;
- const char *fmt = NULL;
mb_size_t sz = 0;
va_start(args);
- mb = va_arg(args, MemBuf *);
- fmt = va_arg(args, char *);
+ const char *fmt = va_arg(args, char *);
#endif
- memBufVPrintf(mb, fmt, args);
+ vPrintf(fmt, args);
va_end(args);
}
-/* vprintf for other printf()'s to use; calls vsnprintf, extends buf if needed */
+/* vPrintf for other printf()'s to use; calls vsnprintf, extends buf if needed */
void
-memBufVPrintf(MemBuf * mb, const char *fmt, va_list vargs) {
+MemBuf::vPrintf(const char *fmt, va_list vargs) {
#ifdef VA_COPY
va_list ap;
#endif
int sz = 0;
- assert(mb && fmt);
- assert(mb->buf);
- assert(!mb->stolen); /* not frozen */
+ assert(fmt);
+ assert(buf);
+ assert(!stolen); /* not frozen */
/* assert in Grow should quit first, but we do not want to have a scary infinite loop */
- while (mb->capacity <= mb->max_capacity) {
- mb_size_t free_space = mb->capacity - mb->size;
+ while (capacity <= max_capacity) {
+ mb_size_t free_space = capacity - size;
/* put as much as we can */
#ifdef VA_COPY
* incase we loop around and call vsnprintf() again.
*/
VA_COPY(ap,vargs);
- sz = vsnprintf(mb->buf + mb->size, free_space, fmt, ap);
+ sz = vsnprintf(buf + size, free_space, fmt, ap);
va_end(ap);
#else /* VA_COPY */
- sz = vsnprintf(mb->buf + mb->size, free_space, fmt, vargs);
+ sz = vsnprintf(buf + size, free_space, fmt, vargs);
#endif /*VA_COPY*/
/* check for possible overflow */
/* snprintf on Linuz returns -1 on overflows */
/* snprintf on FreeBSD returns at least free_space on overflows */
if (sz < 0 || sz >= free_space)
- memBufGrow(mb, mb->capacity + 1);
+ grow(capacity + 1);
else
break;
}
- mb->size += sz;
+ size += sz;
/* on Linux and FreeBSD, '\0' is not counted in return value */
/* on XXX it might be counted */
/* check that '\0' is appended and not counted */
- if (!mb->size || mb->buf[mb->size - 1]) {
- assert(!mb->buf[mb->size]);
+ if (!size || buf[size - 1]) {
+ assert(!buf[size]);
} else {
- mb->size--;
+ size--;
}
}
* (you still can read-access .buf and .size)
*/
FREE *
-memBufFreeFunc(MemBuf * mb) {
+MemBuf::freeFunc() {
FREE *ff;
- assert(mb);
- assert(mb->buf);
- assert(!mb->stolen); /* not frozen */
+ assert(buf);
+ assert(!stolen); /* not frozen */
- ff = memFreeBufFunc((size_t) mb->capacity);
- mb->stolen = 1; /* freeze */
+ ff = memFreeBufFunc((size_t) capacity);
+ stolen = 1; /* freeze */
return ff;
}
/* grows (doubles) internal buffer to satisfy required minimal capacity */
-static void
-memBufGrow(MemBuf * mb, mb_size_t min_cap) {
+void
+MemBuf::grow(mb_size_t min_cap) {
size_t new_cap;
size_t buf_cap;
- assert(mb);
- assert(!mb->stolen);
- assert(mb->capacity < min_cap);
+ assert(!stolen);
+ assert(capacity < min_cap);
/* determine next capacity */
}
/* last chance to fit before we assert(!overflow) */
- if (new_cap > (size_t) mb->max_capacity)
- new_cap = (size_t) mb->max_capacity;
+ if (new_cap > (size_t) max_capacity)
+ new_cap = (size_t) max_capacity;
- assert(new_cap <= (size_t) mb->max_capacity); /* no overflow */
+ assert(new_cap <= (size_t) max_capacity); /* no overflow */
- assert(new_cap > (size_t) mb->capacity); /* progress */
+ assert(new_cap > (size_t) capacity); /* progress */
- buf_cap = (size_t) mb->capacity;
+ buf_cap = (size_t) capacity;
- mb->buf = (char *)memReallocBuf(mb->buf, new_cap, &buf_cap);
+ buf = (char *)memReallocBuf(buf, new_cap, &buf_cap);
/* done */
- mb->capacity = (mb_size_t) buf_cap;
+ capacity = (mb_size_t) buf_cap;
}
void
memBufReport(MemBuf * mb) {
assert(mb);
- memBufPrintf(mb, "memBufReport is not yet implemented @?@\n");
+ mb->Printf("memBufReport is not yet implemented @?@\n");
}
#ifndef _USE_INLINE_
/*
- * $Id: MemBuf.h,v 1.4 2005/09/17 05:05:08 wessels Exp $
+ * $Id: MemBuf.h,v 1.5 2005/09/17 05:50:07 wessels Exp $
*
*
* SQUID Web Proxy Cache http://www.squid-cache.org/
void terminate(); // zero-terminates the buffer w/o increasing contentSize
+ /* init with specific sizes */
+ void init(mb_size_t szInit, mb_size_t szMax);
+
+ /* init with defaults */
+ void init();
+
+ /* cleans mb; last function to call if you do not give .buf away */
+ void clean();
+
+ /* resets mb preserving (or initializing if needed) memory buffer */
+ void reset();
+
+ /* unfirtunate hack to test if the buffer has been Init()ialized */
+ int isNull();
+
+ /* calls snprintf, extends buffer if needed */
+ /* note we use Printf instead of printf so the compiler won't */
+ /* think we're calling the libc printf() */
+#if STDC_HEADERS
+
+ void Printf(const char *fmt,...) PRINTF_FORMAT_ARG2;
+#else
+
+ void Printf();
+#endif
+
+ /* vPrintf for other printf()'s to use */
+ void vPrintf(const char *fmt, va_list ap);
+
+ /* returns free() function to be used, _freezes_ the object! */
+ FREE *freeFunc();
+
+
private:
/*
* private copy constructor and assignment operator generates
MemBuf& operator= (const MemBuf& m) {assert(false); return *this;};
+ void grow(mb_size_t min_cap);
+
CBDATA_CLASS2(MemBuf);
public:
#include "MemBuf.cci"
#endif
-/* MemBuf */
-/* init with specific sizes */
-SQUIDCEXTERN void memBufInit(MemBuf * mb, mb_size_t szInit, mb_size_t szMax);
-/* init with defaults */
-SQUIDCEXTERN void memBufDefInit(MemBuf * mb);
-/* cleans mb; last function to call if you do not give .buf away */
-SQUIDCEXTERN void memBufClean(MemBuf * mb);
-/* resets mb preserving (or initializing if needed) memory buffer */
-SQUIDCEXTERN void memBufReset(MemBuf * mb);
-/* unfirtunate hack to test if the buffer has been Init()ialized */
-SQUIDCEXTERN int memBufIsNull(MemBuf * mb);
-/* calls memcpy, appends exactly size bytes, extends buffer if needed */
-SQUIDCEXTERN void memBufAppend(MemBuf * mb, const char *buf, mb_size_t size);
-/* calls snprintf, extends buffer if needed */
-#if STDC_HEADERS
-SQUIDCEXTERN void
-memBufPrintf(MemBuf * mb, const char *fmt,...) PRINTF_FORMAT_ARG2;
-#else
-SQUIDCEXTERN void memBufPrintf();
-#endif
-/* vprintf for other printf()'s to use */
-SQUIDCEXTERN void memBufVPrintf(MemBuf * mb, const char *fmt, va_list ap);
/* returns free() function to be used, _freezes_ the object! */
-SQUIDCEXTERN FREE *memBufFreeFunc(MemBuf * mb);
-/* puts report on MemBuf _module_ usage into mb */
SQUIDCEXTERN void memBufReport(MemBuf * mb);
#endif /* SQUID_MEM_H */
/*
- * $Id: MemObject.cc,v 1.16 2005/09/17 04:53:44 wessels Exp $
+ * $Id: MemObject.cc,v 1.17 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 19 Store Memory Primitives
* AUTHOR: Robert Collins
void
MemObject::stat (MemBuf * mb) const
{
- memBufPrintf(mb, "\t%s %s\n",
- RequestMethodStr[method], log_url);
- memBufPrintf(mb, "\tinmem_lo: %d\n", (int) inmem_lo);
- memBufPrintf(mb, "\tinmem_hi: %d\n", (int) data_hdr.endOffset());
- memBufPrintf(mb, "\tswapout: %d bytes queued\n",
- (int) swapout.queue_offset);
+ mb->Printf("\t%s %s\n",
+ RequestMethodStr[method], log_url);
+ mb->Printf("\tinmem_lo: %d\n", (int) inmem_lo);
+ mb->Printf("\tinmem_hi: %d\n", (int) data_hdr.endOffset());
+ mb->Printf("\tswapout: %d bytes queued\n",
+ (int) swapout.queue_offset);
if (swapout.sio.getRaw())
- memBufPrintf(mb, "\tswapout: %d bytes written\n",
- (int) swapout.sio->offset());
+ mb->Printf("\tswapout: %d bytes written\n",
+ (int) swapout.sio->offset());
StoreClientStats statsVisitor(mb);
/*
- * $Id: Packer.cc,v 1.18 2005/09/17 04:53:44 wessels Exp $
+ * $Id: Packer.cc,v 1.19 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 60 Packer: A uniform interface to store-like modules
* AUTHOR: Alex Rousskov
* warning (e.g., "warning: assignment from incompatible pointer type").
*/
+static void
+memBufAppend(MemBuf *mb, const char *buf, mb_size_t len)
+{
+ mb->append(buf, len);
+}
+
+static void
+memBufVPrintf(MemBuf * mb, const char *fmt, va_list vargs)
+{
+ mb->vPrintf(fmt, vargs);
+}
+
+
/* append()'s */
static void (*const store_append) (StoreEntry *, const char *, int) = &storeAppend;
static void (*const memBuf_append) (MemBuf *, const char *, mb_size_t) = &memBufAppend;
/*
- * $Id: access_log.cc,v 1.104 2005/09/17 04:53:44 wessels Exp $
+ * $Id: access_log.cc,v 1.105 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 46 Access Log
* AUTHOR: Duane Wessels
char tmp[1024];
String sb;
- memBufReset(&mb);
+ mb.reset();
lf = log->logFormat;
logfile = log->logfile;
case LFT_SQUID_HIERARCHY:
if (al->hier.ping.timedout)
- memBufAppend(&mb, "TIMEOUT_", 8);
+ mb.append("TIMEOUT_", 8);
out = hier_strings[al->hier.code];
if (fmt->width) {
if (fmt->left)
- memBufPrintf(&mb, "%-*s", (int) fmt->width, out);
+ mb.Printf("%-*s", (int) fmt->width, out);
else
- memBufPrintf(&mb, "%*s", (int) fmt->width, out);
+ mb.Printf("%*s", (int) fmt->width, out);
} else
- memBufAppend(&mb, out, strlen(out));
+ mb.append(out, strlen(out));
} else {
- memBufAppend(&mb, "-", 1);
+ mb.append("-", 1);
}
if (fmt->space)
- memBufAppend(&mb, " ", 1);
+ mb.append(" ", 1);
sb.clean();
/*
- * $Id: cache_cf.cc,v 1.479 2005/09/17 04:53:44 wessels Exp $
+ * $Id: cache_cf.cc,v 1.480 2005/09/17 05:50:07 wessels Exp $
*
* DEBUG: section 3 Configuration File Parsing
* AUTHOR: Harvest Derived
wordlistCat(const wordlist * w, MemBuf * mb)
{
while (NULL != w) {
- memBufPrintf(mb, "%s\n", w->key);
+ mb->Printf("%s\n", w->key);
w = w->next;
}
}
/*
- * $Id: client_side.cc,v 1.697 2005/09/17 04:53:44 wessels Exp $
+ * $Id: client_side.cc,v 1.698 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 33 Client-side Routines
* AUTHOR: Duane Wessels
if (Config.onoff.log_mime_hdrs) {
Packer p;
MemBuf mb;
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
httpHeaderPackInto(&request->header, &p);
aLogEntry->headers.request = xstrdup(mb.buf);
packerClean(&p);
- memBufClean(&mb);
+ mb.clean();
}
aLogEntry->http.method = request->method;
}
MemBuf mb;
- memBufDefInit(&mb);
+ mb.init();
packRange(bodyData, &mb);
if (mb.contentSize())
static void
clientPackTermBound(String boundary, MemBuf * mb)
{
- memBufPrintf(mb, "\r\n--%s--\r\n", boundary.buf());
+ mb->Printf("\r\n--%s--\r\n", boundary.buf());
debug(33, 6) ("clientPackTermBound: buf offset: %ld\n", (long int) mb->size);
}
/* put boundary */
debug(33, 5) ("clientPackRangeHdr: appending boundary: %s\n", boundary.buf());
/* rfc2046 requires to _prepend_ boundary with <crlf>! */
- memBufPrintf(mb, "\r\n--%s\r\n", boundary.buf());
+ mb->Printf("\r\n--%s\r\n", boundary.buf());
/* stuff the header with required entries and pack it */
httpHeaderClean(&hdr);
/* append <crlf> (we packed a header, not a reply) */
- memBufPrintf(mb, "\r\n");
+ mb->Printf("\r\n");
}
/*
noteSentBodyBytes (copy_sz);
- memBufAppend(mb, buf, copy_sz);
+ mb->append(buf, copy_sz);
/*
* update offsets
assert(memObject());
- memBufDefInit(&mb);
+ mb.init();
HttpHdrRange::iterator pos = request->range->begin();
while (pos != request->range->end()) {
/* account for headers for this range */
- memBufReset(&mb);
+ mb.reset();
clientPackRangeHdr(memObject()->getReply(),
*pos, range_iter.boundary, &mb);
clen += mb.size;
}
/* account for the terminating boundary */
- memBufReset(&mb);
+ mb.reset();
clientPackTermBound(range_iter.boundary, &mb);
clen += mb.size;
- memBufClean(&mb);
+ mb.clean();
return clen;
}
size_t length = lengthToSend(bodyData.range());
noteSentBodyBytes (length);
- memBufAppend(mb, bodyData.data, length);
+ mb->append(bodyData.data, length);
} else {
packRange(bodyData, mb);
}
/*
- * $Id: comm.cc,v 1.410 2005/09/17 04:53:44 wessels Exp $
+ * $Id: comm.cc,v 1.411 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 5 Socket Functions
* AUTHOR: Harvest Derived
/* a wrapper around comm_write to allow for MemBuf to be comm_written in a snap */
void
comm_old_write_mbuf(int fd, MemBuf *mb, CWCB * handler, void *handler_data) {
- comm_old_write(fd, mb->buf, mb->size, handler, handler_data, memBufFreeFunc(mb));
+ comm_old_write(fd, mb->buf, mb->size, handler, handler_data, mb->freeFunc());
}
/*
- * $Id: disk.cc,v 1.170 2005/09/17 04:53:44 wessels Exp $
+ * $Id: disk.cc,v 1.171 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 6 Disk I/O Routines
* AUTHOR: Harvest Derived
void
file_write_mbuf(int fd, off_t off, MemBuf mb, DWCB * handler, void *handler_data)
{
- file_write(fd, off, mb.buf, mb.size, handler, handler_data, memBufFreeFunc(&mb));
+ file_write(fd, off, mb.buf, mb.size, handler, handler_data, mb.freeFunc());
}
/* Read from FD */
/*
- * $Id: dns_internal.cc,v 1.81 2005/09/17 04:53:44 wessels Exp $
+ * $Id: dns_internal.cc,v 1.82 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 78 DNS lookups; interacts with lib/rfc1035.c
* AUTHOR: Duane Wessels
nsvc *vc = nameservers[ns].vc;
- memBufReset(vc->queue);
+ vc->queue->reset();
short head = htons(q->sz);
- memBufAppend(vc->queue, (char *)&head, 2);
+ vc->queue->append((char *)&head, 2);
- memBufAppend(vc->queue, q->buf, q->sz);
+ vc->queue->append(q->buf, q->sz);
idnsDoSendQueryVC(vc);
}
inet_ntoa(nameservers[vc->ns].S.sin_addr));
idnsGrokReply(vc->msg->buf, vc->msg->contentSize());
- memBufClean(vc->msg);
+ vc->msg->clean();
comm_read(fd, (char *)&vc->msglen, 2 , idnsReadVCHeader, vc);
}
vc->msglen = ntohs(vc->msglen);
- memBufInit(vc->msg, vc->msglen, vc->msglen);
+ vc->msg->init(vc->msglen, vc->msglen);
comm_read(fd, vc->msg->buf, vc->msglen, idnsReadVC, vc);
}
/*
- * $Id: errorpage.cc,v 1.203 2005/09/17 04:53:44 wessels Exp $
+ * $Id: errorpage.cc,v 1.204 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 4 Error Generation
* AUTHOR: Duane Wessels
return NULL;
}
- memBufDefInit(&textbuf);
+ textbuf.init();
while((len = FD_READ_METHOD(fd, buf, sizeof(buf))) > 0) {
- memBufAppend(&textbuf, buf, len);
+ textbuf.append(buf, len);
}
if (len < 0) {
file_close(fd);
if (strstr(textbuf.buf, "%s") == NULL)
- memBufAppend(&textbuf, "%S", 2); /* add signature */
+ textbuf.append("%S", 2); /* add signature */
/* Shrink memory size down to exact size. MemBuf has a tencendy
* to be rather large..
*/
text = xstrdup(textbuf.buf);
- memBufClean(&textbuf);
+ textbuf.clean();
return text;
}
HttpRequest *r = err->request;
MemBuf str;
const char *p = NULL; /* takes priority over mb if set */
- memBufReset(&str);
+ str.reset();
/* email subject line */
- memBufPrintf(&str, "CacheErrorInfo - %s", errorPageName(err->type));
- memBufPrintf(mb, "?subject=%s", rfc1738_escape_part(str.buf));
- memBufReset(&str);
+ str.Printf("CacheErrorInfo - %s", errorPageName(err->type));
+ mb->Printf("?subject=%s", rfc1738_escape_part(str.buf));
+ str.reset();
/* email body */
- memBufPrintf(&str, "CacheHost: %s\r\n", getMyHostname());
+ str.Printf("CacheHost: %s\r\n", getMyHostname());
/* - Err Msgs */
- memBufPrintf(&str, "ErrPage: %s\r\n", errorPageName(err->type));
+ str.Printf("ErrPage: %s\r\n", errorPageName(err->type));
if (err->xerrno) {
- memBufPrintf(&str, "Err: (%d) %s\r\n", err->xerrno, strerror(err->xerrno));
+ str.Printf("Err: (%d) %s\r\n", err->xerrno, strerror(err->xerrno));
} else {
- memBufPrintf(&str, "Err: [none]\r\n");
+ str.Printf("Err: [none]\r\n");
}
if (err->auth_user_request->denyMessage())
- memBufPrintf(&str, "Auth ErrMsg: %s\r\n", err->auth_user_request->denyMessage());
+ str.Printf("Auth ErrMsg: %s\r\n", err->auth_user_request->denyMessage());
if (err->dnsserver_msg) {
- memBufPrintf(&str, "DNS Server ErrMsg: %s\r\n", err->dnsserver_msg);
+ str.Printf("DNS Server ErrMsg: %s\r\n", err->dnsserver_msg);
}
/* - TimeStamp */
- memBufPrintf(&str, "TimeStamp: %s\r\n\r\n", mkrfc1123(squid_curtime));
+ str.Printf("TimeStamp: %s\r\n\r\n", mkrfc1123(squid_curtime));
/* - IP stuff */
- memBufPrintf(&str, "ClientIP: %s\r\n", inet_ntoa(err->src_addr));
+ str.Printf("ClientIP: %s\r\n", inet_ntoa(err->src_addr));
if (err->host) {
- memBufPrintf(&str, "ServerIP: %s\r\n", err->host);
+ str.Printf("ServerIP: %s\r\n", err->host);
}
- memBufPrintf(&str, "\r\n");
+ str.Printf("\r\n");
/* - HTTP stuff */
- memBufPrintf(&str, "HTTP Request:\r\n");
+ str.Printf("HTTP Request:\r\n");
if (NULL != r) {
Packer p;
- memBufPrintf(&str, "%s %s HTTP/%d.%d\n",
- RequestMethodStr[r->method],
- r->urlpath.size() ? r->urlpath.buf() : "/",
- r->http_ver.major, r->http_ver.minor);
+ str.Printf("%s %s HTTP/%d.%d\n",
+ RequestMethodStr[r->method],
+ r->urlpath.size() ? r->urlpath.buf() : "/",
+ r->http_ver.major, r->http_ver.minor);
packerToMemInit(&p, &str);
httpHeaderPackInto(&r->header, &p);
packerClean(&p);
p = "[none]";
}
- memBufPrintf(&str, "\r\n");
+ str.Printf("\r\n");
/* - FTP stuff */
if (err->ftp.request) {
- memBufPrintf(&str, "FTP Request: %s\r\n", err->ftp.request);
- memBufPrintf(&str, "FTP Reply: %s\r\n", err->ftp.reply);
- memBufPrintf(&str, "FTP Msg: ");
+ str.Printf("FTP Request: %s\r\n", err->ftp.request);
+ str.Printf("FTP Reply: %s\r\n", err->ftp.reply);
+ str.Printf("FTP Msg: ");
wordlistCat(err->ftp.server_msg, &str);
- memBufPrintf(&str, "\r\n");
+ str.Printf("\r\n");
}
- memBufPrintf(&str, "\r\n");
- memBufPrintf(mb, "&body=%s", rfc1738_escape_part(str.buf));
- memBufClean(&str);
+ str.Printf("\r\n");
+ mb->Printf("&body=%s", rfc1738_escape_part(str.buf));
+ str.clean();
return 0;
}
const char *p = NULL; /* takes priority over mb if set */
int do_quote = 1;
- memBufReset(&mb);
+ mb.reset();
switch (token) {
break;
case 'e':
- memBufPrintf(&mb, "%d", err->xerrno);
+ mb.Printf("%d", err->xerrno);
break;
case 'E':
if (err->xerrno)
- memBufPrintf(&mb, "(%d) %s", err->xerrno, strerror(err->xerrno));
+ mb.Printf("(%d) %s", err->xerrno, strerror(err->xerrno));
else
- memBufPrintf(&mb, "[No Error]");
+ mb.Printf("[No Error]");
break;
break;
case 'h':
- memBufPrintf(&mb, "%s", getMyHostname());
+ mb.Printf("%s", getMyHostname());
break;
break;
case 'i':
- memBufPrintf(&mb, "%s", inet_ntoa(err->src_addr));
+ mb.Printf("%s", inet_ntoa(err->src_addr));
break;
case 'I':
if (err->host) {
- memBufPrintf(&mb, "%s", err->host);
+ mb.Printf("%s", err->host);
} else
p = "[unknown]";
case 'L':
if (Config.errHtmlText) {
- memBufPrintf(&mb, "%s", Config.errHtmlText);
+ mb.Printf("%s", Config.errHtmlText);
do_quote = 0;
} else
p = "[not available]";
case 'p':
if (r) {
- memBufPrintf(&mb, "%d", (int) r->port);
+ mb.Printf("%d", (int) r->port);
} else {
p = "[unknown port]";
}
if (NULL != r) {
Packer p;
- memBufPrintf(&mb, "%s %s HTTP/%d.%d\n",
- RequestMethodStr[r->method],
- r->urlpath.size() ? r->urlpath.buf() : "/",
- r->http_ver.major, r->http_ver.minor);
+ mb.Printf("%s %s HTTP/%d.%d\n",
+ RequestMethodStr[r->method],
+ r->urlpath.size() ? r->urlpath.buf() : "/",
+ r->http_ver.major, r->http_ver.minor);
packerToMemInit(&p, &mb);
httpHeaderPackInto(&r->header, &p);
packerClean(&p);
const int saved_id = err->page_id;
err->page_id = ERR_SQUID_SIGNATURE;
MemBuf *sign_mb = errorBuildContent(err);
- memBufPrintf(&mb, "%s", sign_mb->content());
- memBufClean(sign_mb);
+ mb.Printf("%s", sign_mb->content());
+ sign_mb->clean();
delete sign_mb;
err->page_id = saved_id;
do_quote = 0;
break;
case 't':
- memBufPrintf(&mb, "%s", mkhttpdlogtime(&squid_curtime));
+ mb.Printf("%s", mkhttpdlogtime(&squid_curtime));
break;
case 'T':
- memBufPrintf(&mb, "%s", mkrfc1123(squid_curtime));
+ mb.Printf("%s", mkrfc1123(squid_curtime));
break;
case 'U':
case 'w':
if (Config.adminEmail)
- memBufPrintf(&mb, "%s", Config.adminEmail);
+ mb.Printf("%s", Config.adminEmail);
else
p = "[unknown]";
break;
default:
- memBufPrintf(&mb, "%%%c", token);
+ mb.Printf("%%%c", token);
do_quote = 0;
const char *t;
assert(err != NULL);
assert(err->page_id > ERR_NONE && err->page_id < error_page_count);
- memBufDefInit(content);
+ content->init();
m = error_text[err->page_id];
assert(m);
while ((p = strchr(m, '%'))) {
- memBufAppend(content, m, p - m); /* copy */
+ content->append(m, p - m); /* copy */
t = errorConvert(*++p, err); /* convert */
- memBufPrintf(content, "%s", t); /* copy */
+ content->Printf("%s", t); /* copy */
m = p + 1; /* advance */
}
if (*m)
- memBufPrintf(content, "%s", m); /* copy tail */
+ content->Printf("%s", m); /* copy tail */
assert((size_t)content->contentSize() == strlen(content->content()));
/*
- * $Id: external_acl.cc,v 1.65 2005/09/17 04:53:44 wessels Exp $
+ * $Id: external_acl.cc,v 1.66 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 82 External ACL
* AUTHOR: Henrik Nordstrom, MARA Systems AB
wordlist *result = NULL;
wordlist *arg;
MemBuf mb;
- memBufDefInit(&mb);
- memBufPrintf(&mb, "%s", acl->def->name);
+ mb.init();
+ mb.Printf("%s", acl->def->name);
for (arg = acl->arguments; arg; arg = arg->next) {
- memBufPrintf(&mb, " %s", arg->key);
+ mb.Printf(" %s", arg->key);
}
wordlistAdd(&result, mb.buf);
- memBufClean(&mb);
+ mb.clean();
return result;
}
wordlist *arg;
external_acl_format *format;
HttpRequest *request = ch->request;
- memBufReset(&mb);
+ mb.reset();
for (format = acl_data->def->format; format; format = format->next) {
const char *str = NULL;
str = "-";
if (!first)
- memBufAppend(&mb, " ", 1);
+ mb.append(" ", 1);
if (acl_data->def->quote == external_acl::QUOTE_METHOD_URL) {
const char *quoted = rfc1738_escape(str);
- memBufAppend(&mb, quoted, strlen(quoted));
+ mb.append(quoted, strlen(quoted));
} else {
strwordquote(&mb, str);
}
for (arg = acl_data->arguments; arg; arg = arg->next) {
if (!first)
- memBufAppend(&mb, " ", 1);
+ mb.append(" ", 1);
if (acl_data->def->quote == external_acl::QUOTE_METHOD_URL) {
const char *quoted = rfc1738_escape(arg->key);
- memBufAppend(&mb, quoted, strlen(quoted));
+ mb.append(quoted, strlen(quoted));
} else {
strwordquote(&mb, arg->key);
}
}
/* Send it off to the helper */
- memBufDefInit(&buf);
+ buf.init();
- memBufPrintf(&buf, "%s\n", key);
+ buf.Printf("%s\n", key);
helperSubmit(def->theHelper, buf.buf, externalAclHandleReply, state);
dlinkAdd(state, &state->list, &def->queue);
- memBufClean(&buf);
+ buf.clean();
}
if (graceful) {
/*
- * $Id: gopher.cc,v 1.190 2005/09/17 04:53:44 wessels Exp $
+ * $Id: gopher.cc,v 1.191 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 10 Gopher
* AUTHOR: Harvest Derived
char *cenc = mimeGetContentEncoding(name);
if (cenc)
- memBufPrintf(mb, "Content-Encoding: %s\r\n", cenc);
+ mb->Printf("Content-Encoding: %s\r\n", cenc);
- memBufPrintf(mb, "Content-Type: %s\r\n",
- ctype ? ctype : def_ctype);
+ mb->Printf("Content-Type: %s\r\n",
+ ctype ? ctype : def_ctype);
}
{
MemBuf mb;
- memBufDefInit(&mb);
+ mb.init();
- memBufPrintf(&mb,
- "HTTP/1.0 200 OK Gatewaying\r\n"
- "Server: Squid/%s\r\n"
- "Date: %s\r\n",
- version_string, mkrfc1123(squid_curtime));
+ mb.Printf("HTTP/1.0 200 OK Gatewaying\r\n"
+ "Server: Squid/%s\r\n"
+ "Date: %s\r\n",
+ version_string, mkrfc1123(squid_curtime));
switch (gopherState->type_id) {
case GOPHER_WWW:
case GOPHER_CSO:
- memBufPrintf(&mb, "Content-Type: text/html\r\n");
+ mb.Printf("Content-Type: text/html\r\n");
break;
case GOPHER_GIF:
case GOPHER_IMAGE:
case GOPHER_PLUS_IMAGE:
- memBufPrintf(&mb, "Content-Type: image/gif\r\n");
+ mb.Printf("Content-Type: image/gif\r\n");
break;
case GOPHER_SOUND:
case GOPHER_PLUS_SOUND:
- memBufPrintf(&mb, "Content-Type: audio/basic\r\n");
+ mb.Printf("Content-Type: audio/basic\r\n");
break;
case GOPHER_PLUS_MOVIE:
- memBufPrintf(&mb, "Content-Type: video/mpeg\r\n");
+ mb.Printf("Content-Type: video/mpeg\r\n");
break;
case GOPHER_MACBINHEX:
break;
}
- memBufPrintf(&mb, "\r\n");
+ mb.Printf("\r\n");
EBIT_CLR(gopherState->entry->flags, ENTRY_FWD_HDR_WAIT);
storeAppend(gopherState->entry, mb.buf, mb.size);
- memBufClean(&mb);
+ mb.clean();
}
/* Parse a gopher request into components. By Anawat. */
/*
- * $Id: helper.cc,v 1.68 2005/09/17 04:53:44 wessels Exp $
+ * $Id: helper.cc,v 1.69 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 84 Helper process maintenance
* AUTHOR: Harvest Derived?
srv->rbuf = NULL;
}
- memBufClean(srv->wqueue);
+ srv->wqueue->clean();
delete srv->wqueue;
if (srv->writebuf) {
- memBufClean(srv->writebuf);
+ srv->writebuf->clean();
delete srv->writebuf;
srv->writebuf = NULL;
}
}
#if 0
- memBufClean(srv->wqueue);
+ srv->wqueue->clean();
delete srv->wqueue;
{
helper_server *srv = (helper_server *)data;
- memBufClean(srv->writebuf);
+ srv->writebuf->clean();
delete srv->writebuf;
srv->writebuf = NULL;
srv->flags.writing = 0;
return;
}
- if (!memBufIsNull(srv->wqueue)) {
+ if (!srv->wqueue->isNull()) {
srv->writebuf = srv->wqueue;
srv->wqueue = new MemBuf;
srv->flags.writing = 1;
srv->stats.pending += 1;
r->dispatch_time = current_time;
- if (memBufIsNull(srv->wqueue))
- memBufDefInit(srv->wqueue);
+ if (srv->wqueue->isNull())
+ srv->wqueue->init();
if (hlp->concurrency)
- memBufPrintf(srv->wqueue, "%d %s", slot, r->buf);
+ srv->wqueue->Printf("%d %s", slot, r->buf);
else
- memBufAppend(srv->wqueue, r->buf, strlen(r->buf));
+ srv->wqueue->append(r->buf, strlen(r->buf));
if (!srv->flags.writing) {
assert(NULL == srv->writebuf);
/*
- * $Id: htcp.cc,v 1.59 2005/09/17 04:53:44 wessels Exp $
+ * $Id: htcp.cc,v 1.60 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 31 Hypertext Caching Protocol
* AUTHOR: Duane Wesssels
if (spec)
{
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
stuff.S.method = spec->method;
stuff.S.uri = spec->uri;
httpHeaderPackInto(&hdr, &p);
stuff.D.resp_hdrs = xstrdup(mb.buf);
debug(31, 3) ("htcpTstReply: resp_hdrs = {%s}\n", stuff.D.resp_hdrs);
- memBufReset(&mb);
+ mb.reset();
httpHeaderReset(&hdr);
if (e->expires > -1)
debug(31, 3) ("htcpTstReply: entity_hdrs = {%s}\n", stuff.D.entity_hdrs);
- memBufReset(&mb);
+ mb.reset();
httpHeaderReset(&hdr);
httpHeaderPackInto(&hdr, &p);
stuff.D.cache_hdrs = xstrdup(mb.buf);
debug(31, 3) ("htcpTstReply: cache_hdrs = {%s}\n", stuff.D.cache_hdrs);
- memBufClean(&mb);
+ mb.clean();
httpHeaderClean(&hdr);
packerClean(&p);
}
httpBuildRequestHeader(req, req, e, &hdr, flags);
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&pa, &mb);
pkt = htcpBuildPacket(&stuff, &pktlen);
- memBufClean(&mb);
+ mb.clean();
if (pkt == NULL) {
debug(31, 0) ("htcpQuery: htcpBuildPacket() failed\n");
/*
- * $Id: http.cc,v 1.458 2005/09/17 04:53:44 wessels Exp $
+ * $Id: http.cc,v 1.459 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 11 Hypertext Transfer Protocol (HTTP)
* AUTHOR: Harvest Derived
storeUnlockObject(httpState->entry);
- if (!memBufIsNull(&httpState->reply_hdr)) {
- memBufClean(&httpState->reply_hdr);
+ if (!httpState->reply_hdr.isNull()) {
+ httpState->reply_hdr.clean();
}
requestUnlink(httpState->request);
debug(11, 3) ("httpProcessReplyHeader: key '%s'\n",
entry->getMD5Text());
- if (memBufIsNull(&reply_hdr))
- memBufDefInit(&reply_hdr);
+ if (reply_hdr.isNull())
+ reply_hdr.init();
assert(!flags.headers_parsed);
- memBufAppend(&reply_hdr, buf, size);
+ reply_hdr.append(buf, size);
hdr_len = reply_hdr.size;
if (hdr_len > 4 && strncmp(reply_hdr.buf, "HTTP/", 5)) {
debugs(11, 3, "httpProcessReplyHeader: Non-HTTP-compliant header: '" << reply_hdr.buf << "'");
flags.headers_parsed = 1;
- memBufClean(&reply_hdr);
+ reply_hdr.clean();
failReply (reply, HTTP_INVALID_HEADER);
ctx_exit(ctx);
return;
if (hdr_len > Config.maxReplyHeaderSize) {
debugs(11, 1, "httpProcessReplyHeader: Too large reply header");
- if (!memBufIsNull(&reply_hdr))
- memBufClean(&reply_hdr);
+ if (!reply_hdr.isNull())
+ reply_hdr.clean();
failReply (reply, HTTP_HEADER_TOO_LARGE);
}
/* Cut away any excess body data (only needed for debug?) */
- memBufAppend(&reply_hdr, "\0", 1);
+ reply_hdr.append("\0", 1);
reply_hdr.buf[hdr_size] = '\0';
{
const int offset = mb->size;
HttpVersion httpver(1, 0);
- memBufPrintf(mb, "%s %s HTTP/%d.%d\r\n",
- RequestMethodStr[request->method],
- request->urlpath.size() ? request->urlpath.buf() : "/",
- httpver.major,httpver.minor);
+ mb->Printf("%s %s HTTP/%d.%d\r\n",
+ RequestMethodStr[request->method],
+ request->urlpath.size() ? request->urlpath.buf() : "/",
+ httpver.major,httpver.minor);
/* build and pack headers */
{
HttpHeader hdr(hoRequest);
packerClean(&p);
}
/* append header terminator */
- memBufAppend(mb, crlf, 2);
+ mb->append(crlf, 2);
return mb->size - offset;
}
httpState->flags.front_end_https = httpState->_peer->front_end_https;
}
- memBufDefInit(&mb);
+ mb.init();
httpBuildRequestPrefix(req,
httpState->orig_request,
entry,
/*
- * $Id: ident.cc,v 1.71 2005/09/17 04:53:44 wessels Exp $
+ * $Id: ident.cc,v 1.72 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 30 Ident (RFC 931)
* AUTHOR: Duane Wessels
}
MemBuf mb;
- memBufDefInit(&mb);
- memBufPrintf(&mb, "%d, %d\r\n",
- ntohs(state->my_peer.sin_port),
- ntohs(state->me.sin_port));
+ mb.init();
+ mb.Printf("%d, %d\r\n",
+ ntohs(state->my_peer.sin_port),
+ ntohs(state->me.sin_port));
comm_old_write_mbuf(fd, &mb, NULL, state);
comm_read(fd, state->buf, BUFSIZ, identReadReply, state);
commSetTimeout(fd, Config.Timeout.ident, identTimeout, state);
/*
- * $Id: internal.cc,v 1.32 2005/09/17 04:53:44 wessels Exp $
+ * $Id: internal.cc,v 1.33 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 76 Internal Squid Object handling
* AUTHOR: Duane, Alex, Henrik
/* build uri in mb */
static MemBuf mb;
- memBufReset(&mb);
+ mb.reset();
- memBufPrintf(&mb, "http://%s", lc_host);
+ mb.Printf("http://%s", lc_host);
/* append port if not default */
if (port && port != urlDefaultPort(PROTO_HTTP))
- memBufPrintf(&mb, ":%d", port);
+ mb.Printf(":%d", port);
if (dir)
- memBufPrintf(&mb, "%s", dir);
+ mb.Printf("%s", dir);
- memBufPrintf(&mb, "%s", name);
+ mb.Printf("%s", name);
/* return a pointer to a local static buffer */
return mb.buf;
/*
- * $Id: mime.cc,v 1.118 2005/09/17 04:53:44 wessels Exp $
+ * $Id: mime.cc,v 1.119 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 25 MIME Parsing
* AUTHOR: Harvest Derived
if (Config.icons.use_short_names) {
static MemBuf mb;
- memBufReset(&mb);
- memBufPrintf(&mb, "/squid-internal-static/icons/%s", icon);
+ mb.reset();
+ mb.Printf("/squid-internal-static/icons/%s", icon);
return mb.content();
} else {
return internalLocalUri("/squid-internal-static/icons/", icon);
/*
- * $Id: stat.cc,v 1.391 2005/09/17 04:53:44 wessels Exp $
+ * $Id: stat.cc,v 1.392 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 18 Cache Manager Statistics
* AUTHOR: Harvest Derived
statStoreEntry(MemBuf * mb, StoreEntry * e)
{
MemObject *mem = e->mem_obj;
- memBufPrintf(mb, "KEY %s\n", e->getMD5Text());
- memBufPrintf(mb, "\t%s\n", describeStatuses(e));
- memBufPrintf(mb, "\t%s\n", storeEntryFlags(e));
- memBufPrintf(mb, "\t%s\n", describeTimestamps(e));
- memBufPrintf(mb, "\t%d locks, %d clients, %d refs\n",
- (int) e->lock_count,
- storePendingNClients(e),
- (int) e->refcount);
- memBufPrintf(mb, "\tSwap Dir %d, File %#08X\n",
- e->swap_dirn, e->swap_filen);
+ mb->Printf("KEY %s\n", e->getMD5Text());
+ mb->Printf("\t%s\n", describeStatuses(e));
+ mb->Printf("\t%s\n", storeEntryFlags(e));
+ mb->Printf("\t%s\n", describeTimestamps(e));
+ mb->Printf("\t%d locks, %d clients, %d refs\n",
+ (int) e->lock_count,
+ storePendingNClients(e),
+ (int) e->refcount);
+ mb->Printf("\tSwap Dir %d, File %#08X\n",
+ e->swap_dirn, e->swap_filen);
if (mem != NULL)
mem->stat (mb);
- memBufPrintf(mb, "\n");
+ mb->Printf("\n");
}
/* process objects list */
storeBuffer(state->sentry);
size_t statCount = 0;
MemBuf mb;
- memBufDefInit(&mb);
+ mb.init();
while (statCount++ < static_cast<size_t>(Config.Store.objectsPerBucket) && state->
theSearch->next()) {
if (mb.size)
storeAppend(state->sentry, mb.buf, mb.size);
- memBufClean(&mb);
+ mb.clean();
eventAdd("statObjects", statObjects, state, 0.0, 1);
}
/*
- * $Id: store_client.cc,v 1.140 2005/09/17 04:53:44 wessels Exp $
+ * $Id: store_client.cc,v 1.141 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 90 Storage Manager Client-Side Interface
* AUTHOR: Duane Wessels
if (_callback.pending())
return;
- memBufPrintf(output, "\tClient #%d, %p\n", clientNumber, _callback.callback_data);
+ output->Printf("\tClient #%d, %p\n", clientNumber, _callback.callback_data);
- memBufPrintf(output, "\t\tcopy_offset: %lu\n",
- (unsigned long) copyInto.offset);
+ output->Printf("\t\tcopy_offset: %lu\n",
+ (unsigned long) copyInto.offset);
- memBufPrintf(output, "\t\tcopy_size: %d\n",
- (int) copyInto.length);
+ output->Printf("\t\tcopy_size: %d\n",
+ (int) copyInto.length);
- memBufPrintf(output, "\t\tflags:");
+ output->Printf("\t\tflags:");
if (flags.disk_io_pending)
- memBufPrintf(output, " disk_io_pending");
+ output->Printf(" disk_io_pending");
if (flags.store_copying)
- memBufPrintf(output, " store_copying");
+ output->Printf(" store_copying");
if (flags.copy_event_pending)
- memBufPrintf(output, " copy_event_pending");
+ output->Printf(" copy_event_pending");
- memBufPrintf(output, "\n");
+ output->Printf("\n");
}
bool
/*
- * $Id: tools.cc,v 1.262 2005/09/17 04:53:45 wessels Exp $
+ * $Id: tools.cc,v 1.263 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 21 Misc Functions
* AUTHOR: Harvest Derived
MemBuf mb;
Packer p;
assert(label && obj && pm);
- memBufDefInit(&mb);
+ mb.init();
packerToMemInit(&p, &mb);
(*pm) (obj, &p);
debug(section, level) ("%s%s", label, mb.buf);
packerClean(&p);
- memBufClean(&mb);
+ mb.clean();
}
void
if (strchr(str, ' ')) {
quoted = 1;
- memBufAppend(mb, "\"", 1);
+ mb->append("\"", 1);
}
while (*str) {
int l = strcspn(str, "\"\\\n\r");
- memBufAppend(mb, str, l);
+ mb->append(str, l);
str += l;
switch(*str) {
case '\n':
- memBufAppend(mb, "\\n", 2);
+ mb->append("\\n", 2);
str++;
break;
case '\r':
- memBufAppend(mb, "\\r", 2);
+ mb->append("\\r", 2);
str++;
break;
break;
default:
- memBufAppend(mb, "\\", 1);
- memBufAppend(mb, str, 1);
+ mb->append("\\", 1);
+ mb->append(str, 1);
str++;
break;
}
}
if (quoted)
- memBufAppend(mb, "\"", 1);
+ mb->append("\"", 1);
}
/*
- * $Id: tunnel.cc,v 1.153 2005/09/17 04:53:45 wessels Exp $
+ * $Id: tunnel.cc,v 1.154 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 26 Secure Sockets Layer Proxy
* AUTHOR: Duane Wessels
memset(&flags, '\0', sizeof(flags));
flags.proxying = sslState->request->flags.proxying;
MemBuf mb;
- memBufDefInit(&mb);
- memBufPrintf(&mb, "CONNECT %s HTTP/1.0\r\n", sslState->url);
+ mb.init();
+ mb.Printf("CONNECT %s HTTP/1.0\r\n", sslState->url);
httpBuildRequestHeader(sslState->request,
sslState->request,
NULL, /* StoreEntry */
httpHeaderPackInto(&hdr_out, &p);
httpHeaderClean(&hdr_out);
packerClean(&p);
- memBufAppend(&mb, "\r\n", 2);
+ mb.append("\r\n", 2);
comm_old_write_mbuf(sslState->server.fd(), &mb, sslProxyConnectedWriteDone, sslState);
/*
- * $Id: urn.cc,v 1.89 2005/09/17 04:53:45 wessels Exp $
+ * $Id: urn.cc,v 1.90 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 52 URN Parsing
* AUTHOR: Kostas Anagnostakis
qsort(urls, urlcnt, sizeof(*urls), url_entry_sort);
storeBuffer(e);
mb = new MemBuf;
- memBufDefInit(mb);
- memBufPrintf(mb,
- "<TITLE>Select URL for %s</TITLE>\n"
- "<STYLE type=\"text/css\"><!--BODY{background-color:#ffffff;font-family:verdana,sans-serif}--></STYLE>\n"
- "<H2>Select URL for %s</H2>\n"
- "<TABLE BORDER=\"0\" WIDTH=\"100%%\">\n", storeUrl(e), storeUrl(e));
+ mb->init();
+ mb->Printf( "<TITLE>Select URL for %s</TITLE>\n"
+ "<STYLE type=\"text/css\"><!--BODY{background-color:#ffffff;font-family:verdana,sans-serif}--></STYLE>\n"
+ "<H2>Select URL for %s</H2>\n"
+ "<TABLE BORDER=\"0\" WIDTH=\"100%%\">\n", storeUrl(e), storeUrl(e));
for (i = 0; i < urlcnt; i++) {
u = &urls[i];
debug(52, 3) ("URL {%s}\n", u->url);
- memBufPrintf(mb,
-
"<TR><TD><A HREF=\"%s\">%s</A></TD>", u->url, u->url);
+ mb->Printf(
+ "<TR><TD><A HREF=\"%s\">%s</A></TD>", u->url, u->url);
if (urls[i].rtt > 0)
- memBufPrintf(mb,
- "<TD align=\"right\">%4d <it>ms</it></TD>", u->rtt);
+ mb->Printf(
+ "<TD align=\"right\">%4d <it>ms</it></TD>", u->rtt);
else
- memBufPrintf(mb, "<TD align=\"right\">Unknown</TD>");
+ mb->Printf("<TD align=\"right\">Unknown</TD>");
- memBufPrintf(mb,
- "<TD>%s</TD></TR>\n", u->flags.cached ? " [cached]" : " ");
+ mb->Printf(
+ "<TD>%s</TD></TR>\n", u->flags.cached ? " [cached]" : " ");
}
- memBufPrintf(mb,
- "</TABLE>"
- "<HR noshade size=\"1px\">\n"
- "Generated by %s@%s\n"
- "</ADDRESS>\n",
- full_appname_string, getMyHostname());
+ mb->Printf(
+ "</TABLE>"
+ "<HR noshade size=\"1px\">\n"
+ "<ADDRESS>\n"
+ "Generated by %s@%s\n"
+ "</ADDRESS>\n",
+ full_appname_string, getMyHostname());
rep = httpReplyCreate();
httpReplySetHeaders(rep, version, HTTP_MOVED_TEMPORARILY, NULL,
"text/html", mb->contentSize(), 0, squid_curtime);
/*
- * $Id: wais.cc,v 1.153 2005/09/17 04:53:45 wessels Exp $
+ * $Id: wais.cc,v 1.154 2005/09/17 05:50:08 wessels Exp $
*
* DEBUG: section 24 WAIS Relay
* AUTHOR: Harvest Derived
MemBuf mb;
const char *Method = RequestMethodStr[waisState->method];
debug(24, 5) ("waisSendRequest: FD %d\n", fd);
- memBufDefInit(&mb);
- memBufPrintf(&mb, "%s %s HTTP/1.0\r\n", Method, waisState->url);
+ mb.init();
+ mb.Printf("%s %s HTTP/1.0\r\n", Method, waisState->url);
if (waisState->request_hdr) {
Packer p;
packerClean(&p);
}
- memBufPrintf(&mb, "\r\n");
+ mb.Printf("\r\n");
debug(24, 6) ("waisSendRequest: buf: %s\n", mb.buf);
comm_old_write_mbuf(fd, &mb, waisSendComplete, waisState);
projects / thirdparty / squid.git / commitdiff
