/*
* rules are of the form:
* <reg exp> <String> <repl exp> [<repl exp>]
*/
extern int
getrules(void)
{
Biobuf *rfp;
String *line;
String *type;
String *file;
file = abspath("rewrite", UPASLIB, (String *)0);
rfp = sysopen(s_to_c(file), "r", 0);
if(rfp == 0) {
rulep = 0;
return -1;
}
rlastp = 0;
line = s_new();
type = s_new();
while(s_getline(rfp, s_restart(line)))
if(getrule(line, type, thissys) && altthissys)
getrule(s_restart(line), type, altthissys);
s_free(type);
s_free(line);
s_free(file);
sysclose(rfp);
return 0;
}
KSmfTrackList *KSmfTrackList_new() {
KSmfTrackList *list = s_new(KSmfTrackList);
list->size = 32;
list->len = 0;
list->ptr = s_new_a(KSmfTrack*, list->size);
return list;
}
/*
* like trylock, but we've already got the lock on fd,
* and don't want an L. lock file.
*/
static Mlock *
keeplockalive(char *path, int fd)
{
char buf[1];
Mlock *l;
l = malloc(sizeof(Mlock));
if(l == 0)
return 0;
l->fd = fd;
l->name = s_new();
s_append(l->name, path);
/* fork process to keep lock alive until sysunlock(l) */
switch(l->pid = rfork(RFPROC)){
default:
break;
case 0:
fd = l->fd;
for(;;){
sleep(1000*60);
if(pread(fd, buf, 1, 0) < 0)
break;
}
_exits(0);
}
return l;
}
struct s_node *mkalt(struct s_node *l) {
struct s_node *r;
r = s_new(alt);
if (!r) nomem();
r->first = l;
return r;
}
struct s_node *mkcall(char *name) {
struct s_node *r;
r = s_new(call);
if (!r) nomem();
r->text = name;
return r;
}
/*
* report a recipient to remote
*/
char *
rcptto(char *to)
{
String *s;
s = unescapespecial(bangtoat(to));
if(toline == 0)
toline = s_new();
else
s_append(toline, ", ");
s_append(toline, s_to_c(s));
if(strchr(s_to_c(s), '@'))
dBprint("RCPT TO:<%s>\r\n", s_to_c(s));
else {
s_append(toline, "@");
s_append(toline, ddomain);
dBprint("RCPT TO:<%s@%s>\r\n", s_to_c(s), ddomain);
}
alarm(10*alarmscale);
switch(getreply()){
case 2:
break;
case 5:
return Giveup;
default:
return Retry;
}
return 0;
}
/*
* Get the next token from `line'. The symbol `\l' is replaced by
* the name of the local system.
*/
extern String *
rule_parse(String *line, char *system, int *backl)
{
String *token;
String *expanded;
char *cp;
token = s_parse(line, 0);
if(token == 0)
return(token);
if(strchr(s_to_c(token), '\\')==0)
return(token);
expanded = s_new();
for(cp = s_to_c(token); *cp; cp++) {
if(*cp == '\\') switch(*++cp) {
case 'l':
s_append(expanded, system);
*backl = 1;
break;
case '\\':
s_putc(expanded, '\\');
break;
default:
s_putc(expanded, '\\');
s_putc(expanded, *cp);
break;
} else
s_putc(expanded, *cp);
}
s_free(token);
s_terminate(expanded);
return(expanded);
}
/* return 1 if name found in one of the files
* 0 if name not found in one of the files
* -1 if neither file exists
*/
extern int
lookup(char *cp, char *local, Biobuf **lfpp, char *global, Biobuf **gfpp)
{
static String *file = 0;
if (local) {
if (file == 0)
file = s_new();
abspath(local, UPASLIB, s_restart(file));
if (*lfpp != 0 || (*lfpp = sysopen(s_to_c(file), "r", 0)) != 0) {
if (okfile(cp, *lfpp))
return 1;
} else
local = 0;
}
if (global) {
abspath(global, UPASLIB, s_restart(file));
if (*gfpp != 0 || (*gfpp = sysopen(s_to_c(file), "r", 0)) != 0) {
if (okfile(cp, *gfpp))
return 1;
} else
global = 0;
}
return (local || global)? 0 : -1;
}
struct s_node *mklit(char *t) {
struct s_node *r;
r = s_new(lit);
if (!r) nomem();
r->text = t;
return r;
}
struct s_node *mkseq(struct s_node *l) {
struct s_node *r;
r = s_new(seq);
if (!r) nomem();
r->first = l;
return r;
}
KSmfTrack *KSmfTrack_new() {
KSmfTrack *track = s_new(KSmfTrack);
track->size = 256;
track->len = 0;
track->ptr = s_new_a(KSmfEvent*, track->size);
return track;
}
/* Get the next field from a String. The field is delimited by white space,
* single or double quotes.
*/
String *
s_parse(String *from, String *to)
{
if (*from->ptr == '\0')
return 0;
if (to == 0)
to = s_new();
if (*from->ptr == '\'') {
from->ptr++;
for (;*from->ptr != '\'' && *from->ptr != '\0'; from->ptr++)
s_putc(to, *from->ptr);
if (*from->ptr == '\'')
from->ptr++;
} else if (*from->ptr == '"') {
from->ptr++;
for (;*from->ptr != '"' && *from->ptr != '\0'; from->ptr++)
s_putc(to, *from->ptr);
if (*from->ptr == '"')
from->ptr++;
} else {
for (;!isspace(*from->ptr) && *from->ptr != '\0'; from->ptr++)
s_putc(to, *from->ptr);
}
s_terminate(to);
/* crunch trailing white */
while(isspace(*from->ptr))
from->ptr++;
return to;
}
int pacc_wrap(const char *ign0, char *ign1, off_t ign2, struct s_node **result) {
struct s_node *p, *q, *r, *s;
/* A single character with value:
*
* char *A ← 'a' &( 'b' ) . { ref_str() }
*
*/
p = new_node(expr); p->text = "ref_str()"; q = p;
q = cons(s_new(any), q);
p = new_node(lit); p->text = "b"; s = p;
p = new_node(seq); p->first = s; s = p;
p = new_node(and); p->first = s; p->next = q; q = p;
p = new_node(lit); p->text = "a"; p->next = q; q = p;
p = new_node(seq); p->first = q; q = p;
p = new_node(type); p->text = "char *"; p->next = q; q = p;
p = new_node(rule); p->text = "A"; p->first = q; r = p;
r = cons(s_text(preamble, 0), r);
p = s_kid(grammar, r);
*result = p;
return 1;
}
bool MethodComparator::methods_EMCP(methodOop old_method, methodOop new_method) {
if (old_method->code_size() != new_method->code_size())
return false;
if (check_stack_and_locals_size(old_method, new_method) != 0) {
// RC_TRACE macro has an embedded ResourceMark
RC_TRACE(0x00800000, ("Methods %s non-comparable with diagnosis %d",
old_method->name()->as_C_string(),
check_stack_and_locals_size(old_method, new_method)));
return false;
}
_old_cp = old_method->constants();
_new_cp = new_method->constants();
BytecodeStream s_old(old_method);
BytecodeStream s_new(new_method);
_s_old = &s_old;
_s_new = &s_new;
_switchable_test = false;
Bytecodes::Code c_old, c_new;
while ((c_old = s_old.next()) >= 0) {
if ((c_new = s_new.next()) < 0 || c_old != c_new)
return false;
if (! args_same(c_old, c_new))
return false;
}
return true;
}
struct s_node *s_ccnode(const unsigned char *v) {
uint32_t c, s;
struct s_node *p = s_new(cceq);
assert(v);
if (v[0] == '\\') {
switch (v[1]) {
case 'a': c = 7; break;
case 'b': c = 8; break;
case 'f': c = 12; break;
case 'n': c = 10; break;
case 'r': c = 13; break;
case 't': c = 9; break;
case 'v': c = 11; break;
case '"': c = 34; break;
case '\'': c = 39; break;
case '?': c = 63; break;
case '\\': c = 92; break;
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7':
c = strtol((const char * restrict)v + 1, 0, 8); break;
case 'x': case 'u': case 'U':
c = strtol((const char * restrict)v + 2, 0, 16); break;
default: assert(0);
}
} else {
static void cook0(struct s_node *n) {
static char *name;
struct s_node *p;
if (n->type == rule)
name = n->text;
/* Replace
* ... _ foo
* with
* ... _ (foo / !.)
* for any non-empty foo.
*/
if (n->type == cafe) {
struct s_node *t;
//fprintf(stderr, "match at node %ld\n", n->id);
if (!n->next)
fatal3("invalid `$' at the end of rule `", name, "'");
t = s_kid(seq, s_kid(not, s_new(any)));
t = cons(s_kid(seq, n->next), t);
t = s_kid(alt, t);
// pre->next = t;
// free(n);
n->next = t;
}
if (s_has_children(n->type))
for (p = n->first; p; p = p->next)
cook0(p);
}
struct s_node *mkrule(char *name, struct s_node *what) {
struct s_node *r;
r = s_new(rule);
if (!r) nomem();
r->text = name;
r->first = what;
return r;
}
extern message *
m_new(void)
{
message *mp;
mp = (message *)mallocz(sizeof(message), 1);
if (mp == 0) {
perror("message:");
exit(1);
}
mp->sender = s_new();
mp->replyaddr = s_new();
mp->date = s_new();
mp->body = s_new();
mp->size = 0;
mp->fd = -1;
return mp;
}
/*
* if name is int32_ter than Namsiz bytes, try to split it at a slash and fit the
* pieces into hp->prefix and hp->name.
*/
static int
putfullname(Hdr *hp, char *name)
{
int namlen, pfxlen;
char *sl, *osl;
String *slname = nil;
if (isdir(hp)) {
slname = s_new();
s_append(slname, name);
s_append(slname, "/"); /* posix requires this */
name = s_to_c(slname);
}
namlen = strlen(name);
if (namlen <= Namsiz) {
strncpy(hp->name, name, Namsiz);
hp->prefix[0] = '\0'; /* ustar paranoia */
return 0;
}
if (!posix || namlen > Maxname) {
fprint(2, "%s: name too int32_t for tar header: %s\n",
argv0, name);
return -1;
}
/*
* try various splits until one results in pieces that fit into the
* appropriate fields of the header. look for slashes from right
* to left, in the hopes of putting the largest part of the name into
* hp->prefix, which is larger than hp->name.
*/
sl = strrchr(name, '/');
while (sl != nil) {
pfxlen = sl - name;
if (pfxlen <= sizeof hp->prefix && namlen-1 - pfxlen <= Namsiz)
break;
osl = sl;
*osl = '\0';
sl = strrchr(name, '/');
*osl = '/';
}
if (sl == nil) {
fprint(2, "%s: name can't be split to fit tar header: %s\n",
argv0, name);
return -1;
}
*sl = '\0';
strncpy(hp->prefix, name, sizeof hp->prefix);
*sl++ = '/';
strncpy(hp->name, sl, sizeof hp->name);
if (slname)
s_free(slname);
return 0;
}
bool MethodComparator::methods_switchable(methodOop old_method, methodOop new_method,
BciMap &bci_map) {
if (old_method->code_size() > new_method->code_size())
// Something has definitely been deleted in the new method, compared to the old one.
return false;
if (! check_stack_and_locals_size(old_method, new_method))
return false;
_old_cp = old_method->constants();
_new_cp = new_method->constants();
BytecodeStream s_old(old_method);
BytecodeStream s_new(new_method);
_s_old = &s_old;
_s_new = &s_new;
_bci_map = &bci_map;
_switchable_test = true;
GrowableArray<int> fwd_jmps(16);
_fwd_jmps = &fwd_jmps;
Bytecodes::Code c_old, c_new;
while ((c_old = s_old.next()) >= 0) {
if ((c_new = s_new.next()) < 0)
return false;
if (! (c_old == c_new && args_same(c_old, c_new))) {
int old_bci = s_old.bci();
int new_st_bci = s_new.bci();
bool found_match = false;
do {
c_new = s_new.next();
if (c_new == c_old && args_same(c_old, c_new)) {
found_match = true;
break;
}
} while (c_new >= 0);
if (! found_match)
return false;
int new_end_bci = s_new.bci();
bci_map.store_fragment_location(old_bci, new_st_bci, new_end_bci);
}
}
// Now we can test all forward jumps
for (int i = 0; i < fwd_jmps.length() / 2; i++) {
if (! bci_map.old_and_new_locations_same(fwd_jmps.at(i*2), fwd_jmps.at(i*2+1))) {
RC_TRACE(0x00800000,
("Fwd jump miss: old dest = %d, calc new dest = %d, act new dest = %d",
fwd_jmps.at(i*2), bci_map.new_bci_for_old(fwd_jmps.at(i*2)),
fwd_jmps.at(i*2+1)));
return false;
}
}
return true;
}
void client_proxy(zsock_t *pipe, void *arg) {
client_proxy_t *self = s_new(pipe);
assert(self);
zsock_signal(self->pipe, 0);
zloop_reader(self->loop, self->pipe, pipe_loop_handler, self);
zloop_start(self->loop);
zloop_reader_end(self->loop, self->pipe);
if (self->rep != NULL)
zloop_reader_end(self->loop, self->rep);
s_destroy(&self);
}
String*
s_reset(String *s)
{
if(s != nil){
s = s_unique(s);
s->ptr = s->base;
*s->ptr = '\0';
} else
s = s_new();
return s;
}
void ticket_hid_printer(zsock_t *pipe, void *arg) {
char *device_path = (char *) arg;
ticket_printer_t *self = s_new(pipe, device_path);
zsock_signal(self->pipe, 0);
int main_timer_id = zloop_timer(self->loop, 300, 0, timer_main_loop, self);
zloop_reader(self->loop, self->pipe, reader_pipe_event, self);
zloop_start(self->loop);
zloop_timer_end(self->loop, main_timer_id);
zloop_reader_end(self->loop, self->pipe);
s_destroy(&self);
}
/* * Convert from `bang' to `source routing' format. * * a.x.y!b.p.o!c!d -> @a.x.y:[email protected] */ String * bangtoat(char *addr) { String *buf; register int i; int j, d; char *field[128]; /* parse the '!' format address */ buf = s_new(); for(i = 0; addr; i++){ field[i] = addr; addr = strchr(addr, '!'); if(addr) *addr++ = 0; } if (i==1) { s_append(buf, field[0]); return buf; } /* * count leading domain fields (non-domains don't count) */ for(d = 0; d<i-1; d++) if(strchr(field[d], '.')==0) break; /* * if there are more than 1 leading domain elements, * put them in as source routing */ if(d > 1){ addhostdom(buf, field[0]); for(j=1; j<d-1; j++){ s_append(buf, ","); s_append(buf, "@"); s_append(buf, field[j]); } s_append(buf, ":"); } /* * throw in the non-domain elements separated by '!'s */ s_append(buf, field[d]); for(j=d+1; j<=i-1; j++) { s_append(buf, "!"); s_append(buf, field[j]); } if(d) addhostdom(buf, field[d-1]); return buf; }
/* append a char array to a String */
String *
s_append(String *to, char *from)
{
if (to == 0)
to = s_new();
if (from == 0)
return to;
for(; *from; from++)
s_putc(to, *from);
s_terminate(to);
return to;
}
static int
getrule(String *line, String *type, char *system)
{
rule *rp;
String *re;
int backl;
backl = 0;
/* get a rule */
re = rule_parse(s_restart(line), system, &backl);
if(re == 0)
return 0;
rp = (rule *)malloc(sizeof(rule));
if(rp == 0) {
perror("getrules:");
exit(1);
}
rp->next = 0;
s_tolower(re);
rp->matchre = s_new();
s_append(rp->matchre, s_to_c(re));
s_restart(rp->matchre);
s_free(re);
s_parse(line, s_restart(type));
rp->repl1 = rule_parse(line, system, &backl);
rp->repl2 = rule_parse(line, system, &backl);
rp->program = 0;
if(strcmp(s_to_c(type), "|") == 0)
rp->type = d_pipe;
else if(strcmp(s_to_c(type), ">>") == 0)
rp->type = d_cat;
else if(strcmp(s_to_c(type), "alias") == 0)
rp->type = d_alias;
else if(strcmp(s_to_c(type), "translate") == 0)
rp->type = d_translate;
else if(strcmp(s_to_c(type), "auth") == 0)
rp->type = d_auth;
else {
s_free(rp->matchre);
s_free(rp->repl1);
s_free(rp->repl2);
free((char *)rp);
fprint(2,"illegal rewrite rule: %s\n", s_to_c(line));
return 0;
}
if(rulep == 0)
rulep = rlastp = rp;
else
rlastp = rlastp->next = rp;
return backl;
}
int
matcher(char *action, Pattern *p, char *message, Resub *m)
{
char *cp;
String *s;
for(cp = message; matchpat(p, cp, m); cp = m->ep) {
switch(p->action) {
case SaveLine:
if(vflag)
xprint(2, action, m);
saveline(linefile, sender, m);
break;
case HoldHeader:
case Hold:
if(nflag)
continue;
if(vflag)
xprint(2, action, m);
*qdir = holdqueue;
if(hflag && qname) {
cp = strchr(sender, '!');
if(cp) {
*cp = 0;
*qname = strdup(sender);
*cp = '!';
} else
*qname = strdup(sender);
}
return 1;
case Dump:
if(vflag)
xprint(2, action, m);
*(m->ep) = 0;
if(!tflag) {
s = s_new();
s_append(s, sender);
s = unescapespecial(s);
syslog(0, "smtpd", "Dumped %s [%s] to %s", s_to_c(s), m->sp,
s_to_c(s_restart(recips)));
s_free(s);
}
tflag = 1;
if(sflag)
cout = opendump(sender);
return 1;
default:
break;
}
}
return 0;
}
void
logcall(int nbytes)
{
Link *l;
String *to, *from;
to = s_new();
from = s_new();
for(l = senders.first; l; l = l->next){
if(l != senders.first)
s_append(from, ", ");
s_append(from, s_to_c(l->p));
}
for(l = rcvers.first; l; l = l->next){
if(l != rcvers.first)
s_append(to, ", ");
s_append(to, s_to_c(l->p));
}
syslog(0, "smtpd", "[%s/%s] %s sent %d bytes to %s", him, nci->rsys,
s_to_c(from), nbytes, s_to_c(to));
s_free(to);
s_free(from);
}
/*
* ensure route addr has brackets around it
*/
String*
fixrouteaddr(String *raddr, Node *next, Node *last)
{
String *a;
if(last && last->c == '<' && next && next->c == '>')
return raddr; /* properly formed already */
a = s_new();
s_append(a, "<");
s_append(a, s_to_c(raddr));
s_append(a, ">");
s_free(raddr);
return a;
}
void
lexinit(int fd, char *file)
{
int i;
state = Head0;
Binit(&fin, fd, OREAD);
filename = file;
lineno = 1;
symlist = nil;
for(i = 0; i < nelem(syminit); i++)
install(syminit[i].type, syminit[i].name);
sbuf = s_new();
nerrors = 0;
}
