#include <stdio.h>
#include <unistd.h>
#include <string.h>
+
#include "checkwait_smtpreply.h"
#include "config.h"
+#include "memory.h"
#define USEC_WAIT 1
#define LOOP_WAIT 10000
switch(replytype) {
case MLMMJ_CONNECT:
if(smtpreply[0] != '2' || smtpreply[1] != '2')
- return strdup(smtpreply);
+ return mystrdup(smtpreply);
break;
case MLMMJ_HELO:
if(smtpreply[0] != '2' || smtpreply[1] != '5')
- return strdup(smtpreply);
+ return mystrdup(smtpreply);
break;
case MLMMJ_FROM:
if(smtpreply[0] != '2' || smtpreply[1] != '5')
- return strdup(smtpreply);
+ return mystrdup(smtpreply);
break;
case MLMMJ_RCPTTO:
if(smtpreply[0] != '2' || smtpreply[1] != '5')
- return strdup(smtpreply);
+ return mystrdup(smtpreply);
break;
case MLMMJ_DATA:
if(smtpreply[0] != '3' || smtpreply[1] != '5')
- return strdup(smtpreply);
+ return mystrdup(smtpreply);
break;
case MLMMJ_DOT:
if(smtpreply[0] != '2' || smtpreply[1] != '5')
- return strdup(smtpreply);
+ return mystrdup(smtpreply);
break;
case MLMMJ_QUIT:
if(smtpreply[0] != '2' || smtpreply[1] != '2')
#include "ctrlvalue.h"
#include "mygetline.h"
#include "chomp.h"
+#include "memory.h"
char *ctrlvalue(const char *listdir, const char *ctrlstr)
{
int ctrlfd;
ctrlfd = open(filename, O_RDONLY);
- free(filename);
+ myfree(filename);
if(ctrlfd < 0)
return NULL;
#include "mygetline.h"
#include "chomp.h"
#include "mlmmj.h"
+#include "memory.h"
struct strlist *ctrlvalues(const char *listdir, const char *ctrlstr)
{
int ctrlfd;
ctrlfd = open(filename, O_RDONLY);
- free(filename);
+ myfree(filename);
if(ctrlfd < 0)
return NULL;
- ret = malloc(sizeof(struct strlist));
+ ret = mymalloc(sizeof(struct strlist));
ret->count = 0;
ret->strs = NULL;
while((value = mygetline(ctrlfd)) != NULL) {
chomp(value);
ret->count++;
- ret->strs = (char **) realloc(ret->strs, sizeof(char *) *
+ ret->strs = (char **) myrealloc(ret->strs, sizeof(char *) *
(ret->count + 1));
ret->strs[ret->count-1] = value;
ret->strs[ret->count] = NULL;
#include "do_all_the_voodo_here.h"
#include "log_error.h"
#include "wrappers.h"
+#include "memory.h"
int findit(const char *line, const char **headers)
{
readhdrs[i].valuecount++;
valuelen = linelen - tokenlen + 1;
readhdrs[i].values =
- (char **)realloc(readhdrs[i].values,
+ (char **)myrealloc(readhdrs[i].values,
readhdrs[i].valuecount * sizeof(char *));
readhdrs[i].values[readhdrs[i].valuecount - 1] =
- (char *)malloc(valuelen + 1);
+ (char *)mymalloc(valuelen + 1);
strncpy(readhdrs[i].values[readhdrs[i].valuecount - 1],
line+tokenlen-1, valuelen);
chomp(readhdrs[i].values[readhdrs[i].valuecount - 1]);
if(dumpfd2fd(hdrfd, outfd) < 0) {
log_error(LOG_ARGS, "Could not "
"add extra headers");
- free(hdrline);
+ myfree(hdrline);
return -1;
}
}
write(outfd, hdrline, strlen(hdrline));
fsync(outfd);
- free(hdrline);
+ myfree(hdrline);
break;
}
/* Do we want info from hdrs? Get it before it's gone */
" ", hdrline + 9);
writen(outfd, subject,
strlen(subject));
- free(subject);
- free(hdrline);
+ myfree(subject);
+ myfree(hdrline);
continue;
}
}
writen(outfd, hdrline, strlen(hdrline));
- free(hdrline);
+ myfree(hdrline);
}
/* Just print the rest of the mail */
* IN THE SOFTWARE.
*/
-#include "find_email_adr.h"
#include <string.h>
#include <strings.h>
#include <stdio.h>
#include <stdlib.h>
+#include "find_email_adr.h"
+#include "memory.h"
+
struct email_container *find_email_adr(const char *str,
struct email_container *retstruct)
{
size_t len;
char *index_atsign;
- char *tempstr = strdup(str);
+ char *tempstr = mystrdup(str);
char *c, *first_char = NULL, *last_char = NULL;
index_atsign = strchr(tempstr, '@');
retstruct->emaillist = (char **)realloc(retstruct->emaillist,
sizeof(char *) * retstruct->emailcount);
retstruct->emaillist[retstruct->emailcount-1] =
- (char *)malloc(len + 1);
+ (char *)mymalloc(len + 1);
snprintf(retstruct->emaillist[retstruct->emailcount-1], len,
"%s", first_char);
#if 0
*index_atsign = 'A'; /* Clear it so we don't find it again */
index_atsign = strchr(tempstr, '@');
}
- free(tempstr);
+ myfree(tempstr);
return retstruct;
}
#include "mygetline.h"
#include "gethdrline.h"
#include "strgen.h"
+#include "memory.h"
char *gethdrline(int fd)
{
nextline = mygetline(fd);
tmp = retstr;
retstr = concatstr(3, retstr, line, nextline);
- free(tmp);
- free(line);
- free(nextline);
+ myfree(tmp);
+ myfree(line);
+ myfree(nextline);
tmp = line = nextline = NULL;
if(read(fd, &ch, 1) == (size_t)1)
lseek(fd, -1, SEEK_CUR);
} else {
tmp = retstr;
retstr = concatstr(3, retstr, line, nextline);
- free(tmp);
+ myfree(tmp);
return retstr;
}
#include "log_error.h"
#include "mygetline.h"
#include "strgen.h"
+#include "memory.h"
char *getlistaddr(const char *listdir)
{
log_error(LOG_ARGS, "Could not open '%s'", tmpstr);
exit(EXIT_FAILURE);
}
- free(tmpstr);
+ myfree(tmpstr);
tmpstr = mygetline(listnamefd);
#include "itoa.h"
#include "log_error.h"
#include "strgen.h"
+#include "memory.h"
#define INTBUF_SIZE 32
fd = open(indexfilename, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
if(fd == -1) {
- free(indexfilename);
+ myfree(indexfilename);
log_error(LOG_ARGS, "Error opening index file");
return 0;
}
lock = myexcllock(fd);
if(lock) {
- free(indexfilename);
+ myfree(indexfilename);
log_error(LOG_ARGS, "Error locking index file");
close(fd);
return 0;
myunlock(fd);
close(fd);
- free(indexfilename);
+ myfree(indexfilename);
return index;
}
#include "statctrl.h"
#include "mygetline.h"
#include "chomp.h"
+#include "memory.h"
enum ctrl_e {
CTRL_SUBSCRIBE,
MY_ASSERT(atsign);
len = atsign - recipdelimsign;
- controlstr = malloc(len);
+ controlstr = mymalloc(len);
MY_ASSERT(controlstr);
snprintf(controlstr, len, "%s", recipdelimsign + 1);
if (ctrl_commands[ctrl].accepts_parameter &&
(controlstr[cmdlen] == '-')) {
- param = strdup(controlstr + cmdlen + 1);
+ param = mystrdup(controlstr + cmdlen + 1);
MY_ASSERT(param);
if (strchr(param, '/')) {
errno = 0;
" discarding mail");
exit(EXIT_SUCCESS);
}
- free(controlstr);
+ myfree(controlstr);
break;
} else if (!ctrl_commands[ctrl].accepts_parameter &&
(controlstr[cmdlen] == '\0')) {
param = NULL;
- free(controlstr);
+ myfree(controlstr);
break;
} else {
log_error(LOG_ARGS, "Received a malformed"
" list control request");
- free(controlstr);
+ myfree(controlstr);
return -1;
}
unlink(mailname);
if (closedlist) exit(EXIT_SUCCESS);
conffilename = concatstr(3, listdir, "/subconf/", param);
- free(param);
+ myfree(param);
if((tmpfd = open(conffilename, O_RDONLY)) > 0) {
tmpstr = mygetline(tmpfd);
chomp(tmpstr);
exit(EXIT_FAILURE);
} else {
/* Not proper confirm */
- free(tmpstr);
+ myfree(tmpstr);
exit(EXIT_SUCCESS);
}
} else /* Not a confirm so silently ignore */
unlink(mailname);
if (closedlist) exit(EXIT_SUCCESS);
conffilename = concatstr(3, listdir, "/unsubconf/", param);
- free(param);
+ myfree(param);
if((tmpfd = open(conffilename, O_RDONLY))) {
tmpstr = mygetline(tmpfd);
close(tmpfd);
mlmmjunsub);
exit(EXIT_FAILURE);
} else {
- free(tmpstr);
+ myfree(tmpstr);
exit(EXIT_SUCCESS);
}
} else /* Not a confirm so silently ignore */
/* TODO Add accept/reject parameter to moderate */
unlink(mailname);
moderatefilename = concatstr(3, listdir, "/moderation/", param);
- free(param);
+ myfree(param);
if(stat(moderatefilename, &stbuf) < 0) {
- free(moderatefilename);
+ myfree(moderatefilename);
exit(EXIT_SUCCESS); /* just exit, no mail to moderate */
} else {
execlp(mlmmjsend, mlmmjsend,
#include "log_error.h"
#include "../config.h"
+#include "memory.h"
#ifdef HAVE_SYSLOG_H
#include <syslog.h>
void log_set_name(const char* name)
{
- if (log_name) free(log_name);
- log_name = strdup(name);
+ if (log_name) myfree(log_name);
+ log_name = mystrdup(name);
}
void log_free_name()
{
- free(log_name);
+ myfree(log_name);
}
void log_error(const char *file, int line, const char *errstr,
#include "mail-functions.h"
#include "wrappers.h"
#include "log_error.h"
+#include "memory.h"
/* "HELO \r\n " has length 7 */
#define EXTRA_HELO_LEN 8
char *helo;
size_t bytes_written;
- if((helo = malloc(len)) == 0)
+ if((helo = mymalloc(len)) == 0)
return errno;
snprintf(helo, len, "HELO %s\r\n", hostname);
len = strlen(helo);
bytes_written = writen(sockfd, helo, len);
if(bytes_written < 0) {
log_error(LOG_ARGS, "Could not write HELO");
- free(helo);
+ myfree(helo);
return errno;
}
- free(helo);
+ myfree(helo);
return 0;
}
/* "MAIL FROM: <>\r\n" has length 15 */
char *mail_from;
size_t bytes_written;
- if((mail_from = malloc(len)) == NULL)
+ if((mail_from = mymalloc(len)) == NULL)
return errno;
snprintf(mail_from, len, "MAIL FROM: <%s>\r\n", from_addr);
len = strlen(mail_from);
bytes_written = writen(sockfd, mail_from, len);
if(bytes_written < 0) {
log_error(LOG_ARGS, "Could not write FROM");
- free(mail_from);
+ myfree(mail_from);
return errno;
}
- free(mail_from);
+ myfree(mail_from);
return 0;
}
char *rcpt_to;
size_t bytes_written;
- if((rcpt_to = malloc(len)) == 0)
+ if((rcpt_to = mymalloc(len)) == 0)
return errno;
snprintf(rcpt_to, len, "RCPT TO: <%s>\r\n", rcpt_addr);
bytes_written = writen(sockfd, rcpt_to, len);
if(bytes_written < 0) {
log_error(LOG_ARGS, "Could not write TO");
- free(rcpt_to);
+ myfree(rcpt_to);
return errno;
}
- free(rcpt_to);
+ myfree(rcpt_to);
return 0;
}
size_t bytes_written;
char *customline;
- if((customline = malloc(len)) == 0)
+ if((customline = mymalloc(len)) == 0)
return errno;
snprintf(customline, len, "%s\r\n", line);
bytes_written = writen(sockfd, customline, len);
if(bytes_written < 0) {
log_error(LOG_ARGS, "Could not write customline");
- free(customline);
+ myfree(customline);
return errno;
}
- free(customline);
+ myfree(customline);
return 0;
}
char *replyto;
size_t bytes_written;
- if((replyto = malloc(len)) == 0)
+ if((replyto = mymalloc(len)) == 0)
return errno;
snprintf(replyto, len, "Reply-To: %s\r\n", replyaddr);
bytes_written = writen(sockfd, replyto, len);
if(bytes_written < 0) {
log_error(LOG_ARGS, "Could not write Reply-To header");
- free(replyto);
+ myfree(replyto);
return errno;
}
- free(replyto);
+ myfree(replyto);
return 0;
}
#include "mygetline.h"
#include "chomp.h"
#include "prepstdreply.h"
+#include "memory.h"
char *fetchindexes(const char *bouncefile)
{
for(next = cur = start; next < start + st.st_size; next++) {
if(*next == '\n') {
len = next - cur;
- line = malloc(len + 1);
+ line = mymalloc(len + 1);
strncpy(line, cur, len);
line[len] = '\0';
cur = next + 1;
*colon = '\0';
s = indexstr;
indexstr = concatstr(4, s, " ", line, "\n");
- free(s);
- free(line);
+ myfree(s);
+ myfree(line);
}
munmap(start, st.st_size);
int fd;
time_t t;
- myaddr = strdup(addr);
- MY_ASSERT(myaddr);
+ myaddr = mystrdup(addr);
listaddr = getlistaddr(listdir);
chomp(listaddr);
a = strchr(myaddr, '=');
if (!a) {
- free(myaddr);
- free(from);
+ myfree(myaddr);
+ myfree(from);
log_error(LOG_ARGS, "do_probe(): malformed address");
exit(EXIT_FAILURE);
}
queuefilename = prepstdreply(listdir, "bounce-probe", fromstr,
myaddr, NULL, subjectstr, 2, maildata);
MY_ASSERT(queuefilename);
- free(fromstr);
- free(subjectstr);
- free(listaddr);
- free(listfqdn);
- free(listname);
- free(indexstr);
+ myfree(fromstr);
+ myfree(subjectstr);
+ myfree(listaddr);
+ myfree(listfqdn);
+ myfree(listname);
+ myfree(indexstr);
probefile = concatstr(4, listdir, "/bounce/", addr, "-probe");
MY_ASSERT(probefile);
t = time(NULL);
- a = malloc(32);
+ a = mymalloc(32);
snprintf(a, 31, "%ld", (long int)t);
a[31] = '\0';
unlink(probefile);
if(writen(fd, a, strlen(a)) < 0)
log_error(LOG_ARGS, "Could not write time in probe");
- free(probefile);
+ myfree(probefile);
execlp(mlmmjsend, mlmmjsend,
"-l", "1",
bindir = mydirname(argv[0]);
mlmmjsend = concatstr(2, bindir, "/mlmmj-send");
- free(bindir);
+ myfree(bindir);
while ((opt = getopt(argc, argv, "hVL:a:n:m:p")) != -1) {
switch(opt) {
a = concatstr(5, listdir, "/subconf/", address + 8, "-",
number);
unlink(a);
- free(a);
+ myfree(a);
exit(EXIT_SUCCESS);
}
if(strncmp(address, "confunsub-", 10) == 0) {
a = concatstr(5, listdir, "/unsubconf/", address + 10, "-",
number);
unlink(a);
- free(a);
+ myfree(a);
exit(EXIT_SUCCESS);
}
/* Below checks for bounce probes bouncing. If they do, simply remove
a = concatstr(4, listdir, "/bounce/", address, "-probe");
unlink(a);
unlink(mailname);
- free(a);
+ myfree(a);
exit(EXIT_SUCCESS);
}
/* make sure it's a subscribed address */
if(is_subbed(listdir, address)) {
- free(bfilename);
+ myfree(bfilename);
exit(EXIT_SUCCESS); /* Not subbed, so exit silently */
}
if ((fd = open(bfilename, O_WRONLY|O_APPEND|O_CREAT,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", bfilename);
- free(bfilename);
+ myfree(bfilename);
exit(EXIT_FAILURE);
}
/* int + ":" + int + " # Wed Jun 30 21:49:08 1993\n" + NUL */
len = 20 + 1 + 20 + 28 + 1;
- buf = malloc(len);
+ buf = mymalloc(len);
if (!buf) exit(EXIT_FAILURE);
t = time(NULL);
if(mailname)
unlink(mailname);
- free(bfilename);
+ myfree(bfilename);
return EXIT_SUCCESS;
}
#include "log_error.h"
#include "mygetline.h"
#include "wrappers.h"
+#include "memory.h"
static int maintdlogfd = -1;
char *moddirname = concatstr(2, listdir, "/moderation");
int ret = delolder(moddirname, MODREQLIFE);
- free(moddirname);
+ myfree(moddirname);
return ret;
}
char *discardeddirname = concatstr(2, listdir, "/queue/discarded");
int ret = delolder(discardeddirname, DISCARDEDLIFE);
- free(discardeddirname);
+ myfree(discardeddirname);
return ret;
}
if(chdir(dirname) < 0) {
log_error(LOG_ARGS, "Could not chdir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
if((queuedir = opendir(dirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
- free(dirname);
+ myfree(dirname);
while((dp = readdir(queuedir)) != NULL) {
if(stat(dp->d_name, &st) < 0) {
continue;
if(strchr(dp->d_name, '.')) {
- mailname = strdup(dp->d_name);
+ mailname = mystrdup(dp->d_name);
ch = strchr(mailname, '.');
*ch = '\0';
if(stat(mailname, &st) < 0)
if(errno == ENOENT)
unlink(dp->d_name);
- free(mailname);
+ myfree(mailname);
continue;
}
discarded = discardmail(mailname,
discardedname,
3600);
- free(discardedname);
+ myfree(discardedname);
} else {
log_error(LOG_ARGS, "Could not stat(%s)",
dp->d_name);
discarded = discardmail(mailname,
discardedname,
3600);
- free(discardedname);
+ myfree(discardedname);
} else {
log_error(LOG_ARGS, "Could not stat(%s)",
dp->d_name);
unlink(toname);
unlink(reptoname);
}
- free(mailname);
- free(fromname);
- free(toname);
- free(reptoname);
+ myfree(mailname);
+ myfree(fromname);
+ myfree(toname);
+ myfree(reptoname);
if(fromfd >= 0)
close(fromfd);
continue;
chomp(from);
close(fromfd);
unlink(fromname);
- free(fromname);
+ myfree(fromname);
to = mygetline(tofd);
chomp(to);
close(tofd);
unlink(toname);
- free(toname);
+ myfree(toname);
fd = open(reptoname, O_RDONLY);
if(fd < 0) {
- free(reptoname);
+ myfree(reptoname);
repto = NULL;
} else {
repto = mygetline(fd);
chomp(repto);
close(fd);
unlink(reptoname);
- free(reptoname);
+ myfree(reptoname);
}
childpid = fork();
if(childpid < 0) {
- free(mailname);
- free(from);
- free(to);
- free(repto);
+ myfree(mailname);
+ myfree(from);
+ myfree(to);
+ myfree(repto);
log_error(LOG_ARGS, "Could not fork");
continue;
}
if(childpid > 0) {
- free(mailname);
- free(from);
- free(to);
- free(repto);
+ myfree(mailname);
+ myfree(from);
+ myfree(to);
+ myfree(repto);
do /* Parent waits for the child */
pid = waitpid(childpid, &status, 0);
while(pid == -1 && errno == EINTR);
if(chdir(dirname) < 0) {
log_error(LOG_ARGS, "Could not chdir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
if((queuedir = opendir(dirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
- free(dirname);
+ myfree(dirname);
while((dp = readdir(queuedir)) != NULL) {
if((strcmp(dp->d_name, "..") == 0) ||
* yet because it's still getting sent, so just
* continue
*/
- free(archivefilename);
+ myfree(archivefilename);
continue;
}
subfilename = concatstr(3, dirname, dp->d_name, "/subscribers");
if(stat(subfilename, &st) < 0) {
log_error(LOG_ARGS, "Could not stat(%s)", subfilename);
- free(archivefilename);
- free(subfilename);
+ myfree(archivefilename);
+ myfree(subfilename);
continue;
}
if(rename(subfilename, subnewname) < 0) {
log_error(LOG_ARGS, "Could not rename(%s, %s)",
subfilename, subnewname);
- free(archivefilename);
- free(subfilename);
- free(subnewname);
+ myfree(archivefilename);
+ myfree(subfilename);
+ myfree(subnewname);
continue;
}
- free(subfilename);
+ myfree(subfilename);
childpid = fork();
if(childpid < 0) {
- free(archivefilename);
- free(subnewname);
+ myfree(archivefilename);
+ myfree(subnewname);
log_error(LOG_ARGS, "Could not fork");
continue;
}
if(childpid > 0) {
- free(archivefilename);
- free(subnewname);
+ myfree(archivefilename);
+ myfree(subnewname);
do /* Parent waits for the child */
pid = waitpid(childpid, &status, 0);
while(pid == -1 && errno == EINTR);
if(chdir(dirname) < 0) {
log_error(LOG_ARGS, "Could not chdir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
if((bouncedir = opendir(dirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
- free(dirname);
+ myfree(dirname);
while((dp = readdir(bouncedir)) != NULL) {
if((strcmp(dp->d_name, "..") == 0) ||
continue;
}
- filename = strdup(dp->d_name);
+ filename = mystrdup(dp->d_name);
if((s = strstr(filename, "-probe"))) {
probefd = open(filename, O_RDONLY);
close(probefd);
chomp(probetimestr);
probetime = (time_t)strtol(probetimestr, NULL, 10);
- free(probetimestr);
+ myfree(probetimestr);
t = time(NULL);
if(t - probetime > WAITPROBE) {
unlink(filename);
unlink(filename);
}
}
- free(filename);
+ myfree(filename);
}
closedir(bouncedir);
if(chdir(dirname) < 0) {
log_error(LOG_ARGS, "Could not chdir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
if((bouncedir = opendir(dirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
- free(dirname);
+ myfree(dirname);
while((dp = readdir(bouncedir)) != NULL) {
if((strcmp(dp->d_name, "..") == 0) ||
/* Skip files which already have a probe out */
if(stat(probefile, &st) == 0) {
- free(probefile);
+ myfree(probefile);
continue;
}
- free(probefile);
+ myfree(probefile);
childpid = fork();
pid = waitpid(childpid, &status, 0);
while(pid == -1 && errno == EINTR);
} else {
- probefile = strdup(dp->d_name);
+ probefile = mystrdup(dp->d_name);
execlp(mlmmjbounce, mlmmjbounce,
"-L", listdir,
"-a", probefile,
if(chdir(dirname) < 0) {
log_error(LOG_ARGS, "Could not chdir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
if((bouncedir = opendir(dirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)", dirname);
- free(dirname);
+ myfree(dirname);
return 1;
}
- free(dirname);
+ myfree(dirname);
while((dp = readdir(bouncedir)) != NULL) {
if((strcmp(dp->d_name, "..") == 0) ||
/* Skip files which already have a probe out */
if(stat(probefile, &st) == 0) {
- free(probefile);
+ myfree(probefile);
continue;
}
- free(probefile);
+ myfree(probefile);
/* Get the first line of the bounce file to check if it's
* been bouncing for long enough
/* End the string at the comment */
a = strchr(firstbounce, '#');
if(a == NULL) {
- free(firstbounce);
+ myfree(firstbounce);
continue;
}
*a = '\0';
- bouncedata = strdup(a+1); /* Save for the log */
+ bouncedata = mystrdup(a+1); /* Save for the log */
chomp(bouncedata);
a = strchr(firstbounce, ':');
if(a == NULL) {
- free(firstbounce);
+ myfree(firstbounce);
continue;
}
a++; /* Increase to first digit */
bouncetime = (time_t)strtol(a, NULL, 10);
- free(firstbounce);
+ myfree(firstbounce);
t = time(NULL);
if(t - bouncetime < BOUNCELIFE + WAITPROBE)
continue; /* ok, don't unsub this one */
/* Ok, go ahead and unsubscribe the address */
- address = strdup(dp->d_name);
+ address = mystrdup(dp->d_name);
a = strchr(address, '=');
if(a == NULL) { /* skip malformed */
- free(address);
+ myfree(address);
continue;
}
*a = '@';
if(childpid > 0) {
WRITEMAINTLOG6(5, "UNSUB: ", address, ". Bounced since",
bouncedata, ".\n");
- free(address);
- free(bouncedata);
+ myfree(address);
+ myfree(bouncedata);
do /* Parent waits for the child */
pid = waitpid(childpid, &status, 0);
while(pid == -1 && errno == EINTR);
mlmmjsend = concatstr(2, bindir, "/mlmmj-send");
mlmmjbounce = concatstr(2, bindir, "/mlmmj-bounce");
mlmmjunsub = concatstr(2, bindir, "/mlmmj-unsub");
- free(bindir);
+ myfree(bindir);
if(daemonize && daemon(1,0) < 0) {
log_error(LOG_ARGS, "Could not daemonize. Only one "
for(;;) {
random = random_str();
logname = concatstr(3, listdir, "maintdlog-", random);
- free(random);
+ myfree(random);
maintdlogfd = open(logname, O_WRONLY|O_EXCL|O_CREAT,
S_IRUSR|S_IWUSR);
if(maintdlogfd < 0) {
- free(logname);
+ myfree(logname);
log_error(LOG_ARGS, "Could not open maintenance logfile");
exit(EXIT_FAILURE);
}
log_error(LOG_ARGS, "Could not rename(%s,%s)",
logname, logstr);
- free(logname);
- free(logstr);
+ myfree(logname);
+ myfree(logstr);
if(daemonize == 0)
break;
sleep(MAINTD_SLEEP);
}
- free(mlmmjbounce);
- free(mlmmjsend);
- free(mlmmjunsub);
+ myfree(mlmmjbounce);
+ myfree(mlmmjsend);
+ myfree(mlmmjunsub);
log_free_name();
#include "getlistaddr.h"
#include "prepstdreply.h"
#include "subscriberfuncs.h"
+#include "memory.h"
void newmoderated(const char *listdir, const char *mailfilename,
const char *mlmmjsend)
moderatorfilename = concatstr(2, listdir, "/text/moderation");
if((moderatorfd = open(moderatorfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open text/moderation");
- free(moderatorfilename);
+ myfree(moderatorfilename);
exit(EXIT_FAILURE);
}
- free(moderatorfilename);
+ myfree(moderatorfilename);
moderatorsfilename = concatstr(2, listdir, "/control/moderators");
if((moderatorsfd = open(moderatorsfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", moderatorsfilename);
- free(queuefilename);
- free(moderatorsfilename);
+ myfree(queuefilename);
+ myfree(moderatorsfilename);
close(queuefd);
exit(EXIT_FAILURE);
}
- free(moderatorsfilename);
+ myfree(moderatorsfilename);
if((mailfd = open(mailfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", mailfilename);
- free(queuefilename);
- free(moderatorsfilename);
+ myfree(queuefilename);
+ myfree(moderatorsfilename);
close(queuefd);
exit(EXIT_FAILURE);
}
if((queuefd = open(queuefilename, O_WRONLY|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", queuefilename);
- free(queuefilename);
- free(randomstr);
+ myfree(queuefilename);
+ myfree(randomstr);
exit(EXIT_FAILURE);
}
- free(randomstr);
+ myfree(randomstr);
from = concatstr(3, listname, "+owner@", fqdn);
s1 = concatstr(15, "From: ", from, "\nTo: ", listname, "-moderators@",
log_error(LOG_ARGS, "Could not write to %s", queuefilename);
exit(EXIT_FAILURE);
}
- free(s1);
+ myfree(s1);
s1 = concatstr(5, listname, "+moderate-", mailbasename, "@", fqdn);
while((buf = mygetline(moderatorfd))) {
queuefilename);
exit(EXIT_FAILURE);
}
- free(s1);
+ myfree(s1);
} else if(strncmp(buf, "*MODERATORS*", 12) == 0) {
- free(buf);
+ myfree(buf);
while((buf = mygetline(moderatorsfd))) {
if(writen(queuefd, buf, strlen(buf)) < 0)
log_error(LOG_ARGS,
"Could not write moderators");
- free(buf);
+ myfree(buf);
buf = NULL;
}
} else
"Could not write moderatemail");
exit(EXIT_FAILURE);
}
- free(buf);
+ myfree(buf);
}
close(moderatorfd);
close(moderatorsfd);
while((buf = mygetline(mailfd)) && count < 100) {
s1 = concatstr(2, " ", buf);
- free(buf);
+ myfree(buf);
writen(queuefd, s1, strlen(s1));
- free(s1);
+ myfree(s1);
count++;
}
close(queuefd);
mlmmjsub = concatstr(2, bindir, "/mlmmj-sub");
mlmmjunsub = concatstr(2, bindir, "/mlmmj-unsub");
mlmmjbounce = concatstr(2, bindir, "/mlmmj-bounce");
- free(bindir);
+ myfree(bindir);
while ((opt = getopt(argc, argv, "hVPm:L:")) != -1) {
switch(opt) {
donemailfd = open(donemailname, O_RDWR|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR);
while(donemailfd < 0 && errno == EEXIST) {
- free(donemailname);
+ myfree(donemailname);
randomstr = random_str();
donemailname = concatstr(3, listdir, "/queue/", randomstr);
fd = open(donemailname, O_RDWR|O_CREAT|O_EXCL,
}
if(donemailfd < 0) {
- free(donemailname);
+ myfree(donemailname);
log_error(LOG_ARGS, "could not create mail file in queue"
"directory");
exit(EXIT_FAILURE);
log_error(LOG_ARGS, "donemailname = [%s]\n", donemailname);
#endif
if((rawmailfd = open(mailfile, O_RDONLY)) < 0) {
- free(donemailname);
+ myfree(donemailname);
log_error(LOG_ARGS, "could not open() input mail file");
exit(EXIT_FAILURE);
}
headerfilename = concatstr(2, listdir, "/control/customheaders");
hdrfd = open(headerfilename, O_RDONLY);
- free(headerfilename);
+ myfree(headerfilename);
footerfilename = concatstr(2, listdir, "/control/footer");
footfd = open(footerfilename, O_RDONLY);
- free(footerfilename);
+ myfree(footerfilename);
delheaders = ctrlvalues(listdir, "delheaders");
if(delheaders == NULL) {
- delheaders = malloc(sizeof(struct strlist));
+ delheaders = mymalloc(sizeof(struct strlist));
delheaders->count = 0;
delheaders->strs = NULL;
}
- delheaders->strs = realloc(delheaders->strs,
+ delheaders->strs = myrealloc(delheaders->strs,
(delheaders->count+3) * sizeof(char *));
- delheaders->strs[delheaders->count++] = strdup("From ");
- delheaders->strs[delheaders->count++] = strdup("Return-Path:");
+ delheaders->strs[delheaders->count++] = mystrdup("From ");
+ delheaders->strs[delheaders->count++] = mystrdup("Return-Path:");
delheaders->strs[delheaders->count++] = NULL;
subjectprefix = ctrlvalue(listdir, "prefix");
}
for(i = 0; i < delheaders->count; i++)
- free(delheaders->strs[i]);
- free(delheaders->strs);
- free(delheaders);
+ myfree(delheaders->strs[i]);
+ myfree(delheaders->strs);
+ myfree(delheaders);
close(rawmailfd);
close(donemailfd);
"/queue/discarded/",
randomstr);
rename(donemailname, discardname);
- free(donemailname);
- free(discardname);
+ myfree(donemailname);
+ myfree(discardname);
/* TODO: free emailstructs */
exit(EXIT_SUCCESS);
}
queuefilename = prepstdreply(listdir, "notintocc", fromstr,
fromemails.emaillist[0], NULL,
subject, 1, maildata);
- free(listaddr);
- free(listname);
- free(listfqdn);
- free(fromstr);
- free(subject);
+ myfree(listaddr);
+ myfree(listname);
+ myfree(listfqdn);
+ myfree(fromstr);
+ myfree(subject);
execlp(mlmmjsend, mlmmjsend,
"-l", "1",
"-T", fromemails.emaillist[0],
queuefilename = prepstdreply(listdir, "subonlypost",
fromstr, fromemails.emaillist[0], NULL,
subject, 2, maildata);
- free(listaddr);
- free(listname);
- free(listfqdn);
- free(fromstr);
- free(subject);
+ myfree(listaddr);
+ myfree(listname);
+ myfree(listfqdn);
+ myfree(fromstr);
+ myfree(subject);
execlp(mlmmjsend, mlmmjsend,
"-l", "1",
"-T", fromemails.emaillist[0],
if(moderated) {
mqueuename = concatstr(3, listdir, "/moderation/",
randomstr);
- free(randomstr);
+ myfree(randomstr);
if(rename(donemailname, mqueuename) < 0) {
log_error(LOG_ARGS, "could not rename(%s,%s)",
donemailname, mqueuename);
- free(donemailname);
- free(mqueuename);
+ myfree(donemailname);
+ myfree(mqueuename);
exit(EXIT_FAILURE);
}
- free(donemailname);
+ myfree(donemailname);
newmoderated(listdir, mqueuename, mlmmjsend);
return EXIT_SUCCESS;
}
if(noprocess) {
- free(donemailname);
- /* XXX: toemails and ccemails etc. have to be free() */
+ myfree(donemailname);
+ /* XXX: toemails and ccemails etc. have to be myfree() */
exit(EXIT_SUCCESS);
}
#include "mygetline.h"
#include "strgen.h"
#include "log_error.h"
+#include "memory.h"
extern char *optarg;
bindir = mydirname(argv[0]);
mlmmjprocess = concatstr(2, bindir, "/mlmmj-process");
- free(bindir);
+ myfree(bindir);
while ((opt = getopt(argc, argv, "hPVL:F")) != -1) {
switch(opt) {
}
infilename = concatstr(3, listdir, "/incoming/", randomstr);
- free(randomstr);
+ myfree(randomstr);
fd = open(infilename, O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);
while(fd < 0 && errno == EEXIST) {
- free(infilename);
+ myfree(infilename);
randomstr = random_str();
infilename = concatstr(3, listdir, "/incoming/", randomstr);
- free(randomstr);
+ myfree(randomstr);
fd = open(infilename, O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);
}
if(fd < 0) {
log_error(LOG_ARGS, "could not create mail file in "
"%s/incoming directory", listdir);
- free(infilename);
+ myfree(infilename);
exit(EXIT_FAILURE);
}
close(fd);
if(noprocess) {
- free(infilename);
+ myfree(infilename);
exit(EXIT_SUCCESS);
}
#include "log_error.h"
#include "mygetline.h"
#include "wrappers.h"
+#include "memory.h"
char *bounce_from_adr(const char *recipient, const char *listadr,
const char *mailfilename)
char *indexstr, *listdomain, *a, *mymailfilename;
size_t len;
- mymailfilename = strdup(mailfilename);
+ mymailfilename = mystrdup(mailfilename);
if (!mymailfilename) {
return NULL;
}
indexstr = mymailfilename;
}
- myrecipient = strdup(recipient);
+ myrecipient = mystrdup(recipient);
if (!myrecipient) {
- free(mymailfilename);
+ myfree(mymailfilename);
return NULL;
}
a = strchr(myrecipient, '@');
if (a) *a = '=';
- mylistadr = strdup(listadr);
+ mylistadr = mystrdup(listadr);
if (!mylistadr) {
- free(mymailfilename);
- free(myrecipient);
+ myfree(mymailfilename);
+ myfree(myrecipient);
return NULL;
}
listdomain = strchr(mylistadr, '@');
if (!listdomain) {
- free(mymailfilename);
- free(myrecipient);
- free(mylistadr);
+ myfree(mymailfilename);
+ myfree(myrecipient);
+ myfree(mylistadr);
return NULL;
}
*listdomain++ = '\0';
/* 12 = RECIPDELIM + "bounces-" + "-" + "@" + NUL */
len = strlen(mylistadr) + strlen(myrecipient) + strlen(indexstr)
+ strlen(listdomain) + 12;
- bounceaddr = malloc(len);
+ bounceaddr = mymalloc(len);
if (!bounceaddr) {
- free(myrecipient);
- free(mylistadr);
+ myfree(myrecipient);
+ myfree(mylistadr);
return NULL;
}
snprintf(bounceaddr, len, "%s%cbounces-%s-%s@%s", mylistadr, RECIPDELIM,
myrecipient, indexstr, listdomain);
- free(myrecipient);
- free(mylistadr);
- free(mymailfilename);
+ myfree(myrecipient);
+ myfree(mylistadr);
+ myfree(mymailfilename);
return bounceaddr;
}
int bouncemail(const char *listdir, const char *mlmmjbounce, const char *from)
{
- char *myfrom = strdup(from);
+ char *myfrom = mystrdup(from);
char *addr, *num, *c;
size_t len;
pid_t pid = 0;
if((c = strchr(myfrom, '@')) == NULL) {
- free(myfrom);
+ myfree(myfrom);
return 0; /* Success when malformed 'from' */
}
*c = '\0';
myfrom = strchr(c, '-');
myfrom++;
len = num - myfrom - 1;
- addr = malloc(len + 1);
+ addr = mymalloc(len + 1);
addr[len] = '\0';
strncpy(addr, myfrom, len);
if(reply) {
log_error(LOG_ARGS, "Error in MAIL FROM. Reply = [%s]",
reply);
- free(reply);
+ myfree(reply);
write_rset(sockfd);
checkwait_smtpreply(sockfd, MLMMJ_RSET);
return MLMMJ_FROM;
checkwait_smtpreply(sockfd, MLMMJ_RSET);
if(mlmmjbounce && ((reply[0] == '4') || (reply[0] == '5'))
&& (reply[1] == '5')) {
- free(reply);
+ myfree(reply);
return bouncemail(listdir, mlmmjbounce, from);
} else {
log_error(LOG_ARGS, "Error in RCPT TO. Reply = [%s]",
reply);
- free(reply);
+ myfree(reply);
return MLMMJ_RCPTTO;
}
}
reply = checkwait_smtpreply(sockfd, MLMMJ_DATA);
if(reply) {
log_error(LOG_ARGS, "Error with DATA. Reply = [%s]", reply);
- free(reply);
+ myfree(reply);
write_rset(sockfd);
checkwait_smtpreply(sockfd, MLMMJ_RSET);
return MLMMJ_DATA;
log_error(LOG_ARGS, "Mailserver did not ack end of mail.\n"
"<CR><LF>.<CR><LF> was written, to no"
"avail. Reply = [%s]", reply);
- free(reply);
+ myfree(reply);
write_rset(sockfd);
checkwait_smtpreply(sockfd, MLMMJ_RSET);
return MLMMJ_DOT;
if((reply = checkwait_smtpreply(*sockfd, MLMMJ_CONNECT)) != NULL) {
log_error(LOG_ARGS, "No proper greeting to our connect"
"Reply: [%s]", reply);
- free(reply);
+ myfree(reply);
retval = MLMMJ_CONNECT;
/* FIXME: Queue etc. */
}
write_helo(*sockfd, myhostname);
- free(myhostname);
+ myfree(myhostname);
if((reply = checkwait_smtpreply(*sockfd, MLMMJ_HELO)) != NULL) {
log_error(LOG_ARGS, "Error with HELO. Reply: [%s]", reply);
/* FIXME: quit and tell admin to configure correctly */
- free(reply);
+ myfree(reply);
retval = MLMMJ_HELO;
}
if((reply = checkwait_smtpreply(*sockfd, MLMMJ_QUIT)) != 0) {
log_error(LOG_ARGS, "Mailserver would not let us QUIT. "
"We close the socket anyway though.");
- free(reply);
+ myfree(reply);
retval = MLMMJ_QUIT;
}
len = next - cur;
if(next == start + st.st_size - 1 && *next != '\n')
len++;
- addr = malloc(len + 1);
+ addr = mymalloc(len + 1);
strncpy(addr, cur, len);
addr[len] = '\0';
cur = next + 1;
archivefilename);
sendres = send_mail(sockfd, bounceaddr, addr, replyto,
mailmap, mailsize, listdir, mlmmjbounce);
- free(bounceaddr);
+ myfree(bounceaddr);
}
if(sendres && listaddr && archivefilename) {
/* we failed, so save the addresses and bail */
index = mybasename(archivefilename);
dirname = concatstr(3, listdir, "/requeue/", index);
- free(index);
+ myfree(index);
if(mkdir(dirname, 0750) < 0) {
log_error(LOG_ARGS, "Could not mkdir(%s) for "
"requeueing. Mail cannot "
"be requeued.", dirname);
- free(dirname);
- free(addr);
+ myfree(dirname);
+ myfree(addr);
return -1;
}
addrfilename = concatstr(2, dirname, "/subscribers");
- free(dirname);
+ myfree(dirname);
addrfd = open(addrfilename, O_WRONLY|O_CREAT|O_APPEND,
S_IRUSR|S_IWUSR);
if(addrfd < 0) {
log_error(LOG_ARGS, "Could not write to %s",
addrfilename);
- free(addrfilename);
- free(addr);
+ myfree(addrfilename);
+ myfree(addr);
return -1;
} else { /* dump the remaining addresses */
do {
"Could not add [%s] "
"to requeue address "
"file.", addr);
- free(addr);
+ myfree(addr);
addr = mygetline(subfd);
} while(addr);
}
- free(addr);
- free(addrfilename);
+ myfree(addr);
+ myfree(addrfilename);
close(addrfd);
return -1;
}
- free(addr);
+ myfree(addr);
}
return 0;
}
bindir = mydirname(argv[0]);
mlmmjbounce = concatstr(2, bindir, "/mlmmj-bounce");
- free(bindir);
+ myfree(bindir);
while ((opt = getopt(argc, argv, "aVDhm:l:L:R:F:T:r:s:")) != -1){
switch(opt) {
}
if(!listctrl)
- listctrl = strdup("0");
+ listctrl = mystrdup("0");
/* get the list address */
if((subfd = open(subfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s':",
subfilename);
- free(subfilename);
+ myfree(subfilename);
/* No moderators is no error. Could be the sysadmin
* likes to do it manually.
*/
if(archive) {
mindex = incindexfile((const char *)listdir);
len = strlen(listdir) + 9 + 20;
- archivefilename = malloc(len);
+ archivefilename = mymalloc(len);
snprintf(archivefilename, len, "%s/archive/%d", listdir,
mindex);
}
if(!relayhost)
- relayhost = strdup(RELAYHOST);
+ relayhost = mystrdup(RELAYHOST);
switch(listctrl[0]) {
case '1': /* A single mail is to be sent */
tmpstr = concatstr(2, mailfilename, ".mailfrom");
tmpfd = open(tmpstr, O_WRONLY|O_CREAT|O_TRUNC,
S_IRUSR|S_IWUSR);
- free(tmpstr);
+ myfree(tmpstr);
if(tmpfd >= 0) {
writen(tmpfd, bounceaddr, strlen(to_addr));
fsync(tmpfd);
tmpstr = concatstr(2, mailfilename, ".reciptto");
tmpfd = open(tmpstr, O_WRONLY|O_CREAT|O_TRUNC,
S_IRUSR|S_IWUSR);
- free(tmpstr);
+ myfree(tmpstr);
if(tmpfd >= 0) {
writen(tmpfd, to_addr, strlen(bounceaddr));
fsync(tmpfd);
".reply-to");
tmpfd = open(tmpstr, O_WRONLY|O_CREAT|O_TRUNC,
S_IRUSR|S_IWUSR);
- free(tmpstr);
+ myfree(tmpstr);
if(tmpfd >= 0) {
writen(tmpfd, replyto,
strlen(replyto));
if((subddir = opendir(subddirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)",
subddirname);
- free(subddirname);
+ myfree(subddirname);
exit(EXIT_FAILURE);
}
- free(subddirname);
+ myfree(subddirname);
while((dp = readdir(subddir)) != NULL) {
if(!strcmp(dp->d_name, "."))
if((subfd = open(subfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'",
subfilename);
- free(subfilename);
+ myfree(subfilename);
continue;
}
- free(subfilename);
+ myfree(subfilename);
initsmtp(&sockfd, relayhost);
sendres = send_mail_many(sockfd, NULL, NULL, mailmap,
if(archive) {
rename(mailfilename, archivefilename);
- free(archivefilename);
+ myfree(archivefilename);
} else if(deletewhensent)
unlink(mailfilename);
#include "subscriberfuncs.h"
#include "log_error.h"
#include "mygetline.h"
+#include "memory.h"
void confirm_sub(const char *listdir, const char *listaddr,
const char *subaddr, const char *mlmmjsend)
if((subtextfd = open(subtextfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", subtextfilename);
- free(subtextfilename);
+ myfree(subtextfilename);
exit(EXIT_FAILURE);
}
- free(subtextfilename);
+ myfree(subtextfilename);
listname = genlistname(listaddr);
listfqdn = genlistfqdn(listaddr);
if((queuefd = open(queuefilename, O_WRONLY|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", queuefilename);
- free(queuefilename);
- free(randomstr);
+ myfree(queuefilename);
+ myfree(randomstr);
exit(EXIT_FAILURE);
}
- free(randomstr);
+ myfree(randomstr);
fromaddr = concatstr(3, listname, "+bounces-help@", listfqdn);
log_error(LOG_ARGS, "Could not write welcome mail");
exit(EXIT_FAILURE);
}
- free(s1);
+ myfree(s1);
while((buf = mygetline(subtextfd))) {
if(strncmp(buf, "*LSTADDR*", 9) == 0) {
if(writen(queuefd, listaddr, strlen(listaddr)) < 0) {
- log_error(LOG_ARGS, "Could not write welcome mail");
+ log_error(LOG_ARGS, "Could not write welcome"
+ " mail");
exit(EXIT_FAILURE);
}
} else {
if(writen(queuefd, buf, strlen(buf)) < 0) {
- log_error(LOG_ARGS, "Could not write welcome mail");
+ log_error(LOG_ARGS, "Could not write welcome"
+ " mail");
exit(EXIT_FAILURE);
}
}
- free(buf);
+ myfree(buf);
}
- free(listname);
- free(listfqdn);
+ myfree(listname);
+ myfree(listfqdn);
close(subtextfd);
close(queuefd);
if((subconffd = open(confirmfilename, O_RDWR|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", confirmfilename);
- free(confirmfilename);
- free(randomstr);
+ myfree(confirmfilename);
+ myfree(randomstr);
exit(EXIT_FAILURE);
}
exit(EXIT_FAILURE);
}
close(subconffd);
- free(confirmfilename);
+ myfree(confirmfilename);
confirmaddr = concatstr(5, listname, "+confsub-", randomstr, "@",
listfqdn);
if((subtextfd = open(subtextfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", subtextfilename);
- free(randomstr);
- free(subtextfilename);
+ myfree(randomstr);
+ myfree(subtextfilename);
exit(EXIT_FAILURE);
}
- free(subtextfilename);
+ myfree(subtextfilename);
queuefilename = concatstr(3, listdir, "/queue/", randomstr);
if((queuefd = open(queuefilename, O_RDWR|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", queuefilename);
- free(queuefilename);
- free(randomstr);
+ myfree(queuefilename);
+ myfree(randomstr);
exit(EXIT_FAILURE);
}
- free(randomstr);
+ myfree(randomstr);
s1 = concatstr(9, "From: ", listname, "+help@", listfqdn, "\nTo: ",
subaddr, "\nSubject: Confirm subscribe to ", listaddr,
exit(EXIT_FAILURE);
}
- free(s1);
+ myfree(s1);
while((buf = mygetline(subtextfd))) {
if(strncmp(buf, "*LSTADDR*", 9) == 0) {
}
}
- free(listname);
- free(listfqdn);
+ myfree(listname);
+ myfree(listfqdn);
close(subtextfd);
close(queuefd);
bindir = mydirname(argv[0]);
mlmmjsend = concatstr(2, bindir, "/mlmmj-send");
- free(bindir);
+ myfree(bindir);
while ((opt = getopt(argc, argv, "hcCVL:a:")) != -1) {
switch(opt) {
}
} else {
myunlock(subfilefd);
- free(subfilename);
+ myfree(subfilename);
close(subfilefd);
return EXIT_SUCCESS;
if(confirmsub)
confirm_sub(listdir, listaddr, address, mlmmjsend);
- free(listaddr);
+ myfree(listaddr);
return EXIT_SUCCESS;
}
#include "subscriberfuncs.h"
#include "strgen.h"
#include "log_error.h"
+#include "memory.h"
void confirm_unsub(const char *listdir, const char *listaddr,
const char *subaddr, const char *mlmmjsend)
if((subtextfd = open(subtextfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", subtextfilename);
- free(subtextfilename);
+ myfree(subtextfilename);
exit(EXIT_FAILURE);
}
- free(subtextfilename);
+ myfree(subtextfilename);
listname = genlistname(listaddr);
listfqdn = genlistfqdn(listaddr);
if((queuefd = open(queuefilename, O_WRONLY|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", queuefilename);
- free(queuefilename);
- free(randomstr);
+ myfree(queuefilename);
+ myfree(randomstr);
exit(EXIT_FAILURE);
}
- free(randomstr);
+ myfree(randomstr);
fromaddr = concatstr(3, listname, "+bounces-help@", listfqdn);
exit(EXIT_FAILURE);
}
- free(s1);
+ myfree(s1);
while((buf = mygetline(subtextfd))) {
if(strncmp(buf, "*LSTADDR*", 9) == 0) {
}
}
- free(listname);
- free(listfqdn);
+ myfree(listname);
+ myfree(listfqdn);
close(subtextfd);
close(queuefd);
if((subconffd = open(confirmfilename, O_WRONLY|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", confirmfilename);
- free(confirmfilename);
- free(randomstr);
+ myfree(confirmfilename);
+ myfree(randomstr);
exit(EXIT_FAILURE);
}
- free(confirmfilename);
+ myfree(confirmfilename);
if(writen(subconffd, subaddr, strlen(subaddr)) < 0) {
log_error(LOG_ARGS, "Could not write unsubconffile");
if((subtextfd = open(subtextfilename, O_RDONLY)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", subtextfilename);
- free(randomstr);
- free(subtextfilename);
+ myfree(randomstr);
+ myfree(subtextfilename);
exit(EXIT_FAILURE);
}
- free(subtextfilename);
+ myfree(subtextfilename);
queuefilename = concatstr(3, listdir, "/queue/", randomstr);
if((queuefd = open(queuefilename, O_WRONLY|O_CREAT|O_EXCL,
S_IRUSR|S_IWUSR)) < 0) {
log_error(LOG_ARGS, "Could not open '%s'", queuefilename);
- free(queuefilename);
- free(randomstr);
+ myfree(queuefilename);
+ myfree(randomstr);
exit(EXIT_FAILURE);
}
- free(randomstr);
+ myfree(randomstr);
s1 = concatstr(9, "From: ", listname, "+help@", listfqdn, "\nTo: ",
subaddr, "\nSubject: Confirm unsubscribe from ",
exit(EXIT_FAILURE);
}
- free(s1);
+ myfree(s1);
while((buf = mygetline(subtextfd))) {
if(strncmp(buf, "*LSTADDR*", 9) == 0) {
}
}
- free(listname);
- free(listfqdn);
+ myfree(listname);
+ myfree(listfqdn);
close(subtextfd);
close(queuefd);
bindir = mydirname(argv[0]);
mlmmjsend = concatstr(2, bindir, "/mlmmj-send");
- free(bindir);
+ myfree(bindir);
while ((opt = getopt(argc, argv, "hcCVL:a:")) != -1) {
switch(opt) {
if((subddir = opendir(subddirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)",
subddirname);
- free(subddirname);
+ myfree(subddirname);
exit(EXIT_FAILURE);
}
- free(subddirname);
+ myfree(subddirname);
while((dp = readdir(subddir)) != NULL) {
if(!strcmp(dp->d_name, "."))
continue;
subread = open(subreadname, O_RDWR);
if(subread == -1) {
log_error(LOG_ARGS, "Could not open '%s'", subreadname);
- free(subreadname);
+ myfree(subreadname);
continue;
}
suboff = find_subscriber(subread, address);
if(suboff == -1) {
close(subread);
- free(subreadname);
+ myfree(subreadname);
continue;
}
log_error(LOG_ARGS, "Error locking '%s' file",
subreadname);
close(subread);
- free(subreadname);
+ myfree(subreadname);
continue;
}
subwritename);
myunlock(subread);
close(subread);
- free(subreadname);
- free(subwritename);
+ myfree(subreadname);
+ myfree(subwritename);
continue;
}
myunlock(subread);
close(subread);
close(subwrite);
- free(subreadname);
- free(subwritename);
+ myfree(subreadname);
+ myfree(subwritename);
continue;
}
close(subread);
close(subwrite);
unlink(subwritename);
- free(subreadname);
- free(subwritename);
+ myfree(subreadname);
+ myfree(subwritename);
continue;
}
myunlock(subwrite);
close(subread);
close(subwrite);
- free(subreadname);
- free(subwritename);
+ myfree(subreadname);
+ myfree(subwritename);
continue;
}
} else /* unsubres == 0, no subscribers left */
myunlock(subwrite);
close(subread);
close(subwrite);
- free(subreadname);
- free(subwritename);
+ myfree(subreadname);
+ myfree(subwritename);
if(confirmunsub)
confirm_unsub(listdir, listaddr, address, mlmmjsend);
}
closedir(subddir);
- free(listaddr);
+ myfree(listaddr);
return EXIT_SUCCESS;
}
#include <string.h>
#include <unistd.h>
#include <errno.h>
+
#include "mygetline.h"
+#include "memory.h"
char *mygetline(int fd)
{
size_t i = 0, res, buf_size = BUFSIZE; /* initial buffer size */
- char *buf = malloc(buf_size);
+ char *buf = mymalloc(buf_size);
char ch;
buf[0] = '\0';
if(errno == EINTR)
continue;
else {
- free(buf);
+ myfree(buf);
return NULL;
}
}
buf[i] = '\0';
return buf;
} else {
- free(buf);
+ myfree(buf);
return NULL;
}
}
if(i == buf_size - 1) {
buf_size *= 2;
- buf = realloc(buf, buf_size);
+ buf = myrealloc(buf, buf_size);
}
buf[i++] = ch;
if(ch == '\n') {
#include "strgen.h"
#include "wrappers.h"
+#include "memory.h"
int openrandexclrw(const char *dir, const char *prefix, mode_t mode)
{
do {
randomstr = random_str();
- free(filename); /* It is OK to free() NULL, as this
- will in the first iteration. */
+ myfree(filename); /* It is OK to free NULL, as this
+ will do in the first iteration. */
filename = concatstr(4, dir, "/", prefix, randomstr);
- free(randomstr);
+ myfree(randomstr);
fd = open(filename, O_RDWR|O_CREAT|O_EXCL, mode);
} while ((fd < 0) && (errno == EEXIST));
+ /* TODO error checking, bail out */
+
return fd;
}
#include "log_error.h"
#include "mygetline.h"
#include "wrappers.h"
+#include "memory.h"
char *prepstdreply(const char *listdir, const char *filename, const char *from,
const char *to, const char *replyto, const char *subject,
tmp = concatstr(3, listdir, "/text/", filename);
infd = open(tmp, O_RDONLY);
- free(tmp);
+ myfree(tmp);
if(infd < 0) {
log_error(LOG_ARGS, "Could not open std mail %s", filename);
return NULL;
}
- tmp = concatstr(6, "From: ", from, "\nTo: ", to, "\nSubject: ", subject);
+ tmp = concatstr(6, "From: ", from,
+ "\nTo: ", to,
+ "\nSubject: ", subject);
if(replyto)
str = concatstr(3, tmp, "\nReply-To: ", replyto, "\n\n");
else
str = concatstr(2, tmp, "\n\n");
- free(tmp);
+ myfree(tmp);
tmp = random_str();
retstr = concatstr(3, listdir, "/queue/", random);
- free(tmp);
+ myfree(tmp);
outfd = open(retstr, O_RDWR|O_CREAT|O_EXCL, S_IRUSR|S_IWUSR);
if(outfd < 0) {
log_error(LOG_ARGS, "Could not open std mail %s", tmp);
log_error(LOG_ARGS, "Could not write std mail");
return NULL;
}
- free(str);
+ myfree(str);
while((str = mygetline(infd))) {
for(i = 0; i < tokencount; i++) {
if(strncmp(str, data[i*2], strlen(data[i*2])) == 0) {
- free(str);
- str = strdup(data[(i*2)+1]);
+ myfree(str);
+ str = mystrdup(data[(i*2)+1]);
}
}
if(writen(outfd, str, strlen(str)) < 0) {
log_error(LOG_ARGS, "Could not write std mail");
return NULL;
}
- free(str);
+ myfree(str);
}
fsync(outfd);
close(outfd);
return retstr;
-}
+}
#include "wrappers.h"
#include "mygetline.h"
#include "prepstdreply.h"
+#include "memory.h"
void send_help(const char *listdir, const char *emailaddr,
const char *mlmmjsend)
exit(EXIT_FAILURE);
}
- free(fromstr);
- free(listaddr);
- free(listname);
- free(listfqdn);
- free(maildata[1]);
- free(maildata[3]);
- free(maildata[5]);
- free(subject);
+ myfree(fromstr);
+ myfree(listaddr);
+ myfree(listname);
+ myfree(listfqdn);
+ myfree(maildata[1]);
+ myfree(maildata[3]);
+ myfree(maildata[5]);
+ myfree(subject);
execlp(mlmmjsend, mlmmjsend,
"-l", "1",
#include "strgen.h"
#include "statctrl.h"
+#include "memory.h"
int statctrl(const char *listdir, const char *ctrlstr)
{
int res;
res = stat(filename, &st);
- free(filename);
+ myfree(filename);
if(res == 0)
return 1;
#include "strgen.h"
#include "wrappers.h"
+#include "memory.h"
char *random_str()
{
size_t len = 32;
- char *dest = malloc(len);
+ char *dest = mymalloc(len);
snprintf(dest, len, "%X%X", random_int(), random_int());
char *random_plus_addr(const char *addr)
{
size_t len = strlen(addr) + 16;
- char *dest = malloc(len);
+ char *dest = mymalloc(len);
char *atsign;
char *tmpstr;
- tmpstr = malloc(len);
+ tmpstr = mymalloc(len);
snprintf(tmpstr, len, "%s", addr);
atsign = index(tmpstr, '@');
snprintf(dest, len, "%d-%s", random_int(), tmpstr);
- free(tmpstr);
+ myfree(tmpstr);
return dest;
}
char *headerstr(const char *headertoken, const char *str)
{
size_t len = strlen(headertoken) + strlen(str) + 2;
- char *dest = malloc(len);
+ char *dest = mymalloc(len);
snprintf(dest, len, "%s%s\n", headertoken, str);
atsign = index(listaddr, '@');
len = atsign - listaddr + 1;
- dest = malloc(len);
+ dest = mymalloc(len);
snprintf(dest, len, "%s", listaddr);
atsign = index(listaddr, '@');
len = strlen(listaddr) - (atsign - listaddr);
- dest = malloc(len);
+ dest = mymalloc(len);
snprintf(dest, len, "%s", atsign + 1);
return dest;
len += strlen(str);
}
- retstr = malloc(len + 1);
+ retstr = mymalloc(len + 1);
retstr[0] = retstr[len] = 0;
va_start(arg, count);
hostname[sizeof(hostname)-1] = '\0';
hostlookup = gethostbyname(hostname);
- return strdup(hostlookup->h_name);
+ return mystrdup(hostlookup->h_name);
}
char *mydirname(const char *path)
{
char *mypath, *dname, *ret;
- mypath = strdup(path);
+ mypath = mystrdup(path);
dname = dirname(mypath);
- ret = strdup(dname);
+ ret = mystrdup(dname);
/* We don't free mypath until we have strdup()'ed dname, because
* dirname() returns a pointer into mypath -- mortenp 20040527 */
- free(mypath);
+ myfree(mypath);
return ret;
}
{
char *mypath, *bname, *ret;
- mypath = strdup(path);
+ mypath = mystrdup(path);
bname = basename(mypath);
- ret = strdup(bname);
+ ret = mystrdup(bname);
/* We don't free mypath until we have strdup()'ed bname, because
* basename() returns a pointer into mypath -- mortenp 20040527 */
- free(mypath);
+ myfree(mypath);
return ret;
}
#include "log_error.h"
#include "wrappers.h"
#include "strgen.h"
+#include "memory.h"
off_t find_subscriber(int fd, const char *address)
{
subddirname = concatstr(2, listdir, "/subscribers.d/");
if((subddir = opendir(subddirname)) == NULL) {
log_error(LOG_ARGS, "Could not opendir(%s)", subddirname);
- free(subddirname);
+ myfree(subddirname);
exit(EXIT_FAILURE);
}
- free(subddirname);
+ myfree(subddirname);
while((dp = readdir(subddir)) != NULL) {
if(!strcmp(dp->d_name, "."))
if(subread < 0) {
log_error(LOG_ARGS, "Could not open '%s'",
subreadname);
- free(subreadname);
+ myfree(subreadname);
continue;
}
suboff = find_subscriber(subread, address);
close(subread);
- free(subreadname);
+ myfree(subreadname);
if(suboff == -1) {
continue;
projects / thirdparty / mlmmj.git / commitdiff
