ExternalVendorCode/serval-dna
1
0
Fork 0
mirror of https://github.com/servalproject/serval-dna.git synced 2025-02-21 01:42:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Introduce struct __sourceloc

Browse Source 
Replaces (const char *file, unsigned int line, const char *function) arguments
to all logging functions, simplifies malloc/free tracking code in
overlay_buffer.c and Rhizome manifest alloc/free tracking in rhizome_bundle.c.

Use __HERE__ macro instead of (__FILE__, __LINE__, __FUNCTION__) everywhere.

Special __NOWHERE__ macro is equivalent to (NULL, 0, NULL).

Declare net.c functions in new "net.h" header, so log.c doesn't have to pull
in the entire "serval.h" just to use write_str().

Facilitates progress on issue #2.
This commit is contained in:
Andrew Bettison 2012-08-23 12:31:07 +09:30
parent fd3da58a7c
commit 27a0a6eeb5
11 changed files with 169 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile.in
View File

@ -88,6 +88,7 @@ HDRS= fifo.h \
sha2.h \
conf.h \
log.h \
net.h \
xprintf.h \
constants.h \
monitor-client.h \

68
log.c
View File

@ -32,6 +32,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#include <fcntl.h>
#include "log.h"
#include "net.h"
#include "conf.h"
#include "strbuf.h"
#include "strbuf_helpers.h"
@ -128,7 +129,7 @@ static const char *_trimbuildpath(const char *path)
return &path[lastsep];
}
static int _log_prepare(int level, const char *file, unsigned int line, const char *function)
static int _log_prepare(int level, struct __sourceloc where)
{
if (level == LOG_LEVEL_SILENT)
return 0;
@ -161,21 +162,22 @@ static int _log_prepare(int level, const char *file, unsigned int line, const ch
strbuf_sprintf(&logbuf, "%s.%03u ", buf, tv.tv_usec / 1000);
}
}
if (file) {
strbuf_sprintf(&logbuf, "%s", _trimbuildpath(file));
if (line)
strbuf_sprintf(&logbuf, ":%u", line);
if (function)
strbuf_sprintf(&logbuf, ":%s()", function);
if (where.file) {
strbuf_sprintf(&logbuf, "%s", _trimbuildpath(where.file));
if (where.line)
strbuf_sprintf(&logbuf, ":%u", where.line);
if (where.function)
strbuf_sprintf(&logbuf, ":%s()", where.function);
strbuf_putc(&logbuf, ' ');
} else if (function) {
strbuf_sprintf(&logbuf, "%s() ", function);
} else if (where.function) {
strbuf_sprintf(&logbuf, "%s() ", where.function);
}
strbuf_putc(&logbuf, ' ');
return 1;
}
static void _log_internal(int level, struct strbuf *buf){
static void _log_internal(int level, struct strbuf *buf)
{
#ifdef ANDROID
int alevel = ANDROID_LOG_UNKNOWN;
switch (level) {
@ -196,20 +198,22 @@ static void _log_internal(int level, struct strbuf *buf){
#endif
}
void (*_log_implementation)(int level, struct strbuf *buf)=_log_internal;
void (*_log_implementation)(int level, struct strbuf *buf) = _log_internal;
static void _log_finish(int level){
if(_log_implementation)
static void _log_finish(int level)
{
if (_log_implementation)
_log_implementation(level, &logbuf);
}
void set_log_implementation(void (*log_function)(int level, struct strbuf *buf)){
void set_log_implementation(void (*log_function)(int level, struct strbuf *buf))
{
_log_implementation=log_function;
}
void logArgv(int level, const char *file, unsigned int line, const char *function, const char *label, int argc, const char *const *argv)
void logArgv(int level, struct __sourceloc where, const char *label, int argc, const char *const *argv)
{
if (_log_prepare(level, file, line, function)) {
if (_log_prepare(level, where)) {
if (label) {
strbuf_puts(&logbuf, label);
strbuf_putc(&logbuf, ' ');
@ -227,47 +231,47 @@ void logArgv(int level, const char *file, unsigned int line, const char *functio
}
}
void logString(int level, const char *file, unsigned int line, const char *function, const char *str)
void logString(int level, struct __sourceloc where, const char *str)
{
const char *s = str;
const char *p;
for (p = str; *p; ++p) {
if (*p == '\n') {
if (_log_prepare(level, file, line, function)) {
if (_log_prepare(level, where)) {
strbuf_ncat(&logbuf, s, p - s);
_log_finish(level);
}
s = p + 1;
}
}
if (p > s && _log_prepare(level, file, line, function)) {
if (p > s && _log_prepare(level, where)) {
strbuf_ncat(&logbuf, s, p - s);
_log_finish(level);
}
}
void logMessage(int level, const char *file, unsigned int line, const char *function, const char *fmt, ...)
void logMessage(int level, struct __sourceloc where, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vlogMessage(level, file, line, function, fmt, ap);
vlogMessage(level, where, fmt, ap);
va_end(ap);
}
void vlogMessage(int level, const char *file, unsigned int line, const char *function, const char *fmt, va_list ap)
void vlogMessage(int level, struct __sourceloc where, const char *fmt, va_list ap)
{
if (_log_prepare(level, file, line, function)) {
if (_log_prepare(level, where)) {
strbuf_vsprintf(&logbuf, fmt, ap);
_log_finish(level);
}
}
int logDump(int level, const char *file, unsigned int line, const char *function, char *name, unsigned char *addr, size_t len)
int logDump(int level, struct __sourceloc where, char *name, unsigned char *addr, size_t len)
{
char buf[100];
size_t i;
if (name)
logMessage(level, file, line, function, "Dump of %s", name);
logMessage(level, where, "Dump of %s", name);
for(i = 0; i < len; i += 16) {
strbuf b = strbuf_local(buf, sizeof buf);
strbuf_sprintf(b, " %04x :", i);
@ -279,7 +283,7 @@ int logDump(int level, const char *file, unsigned int line, const char *function
strbuf_puts(b, " ");
for (j = 0; j < 16 && i + j < len; j++)
strbuf_sprintf(b, "%c", addr[i+j] >= ' ' && addr[i+j] < 0x7f ? addr[i+j] : '.');
logMessage(level, file, line, function, "%s", strbuf_str(b));
logMessage(level, where, "%s", strbuf_str(b));
}
return 0;
}
@ -393,7 +397,7 @@ ssize_t get_self_executable_path(char *buf, size_t len)
return WHYF("Not implemented");
}
int log_backtrace(const char *file, unsigned int line, const char *function)
int log_backtrace(struct __sourceloc where)
{
open_logging();
char execpath[160];
@ -445,7 +449,7 @@ int log_backtrace(const char *file, unsigned int line, const char *function)
}
// parent
close(stdout_fds[1]);
logMessage(LOG_LEVEL_DEBUG, file, line, function, "GDB BACKTRACE");
logMessage(LOG_LEVEL_DEBUG, where, "GDB BACKTRACE");
char buf[1024];
char *const bufe = buf + sizeof buf;
char *linep = buf;
@ -457,14 +461,14 @@ int log_backtrace(const char *file, unsigned int line, const char *function)
for (; p < readp; ++p)
if (*p == '\n' || *p == '\0') {
*p = '\0';
logMessage(LOG_LEVEL_DEBUG, NULL, 0, NULL, "%s", linep);
logMessage(LOG_LEVEL_DEBUG, __NOWHERE__, "%s", linep);
linep = p + 1;
}
if (readp >= bufe && linep == buf) {
// Line does not fit into buffer.
char t = bufe[-1];
bufe[-1] = '\0';
logMessage(LOG_LEVEL_DEBUG, NULL, 0, NULL, "%s", buf);
logMessage(LOG_LEVEL_DEBUG, __NOWHERE__, "%s", buf);
buf[0] = t;
readp = buf + 1;
} else if (readp + 120 >= bufe && linep != buf) {
@ -480,7 +484,7 @@ int log_backtrace(const char *file, unsigned int line, const char *function)
WHY_perror("read");
if (readp > linep) {
*readp = '\0';
logMessage(LOG_LEVEL_DEBUG, NULL, 0, NULL, "%s", linep);
logMessage(LOG_LEVEL_DEBUG, __NOWHERE__, "%s", linep);
}
close(stdout_fds[0]);
int status = 0;
@ -488,7 +492,7 @@ int log_backtrace(const char *file, unsigned int line, const char *function)
WHY_perror("waitpid");
strbuf b = strbuf_local(buf, sizeof buf);
strbuf_append_exit_status(b, status);
logMessage(LOG_LEVEL_DEBUG, NULL, 0, NULL, "gdb %s", buf);
logMessage(LOG_LEVEL_DEBUG, __NOWHERE__, "gdb %s", buf);
unlink(tempfile);
return 0;
}

36
log.h
View File

@ -63,29 +63,37 @@ extern unsigned int debug;
struct strbuf;
struct __sourceloc {
const char *file;
unsigned int line;
const char *function;
};
void set_logging(FILE *f);
FILE *open_logging();
void close_logging();
void logArgv(int level, const char *file, unsigned int line, const char *function, const char *label, int argc, const char *const *argv);
void logString(int level, const char *file, unsigned int line, const char *function, const char *str);
void logMessage(int level, const char *file, unsigned int line, const char *function, const char *fmt, ...);
void vlogMessage(int level, const char *file, unsigned int line, const char *function, const char *fmt, va_list);
void logArgv(int level, struct __sourceloc where, const char *label, int argc, const char *const *argv);
void logString(int level, struct __sourceloc where, const char *str);
void logMessage(int level, struct __sourceloc where, const char *fmt, ...);
void vlogMessage(int level, struct __sourceloc where, const char *fmt, va_list);
unsigned int debugFlagMask(const char *flagname);
int logDump(int level, const char *file, unsigned int line, const char *function, char *name, unsigned char *addr, size_t len);
int logDump(int level, struct __sourceloc where, char *name, unsigned char *addr, size_t len);
char *toprint(char *dstStr, ssize_t dstBufSiz, const char *srcBuf, size_t srcBytes);
size_t toprint_strlen(const char *srcBuf, size_t srcBytes);
ssize_t get_self_executable_path(char *buf, size_t len);
int log_backtrace(const char *file, unsigned int line, const char *function);
int log_backtrace(struct __sourceloc where);
void set_log_implementation(void (*log_function)(int level, struct strbuf *buf));
#define alloca_toprint(dstlen,buf,len) toprint((char *)alloca((dstlen) == -1 ? toprint_strlen((buf),(len)) + 1 : (dstlen)), (dstlen), (buf), (len))
#define LOGF(L,F,...) (logMessage(L, __FILE__, __LINE__, __FUNCTION__, F, ##__VA_ARGS__))
#define LOGF_perror(L,F,...) logMessage_perror(L, __FILE__, __LINE__, __FUNCTION__, F, ##__VA_ARGS__)
#define __HERE__ ((struct __sourceloc){ .file = __FILE__, .line = __LINE__, .function = __FUNCTION__ })
#define __NOWHERE__ ((struct __sourceloc){ .file = NULL, .line = 0, .function = NULL })
#define LOGF(L,F,...) (logMessage(L, __HERE__, F, ##__VA_ARGS__))
#define LOGF_perror(L,F,...) logMessage_perror(L, __HERE__, F, ##__VA_ARGS__)
#define LOG_perror(L,X) LOGF_perror(L, "%s", (X))
#define logMessage_perror(L,file,line,func,F,...) \
(logMessage(L, file, line, func, F ": %s [errno=%d]", ##__VA_ARGS__, strerror(errno), errno))
#define logMessage_perror(L,where,F,...) (logMessage(L, where, F ": %s [errno=%d]", ##__VA_ARGS__, strerror(errno), errno))
#define FATALF(F,...) do { LOGF(LOG_LEVEL_FATAL, F, ##__VA_ARGS__); exit(-1); } while (1)
#define FATAL(X) FATALF("%s", (X))
@ -102,7 +110,7 @@ void set_log_implementation(void (*log_function)(int level, struct strbuf *buf))
#define WARNF(F,...) LOGF(LOG_LEVEL_WARN, F, ##__VA_ARGS__)
#define WARN(X) WARNF("%s", (X))
#define WARN_perror(X) WARNF("%s: %s [errno=%d]", (X), strerror(errno), errno)
#define WHY_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_ERROR, __FILE__, __LINE__, __FUNCTION__, (X), (ARGC), (ARGV))
#define WHY_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_ERROR, __HERE__, (X), (ARGC), (ARGV))
#define INFOF(F,...) LOGF(LOG_LEVEL_INFO, F, ##__VA_ARGS__)
#define INFO(X) INFOF("%s", (X))
@ -112,10 +120,10 @@ void set_log_implementation(void (*log_function)(int level, struct strbuf *buf))
#define DEBUGF_perror(F,...) DEBUGF(F ": %s [errno=%d]", ##__VA_ARGS__, strerror(errno), errno)
#define DEBUG_perror(X) DEBUGF("%s: %s [errno=%d]", (X), strerror(errno), errno)
#define D DEBUG("D")
#define DEBUG_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_DEBUG, __FILE__, __LINE__, __FUNCTION__, (X), (ARGC), (ARGV))
#define DEBUG_argv(X,ARGC,ARGV) logArgv(LOG_LEVEL_DEBUG, __HERE__, (X), (ARGC), (ARGV))
#define dump(X,A,N) logDump(LOG_LEVEL_DEBUG, __FILE__, __LINE__, __FUNCTION__, (X), (A), (N))
#define dump(X,A,N) logDump(LOG_LEVEL_DEBUG, __HERE__, (X), (A), (N))
#define BACKTRACE log_backtrace(__FILE__, __LINE__, __FUNCTION__)
#define BACKTRACE log_backtrace(__HERE__)
#endif // __SERVALD_LOG_H

45
net.c
View File

@ -17,37 +17,40 @@ along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "serval.h"
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include "net.h"
int _set_nonblock(int fd, const char *file, unsigned int line, const char *function)
int _set_nonblock(int fd, struct __sourceloc where)
{
int flags;
if ((flags = fcntl(fd, F_GETFL, NULL)) == -1) {
logMessage_perror(LOG_LEVEL_ERROR, file, line, function, "set_nonblock: fcntl(%d,F_GETFL,NULL)", fd);
logMessage_perror(LOG_LEVEL_ERROR, where, "set_nonblock: fcntl(%d,F_GETFL,NULL)", fd);
return -1;
}
if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) {
logMessage_perror(LOG_LEVEL_ERROR, file, line, function, "set_nonblock: fcntl(%d,F_SETFL,0x%x|O_NONBLOCK)", fd, flags);
logMessage_perror(LOG_LEVEL_ERROR, where, "set_nonblock: fcntl(%d,F_SETFL,0x%x|O_NONBLOCK)", fd, flags);
return -1;
}
return 0;
}
int _set_block(int fd, const char *file, unsigned int line, const char *function)
int _set_block(int fd, struct __sourceloc where)
{
int flags;
if ((flags = fcntl(fd, F_GETFL, NULL)) == -1) {
logMessage_perror(LOG_LEVEL_ERROR, file, line, function, "set_block: fcntl(%d,F_GETFL,NULL)", fd);
logMessage_perror(LOG_LEVEL_ERROR, where, "set_block: fcntl(%d,F_GETFL,NULL)", fd);
return -1;
}
if (fcntl(fd, F_SETFL, flags & ~O_NONBLOCK) == -1) {
logMessage_perror(LOG_LEVEL_ERROR, file, line, function, "set_block: fcntl(%d,F_SETFL,0x%x&~O_NONBLOCK)", fd, flags);
logMessage_perror(LOG_LEVEL_ERROR, where, "set_block: fcntl(%d,F_SETFL,0x%x&~O_NONBLOCK)", fd, flags);
return -1;
}
return 0;
}
ssize_t _read_nonblock(int fd, void *buf, size_t len, const char *file, unsigned int line, const char *function)
ssize_t _read_nonblock(int fd, void *buf, size_t len, struct __sourceloc where)
{
ssize_t nread = read(fd, buf, len);
if (nread == -1) {
@ -59,30 +62,30 @@ ssize_t _read_nonblock(int fd, void *buf, size_t len, const char *file, unsigned
#endif
return 0;
}
logMessage_perror(LOG_LEVEL_ERROR, file, line, function, "read_nonblock: read(%d,%p,%lu)",
logMessage_perror(LOG_LEVEL_ERROR, where, "read_nonblock: read(%d,%p,%lu)",
fd, buf, (unsigned long)len);
return -1;
}
return nread;
}
ssize_t _write_all(int fd, const void *buf, size_t len, const char *file, unsigned int line, const char *function)
ssize_t _write_all(int fd, const void *buf, size_t len, struct __sourceloc where)
{
ssize_t written = write(fd, buf, len);
if (written == -1) {
logMessage_perror(LOG_LEVEL_ERROR, file, line, function, "write_all: write(%d,%p %s,%lu)",
logMessage_perror(LOG_LEVEL_ERROR, where, "write_all: write(%d,%p %s,%lu)",
fd, buf, alloca_toprint(30, buf, len), (unsigned long)len);
return -1;
}
if (written != len) {
logMessage(LOG_LEVEL_ERROR, file, line, function, "write_all: write(%d,%p %s,%lu) returned %ld",
logMessage(LOG_LEVEL_ERROR, where, "write_all: write(%d,%p %s,%lu) returned %ld",
fd, buf, alloca_toprint(30, buf, len), (unsigned long)len, (long)written);
return -1;
}
return written;
}
ssize_t _write_nonblock(int fd, const void *buf, size_t len, const char *file, unsigned int line, const char *function)
ssize_t _write_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where)
{
ssize_t written = write(fd, buf, len);
if (written == -1) {
@ -94,30 +97,30 @@ ssize_t _write_nonblock(int fd, const void *buf, size_t len, const char *file, u
#endif
return 0;
}
logMessage_perror(LOG_LEVEL_ERROR, file, line, function, "write_nonblock: write(%d,%p %s,%lu)",
logMessage_perror(LOG_LEVEL_ERROR, where, "write_nonblock: write(%d,%p %s,%lu)",
fd, buf, alloca_toprint(30, buf, len), (unsigned long)len);
return -1;
}
return written;
}
ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, const char *file, unsigned int line, const char *function)
ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where)
{
ssize_t written = _write_nonblock(fd, buf, len, file, line, function);
ssize_t written = _write_nonblock(fd, buf, len, where);
if (written != -1 && written != len) {
logMessage(LOG_LEVEL_ERROR, file, line, function, "write_all_nonblock: write(%d,%p %s,%lu) returned %ld",
logMessage(LOG_LEVEL_ERROR, where, "write_all_nonblock: write(%d,%p %s,%lu) returned %ld",
fd, buf, alloca_toprint(30, buf, len), (unsigned long)len, (long)written);
return -1;
}
return written;
}
ssize_t _write_str(int fd, const char *str, const char *file, unsigned int line, const char *function)
ssize_t _write_str(int fd, const char *str, struct __sourceloc where)
{
return _write_all(fd, str, strlen(str), file, line, function);
return _write_all(fd, str, strlen(str), where);
}
ssize_t _write_str_nonblock(int fd, const char *str, const char *file, unsigned int line, const char *function)
ssize_t _write_str_nonblock(int fd, const char *str, struct __sourceloc where)
{
return _write_all_nonblock(fd, str, strlen(str), file, line, function);
return _write_all_nonblock(fd, str, strlen(str), where);
}

43
net.h Normal file
View File

@ -0,0 +1,43 @@
/*
Copyright (C) 2012 Serval Project Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __SERVALD_NET_H
#define __SERVALD_NET_H
#include <sys/types.h> // for size_t, ssize_t
#include "log.h" // for __HERE__ and struct __sourceloc
#define set_nonblock(fd) (_set_nonblock(fd, __HERE__))
#define set_block(fd) (_set_block(fd, __HERE__))
#define read_nonblock(fd,buf,len) (_read_nonblock(fd, buf, len, __HERE__))
#define write_all(fd,buf,len) (_write_all(fd, buf, len, __HERE__))
#define write_nonblock(fd,buf,len) (_write_nonblock(fd, buf, len, __HERE__))
#define write_all_nonblock(fd,buf,len) (_write_all_nonblock(fd, buf, len, __HERE__))
#define write_str(fd,str) (_write_str(fd, str, __HERE__))
#define write_str_nonblock(fd,str) (_write_str_nonblock(fd, str, __HERE__))
int _set_nonblock(int fd, struct __sourceloc where);
int _set_block(int fd, struct __sourceloc where);
ssize_t _read_nonblock(int fd, void *buf, size_t len, struct __sourceloc where);
ssize_t _write_all(int fd, const void *buf, size_t len, struct __sourceloc where);
ssize_t _write_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where);
ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, struct __sourceloc where);
ssize_t _write_str(int fd, const char *str, struct __sourceloc where);
ssize_t _write_str_nonblock(int fd, const char *str, struct __sourceloc where);
#endif // __SERVALD_NET_H

12
overlay_buffer.c
View File

@ -377,22 +377,22 @@ int ob_dump(overlay_buffer *b,char *desc)
#undef realloc
#define SDM_GUARD_AFTER 16384
void *_serval_debug_malloc(unsigned int bytes,char *file,const char *func,int line)
void *_serval_debug_malloc(unsigned int bytes, struct __sourceloc where)
{
void *r=malloc(bytes+SDM_GUARD_AFTER);
logMessage(LOG_LEVEL_DEBUG, file, line, func, "malloc(%d) -> %p", bytes, r);
logMessage(LOG_LEVEL_DEBUG, where, "malloc(%d) -> %p", bytes, r);
return r;
}
void *_serval_debug_calloc(unsigned int bytes,unsigned int count,char *file,const char *func,int line)
void *_serval_debug_calloc(unsigned int bytes, unsigned int count, struct __sourceloc where)
{
void *r=calloc((bytes*count)+SDM_GUARD_AFTER,1);
logMessage(LOG_LEVEL_DEBUG, file, line, func, "calloc(%d,%d) -> %p", bytes, count, r);
logMessage(LOG_LEVEL_DEBUG, where, "calloc(%d,%d) -> %p", bytes, count, r);
return r;
}
void _serval_debug_free(void *p,char *file,const char *func,int line)
void _serval_debug_free(void *p, struct __sourceloc where)
{
free(p);
logMessage(LOG_LEVEL_DEBUG, file, line, func, "free(%p)", p);
logMessage(LOG_LEVEL_DEBUG, where, "free(%p)", p);
}

4
overlay_interface.c
View File

@ -1155,7 +1155,7 @@ long long parse_quantity(char *q)
}
}
void logServalPacket(int level, const char *file, unsigned int line, const char *function, const char *message, const unsigned char *packet, size_t len)
void logServalPacket(int level, struct __sourceloc where, const char *message, const unsigned char *packet, size_t len)
{
struct mallocbuf mb = STRUCT_MALLOCBUF_NULL;
if (serval_packetvisualise(XPRINTF_MALLOCBUF(&mb), message, packet, len) == -1)
@ -1163,7 +1163,7 @@ void logServalPacket(int level, const char *file, unsigned int line, const char
else if (mb.buffer == NULL)
WHYF("serval_packetvisualise() output buffer missing, message=%s packet=%p len=%lu", alloca_toprint(-1, message, strlen(message)), packet, len);
else
logString(level, file, line, function, mb.buffer);
logString(level, where, mb.buffer);
if (mb.buffer)
free(mb.buffer);
}

9
rhizome.h
View File

@ -179,11 +179,10 @@ int rhizome_manifest_set_ll(rhizome_manifest *m,char *var,long long value);
int rhizome_manifest_set(rhizome_manifest *m, const char *var, const char *value);
int rhizome_manifest_del(rhizome_manifest *m, const char *var);
long long rhizome_file_size(char *filename);
void _rhizome_manifest_free(const char *sourcefile,const char *funcname,int line,
rhizome_manifest *m);
#define rhizome_manifest_free(m) _rhizome_manifest_free(__FILE__,__FUNCTION__,__LINE__,m)
rhizome_manifest *_rhizome_new_manifest(const char *file,const char *func,int line);
#define rhizome_new_manifest() _rhizome_new_manifest(__FILE__,__FUNCTION__,__LINE__)
void _rhizome_manifest_free(struct __sourceloc where, rhizome_manifest *m);
#define rhizome_manifest_free(m) _rhizome_manifest_free(__HERE__,m)
rhizome_manifest *_rhizome_new_manifest(struct __sourceloc where);
#define rhizome_new_manifest() _rhizome_new_manifest(__HERE__)
int rhizome_manifest_pack_variables(rhizome_manifest *m);
int rhizome_store_bundle(rhizome_manifest *m);
int rhizome_manifest_add_group(rhizome_manifest *m,char *groupid);

59
rhizome_bundle.c
View File

@ -429,35 +429,27 @@ int rhizome_manifest_set_ll(rhizome_manifest *m,char *var,long long value)
rhizome_manifest manifests[MAX_RHIZOME_MANIFESTS];
char manifest_free[MAX_RHIZOME_MANIFESTS];
int manifest_first_free=-1;
const char *manifest_alloc_sourcefiles[MAX_RHIZOME_MANIFESTS];
const char *manifest_alloc_functions[MAX_RHIZOME_MANIFESTS];
int manifest_alloc_lines[MAX_RHIZOME_MANIFESTS];
const char *manifest_free_sourcefiles[MAX_RHIZOME_MANIFESTS];
const char *manifest_free_functions[MAX_RHIZOME_MANIFESTS];
int manifest_free_lines[MAX_RHIZOME_MANIFESTS];
struct __sourceloc manifest_alloc_where[MAX_RHIZOME_MANIFESTS];
struct __sourceloc manifest_free_where[MAX_RHIZOME_MANIFESTS];
static void _log_manifest_trace(const char *filename, const char *funcname, int line, const char *operation)
static void _log_manifest_trace(struct __sourceloc where, const char *operation)
{
int count_free = 0;
int i;
for (i = 0; i != MAX_RHIZOME_MANIFESTS; ++i)
if (manifest_free[i])
++count_free;
logMessage(LOG_LEVEL_DEBUG, filename, line, funcname, "%s(): count_free = %d", operation, count_free);
logMessage(LOG_LEVEL_DEBUG, where, "%s(): count_free = %d", operation, count_free);
}
rhizome_manifest *_rhizome_new_manifest(const char *filename, const char *funcname, int line)
rhizome_manifest *_rhizome_new_manifest(struct __sourceloc where)
{
if (manifest_first_free<0) {
/* Setup structures */
int i;
for(i=0;i<MAX_RHIZOME_MANIFESTS;i++) {
manifest_alloc_sourcefiles[i]="<never allocated>";
manifest_alloc_functions[i]="<never allocated>";
manifest_alloc_lines[i]=-1;
manifest_free_sourcefiles[i]="<never freed>";
manifest_free_functions[i]="<never freed>";
manifest_free_lines[i]=-1;
manifest_alloc_where[i]=__NOWHERE__;
manifest_free_where[i]=__NOWHERE__;
manifest_free[i]=1;
}
manifest_first_free=0;
@ -467,14 +459,14 @@ rhizome_manifest *_rhizome_new_manifest(const char *filename, const char *funcna
if (manifest_first_free>=MAX_RHIZOME_MANIFESTS)
{
int i;
logMessage(LOG_LEVEL_ERROR, filename, line, funcname, "%s(): no free manifest records, this probably indicates a memory leak", __FUNCTION__);
logMessage(LOG_LEVEL_ERROR, where, "%s(): no free manifest records, this probably indicates a memory leak", __FUNCTION__);
WHYF(" Slot# | Last allocated by");
for(i=0;i<MAX_RHIZOME_MANIFESTS;i++) {
WHYF(" %-5d | %s:%d in %s()",
i,
manifest_alloc_sourcefiles[i],
manifest_alloc_lines[i],
manifest_alloc_functions[i]
manifest_alloc_where[i].file,
manifest_alloc_where[i].line,
manifest_alloc_where[i].function
);
}
return NULL;
@ -486,32 +478,27 @@ rhizome_manifest *_rhizome_new_manifest(const char *filename, const char *funcna
/* Indicate where manifest was allocated, and that it is no longer
free. */
manifest_alloc_sourcefiles[manifest_first_free]=filename;
manifest_alloc_lines[manifest_first_free]=line;
manifest_alloc_functions[manifest_first_free]=funcname;
manifest_alloc_where[manifest_first_free]=where;
manifest_free[manifest_first_free]=0;
manifest_free_sourcefiles[manifest_first_free]="<not freed>";
manifest_free_functions[manifest_first_free]="<not freed>";
manifest_free_lines[manifest_first_free]=-1;
manifest_free_where[manifest_first_free]=__NOWHERE__;
/* Work out where next free manifest record lives */
for (; manifest_first_free < MAX_RHIZOME_MANIFESTS && !manifest_free[manifest_first_free]; ++manifest_first_free)
;
if (debug & DEBUG_MANIFESTS) _log_manifest_trace(filename, funcname, line, __FUNCTION__);
if (debug & DEBUG_MANIFESTS) _log_manifest_trace(where, __FUNCTION__);
return m;
}
void _rhizome_manifest_free(const char *sourcefile,const char *funcname,int line,
rhizome_manifest *m)
void _rhizome_manifest_free(struct __sourceloc where, rhizome_manifest *m)
{
if (!m) return;
int i;
int mid=m->manifest_record_number;
if (m!=&manifests[mid]) {
logMessage(LOG_LEVEL_ERROR, sourcefile, line, funcname,
logMessage(LOG_LEVEL_ERROR, where,
"%s(): asked to free manifest %p, which claims to be manifest slot #%d (%p), but isn't",
__FUNCTION__, m, mid, &manifests[mid]
);
@ -519,12 +506,12 @@ void _rhizome_manifest_free(const char *sourcefile,const char *funcname,int line
}
if (manifest_free[mid]) {
logMessage(LOG_LEVEL_ERROR, sourcefile, line, funcname,
logMessage(LOG_LEVEL_ERROR, where,
"%s(): asked to free manifest slot #%d (%p), which was already freed at %s:%d:%s()",
__FUNCTION__, mid, m,
manifest_free_sourcefiles[mid],
manifest_free_lines[mid],
manifest_free_functions[mid]
manifest_free_where[mid].file,
manifest_free_where[mid].line,
manifest_free_where[mid].function
);
exit(-1);
}
@ -543,12 +530,10 @@ void _rhizome_manifest_free(const char *sourcefile,const char *funcname,int line
m->dataFileName=NULL;
manifest_free[mid]=1;
manifest_free_sourcefiles[mid]=sourcefile;
manifest_free_functions[mid]=funcname;
manifest_free_lines[mid]=line;
manifest_free_where[mid]=where;
if (mid<manifest_first_free) manifest_first_free=mid;
if (debug & DEBUG_MANIFESTS) _log_manifest_trace(sourcefile, funcname, line, __FUNCTION__);
if (debug & DEBUG_MANIFESTS) _log_manifest_trace(where, __FUNCTION__);
return;
}

35
serval.h
View File

@ -111,6 +111,7 @@ struct in_addr {
#include "constants.h"
#include "xprintf.h"
#include "log.h"
#include "net.h"
#include "conf.h"
/* All wall clock times in the Serval daemon are represented in milliseconds
@ -681,9 +682,9 @@ int overlay_interface_init_socket(int i);
time_ms_t overlay_time_until_next_tick();
int overlay_rx_messages();
void logServalPacket(int level, const char *file, unsigned int line, const char *function, const char *message, const unsigned char *packet, size_t len);
void logServalPacket(int level, struct __sourceloc where, const char *message, const unsigned char *packet, size_t len);
#define DEBUG_packet_visualise(M,P,N) logServalPacket(LOG_LEVEL_DEBUG, __FILE__, __LINE__, __FUNCTION__, (M), (P), (N))
#define DEBUG_packet_visualise(M,P,N) logServalPacket(LOG_LEVEL_DEBUG, __HERE__, (M), (P), (N))
int overlay_add_selfannouncement();
int overlay_frame_package_fmt1(overlay_frame *p,overlay_buffer *b);
@ -1000,13 +1001,13 @@ int dump_payload(overlay_frame *p,char *message);
int urandombytes(unsigned char *x,unsigned long long xlen);
#ifdef MALLOC_PARANOIA
#define malloc(X) _serval_debug_malloc(X,__FILE__,__FUNCTION__,__LINE__)
#define calloc(X,Y) _serval_debug_calloc(X,Y,__FILE__,__FUNCTION__,__LINE__)
#define free(X) _serval_debug_free(X,__FILE__,__FUNCTION__,__LINE__)
#define malloc(X) _serval_debug_malloc(X,__HERE__)
#define calloc(X,Y) _serval_debug_calloc(X,Y,__HERE__)
#define free(X) _serval_debug_free(X,__HERE__)
void *_serval_debug_malloc(unsigned int bytes,char *file,const char *func,int line);
void *_serval_debug_calloc(unsigned int bytes,unsigned int count,char *file,const char *func,int line);
void _serval_debug_free(void *p,char *file,const char *func,int line);
void *_serval_debug_malloc(unsigned int bytes, struct __sourceloc where);
void *_serval_debug_calloc(unsigned int bytes, unsigned int count, struct __sourceloc where);
void _serval_debug_free(void *p, struct __sourceloc where);
#endif
@ -1118,24 +1119,6 @@ extern int sigIoFlag;
void sigPipeHandler(int signal);
void sigIoHandler(int signal);
#define set_nonblock(fd) (_set_nonblock(fd, __FILE__, __LINE__, __FUNCTION__))
#define set_block(fd) (_set_block(fd, __FILE__, __LINE__, __FUNCTION__))
#define read_nonblock(fd,buf,len) (_read_nonblock(fd, buf, len, __FILE__, __LINE__, __FUNCTION__))
#define write_all(fd,buf,len) (_write_all(fd, buf, len, __FILE__, __LINE__, __FUNCTION__))
#define write_nonblock(fd,buf,len) (_write_nonblock(fd, buf, len, __FILE__, __LINE__, __FUNCTION__))
#define write_all_nonblock(fd,buf,len) (_write_all_nonblock(fd, buf, len, __FILE__, __LINE__, __FUNCTION__))
#define write_str(fd,str) (_write_str(fd, str, __FILE__, __LINE__, __FUNCTION__))
#define write_str_nonblock(fd,str) (_write_str_nonblock(fd, str, __FILE__, __LINE__, __FUNCTION__))
int _set_nonblock(int fd, const char *file, unsigned int line, const char *function);
int _set_block(int fd, const char *file, unsigned int line, const char *function);
ssize_t _read_nonblock(int fd, void *buf, size_t len, const char *file, unsigned int line, const char *function);
ssize_t _write_all(int fd, const void *buf, size_t len, const char *file, unsigned int line, const char *function);
ssize_t _write_nonblock(int fd, const void *buf, size_t len, const char *file, unsigned int line, const char *function);
ssize_t _write_all_nonblock(int fd, const void *buf, size_t len, const char *file, unsigned int line, const char *function);
ssize_t _write_str(int fd, const char *str, const char *file, unsigned int line, const char *function);
ssize_t _write_str_nonblock(int fd, const char *str, const char *file, unsigned int line, const char *function);
int rhizome_http_server_start();
int overlay_mdp_setup_sockets();

5
strbuf.h
View File

@ -443,9 +443,4 @@ __STRBUF_INLINE int strbuf_overrun(const_strbuf sb) {
return sb->end && sb->current > sb->end;
}
#define write_str(fd,str) (_write_str(fd, str, __FILE__, __LINE__, __FUNCTION__))
ssize_t _write_str(int fd, const char *str, const char *file, unsigned int line, const char *function);
ssize_t _write_str_nonblock(int fd, const char *str, const char *file, unsigned int line, const char *function);
#endif // __STRBUF_H__