========================================================
1.35 Items to do for release:
+- Find memory leaks in address_conf.c
+- Network order of port and ip addresses.
+- SetIP in dird/fd_cmds.c is broken.
+- don't use inet_addr() it is deprecated.
+- Fix code in filed.c for init_bsock();
+- Fix code in console.c for init_bsock();
+
+
- Knoppix CDROM
- Make Verify jobs require exclusive use of Volume as Restore
jobs do.
- Fix restore ++++ that get intermingled with "Building directory tree"
- Solve the termcap.h problem on Solaris configure.
+
- Test Win32 errno handling.
- Add bscan to four-concurrent-jobs regression.
- Doc new IPv6 syntax
bool ok;
BSOCK *ua = uac->UA_sock;
+// Emsg4(M_INFO, 0, _("UA Hello from %s:%s:%d is invalid. Len=%d\n"), ua->who,
+// ua->host, ua->port, ua->msglen);
if (ua->msglen < 16 || ua->msglen >= MAX_NAME_LENGTH + 15) {
Emsg4(M_ERROR, 0, _("UA Hello from %s:%s:%d is invalid. Len=%d\n"), ua->who,
ua->host, ua->port, ua->msglen);
ua->host, ua->port, ua->msg);
return 0;
}
-// Dmsg2(000, "Console=%s addr=%s\n", name, inet_ntoa(ua->client_addr.sin_addr));
name[sizeof(name)-1] = 0; /* terminate name */
if (strcmp(name, "*UserAgent*") == 0) { /* default console */
ok = cram_md5_auth(ua, director->password, ssl_need) &&
get_level_since_time(jcr, since, sizeof(since));
- jcr->fname = (char *) get_pool_memory(PM_FNAME);
+ jcr->fname = (char *)get_pool_memory(PM_FNAME);
/*
* Get the Pool record -- first apply any level defined pools
Backup Level: %s%s\n\
Client: %s\n\
FileSet: \"%s\" %s\n\
+Pool: \"%s\"\n\
Start time: %s\n\
End time: %s\n\
FD Files Written: %s\n\
level_to_str(jcr->JobLevel), since,
jcr->client->hdr.name,
jcr->fileset->hdr.name, fsr->cCreateTime,
+ jcr->pool->hdr.name,
sdt,
edt,
edit_uint64_with_commas(jcr->jr.JobFiles, ec1),
void backup_cleanup(void);
void start_UA_server(dlist *addrs);
void init_job_server(int max_workers);
+void term_job_server();
void store_jobtype(LEX *lc, RES_ITEM *item, int index, int pass);
void store_level(LEX *lc, RES_ITEM *item, int index, int pass);
void store_replace(LEX *lc, RES_ITEM *item, int index, int pass);
delete_pid_file(director->pid_directory, "bacula-dir", get_first_port(director->DIRaddrs));
// signal(SIGCHLD, SIG_IGN); /* don't worry about children now */
term_scheduler();
+ term_job_server();
if (runjob) {
free(runjob);
}
token = lex_get_token(lc, T_NAME);
if (pass == 1) {
if (((alist **)item->value)[item->code] == NULL) {
- ((alist **)item->value)[item->code] = new alist(10, owned_by_alist);
+ ((alist **)item->value)[item->code] = new alist(10, owned_by_alist);
// Dmsg1(900, "Defined new ACL alist at %d\n", item->code);
}
((alist **)item->value)[item->code]->append(bstrdup(lc->str));
register_watchdog(wd);
}
+void term_job_server()
+{
+ int stat;
+ if ((stat=jobq_destroy(&job_queue)) != 0) {
+ berrno be;
+ be.set_errno(stat);
+ Emsg1(M_INFO, 0, _("Could not term job queue: ERR=%s\n"), be.strerror());
+ }
+}
+
/*
* Run a job -- typically called by the scheduler, but may also
* be called by the UA (Console program).
jq->engine = engine; /* routine to run */
jq->valid = JOBQ_VALID;
/* Initialize the job queues */
- jq->waiting_jobs = new dlist(item, &item->link);
- jq->running_jobs = new dlist(item, &item->link);
- jq->ready_jobs = new dlist(item, &item->link);
+ jq->waiting_jobs = New(dlist(item, &item->link));
+ jq->running_jobs = New(dlist(item, &item->link));
+ jq->ready_jobs = New(dlist(item, &item->link));
return 0;
}
}
jq->running_jobs->append(je);
Dmsg1(300, "Took jobid=%d from ready and appended to run\n", jcr->JobId);
+
+ /* Release job queue lock */
if ((stat = pthread_mutex_unlock(&jq->mutex)) != 0) {
Jmsg1(NULL, M_ERROR, 0, "pthread_mutex_unlock: ERR=%s\n", strerror(stat));
jq->num_workers--;
jq->engine(je->jcr);
Dmsg1(300, "Back from user engine jobid=%d.\n", jcr->JobId);
+
+ /* Reacquire job queue lock */
if ((stat = pthread_mutex_lock(&jq->mutex)) != 0) {
Jmsg1(NULL, M_ERROR, 0, "pthread_mutex_lock: ERR=%s\n", strerror(stat));
jq->num_workers--;
jcr->job->NumConcurrentJobs--;
}
+ /*
+ * Reschedule the job if necessary and requested
+ */
if (jcr->job->RescheduleOnError &&
jcr->JobStatus != JS_Terminated &&
jcr->JobStatus != JS_Canceled &&
jcr->db = NULL;
}
Dmsg1(300, "====== Termination job=%d\n", jcr->JobId);
+ V(jq->mutex); /* release internal lock */
free_jcr(jcr);
free(je); /* release job entry */
+ P(jq->mutex); /* reacquire job queue lock */
}
/*
* If any job in the wait queue can be run,
if (first) {
first = false;
/* Create scheduled jobs list */
- jobs_to_run = new dlist(next_job, &next_job->link);
+ jobs_to_run = New(dlist(next_job, &next_job->link));
if (one_shot_job_to_run) { /* one shot */
job = (JOB *)GetResWithName(R_JOB, one_shot_job_to_run);
if (!job) {
ASSERT(job);
set_jcr_defaults(jcr, job);
if (run->level) {
- jcr->JobLevel = run->level; /* override run level */
+ jcr->JobLevel = run->level; /* override run level */
}
if (run->pool) {
jcr->pool = run->pool; /* override pool */
}
- if (run->full_pool) {
- jcr->pool = run->full_pool; /* override full pool */
- }
- if (run->inc_pool) {
- jcr->pool = run->inc_pool; /* override inc pool */
- }
- if (run->dif_pool) {
- jcr->pool = run->dif_pool; /* override dif pool */
- }
if (run->storage) {
jcr->store = run->storage; /* override storage */
}
#include "bacula.h"
+static int add_address(dlist **out, IPADDR::i_type type, unsigned short defaultport, int family,
+ const char *hostname_str, const char *port_str, char **errstr);
+
+
IPADDR::IPADDR(const IPADDR &src) : type(src.type)
{
memcpy(&buf, &src.buf, sizeof(buf));
int IPADDR::get_family() const
{
return saddr->sa_family;
-}
+}
struct sockaddr *IPADDR::get_sockaddr()
{
outputbuf[0] = '\0';
#if defined(HAVE_INET_NTOP) && defined(HAVE_IPV6)
inet_ntop(saddr->sa_family, saddr->sa_family == AF_INET ?
- (void*)&(saddr4->sin_addr) : (void*)&(saddr6->sin6_addr),
- outputbuf, outlen);
+ (void*)&(saddr4->sin_addr) : (void*)&(saddr6->sin6_addr),
+ outputbuf, outlen);
#else
bstrncpy(outputbuf, inet_ntoa(saddr4->sin_addr), outlen);
#endif
const char *IPADDR::build_address_str(char *buf, int blen)
{
char tmp[1024];
- snprintf(buf, blen, "host[%s:%s:%hu] ",
+ bsnprintf(buf, blen, "host[%s:%s:%hu] ",
get_family() == AF_INET ? "ipv4" : "ipv6",
- get_address(tmp, sizeof(tmp) - 1), ntohs(get_port()));
+ get_address(tmp, sizeof(tmp) - 1), ntohs(get_port()));
return buf;
}
IPADDR *p;
foreach_dlist(p, addrs) {
char tmp[1024];
- int len = snprintf(work, blen, "%s", p->build_address_str(tmp, sizeof(tmp)));
+ int len = bsnprintf(work, blen, "%s", p->build_address_str(tmp, sizeof(tmp)));
if (len < 0)
- break;
+ break;
work += len;
blen -= len;
}
int get_first_port(dlist * addrs)
{
- return ((IPADDR *)(addrs->first()))->get_port();
+ return ntohs(((IPADDR *)(addrs->first()))->get_port());
}
static int skip_to_next_not_eol(LEX * lc)
}
-void init_default_addresses(dlist ** out, int port)
+void init_default_addresses(dlist **out, int port)
{
char *errstr;
unsigned short sport = port;
}
}
-int add_address(dlist ** out, IPADDR::i_type type, unsigned short defaultport, int family,
- const char *hostname_str, const char *port_str, char **errstr)
+static int add_address(dlist **out, IPADDR::i_type type, unsigned short defaultport, int family,
+ const char *hostname_str, const char *port_str, char **errstr)
{
IPADDR *iaddr;
IPADDR *jaddr;
unsigned short port;
IPADDR::i_type intype = type;
- dlist *addrs = (dlist *) (*(out));
+ dlist *addrs = (dlist *)(*(out));
if (!addrs) {
IPADDR *tmp = 0;
- addrs = *out = new dlist(tmp, &tmp->link);
+ addrs = *out = New(dlist(tmp, &tmp->link));
}
type = (type == IPADDR::R_SINGLE_PORT
- || type == IPADDR::R_SINGLE_ADDR) ? IPADDR::R_SINGLE : type;
+ || type == IPADDR::R_SINGLE_ADDR) ? IPADDR::R_SINGLE : type;
if (type != IPADDR::R_DEFAULT) {
IPADDR *def = 0;
foreach_dlist(iaddr, addrs) {
- if (iaddr->get_type() == IPADDR::R_DEFAULT) {
- def = iaddr;
- } else if (iaddr->get_type() != type) {
- *errstr = (char *)malloc(1024);
- bsnprintf(*errstr, 1023,
+ if (iaddr->get_type() == IPADDR::R_DEFAULT) {
+ def = iaddr;
+ } else if (iaddr->get_type() != type) {
+ *errstr = (char *)malloc(1024);
+ bsnprintf(*errstr, 1023,
"the old style addresses could mixed with new style");
- return 0;
- }
+ return 0;
+ }
}
if (def) {
- addrs->remove(def);
- delete def;
+ addrs->remove(def);
+ delete def;
}
}
} else {
int pnum = atol(port_str);
if (0 < pnum && pnum < 0xffff) {
- port = htons(pnum);
+ port = htons(pnum);
} else {
struct servent *s = getservbyname(port_str, "tcp");
- if (s) {
- port = s->s_port;
- } else {
- *errstr = (char *)malloc(1024);
+ if (s) {
+ port = s->s_port;
+ } else {
+ *errstr = (char *)malloc(1024);
bsnprintf(*errstr, 1023, "can't resolve service(%s)", port_str);
- return 0;
- }
+ return 0;
+ }
}
}
if (!hostaddrs) {
*errstr = (char *)malloc(1024);
bsnprintf(*errstr, 1023, "can't resolve hostname(%s) %s", hostname_str,
- myerrstr);
+ myerrstr);
return 0;
}
if (intype == IPADDR::R_SINGLE_PORT || intype == IPADDR::R_SINGLE_ADDR) {
IPADDR *addr;
if (addrs->size()) {
- addr = (IPADDR *) addrs->first();
+ addr = (IPADDR *)addrs->first();
} else {
- addr = new IPADDR(family);
- addr->set_type(type);
- addr->set_port(defaultport);
- addr->set_addr_any();
- addrs->append(addr);
+ addr = new IPADDR(family);
+ addr->set_type(type);
+ addr->set_port(defaultport);
+ addr->set_addr_any();
+ addrs->append(addr);
}
if (intype == IPADDR::R_SINGLE_PORT) {
- addr->set_port(port);
+ addr->set_port(port);
}
if (intype == IPADDR::R_SINGLE_ADDR) {
- addr->copy_addr((IPADDR *) (hostaddrs->first()));
+ addr->copy_addr((IPADDR *) (hostaddrs->first()));
}
} else {
foreach_dlist(iaddr, hostaddrs) {
- IPADDR *clone;
- /* for duplicates */
- foreach_dlist(jaddr, addrs) {
- if (iaddr->get_sockaddr_len() == jaddr->get_sockaddr_len() &&
- !memcmp(iaddr->get_sockaddr(), jaddr->get_sockaddr(),
- iaddr->get_sockaddr_len()))
- {
- goto skip; /* no price */
- }
- }
- clone = new IPADDR(*iaddr);
- clone->set_type(type);
- clone->set_port(port);
- addrs->append(clone);
+ IPADDR *clone;
+ /* for duplicates */
+ foreach_dlist(jaddr, addrs) {
+ if (iaddr->get_sockaddr_len() == jaddr->get_sockaddr_len() &&
+ !memcmp(iaddr->get_sockaddr(), jaddr->get_sockaddr(),
+ iaddr->get_sockaddr_len()))
+ {
+ goto skip; /* no price */
+ }
+ }
+ clone = new IPADDR(*iaddr);
+ clone->set_type(type);
+ clone->set_port(port);
+ addrs->append(clone);
skip:
- continue;
+ continue;
}
}
free_addresses(hostaddrs);
/*
* = { [[ip|ipv4|ipv6] = { [[addr|port] = [^ ]+[\n;]+] }]+ }
- * or my tests
- * positiv
- * = { ip = { addr = 1.2.3.4; port = 1205; } ipv4 = { addr = 1.2.3.4; port = http; } }
- * = { ip = {
- * addr = 1.2.3.4; port = 1205; }
- * ipv4 = {
- * addr = 1.2.3.4; port = http; }
- * ipv6 = {
- * addr = 1.2.3.4;
- * port = 1205;
- * }
- * ip = {
- * addr = 1.2.3.4
- * port = 1205
- * }
- * ip = {
- * addr = 1.2.3.4
- * }
- * ip = {
- * addr = 2001:220:222::2
- * }
- * ip = {
- * addr = bluedot.thun.net
- ( }
- * }
- * negativ
- * = { ip = { } }
- * = { ipv4 { addr = doof.nowaytoheavenxyz.uhu; } }
- * = { ipv4 { port = 4711 } }
+ * or my tests
+ * positiv
+ * = { ip = { addr = 1.2.3.4; port = 1205; } ipv4 = { addr = 1.2.3.4; port = http; } }
+ * = { ip = {
+ * addr = 1.2.3.4; port = 1205; }
+ * ipv4 = {
+ * addr = 1.2.3.4; port = http; }
+ * ipv6 = {
+ * addr = 1.2.3.4;
+ * port = 1205;
+ * }
+ * ip = {
+ * addr = 1.2.3.4
+ * port = 1205
+ * }
+ * ip = {
+ * addr = 1.2.3.4
+ * }
+ * ip = {
+ * addr = 2001:220:222::2
+ * }
+ * ip = {
+ * addr = bluedot.thun.net
+ ( }
+ * }
+ * negativ
+ * = { ip = { } }
+ * = { ipv4 { addr = doof.nowaytoheavenxyz.uhu; } }
+ * = { ipv4 { port = 4711 } }
*/
token = skip_to_next_not_eol(lc);
scan_err1(lc, _("Expected a string, got: %s"), lc->str);
}
if (!strcmp("ip", lc->str) || !strcmp("ipv4", lc->str)) {
- family = AF_INET;
+ family = AF_INET;
}
#ifdef HAVE_IPV6
else if (!strcmp("ipv6", lc->str)) {
- family = AF_INET6;
+ family = AF_INET6;
}
#endif
else {
exist = EMPTYLINE;
port_str[0] = hostname_str[0] = '\0';
do {
- if (token != T_IDENTIFIER) {
+ if (token != T_IDENTIFIER) {
scan_err1(lc, _("Expected a identifier [addr|port], got: %s"), lc->str);
- }
+ }
if (!strcmp("port", lc->str)) {
- next_line = PORTLINE;
- if (exist & PORTLINE) {
+ next_line = PORTLINE;
+ if (exist & PORTLINE) {
scan_err0(lc, _("Only one port per address block"));
- }
- exist |= PORTLINE;
+ }
+ exist |= PORTLINE;
} else if (!strcmp("addr", lc->str)) {
- next_line = ADDRLINE;
- if (exist & ADDRLINE) {
+ next_line = ADDRLINE;
+ if (exist & ADDRLINE) {
scan_err0(lc, _("Only one addr per address block"));
- }
- exist |= ADDRLINE;
- } else {
+ }
+ exist |= ADDRLINE;
+ } else {
scan_err1(lc, _("Expected a identifier [addr|port], got: %s"), lc->str);
- }
- token = lex_get_token(lc, T_ALL);
- if (token != T_EQUALS) {
+ }
+ token = lex_get_token(lc, T_ALL);
+ if (token != T_EQUALS) {
scan_err1(lc, _("Expected a equal =, got: %s"), lc->str);
- }
- token = lex_get_token(lc, T_ALL);
- switch (next_line) {
- case PORTLINE:
- if (!
- (token == T_UNQUOTED_STRING || token == T_NUMBER
- || token == T_IDENTIFIER)) {
+ }
+ token = lex_get_token(lc, T_ALL);
+ switch (next_line) {
+ case PORTLINE:
+ if (!
+ (token == T_UNQUOTED_STRING || token == T_NUMBER
+ || token == T_IDENTIFIER)) {
scan_err1(lc, _("Expected a number or a string, got: %s"), lc->str);
- }
- bstrncpy(port_str, lc->str, sizeof(port_str));
- break;
- case ADDRLINE:
- if (!(token == T_UNQUOTED_STRING || token == T_IDENTIFIER)) {
+ }
+ bstrncpy(port_str, lc->str, sizeof(port_str));
+ break;
+ case ADDRLINE:
+ if (!(token == T_UNQUOTED_STRING || token == T_IDENTIFIER)) {
scan_err1(lc, _("Expected a ipnumber or a hostname, got: %s"),
- lc->str);
- }
- bstrncpy(hostname_str, lc->str, sizeof(hostname_str));
- break;
- case EMPTYLINE:
+ lc->str);
+ }
+ bstrncpy(hostname_str, lc->str, sizeof(hostname_str));
+ break;
+ case EMPTYLINE:
scan_err0(lc, _("Statemachine missmatch"));
- break;
- }
- token = skip_to_next_not_eol(lc);
+ break;
+ }
+ token = skip_to_next_not_eol(lc);
} while (token == T_IDENTIFIER);
if (token != T_EOB) {
scan_err1(lc, _("Expected a end of block }, got: %s"), lc->str);
}
char *errstr;
- if (!add_address
- ((dlist **) (item->value), IPADDR::R_MULTIPLE, htons(item->default_value),
- family, hostname_str, port_str, &errstr)) {
+ if (!add_address((dlist **)(item->value), IPADDR::R_MULTIPLE,
+ htons(item->default_value), family, hostname_str, port_str, &errstr)) {
scan_err3(lc, _("Can't add hostname(%s) and port(%s) to addrlist (%s)"),
- hostname_str, port_str, errstr);
- free(errstr);
+ hostname_str, port_str, errstr);
+ free(errstr);
}
token = skip_to_next_not_eol(lc);
} while ((token == T_IDENTIFIER || token == T_UNQUOTED_STRING));
}
char *errstr;
if (!add_address((dlist **) (item->value), IPADDR::R_SINGLE_ADDR,
- htons(item->default_value), AF_INET, lc->str, 0, &errstr)) {
+ htons(item->default_value), AF_INET, lc->str, 0, &errstr)) {
scan_err2(lc, _("can't add port (%s) to (%s)"), lc->str, errstr);
free(errstr);
}
scan_err1(lc, _("Expected a port nummer or string, got: %s"), lc->str);
}
char *errstr;
- if (!add_address((dlist **) (item->value), IPADDR::R_SINGLE_PORT,
- htons(item->default_value), AF_INET, 0, lc->str, &errstr)) {
+ if (!add_address((dlist **)(item->value), IPADDR::R_SINGLE_PORT,
+ htons(item->default_value), AF_INET, 0, lc->str, &errstr)) {
scan_err2(lc, _("can't add port (%s) to (%s)"), lc->str, errstr);
free(errstr);
}
}
delete addrs;
}
-
-
extern void free_addresses(dlist * addrs);
extern void store_addresses_address(LEX * lc, RES_ITEM * item, int index, int pass);
extern void store_addresses_port(LEX * lc, RES_ITEM * item, int index, int pass);
-extern int add_address(dlist ** out, IPADDR::i_type type, unsigned short defaultport,
- int family, const char *hostname_str,
- const char *port_str, char **errstr);
-
extern void init_default_addresses(dlist ** addr, int port);
extern const char *get_first_address(dlist * addrs, char *outputbuf, int outlen);
void prepend(void *item);
void *remove(int index);
void *get(int index);
- bool empty();
+ bool empty() const;
void *prev();
void *next();
void *first();
void *last();
void * operator [](int index) const;
- int size();
+ int size() const;
void destroy();
void grow(int num);
void * operator new(size_t);
return items[index];
}
-inline bool alist::empty()
+inline bool alist::empty() const
{
return num_items == 0;
}
/* Current size of list */
-inline int alist::size()
+inline int alist::size() const
{
return num_items;
}
((alist *)item)->destroy();
free(item);
}
+
* This probably should be done in net_open
*/
BSOCK *init_bsock(JCR * jcr, int sockfd, const char *who, const char *host, int port,
- struct sockaddr * client_addr)
+ struct sockaddr *client_addr)
{
+ Dmsg3(100, "who=%s host=%s port=%d\n", who, host, port);
BSOCK *bsock = (BSOCK *)malloc(sizeof(BSOCK));
memset(bsock, 0, sizeof(BSOCK));
bsock->fd = sockfd;
/* see who client is. i.e. who connected to us. */
P(mutex);
-#ifndef HAVE_INET_NTOP
- bstrncpy(buf, inet_ntoa(((sockaddr_in *) & cli_addr)->sin_addr), sizeof(buf)); /* NOT thread safe, use mutex */
-#else
+#ifdef HAVE_INET_NTOP
inet_ntop(clilen == sizeof(sockaddr_in) ? AF_INET : AF_INET6, &clilen,
- buf, clilen);
+ buf, sizeof(buf));
+#else
+ bstrncpy(buf, inet_ntoa(((sockaddr_in *)&cli_addr)->sin_addr), sizeof(buf)); /* NOT thread safe, use mutex */
#endif
- /* possible release of the mutex */
-
- BSOCK *bs =
- init_bsock(NULL, newsockfd, "client", buf, fd_ptr->port, &cli_addr);
+ V(mutex);
+ BSOCK *bs;
+ bs = init_bsock(NULL, newsockfd, "client", buf, fd_ptr->port, &cli_addr);
if (bs == NULL) {
Jmsg0(NULL, M_ABORT, 0, _("Could not create client BSOCK.\n"));
}
/* Queue client to be served */
if ((stat = workq_add(client_wq, (void *)bs, NULL, 0)) != 0) {
berrno be;
- V(mutex);
be.set_errno(stat);
- Jmsg1(NULL, M_ABORT, 0,
- _("Could not add job to client queue: ERR=%s\n"),
+ Jmsg1(NULL, M_ABORT, 0, _("Could not add job to client queue: ERR=%s\n"),
be.strerror());
}
- V(mutex);
}
}
}
/* ===================================================================
* dlist
*/
+
/*
* Append an item to the list
*/
}
}
-void * dlist::next(void *item)
+void * dlist::next(const void *item) const
{
if (item == NULL) {
return head;
return ((dlink *)(((char *)item)+loffset))->next;
}
-void * dlist::prev(void *item)
+void * dlist::prev(const void *item) const
{
if (item == NULL) {
return tail;
jcr_chain->destroy();
free(jcr_chain);
- jcr_chain = new dlist(jcr, &jcr->link);
+ jcr_chain = New(dlist(jcr, &jcr->link));
printf("append 20 items 0-19\n");
for (int i=0; i<20; i++) {
sprintf(buf, "This is dlist item %d", i);
/* Now do a binary insert for the list */
- jcr_chain = new dlist(jcr, &jcr->link);
+ jcr_chain = New(dlist(jcr, &jcr->link));
#define CNT 26
printf("append %d items\n", CNT*CNT*CNT);
strcpy(buf, "ZZZ");
*
*/
+#define M_ABORT 1
+#undef New
+#define New(type) new type
+
/* In case you want to specifically specify the offset to the link */
#define OFFSET(item, link) ((char *)(link) - (char *)(item))
/*
for((var)=NULL; (((void *)(var))=(list)->next(var)); )
#endif
+
struct dlink {
void *next;
void *prev;
};
-
class dlist {
void *head;
void *tail;
int16_t loffset;
uint32_t num_items;
public:
- dlist(void *item, void *link);
+ dlist(void *item, dlink *link);
dlist(void);
~dlist() { destroy(); }
- void init(void *item, void *link);
+ void init(void *item, dlink *link);
void prepend(void *item);
void append(void *item);
void insert_before(void *item, void *where);
void *unique_binary_insert(void *item, int compare(void *item1, void *item2));
void binary_insert(void *item, int compare(void *item1, void *item2));
void remove(void *item);
- bool empty();
- int size();
- void *next(void *item);
- void *prev(void *item);
+ bool empty() const;
+ int size() const;
+ void *next(const void *item) const;
+ void *prev(const void *item) const;
void destroy();
- void *first();
- void *last();
+ void *first() const;
+ void *last() const;
void * operator new(size_t);
void operator delete(void *);
};
+dlist *new_dlist();
+dlist *new_dlist(void *item, dlink *link);
+
+
/*
* This allows us to do explicit initialization,
* allowing us to mix C++ classes inside malloc'ed
* C structures. Define before called in constructor.
*/
-#define M_ABORT 1
-inline void dlist::init(void *item, void *link)
+inline void dlist::init(void *item, dlink *link)
{
head = tail = NULL;
loffset = (char *)link - (char *)item;
* then there is no need to specify the link address
* since the offset is zero.
*/
-inline dlist::dlist(void *item, void *link)
+inline dlist::dlist(void *item, dlink *link)
{
- this->init(item, link);
+ init(item, link);
}
/* Constructor with link at head of item */
-inline dlist::dlist(void)
+inline dlist::dlist(void) : head(0), tail(0), loffset(0), num_items(0)
{
- memset(this, 0, sizeof(dlist));
}
-inline bool dlist::empty()
+inline bool dlist::empty() const
{
return head == NULL;
}
-inline int dlist::size()
+inline int dlist::size() const
{
return num_items;
}
}
-inline void * dlist::first()
+inline void * dlist::first() const
{
return head;
}
-inline void * dlist::last()
+inline void * dlist::last() const
{
return tail;
}
int errstat;
struct s_last_job *job_entry = NULL;
if (!last_jobs) {
- last_jobs = new dlist(job_entry, &job_entry->link);
+ last_jobs = New(dlist(job_entry, &job_entry->link));
if ((errstat=rwl_init(&lock)) != 0) {
Emsg1(M_ABORT, 0, _("Unable to initialize jcr_chain lock. ERR=%s\n"),
strerror(errstat));
Dmsg0(400, "Enter new_jcr\n");
jcr = (JCR *)malloc(size);
memset(jcr, 0, size);
- jcr->msg_queue = new dlist(item, &item->link);
+ jcr->msg_queue = New(dlist(item, &item->link));
jcr->job_end_push.init(1, false);
jcr->sched_time = time(NULL);
jcr->daemon_free_jcr = daemon_free_jcr; /* plug daemon free routine */
*/
+#include "smartall.h"
#include "alist.h"
#include "dlist.h"
#include "bits.h"
#include "btime.h"
-#include "smartall.h"
#include "mem_pool.h"
#include "message.h"
#include "lex.h"
*/
/*
- Copyright (C) 2000, 2001, 2002 Kern Sibbald and John Walker
+ Copyright (C) 2000-2004 Kern Sibbald and John Walker
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
#ifdef SMARTALLOC
+
extern void *sm_malloc(const char *fname, int lineno, unsigned int nbytes),
*sm_calloc(const char *fname, int lineno,
unsigned int nelem, unsigned int elsize),
#endif
+
+#ifdef SMARTALLOC
+
+#define New(type) new(__FILE__, __LINE__ type
+
+#undef SMARTALLOC
+#define SMARTALLOC SMARTALLOC
+
+class SMARTALLOC
+{
+private:
+public:
+
+void *operator new(size_t s, const char *fname, int line)
+{
+ void *p = sm_malloc(fname, line, s > sizeof(int) ? s : sizeof(int));
+ return p;
+}
+void *operator new[](size_t s, const char *fname, int line)
+{
+ void *p = sm_malloc(fname, line, s > sizeof(int) ? s : sizeof(int));
+ return p;
+}
+void operator delete(void *ptr)
+{
+ free(ptr);
+}
+void operator delete[](void *ptr, size_t i)
+{
+ free(ptr);
+}
+
+private:
+void *operator new(size_t s) throw() { return 0; }
+void *operator new[](size_t s) throw() { return 0; }
+};
+
+
+#else
+
+#define New(type) new type
+
+class SMARTALLOC
+{
+ public:
+ void *operator new(size_t s)
+ {
+ return malloc(s);
+ }
+ void *operator new[](size_t s)
+ {
+ return malloc(s);
+ }
+ void operator delete(void *ptr)
+ {
+ free(ptr);
+ }
+ void operator delete[](void *ptr, size_t i)
+ {
+ free(ptr);
+ }
+};
+#endif
Emsg1(M_ABORT, 0, _("Unable to initialize watchdog lock. ERR=%s\n"),
strerror(errstat));
}
- wd_queue = new dlist(dummy, &dummy->link);
- wd_inactive = new dlist(dummy, &dummy->link);
+ wd_queue = New(dlist(dummy, &dummy->link));
+ wd_inactive = New(dlist(dummy, &dummy->link));
if ((stat = pthread_create(&wd_tid, NULL, watchdog_thread, NULL)) != 0) {
return stat;
/* */
#undef VERSION
#define VERSION "1.35.1"
-#define BDATE "06 August 2004"
-#define LSMDATE "06Aug04"
+#define BDATE "12 August 2004"
+#define LSMDATE "12Aug04"
/* Debug flags */
#undef DEBUG
projects / bacula / bacula / commitdiff