static LLVMValueRef genfun_newbe(compile_t* c, gentype_t* g, const char *name,
ast_t* typeargs)
{
ast_t* fun = get_fun(g, name, typeargs);
LLVMValueRef func = get_prototype(c, g, name, typeargs, fun);
if(func == NULL)
{
ast_free_unattached(fun);
return NULL;
}
codegen_startfun(c, func, ast_debug(fun));
name_params(c, g->ast, ast_childidx(fun, 3), func);
genfun_dwarf(c, g, name, typeargs, fun);
if(!gen_field_init(c, g))
{
ast_free_unattached(fun);
return NULL;
}
ast_t* body = ast_childidx(fun, 6);
LLVMValueRef value = gen_expr(c, body);
if(value == NULL)
{
ast_free_unattached(fun);
return NULL;
}
LLVMBuildRetVoid(c->builder);
codegen_finishfun(c);
// Generate the sender.
LLVMValueRef sender = get_sender(c, g, name, typeargs);
codegen_startfun(c, sender, false);
LLVMValueRef this_ptr = LLVMGetParam(sender, 0);
// Send the arguments in a message to 'this'.
uint32_t index = genfun_vtable_index(c, g, name, typeargs);
LLVMTypeRef msg_type_ptr = send_message(c, fun, this_ptr, sender, index);
genfun_dwarf_return(c, body);
// Return 'this'.
LLVMBuildRet(c->builder, this_ptr);
codegen_finishfun(c);
// Add the dispatch case.
add_dispatch_case(c, g, fun, index, func, msg_type_ptr);
ast_free_unattached(fun);
return func;
}
void Mail::set_sender(const std::wstring& addr)
{
AddressHeaderPtr hd = get_sender();
if (!hd)
{
AddressHeaderPtr new_hd(new AddressHeader(L"sender"));
headers.add(new_hd);
hd = new_hd;
}
hd->parse_value(addr);
Addresses& addresses = hd->get_addresses();
if (addresses.size() > 1)
addresses.erase(addresses.begin() + 1, addresses.end());
}
char *_sign_and_sendmoney(char *cointxid,struct ramchain_info *ram,struct cointx_info *cointx,char *othersignedtx,uint64_t *redeems,uint64_t *amounts,int32_t numredeems)
{
uint64_t get_sender(uint64_t *amountp,char *txidstr);
void *extract_jsonkey(cJSON *item,void *arg,void *arg2);
void set_MGW_moneysentfname(char *fname,char *NXTaddr);
int32_t jsonstrcmp(void *ref,void *item);
char txidstr[64],NXTaddr[64],jsonstr[4096],*retstr = 0;
int32_t i;
uint64_t amount,senderbits,redeemtxid;
fprintf(stderr,"achieved consensus and sign! (%s)\n",othersignedtx);
if ( (retstr= _submit_withdraw(ram,cointx,othersignedtx)) != 0 )
{
if ( is_hexstr(retstr) != 0 )
{
strcpy(cointxid,retstr);
//*AMtxidp = _broadcast_moneysentAM(ram,height);
for (i=0; i<numredeems; i++)
{
if ( (redeemtxid = redeems[i]) != 0 && amounts[i] != 0 )
{
printf("signed and sent.%d: %llu %.8f\n",i,(long long)redeemtxid,dstr(amounts[i]));
_ram_update_redeembits(ram,redeemtxid,0,cointxid,0);
expand_nxt64bits(txidstr,redeemtxid);
senderbits = get_sender(&amount,txidstr);
expand_nxt64bits(NXTaddr,senderbits);
sprintf(jsonstr,"{\"NXT\":\"%s\",\"redeemtxid\":\"%llu\",\"amount\":\"%.8f\",\"coin\":\"%s\",\"cointxid\":\"%s\",\"vout\":\"%d\"}",NXTaddr,(long long)redeemtxid,dstr(amounts[i]),ram->name,txidstr,i);
update_MGW_jsonfile(set_MGW_moneysentfname,extract_jsonkey,jsonstrcmp,0,jsonstr,"redeemtxid",0);
update_MGW_jsonfile(set_MGW_moneysentfname,extract_jsonkey,jsonstrcmp,NXTaddr,jsonstr,"redeemtxid",0);
}
}
//backupwallet(cp,ram->coinid);
}
else
{
for (i=0; i<numredeems; i++)
printf("(%llu %.8f) ",(long long)redeems[i],dstr(amounts[i]));
printf("_sign_and_sendmoney: unexpected return.(%s)\n",retstr);
exit(1);
}
return(retstr);
}
else printf("sign_and_sendmoney: error sending rawtransaction %s\n",othersignedtx);
return(0);
}
void main(int argc,char **argv)
{
char *def;
int dash;
optind = getconfopt(argc,argv,options,0,0);
if (argv[optind] == 0)
die_usage();
if (!stralloc_copys(&basedir,argv[optind++])) die_nomem();
sender = get_sender();
if (!sender)
strerr_die2x(100,FATAL,MSG(ERR_NOSENDER));
def = env_get("DEFAULT");
if (argv[optind] != 0) {
dispatch(argv[optind],def);
strerr_die3x(100,FATAL,"Not a directory: ",path.s);
}
else if (!def || !*def)
strerr_die2x(100,FATAL,MSG(ERR_NODEFAULT));
else {
if (def[str_chr(def,'/')] != 0)
strerr_die2x(100,FATAL,"Recipient address may not contain '/'");
dispatch(def,0);
dash = str_len(def);
for (;;) {
while (--dash > 0)
if (def[dash] == '-')
break;
if (dash <= 0)
break;
def[dash] = 0;
dispatch(def,def+dash+1);
def[dash] = '-';
}
strerr_die3x(100,FATAL,"Could not match recipient name to any list: ",def);
}
}
void main(int argc,char **argv)
{
const char *subdir;
const char *addr;
int opt;
int senderissub;
int i;
addr = get_sender();
if (!addr) die_sender(); /* REQUIRE sender */
opt = getconfopt(argc,argv,options,1,0);
initsub(0);
if (opt >= argc)
senderissub = !!issub(0,addr,0);
else {
/* If all the options are absolute, scan each one; else treat the
* first option as the base directory and the rest as database
* names. */
for (i = --opt; i < argc; ++i) {
if (argv[i][0] != '/') {
++opt;
break;
}
}
senderissub = 0;
while ((subdir = argv[opt++]) != 0) {
if (issub(subdir,addr,0)) {
senderissub = 1;
break;
}
}
}
closesub();
_exit(senderissub ? flagsub /* is a subscriber */
: flagsub ? 0 : 99); /* not subscriber anywhere */
}
int main(int argc, char *argv[]) {
char * message;
lockitem * pendingclients = NULL;
if (argc < 3) {
printf("usage: %s filename.txt [R|W]\n", argv[0]);
return 0;
}
if (argv[2][0] == 'R') {
last_message = MSG_REQUEST_READ;
message = "request_read";
} else if (argv[2][0] == 'W') {
last_message = MSG_REQUEST_WRITE;
message = "request_write";
} else {
printf("lock type must be R or W\n");
return 0;
}
spread_connect();
server = argv[1];
spread_send(SERVER_NAME, message, server);
set_alarm_handler();
printf("SIGINT to quit\n");
while (1) {
spread_receive();
char * token = get_token();
char * sender = get_sender();
char * list = get_list();
switch(get_message_type()) {
case MSG_REVOKE:
printf("got a revoke message. quitting.\n");
spread_send(sender, "ack", token);
exit(0);
break;
case MSG_DOWNGRADE:
//TODO: write blocks to server
//TODO: downgrade to read (currently no internal state of this)
printf("got a downgrade message. doin it.\n");
spread_send(sender, "ack", token);
break;
case MSG_CLIENT_LIST:
if (last_message == MSG_REQUEST_WRITE) {
printf("got a client list in response to a write request\n");
parse_client_list(&pendingclients, list);
last_message = MSG_REVOKE;
message_others(pendingclients, "revoke", token);
} else if (last_message == MSG_REQUEST_READ) {
printf("got a client list in response to a read request\n");
parse_client_list(&pendingclients, list);
last_message = MSG_DOWNGRADE;
message_others(pendingclients, "downgrade", token);
} else {
printf("don't know why we got a client list now\n");
}
break;
case MSG_ACK:
if (last_message == MSG_REQUEST_READ || last_message == MSG_REQUEST_WRITE ||
last_message == MSG_DOWNGRADE_DONE || last_message == MSG_REVOKE_DONE) {
printf("got lock!\n");
} else if (last_message == MSG_CLOSE) {
//TODO: write blocks to server
printf("got ack and quitting\n");
return 0;
} else if (last_message == MSG_DOWNGRADE) {
printf("got ack for downgrade, removing from list\n");
removelock(&pendingclients, sender);
if (!pendingclients) {
printf("downgrade is done!\n");
last_message = MSG_DOWNGRADE_DONE;
spread_send(SERVER_NAME, "downgrade_done", token);
}
} else if (last_message == MSG_REVOKE) {
printf("got ack for revoke, removing from list\n");
removelock(&pendingclients, sender);
if (!pendingclients) {
printf("revoke is done!\n");
last_message = MSG_REVOKE_DONE;
spread_send(SERVER_NAME, "revoke_done", token);
}
} else {
printf("got ack for something other than close\n");
}
break;
default:
printf("got a message for me, but what does it mean?\n");
}
}
return 0;
}
int main(int argc,char **argv)
{
const char *dir;
const char *sender;
const char *moddir;
int opt;
int ret = 0;
unsigned int i,j;
const char *program;
stralloc *opts;
stralloc cmds = {0};
int child;
int ismod;
umask(022);
sig_pipeignore();
if (!stralloc_copys(&sendopt,"-")) die_nomem();
if (!stralloc_copys(&storeopt,"-")) die_nomem();
opt = getconfopt(argc,argv,options,1,&dir);
/* storeopts to ezmlm-store only. Others to both (ezmlm-store may */
/* pass them on to ezmlm-send. */
if (!stralloc_catb(&storeopt,sendopt.s+1,sendopt.len-1)) die_nomem();
initsub(0);
sender = get_sender();
ismod = 0;
if (queryext) {
getconf(&cmds,queryext,1);
i = 0;
for (j = 0;j < cmds.len; ++j)
if (!cmds.s[j]) {
switch (cmds.s[i]) {
case '\0': case '#': break; /* ignore blank/comment */
case '|':
ret = mailprog(cmds.s + i + 1); break;
default:
ret = mailprog(cmds.s + i); break;
}
if (ret) break;
i = j + 1;
}
if (!ret || ret == 99) /* 111 => temp error */
ismod = 1; /* 0, 99 => post */
/* other => moderate */
}
moddir = argv[opt++];
if (moddir && !ret) { /* if exit 0 and moddir, add issub */
ismod = 0;
while (moddir && !ismod && sender) {
ismod = issub(moddir,sender,0);
closesub();
moddir = argv[opt++];
}
}
if (ismod) {
program = "/ezmlm-send";
opts = &sendopt;
}
else {
program = "/ezmlm-store";
opts = &storeopt;
}
if (dontact) {
substdio_puts(subfderr, auto_bin());
substdio_puts(subfderr, program);
substdio_put(subfderr, " ", 1);
substdio_put(subfderr, opts->s, opts->len);
substdio_put(subfderr, " ", 1);
substdio_puts(subfderr, dir);
substdio_putsflush(subfderr, "\n");
_exit(0);
}
if ((child = wrap_fork()) == 0)
wrap_execbin(program, opts, dir);
/* parent */
wrap_exitcode(child);
_exit(0);
}
void instance::on_remove_player(const Event& e)
{
on_dropout(get_sender(e));
}
void done()
{
get_sender().send(messaging::close_queue());
}
int main(int argc, char * argv[]) {
tokenitem * locklist = NULL;
spread_connect();
while (1) {
tokenitem * t;
spread_receive();
char * token = get_token();
char * sender = get_sender();
switch (get_message_type()) {
case MSG_REQUEST_WRITE:
// send lock or list of open read and write locks
printf("%s requests write to %s\n", sender, token);
t = token_find_add(&locklist, token);
if (!t->readlocks && !t->writelocks) {
addlock(&(t->writelocks), sender);
spread_send(sender, "ack", token);
} else {
spread_send_list(sender, "client_list", token, format_locklist(t, 1));
}
break;
case MSG_REQUEST_READ:
// send lock or list of open write locks
printf("%s requests read to %s\n", sender, token);
t = token_find_add(&locklist, token);
if (!t->writelocks) {
addlock(&(t->readlocks), sender);
spread_send(sender, "ack", token);
} else {
spread_send_list(sender, "client_list", token, format_locklist(t, 0));
}
break;
case MSG_REVOKE_DONE:
//update tables(this client has write, reads are gone) -> send ack
printf("%s says revoke is done for %s\n", sender, token);
t = token_find_add(&locklist, token);
if (t->writelocks) {
free_locklist(t->writelocks);
t->writelocks = NULL;
}
if (t->readlocks) {
free_locklist(t->readlocks);
t->readlocks = NULL;
}
addlock(&(t->writelocks), sender);
spread_send(sender, "ack", token);
break;
case MSG_DOWNGRADE_DONE:
//updates tables(this client has read, writes are now reads) -> send ack
printf("%s says downgrade is done for %s\n", sender, token);
t = token_find_add(&locklist, token);
if (t->writelocks) {
movelocks(&(t->writelocks), &(t->readlocks));
}
if (t->readlocks) {
removelock(&(t->readlocks), sender);
}
addlock(&(t->readlocks), sender);
spread_send(sender, "ack", token);
break;
case MSG_CLOSE:
//remove any locks for this token for this client
printf("%s says it is closing %s\n", sender, token);
t = token_find(&locklist, token);
if (t) {
if (t->readlocks) {
removelock(&(t->readlocks), sender);
}
if (t->writelocks) {
removelock(&(t->writelocks), sender);
}
if (!t->readlocks && !t->writelocks) {
removetoken(&locklist, token);
}
}
spread_send(sender, "ack", token);
break;
case MSG_UNKNOWN:
printf("unknown message! (%s, %s)\n", sender, token);
}
print_locklist(locklist);
}
return 0;
}
int main(int argc,char **argv)
{
char *action;
const char *err;
unsigned int i;
int act = AC_NONE; /* desired action */
unsigned int actlen = 0;/* str_len of above */
(void) umask(022);
sig_pipeignore();
when = now();
getconfopt(argc,argv,options,1,&dir);
initsub(0);
sender = get_sender();
if (!sender) die_sender();
action = env_get("DEFAULT");
if (!action) strerr_die2x(100,FATAL,MSG(ERR_NODEFAULT));
if (!*sender)
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
if (!sender[str_chr(sender,'@')])
strerr_die2x(100,FATAL,MSG(ERR_ANONYMOUS));
if (str_equal(sender,"#@[]"))
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
action = set_workdir(action);
stralloc_copys(&target,sender);
if (action[0]) {
i = str_chr(action,'-');
if (action[i]) {
action[i] = 0;
stralloc_copys(&target,action + i + 1);
i = byte_rchr(target.s,target.len,'=');
if (i < target.len)
target.s[i] = '@';
}
}
stralloc_0(&target);
set_cptarget(target.s); /* for copy() */
make_verptarget();
act = get_act_ismod(action,&actlen);
stralloc_copy(&from,&outlocal);
stralloc_cats(&from,"-return-@");
stralloc_cat(&from,&outhost);
stralloc_0(&from);
if (qmail_open(&qq) == -1)
strerr_die2sys(111,FATAL,MSG(ERR_QMAIL_QUEUE));
msg_headers(act);
if (act == AC_SUBSCRIBE)
do_subscribe(action);
else if (act == AC_SC)
do_sc(action);
else if (str_start(action,ACTION_RC))
do_rc_tc(action,ACTION_RC);
else if(str_start(action,ACTION_TC))
do_rc_tc(action,ACTION_TC);
else if (act == AC_UNSUBSCRIBE)
do_unsubscribe(action);
else if (str_start(action,ACTION_UC))
do_uc(action);
else if (str_start(action,ACTION_VC))
do_vc_wc(action,ACTION_VC);
else if (str_start(action,ACTION_WC))
do_vc_wc(action,ACTION_WC);
else if (act == AC_LIST || act == AC_LISTN)
do_list(act);
else if (act == AC_LOG)
do_log(action,actlen);
else if (act == AC_EDIT)
do_edit(action);
else if (str_start(action,ACTION_ED))
do_ed(action);
else if (act == AC_GET)
do_get(action);
else if (case_starts(action,ACTION_QUERY) ||
case_starts(action,ALT_QUERY))
do_query();
else if (case_starts(action,ACTION_INFO) ||
case_starts(action,ALT_INFO))
do_info();
else if (case_starts(action,ACTION_FAQ) ||
case_starts(action,ALT_FAQ))
do_faq();
else if (ismod && (act == AC_HELP))
do_mod_help();
else
do_help();
err = qmail_close(&qq);
closesub();
if (*err != '\0')
strerr_die4x(111,FATAL,MSG(ERR_TMP_QMAIL_QUEUE),": ",err + 1);
strnum[fmt_ulong(strnum,qmail_qp(&qq))] = 0;
strerr_die3x(0,INFO,"qp ",strnum);
}
void instance::reject(Event& evt) {
evt.Feedback = EventFeedback::InvalidRequest;
send(get_sender(evt), evt);
}
int main(int argc, char *argv[])
{
pid_t pid;
int i;
int users_number;
int service_probability;
int text_message_probability;
int status;
int deadproc = 0; /* A counter of the already terminated user processes */
int qid;
int sw; /* Qid of the switch */
int dest; /* Destination of the message */
int olddest; /* Destination of the previous message */
int queues[MAXCHILDS + 1]; /* Queue identifiers - 0 is the qid of the switch */
int msg_sender;
int msg_recipient;
char msg_text[160];
int msg_service;
int msg_service_data;
int t;
int timing[MAXCHILDS + 1][2];
int unreachable_destinations[MAXCHILDS + 1];
char *padding = " ";
char text[160];
messagebuf_t msg, in;
/* Command line argument parsing */
if(argc != 4){
usage(argv);
exit(0);
}
users_number = strtol(argv[1], NULL, 10);
service_probability = strtol(argv[2], NULL, 10);
text_message_probability = strtol(argv[3], NULL, 10);
if((users_number < MINCHILDS) || (users_number > MAXCHILDS)){
usage(argv);
exit(1);
}
if((service_probability < 0) || (service_probability > 100)){
usage(argv);
exit(0);
}
if((text_message_probability < 0) || (text_message_probability > 100)){
usage(argv);
exit(0);
}
printf("Number of users: %d\n", users_number);
printf("Probability of a service request: %d%%\n", service_probability);
printf("Probability of a text message: %d%%\n", text_message_probability);
printf("\n");
/* Initialize the random number generator */
srandom(time(NULL));
/* Switch queue initialization */
sw = init_queue(255);
/* Read the last messages we have in the queue */
while(receive_message(sw, TYPE_TEXT, &in)){
printf("%d -- S -- Receiving old text messages\n", (int) time(NULL), i);
}
/* Read the last messages we have in the queue */
while(receive_message(sw, TYPE_SERVICE, &in)){
printf("%d -- S -- Receiving old service messge\n", (int) time(NULL), i);
}
/* All queues are "uninitialized" (set equal to switch queue) */
for(i = 0; i <= users_number; i++){
queues[i] = sw;
unreachable_destinations[i] = 0;
}
/* Create users */
for(i = 1; i <= users_number; i++){
pid = fork();
if (pid == 0){
srandom(time(NULL) + 1000*i);
/* Initialize queue */
qid = init_queue(i);
/* Read the last messages we have in the queue */
while(receive_message(qid, TYPE_TEXT, &in)){
printf("%s%d -- U %02d -- Receiving old text messages\n", padding, (int) time(NULL), i);
}
/* Read the last messages we have in the queue */
while(receive_message(qid, TYPE_SERVICE, &in)){
printf("%s%d -- U %02d -- Receiving old service messge\n", padding, (int) time(NULL), i);
}
/* Let the switch know we are alive */
user_send_connect(i, sw);
/* Let the switch know how to reach us */
user_send_qid(i, qid, sw);
/* Enter the main loop */
while(1){
sleep(rand()%MAX_SLEEP);
/* Check if the switch requested a service */
if(receive_message(qid, TYPE_SERVICE, &in)){
msg_service = get_service(&in);
switch(msg_service){
case SERVICE_TERMINATE:
/* Send an acknowledgement to the switch */
user_send_disconnect(i, getpid(), sw);
/* Read the last messages we have in the queue */
while(receive_message(qid, TYPE_TEXT, &in)){
msg_sender = get_sender(&in);
get_text(&in, msg_text);
printf("%s%d -- U %02d -- Message received\n", padding, (int) time(NULL), i);
printf("%s Sender: %d\n", padding, msg_sender);
printf("%s Text: %s\n", padding, msg_text);
}
/* Remove the queue */
close_queue(qid);
printf("%s%d -- U %02d -- Termination\n", padding, (int) time(NULL), i);
exit(0);
break;
case SERVICE_TIME:
user_send_time(i, sw);
printf("%s%d -- U %02d -- Timing\n", padding, (int) time(NULL), i);
break;
}
}
/* Send a message */
if(random_number(100) < text_message_probability){
dest = random_number(users_number + 1);
/* Do not send a message to the switch, to yourself and to the previous recipient */
while((dest == 0) || (dest == i) || (dest == olddest)){
dest = random_number(users_number + 1);
}
olddest = dest;
printf("%s%d -- U %02d -- Message to user %d\n", padding, (int) time(NULL), i, dest);
sprintf(text, "A message from me (%d) to you (%d)", i, dest);
user_send_text_message(i, dest, text, sw);
}
/* Check the incoming box for simple messages */
if(receive_message(qid, TYPE_TEXT, &in)){
msg_sender = get_sender(&in);
get_text(&in, msg_text);
printf("%s%d -- U %02d -- Message received\n", padding, (int) time(NULL), i);
printf("%s Sender: %d\n", padding, msg_sender);
printf("%s Text: %s\n", padding, msg_text);
}
}
}
}
/* Switch (parent process) */
while(1){
/* Check if some user is answering to service messages */
if(receive_message(sw, TYPE_SERVICE, &in)){
msg_service = get_service(&in);
msg_sender = get_sender(&in);
switch(msg_service){
case SERVICE_CONNECT:
/* A new user has connected */
printf("%d -- S -- Service: connection\n", (int) time(NULL));
printf(" User: %d\n", msg_sender);
break;
case SERVICE_DISCONNECT:
/* The user is terminating */
printf("%d -- S -- Service: disconnection\n", (int) time(NULL));
printf(" User: %d\n", msg_sender);
deadproc++;
break;
case SERVICE_QID:
/* The user is sending us its queue id */
msg_service_data = get_service_data(&in);
printf("%d -- S -- Service: queue\n", (int) time(NULL));
printf(" User: %d\n", msg_sender);
printf(" Qid: %d\n", msg_service_data);
queues[msg_sender] = msg_service_data;
break;
case SERVICE_TIME:
msg_service_data = get_service_data(&in);
/* Timing informations */
timing[msg_sender][1] = msg_service_data - timing[msg_sender][1];
printf("%d -- S -- Service: timing\n", (int) time(NULL));
printf(" User: %d\n", msg_sender);
printf(" Timing: %d\n", timing[msg_sender][1]);
/* The user is no more blocked by a timing operation */
timing[msg_sender][0] = 0;
break;
}
}
/* Check if some user has connected */
if(receive_message(sw, TYPE_TEXT, &in)){
msg_recipient = get_recipient(&in);
msg_sender = get_sender(&in);
get_text(&in, msg_text);
/* If the destination is connected */
if(queues[msg_recipient] != sw){
/* Send the message (forward it) */
switch_send_text_message(msg_sender, msg_text, queues[msg_recipient]);
printf("%d -- S -- Routing message\n", (int) time(NULL));
printf(" Sender: %d -- Destination: %d\n", msg_sender, msg_recipient);
printf(" Text: %s\n", msg_text);
}
else{
unreachable_destinations[msg_sender] += 1;
if (unreachable_destinations[msg_sender] > MAXFAILS) {
continue;
}
printf("%d -- S -- Unreachable destination\n", (int) time(NULL));
printf(" Sender: %d -- Destination: %d\n", msg_sender, msg_recipient);
printf(" Text: %s\n", msg_text);
printf(" Threshold: %d/%d\n", unreachable_destinations[msg_sender], MAXFAILS);
if (unreachable_destinations[msg_sender] == MAXFAILS) {
printf("%d -- S -- User %d reached max unreachable destinations\n", (int) time(NULL), msg_sender);
switch_send_terminate(queues[msg_sender]);
/* Remove its queue from the list */
queues[msg_sender] = sw;
}
}
/* Randomly request a service to the sender of the last message */
if((random_number(100) < service_probability) && (queues[msg_sender] != sw)){
if (random_number(100) < 40){
/* The user must terminate */
printf("%d -- S -- User %d chosen for termination\n", (int) time(NULL), msg_sender);
switch_send_terminate(queues[msg_sender]);
/* Remove its queue from the list */
queues[msg_sender] = sw;
}
else {
/* Check if we are already timing that user */
if(!timing[msg_sender][0]){
timing[msg_sender][0] = 1;
timing[msg_sender][1] = (int) time(NULL);
printf("%d -- S -- User %d chosen for timing...\n", timing[msg_sender][1], msg_sender);
switch_send_time(queues[msg_sender]);
}
}
}
}
else{
if(deadproc == users_number){
/* All childs have been terminated, just wait for the last to complete its jobs */
waitpid(pid, &status, 0);
/* Remove the switch queue */
remove_queue(sw);
printf("\n");
printf("No more active users. Switch turns off.\n");
/* Terminate the program */
exit(0);
}
}
}
}
void main(int argc,char **argv)
{
char *def;
char *local;
const char *action = "";
char *psz;
const char *err;
int fd;
unsigned int i,j;
int flagremote;
int match;
int goodexit = 0; /* exit code for normal exit */
/* in manager this will be set to 0 */
unsigned long from,u,to,issue,prevmax;
unsigned long mno = 0;
unsigned long chunk;
unsigned long subs = 0;
unsigned int pos,pos1;
unsigned int len;
int opt;
char outformat = 0;
msgentry *msgtable;
subentry *subtable;
authentry *authtable;
dateentry *datetable;
struct datetime dt;
char date[DATE822FMT];
(void) umask(022);
sig_pipeignore();
when = now();
datetime_tai(&dt,when);
opt = getconfopt(argc,argv,options,1,0);
initsub(0);
if (flagformat != 0)
if (FORMATS[str_chr(FORMATS,flagformat[0])])
outformat = flagformat[0];
if (outformat == 0) {
outformat =
(getconf_line(&line,"digformat",0)
&& FORMATS[str_chr(FORMATS,line.s[0])])
? line.s[0]
: DEFAULT_FORMAT;
}
/* code to activate digest (-digest-code)*/
if ((digestcode = argv[opt]) == 0) {
if (getconf_line(&digestcodefile,"digestcode",0)
&& digestcodefile.len > 0) {
if (!stralloc_0(&digestcodefile)) die_nomem();
digestcode = digestcodefile.s;
}
}
/* ignore any extra args */
if (!stralloc_copy(&subject,&outlocal)) die_nomem(); /* for subjects */
if (!stralloc_copy(&listname,&outlocal)) die_nomem(); /* for content disp */
local = env_get("LOCAL");
def = env_get("DEFAULT");
sender = get_sender();
if (local && *local) { /* in editor local = outlocal */
if (!sender) strerr_die2x(100,FATAL,MSG(ERR_NOSENDER));
if (!*sender)
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
if (str_equal(sender,"#@[]"))
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
if (!sender[str_chr(sender,'@')])
strerr_die2x(100,FATAL,MSG(ERR_ANONYMOUS));
if (def) {
if (*def) {
action = def;
goodexit = 99;
} else
_exit(0); /* list-@host should do -help from manager */
} else { /* editor */
act = AC_DIGEST; /* on list-@host ! */
flageditor = 1; /* to avoid Mailing-list error on sublists */
/* when running out of dir/editor. */
}
if (case_starts(action,"dig")) {
action += 3;
if (action[0] == '-' || action [0] == '.') {
action++;
if (!digestcode)
strerr_die2x(100,FATAL,MSG(ERR_BAD_DIGCODE));
len = str_len(digestcode);
if (len <= str_len(action) && case_startb(action,len,digestcode)) {
if (FORMATS[str_chr(FORMATS,*(action+len))])
outformat = *(action+len);
act = AC_DIGEST;
} else
strerr_die2x(100,FATAL,MSG(ERR_BAD_DIGCODE));
}
}
} else /* Command line operation */
act = AC_DIGEST;
/* Things we deal with. If anything else just die with success! */
/* At the moment this is -index, -thread, and -get. */
/* If flagdo = 0 we only service -dig commands. This is to support*/
/* "secret" lists that are still archived and digested. -c on */
/* cmd line. */
if (act == AC_NONE) {
if (case_equals(action,ACTION_DIGEST)) {
act = AC_GET; /* list-digest@ => msg since last digest */
action = ACTION_GET;
} else if (case_starts(action,ACTION_GET) || case_starts(action,ALT_GET))
act = AC_GET;
else if (case_starts(action,ACTION_INDEX) || case_starts(action,ALT_INDEX))
act = AC_INDEX;
else if (case_starts(action,ACTION_THREAD) ||
case_starts(action,ALT_THREAD))
act = AC_THREAD;
}
if (act == AC_NONE) /* not for us. Pass the buck. */
_exit(0);
if (act != AC_INDEX) { /* need to do header processing */
if(!getconf(&digheaders,"digheaders",0)) {
if(!stralloc_copys(&digheaders,digsz)) die_nomem();
if (!stralloc_0(&digheaders)) die_nomem();
psz = digheaders.s;
while (*psz) {
if (*psz == '\\') *psz = '\0';
++psz;
}
}
if (!constmap_init(&digheadersmap,digheaders.s,digheaders.len,0))
die_nomem();
}
if (act != AC_DIGEST) {
if (!flagdo) /* only do digests */
strerr_die2x(100,FATAL,MSG(ERR_NOCMD));
if (flagpublic < 0)
flagpublic = !getconf_isset("modgetonly") && getconf_isset("public");
if (!flagpublic) {
/* This all to take care of non-public lists. They should*/
/* still do digests, but do other things only for */
/* moderators that have remote access. Since this is rare*/
/* efforts have been made to keep everything that's not */
/* needed elsewhere in here. */
getconf_line(&moddir,"modsub",0);
flagremote = getconf_line(&line,"remote",0);
if (!flagremote)
strerr_die2x(100,FATAL,MSG(ERR_NOT_PUBLIC));
if (!moddir.len) {
if (line.len) {
if (!stralloc_copy(&moddir,&line)) die_nomem();
} else {
if (!stralloc_copys(&moddir,"mod")) die_nomem();
}
}
if (!stralloc_0(&moddir)) die_nomem();
ismod = issub(moddir.s,sender,&mod);
if (!ismod) /* sender = moderator? */
strerr_die2x(100,FATAL,MSG(ERR_NOT_PUBLIC));
}
}
if (act == AC_DIGEST) {
workdir = "digest";
if (!stralloc_cats(&outlocal,"-digest")) die_nomem();
if (getconf_line(&line,"chunk",0)) {
if (!stralloc_0(&line)) die_nomem();
(void) scan_ulong(line.s,&chunk); /* same chunk as main list */
if (chunk == 0) /* limit range to 1-53 */
chunk = 1L;
else if (chunk > 52)
chunk = 52L;
} else {
chunk = 0L;
}
} else
workdir = ".";
if (!flagarchived)
strerr_die2x(100,FATAL,MSG(ERR_NOT_ARCHIVED));
if (qmail_open(&qq) == -1)
strerr_die2sys(111,FATAL,MSG(ERR_QMAIL_QUEUE));
set_cpnum(""); /* default for <#n#> replacement */
switch (act) {
case AC_DIGEST:
/* -dig{.|-}'digestcode'[f] returns an rfc1153 digest */
/* of messages from the archive. Messages */
/* dignum+1 through the last message received by the list are processed and */
/* dignum is updated to the last message processed. digissue is advanced. */
get_num(); /* max = last successful message */
to = max;
lockup(); /* another digest could corrupt dignum */
/* but will be saved only if flagdigrange==0 */
if(getconf_line(&num,"dignum",0)) {
if(!stralloc_0(&num)) die_nomem();
pos = scan_ulong(num.s,&prevmax);
if (num.s[pos] == ':') pos++;
pos += 1 + scan_ulong(num.s+pos,&cumsize); /* last cumsize */
if (num.s[pos] == ':') pos++;
scan_ulong(num.s+pos,&digwhen); /* last reg dig */
} else {
prevmax = 0L;
cumsize = 0L;
digwhen = 0L;
}
mno = prevmax + 1L;
if(!max || mno > max) /* if a digest-list is "sending" the request, */
/* don't make noise: errors go to postmaster!*/
strerr_die2x(goodexit,FATAL,MSG(ERR_EMPTY_DIGEST));
szmsgnum[fmt_ulong(szmsgnum,mno)] = '\0';
set_cpnum(szmsgnum); /* for copy */
/* prepare subject to get entropy for tagmsg*/
if (!stralloc_cats(&subject," Digest ")) die_nomem();
if (!stralloc_catb(&subject,date,date822fmt(date,&dt)-1))
die_nomem(); /* skip trailing in date '\n' */
if (!stralloc_cats(&subject," Issue ")) die_nomem();
if (getconf_line(&num,"digissue",0)) {
if(!stralloc_0(&num)) die_nomem();
scan_ulong(num.s,&issue);
issue++;
} else {
issue = 1;
}
if (!stralloc_catb(&subject,strnum,fmt_ulong(strnum,issue)))
die_nomem();
/* use the subject as entropy */
if (!stralloc_copy(&line,&subject)) die_nomem();
if (!stralloc_0(&line)) die_nomem();
if (!stralloc_ready(&seed,HASHLEN+1)) die_nomem();
seed.len = HASHLEN + 1;
seed.s[HASHLEN] = '\0';
makehash(line.s,line.len,seed.s);
if (chunk) { /* only if slaves are used */
qmail_puts(&qq,"Ezauth: ");
qmail_put(&qq,seed.s,HASHLEN);
qmail_puts(&qq,"\n");
}
doheaders();
qmail_puts(&qq,"To: ");
if (!quote("ed,&listname)) die_nomem();
qmail_put(&qq,quoted.s,quoted.len);
qmail_puts(&qq,"@");
qmail_put(&qq,outhost.s,outhost.len);
qmail_puts(&qq,"\n");
if (flagindexed && (outformat != NATIVE))
idx_mkthreads(&msgtable,&subtable,&authtable,&datetable,
mno,to,max,flaglocked);
else
idx_mklist(&msgtable,&subtable,&authtable,mno,to);
digest(msgtable,subtable,authtable,mno,to,&subject,AC_DIGEST,outformat);
write_ulong(issue,0L,0L,"digissue","digissuen");
write_ulong(max,cumsizen, (unsigned long) when,"dignum","dignumn");
break;
case AC_GET:
/* -get[-|\.][[num].num2] copies archive num-num2. num & num2 are adjusted */
/* to be > 0 and <= last message, to num2 >= num and to num2-num <= MAXGET. */
zapnonsub(ACTION_GET); /* restrict to subs if requested */
tosender();
/* for rfc1153 */
if (!stralloc_cats(&subject," Digest of: ")) die_nomem();
if (!stralloc_cats(&subject,action)) die_nomem();
to = 0;
pos = str_len(ACTION_GET);
if (!case_starts(action,ACTION_GET))
pos = str_len(ALT_GET);
if (FORMATS[str_chr(FORMATS,action[pos])]) {
outformat = action[pos];
++pos;
}
/* optional - or . after '-get' */
if (action[pos] == '-' || action[pos] == '.') pos++;
get_num(); /* max = last successful message */
/* accept any separator. It may be */
/* the terminal '\n', but then */
/* scan will = 0 on the \0 so should*/
/* be safe */
if (!max)
strerr_die2x(100,FATAL,MSG(ERR_EMPTY_LIST));
szmsgnum[fmt_ulong(szmsgnum,max)] = '\0';
set_cpnum(szmsgnum); /* for copy this is the latest message arch'd*/
doheaders();
if(action[pos += scan_ulong(action + pos,&u)])
scan_ulong(action + pos + 1, &to);
if (u == 0 && to == 0) { /* default: messages since last */
/* digest, or last MAXGET if too many */
to= max;
u = dignum();
if (u == 0) { /* no digest => last up to HISTGET msgs */
to = max;
if (max > HISTGET) u = max - HISTGET; else u = 1;
}
if (to - u >= MAXGET) u = to - MAXGET + 1; /* max MAXGET */
} else if (u > max) {
if (to) { /* -get.999999_x returns 30 and msg since last*/
to = max; /* digest 30*/
u = dignum();
if (u > HISTGET) u -= HISTGET; else u = 1;
if (to - u >= MAXGET) u = to - MAXGET + 1;
} else
u = max;
}
if (u == 0) u = 1; /* -get.5 => 1-5 */
if (to < u) to = u; /* -get23_2 => 23 */
if (to >= u + MAXGET) to = u + MAXGET - 1;
/* no more than MAXGET at a time */
if (to > max) to = max;
if (flagindexed && (outformat != NATIVE)) /* fake out threading */
idx_mkthreads(&msgtable,&subtable,&authtable,&datetable,
u,to,max,0);
else
idx_mklist(&msgtable,&subtable,&authtable,u,to);
digest(msgtable,subtable,authtable,u,to,&subject,AC_GET,outformat);
break;
case AC_INDEX:
/* -index[f][#|-|\.][[num][.num2] Show subject index for messages num-num2 in*/
/* sets of 100. */
/* Default last 2 sets. num and num2 are made reasonable as for get. num2 is */
/* limited to num+MAXINDEX to limit the amount of data sent. */
if (!flagindexed)
strerr_die2x(100,FATAL,MSG(ERR_NOT_INDEXED));
zapnonsub(ACTION_INDEX); /* restrict to subs if requested */
to = 0;
pos = str_len(ACTION_INDEX);
if (!case_starts(action,ACTION_INDEX))
pos = str_len(ALT_INDEX);
if (FORMATS[str_chr(FORMATS,action[pos])]) {
outformat = action[pos]; /* ignored, but be nice ... */
++pos;
}
get_num(); /* max = last successful message */
if (!max)
strerr_die2x(100,FATAL,MSG(ERR_EMPTY_LIST));
szmsgnum[fmt_ulong(szmsgnum,max)] = '\0';
set_cpnum(szmsgnum); /* for copy this is the latest message arch'd*/
doheaders();
tosender();
if (!stralloc_cats(&subject," Result of: ")) die_nomem();
if (!stralloc_cats(&subject,action)) die_nomem();
presub(1,1,&subject,AC_INDEX,outformat);
if (action[pos] == '-' || action[pos] == '.') pos++;
if(action[pos += scan_ulong(action + pos,&u)])
scan_ulong(action + pos + 1, &to);
if (u == 0 && to == 0) { to = max; u = max - 100; }
if (u <= 0) u = 1;
if (u > max) u = max;
if (to < u) to = u;
if (to > u + MAXINDEX) to = u+MAXINDEX; /* max MAXINDEX index files */
if (to > max) to = max;
u /= 100;
to /= 100;
while (u <= to) {
if (!stralloc_copys(&fn,"archive/")) die_nomem();
if (!stralloc_catb(&fn,strnum,fmt_ulong(strnum,u))) die_nomem();
if (!stralloc_cats(&fn,"/index")) die_nomem();
if (!stralloc_0(&fn)) die_nomem();
if (u == max/100) /* lock if last index file in archive */
lockup();
fd = open_read(fn.s);
if (fd == -1)
if (errno != error_noent)
strerr_die2sys(111,FATAL,MSG1(ERR_OPEN,fn.s));
else
code_qputs(MSG(TXT_NOINDEX));
else {
substdio_fdbuf(&sstext,read,fd,textbuf,sizeof(textbuf));
for (;;) {
if (getln(&sstext,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,MSG1(ERR_READ,fn.s));
if (match) {
if (line.s[0] != '\t') { /* subject line */
pos = byte_chr(line.s,line.len,' ');
pos1 = 0;
if (pos && pos != line.len && line.s[pos - 1] == ':')
pos1 = pos + HASHLEN + 1; /* after hash */
if (pos1 >= line.len) { /* bad! */
pos = 0;
pos1 = 0; /* output as is */
}
if (!stralloc_copyb(&line2,line.s,pos)) die_nomem();
if (!stralloc_catb(&line2,line.s+pos1,line.len-pos1)) die_nomem();
} else {
pos = byte_chr(line.s,line.len,';');
if (pos + HASHLEN + 1 < line.len && pos > 15 &&
line.s[pos + 1] != ' ') {
if (!stralloc_copyb(&line2,line.s,pos - 15)) die_nomem();
pos++;
if (!stralloc_catb(&line2,line.s + pos + HASHLEN,
line.len - pos - HASHLEN)) die_nomem();
} else /* old format - no author hash */
if (!stralloc_copyb(&line2,line.s,line.len)) die_nomem();
}
code_qput(line2.s,line2.len);
} else
break;
}
close(fd);
}
if (u == max/100) /* unlock if last index in archive file */
unlock();
u++;
}
normal_bottom(outformat);
postmsg(outformat);
break;
case AC_THREAD:
/* -thread[f][-|.]num returns messages with subject matching message */
/* 'num' in the subject index. If 'num' is not in[1..last_message] an error */
/* message is returned. */
if (!flagindexed)
strerr_die2x(100,FATAL,MSG(ERR_NOT_INDEXED));
zapnonsub(ACTION_THREAD); /* restrict to subs if requested*/
get_num(); /* max = last successful message */
if (!max)
strerr_die2x(100,FATAL,MSG(ERR_EMPTY_LIST));
szmsgnum[fmt_ulong(szmsgnum,max)] = '\0';
set_cpnum(szmsgnum); /* for copy this is the latest message arch'd*/
doheaders();
tosender();
/* for rfc1153 */
if (!stralloc_cats(&subject," Digest of: ")) die_nomem();
if (!stralloc_cats(&subject,action)) die_nomem();
to = 0;
pos = str_len(ACTION_THREAD);
if (!case_starts(action,ACTION_THREAD))
pos = str_len(ALT_THREAD);
if (FORMATS[str_chr(FORMATS,action[pos])]) {
outformat = action[pos];
++pos;
}
if (action[pos] == '-' || action[pos] == '.') pos++;
if(action[pos += scan_ulong(action + pos,&u)])
scan_ulong(action + pos + 1, &to);
if(u == 0 || u > max) {
hdr_add2("Subject: ",subject.s,subject.len);
qmail_puts(&qq,"\n");
copy(&qq,"text/get-bad",flagcd);
} else { /* limit range to at most u-THREAD_BEFORE to u+THREAD_AFTER */
if (u > THREAD_BEFORE)
from = u-THREAD_BEFORE;
else
from = 1L;
if (u + THREAD_AFTER > max) {
idx_mkthread(&msgtable,&subtable,&authtable,from,max,u,max,0);
digest(msgtable,subtable,authtable,from,max,&subject,
AC_THREAD,outformat);
} else {
idx_mkthread(&msgtable,&subtable,&authtable,
from,u+THREAD_AFTER,u,max,0);
digest(msgtable,subtable,authtable,from,u+THREAD_AFTER,
&subject,AC_THREAD,outformat);
}
}
break;
default:
/* This happens if the initial check at the beginning of 'main' */
/* matches something that isn't matched here. Conversely, just */
/* adding an action here is not enough - it has to be added to the */
/* initial check as well. */
strerr_die2x(100,FATAL,
"Program error: I'm supposed to deal with this but I didn't");
}
if (!stralloc_copy(&line,&outlocal)) die_nomem();
if (act == AC_DIGEST) {
if (chunk) {
if (!stralloc_cats(&line,"-return-g-")) die_nomem();
} else
if (!stralloc_cats(&line,"-return-")) die_nomem();
strnum[fmt_ulong(strnum,mno)] = '\0';
if (!stralloc_cats(&line,strnum)) die_nomem();
if (!stralloc_cats(&line,"-@")) die_nomem();
if (!stralloc_cat(&line,&outhost)) die_nomem();
if (!stralloc_cats(&line,"-@[]")) die_nomem();
} else {
if (!stralloc_cats(&line,"-return-@")) die_nomem();
if (!stralloc_cat(&line,&outhost)) die_nomem();
}
if (!stralloc_0(&line)) die_nomem();
qmail_from(&qq,line.s);
if (act == AC_DIGEST) { /* Do recipients */
tagmsg(mno,seed.s,"d",hashout,qq.msgbytes,chunk);
if (chunk) {
if (!stralloc_copys(&line,"T")) die_nomem();
if (!stralloc_cat(&line,&outlocal)) die_nomem();
if (!stralloc_cats(&line,"-s-d-")) die_nomem();
if (!stralloc_catb(&line,hashout,COOKIE)) die_nomem();
if (!stralloc_cats(&line,"-")) die_nomem();
if (!stralloc_cats(&line,strnum)) die_nomem();
if (!stralloc_cats(&line,"-")) die_nomem();
if (!stralloc_copys(&line2,"@")) die_nomem();
if (!stralloc_cat(&line2,&outhost)) die_nomem();
if (!stralloc_0(&line2)) die_nomem();
j = 0;
for (i = 0; i <= 52; i += chunk) { /* To slaves */
qmail_put(&qq,line.s,line.len);
schar[0] = '0' + i / 10;
schar[1] = '0' + (i % 10);
qmail_put(&qq,schar,3);
j += (chunk - 1);
if (j > 52) j = 52;
schar[0] = '0' + j / 10;
schar[1] = '0' + (j % 10);
qmail_put(&qq,schar,2);
qmail_put(&qq,line2.s,line2.len);
}
} else
subs = putsubs(workdir,0L,52L,&subto);
} else { /* if local is set, sender is checked */
if (ismod)
qmail_to(&qq,mod.s);
else
qmail_to(&qq,sender);
}
if (*(err = qmail_close(&qq)) == '\0') { /* Done. Skip rest. */
if (act == AC_DIGEST) {
if (chunk)
(void) logmsg(mno,0L,0L,2);
else
(void) logmsg(mno,0L,subs,4);
}
closesub(); /* close db connection */
unlock(); /* NOP if nothing locked */
strnum[fmt_ulong(strnum,qmail_qp(&qq))] = 0;
strerr_die2x(goodexit,"ezmlm-get: info: qp ",strnum);
} else { /* failed. Reset last msg & issue for digest */
if(act == AC_DIGEST) {
issue--;
write_ulong(issue,0L,0L,"digissue","digissuen");
write_ulong(prevmax,cumsize,(unsigned long) digwhen,"dignum","dignumn");
}
unlock(); /* NOP if nothing locked */
strerr_die4x(111,FATAL,MSG(ERR_TMP_QMAIL_QUEUE),": ",err + 1);
}
}
void instance::on_end_turn(const Event& inEvt) {
// validate: make sure the sender is the active puppet
if (get_sender(inEvt)->get_puppet() != active_puppet_) {
log_->errorStream()
<< get_sender(inEvt)->get_puppet()->getName()
<< " is trying to end his opponent's turn!";
return;
}
// get up all the opponent units with summoning sickness
for (auto unit : waiting_puppet_->getUnits())
if (unit->hasSummoningSickness())
unit->getUp();
// is any of its units charging?
if (!attackers_.empty()) {
in_battle_ = true;
nr_battle_acks_ = 0;
// toggle into Charging state
// and toggle opponent into Blocking state
Event e(EventUID::StartBlockPhase);
broadcast(e);
return;
}
// otherwise, just start the opponent's turn
log_->debugStream()
<< "ending " << active_puppet_->getName() << "'s turn ";
// find the next puppet
waiting_puppet_ = active_puppet_;
if (active_puppet_ == puppets_.back())
active_puppet_ = puppets_.front();
else {
for (puppets_t::const_iterator puppet = puppets_.begin(); puppet != puppets_.end(); ++puppet) {
if ((*puppet) == active_puppet_) {
++puppet;
active_puppet_ = (*puppet);
break;
}
}
/*bool found = false;
for (auto puppet : puppets_) {
if (found)
active_puppet_ = puppet;
break;
if (puppet == active_puppet_)
found = true;
}*/
}
waiting_player_ = active_player_;
active_player_ = get_player(active_puppet_);
// send to all players except the active one
Event _turn_started(EventUID::TurnStarted);
_turn_started.setProperty("P", stringify(active_puppet_->getUID()));
for (auto player : players_) {
if (player != active_player_) {
log_->infoStream() << "\tinforming " <<
player->get_puppet()->getName() <<
player->get_puppet()->getUID() << " that their turn is not active";
send(player, _turn_started);
}
}
log_->debugStream()
<< "starting " << active_puppet_->getName() << "'s turn ";
Event evt(EventUID::StartTurn);
send(active_player_, evt);
this->draw_spells(active_puppet_);
return;
}
void main(int argc,char **argv)
{
char *sender;
char *def;
char *local;
char *action;
int flaginheader;
int flagcomment;
int flaggoodfield;
int flagdone;
int fd, fdlock;
int match;
const char *err;
char encin = '\0';
unsigned int start,confnum;
unsigned int pos,i;
int child;
int opt;
char *cp,*cpnext,*cpfirst,*cplast,*cpafter;
(void) umask(022);
sig_pipeignore();
when = now();
if (!stralloc_copys(&sendopt,"-")) die_nomem();
opt = getconfopt(argc,argv,options,1,&dir);
sender = get_sender();
if (!sender) strerr_die2x(100,FATAL,MSG(ERR_NOSENDER));
local = env_get("LOCAL");
if (!local) strerr_die2x(100,FATAL,MSG(ERR_NOLOCAL));
def = env_get("DEFAULT");
if (!def) strerr_die2x(100,FATAL,MSG(ERR_NODEFAULT));
if (!*sender)
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
if (!sender[str_chr(sender,'@')])
strerr_die2x(100,FATAL,MSG(ERR_ANONYMOUS));
if (str_equal(sender,"#@[]"))
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
/* local should be >= def, but who knows ... */
cp = local + str_len(local) - str_len(def) - 2;
if (cp < local) die_badformat();
action = local + byte_rchr(local,cp - local,'-');
if (action == cp) die_badformat();
action++;
if (!action[0]) die_badformat();
if (!str_start(action,ACTION_ACCEPT) && !str_start(action,ACTION_REJECT))
die_badformat();
start = str_chr(action,'-');
if (!action[start]) die_badformat();
confnum = 1 + start + str_chr(action + start + 1,'.');
if (!action[confnum]) die_badformat();
confnum += 1 + str_chr(action + confnum + 1,'.');
if (!action[confnum]) die_badformat();
if (!stralloc_copyb(&fnbase,action+start+1,confnum-start-1)) die_nomem();
if (!stralloc_0(&fnbase)) die_nomem();
cookie(hash,key.s,key.len,fnbase.s,"","a");
if (byte_diff(hash,COOKIE,action+confnum+1))
die_badformat();
fdlock = lockfile("mod/lock");
switch(checkfile(fnbase.s)) {
case 0:
strerr_die2x(100,FATAL,MSG(ERR_MOD_TIMEOUT));
case -1: /* only error if new request != action taken */
if (str_start(action,ACTION_ACCEPT))
strerr_die2x(0,INFO,MSG(ERR_MOD_ACCEPTED));
else
strerr_die2x(100,FATAL,MSG(ERR_MOD_ACCEPTED));
case -2:
if (str_start(action,ACTION_REJECT))
strerr_die2x(0,INFO,MSG(ERR_MOD_REJECTED));
else
strerr_die2x(100,FATAL,MSG(ERR_MOD_REJECTED));
default:
break;
}
/* Here, we have an existing filename in fnbase with the complete path */
/* from the current dir in fnmsg. */
if (str_start(action,ACTION_REJECT)) {
if (qmail_open(&qq, (stralloc *) 0) == -1)
strerr_die2sys(111,FATAL,MSG(ERR_QMAIL_QUEUE));
/* Build recipient from msg return-path */
fd = open_read(fnmsg.s);
if (fd == -1) {
if (errno != error_noent)
strerr_die2sys(111,FATAL,MSG1(ERR_OPEN,fnmsg.s));
else
strerr_die2x(100,FATAL,MSG(ERR_MOD_TIMEOUT));
}
substdio_fdbuf(&sstext,read,fd,textbuf,sizeof(textbuf));
if (getln(&sstext,&line,&match,'\n') == -1 || !match)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
maketo(); /* extract SENDER from return-path */
/* Build message */
hdr_add2s("Mailing-List: ",MSG(TXT_MAILING_LIST));
if (listid.len > 0)
hdr_add2("List-ID: ",listid.s,listid.len);
hdr_datemsgid(when);
hdr_from("-owner");
if (replyto)
hdr_add2s("Reply-To: ",replyto);
hdr_add2s("To: ",to.s);
hdr_subject(MSG(SUB_RETURNED_POST));
if (flagmime) {
hdr_mime(CTYPE_MULTIPART);
hdr_boundary(0);
hdr_ctype(CTYPE_TEXT);
hdr_transferenc();
}
copy(&qq,"text/top",flagcd);
copy(&qq,"text/mod-reject",flagcd);
flagcomment = 0;
flaginheader = 1;
if (!stralloc_copys(&text,"")) die_nomem();
if (!stralloc_ready(&text,1024)) die_nomem();
for (;;) { /* copy moderator's rejection comment */
if (getln(subfdin,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
if (!match) break;
if (flaginheader) {
if (case_startb(line.s,line.len,"Content-Transfer-Encoding:")) {
pos = 26;
while (line.s[pos] == ' ' || line.s[pos] == '\t') ++pos;
if (case_startb(line.s+pos,line.len-pos,"base64"))
encin = 'B';
else if (case_startb(line.s+pos,line.len-pos,"quoted-printable"))
encin = 'Q';
}
if (line.len == 1)
flaginheader = 0;
} else
if (!stralloc_cat(&text,&line)) die_nomem();
} /* got body */
if (encin) {
if (encin == 'B')
decodeB(text.s,text.len,&line);
else
decodeQ(text.s,text.len,&line);
if (!stralloc_copy(&text,&line)) die_nomem();
}
cp = text.s;
cpafter = text.s + text.len;
if (!stralloc_copys(&line,"\n>>>>> -------------------- >>>>>\n"))
die_nomem();
flaggoodfield = 0;
flagdone = 0;
while ((cpnext = cp + byte_chr(cp,cpafter-cp,'\n')) != cpafter) {
i = byte_chr(cp,cpnext-cp,'%');
if (i <= 5 && cpnext-cp-i >= 3) {
/* max 5 "quote characters" and space for %%% */
if (cp[i+1] == '%' && cp[i+2] == '%') {
if (!flaggoodfield) { /* Start tag */
if (!stralloc_copyb("ed,cp,i)) die_nomem(); /* quote chars*/
flaggoodfield = 1;
cp = cpnext + 1;
cpfirst = cp;
continue;
} else { /* end tag */
if (flagdone) /* 0 no comment lines, 1 comment line */
flagdone = 2; /* 2 at least 1 comment line & end tag */
break;
}
}
}
if (flaggoodfield) {
cplast = cpnext - 1;
if (*cplast == '\r') /* CRLF -> '\n' for base64 encoding */
*cplast = '\n';
else
++cplast;
/* NUL is now ok, so the test for it was removed */
flagdone = 1;
i = cplast - cp + 1;
if (quoted.len && quoted.len <= i &&
!str_diffn(cp,quoted.s,quoted.len)) { /* quote chars */
if (!stralloc_catb(&line,cp+quoted.len,i-quoted.len)) die_nomem();
} else
if (!stralloc_catb(&line,cp,i)) die_nomem(); /* no quote chars */
}
cp = cpnext + 1;
}
if (flagdone == 2) {
if (!stralloc_cats(&line,"<<<<< -------------------- <<<<<\n")) die_nomem();
code_qput(line.s,line.len);
}
if (flagcd == 'B') {
encodeB("",0,&line,2);
qmail_put(&qq,line.s,line.len);
}
if (flagmime) {
hdr_boundary(0);
hdr_ctype(CTYPE_MESSAGE);
}
qmail_puts(&qq,"\n");
if (seek_begin(fd) == -1)
strerr_die2sys(111,FATAL,MSG1(ERR_SEEK,fnmsg.s));
substdio_fdbuf(&sstext,read,fd,textbuf,sizeof(textbuf));
if (qmail_copy(&qq,&sstext,-1) != 0)
strerr_die2sys(111,FATAL,MSG1(ERR_READ,fnmsg.s));
close(fd);
if (flagmime)
hdr_boundary(1);
if (!stralloc_copy(&line,&outlocal)) die_nomem();
if (!stralloc_cats(&line,"-return-@")) die_nomem();
if (!stralloc_cat(&line,&outhost)) die_nomem();
if (!stralloc_0(&line)) die_nomem();
qmail_from(&qq,line.s);
if (to.len)
qmail_to(&qq,to.s);
if (!stralloc_copys(&fnnew,"mod/rejected/")) die_nomem();
if (!stralloc_cats(&fnnew,fnbase.s)) die_nomem();
if (!stralloc_0(&fnnew)) die_nomem();
/* this is strictly to track what happended to a message to give informative */
/* messages to the 2nd-nth moderator that acts on the same message. Since */
/* this isn't vital we ignore errors. Also, it is no big ideal if unlinking */
/* the old file fails. In the worst case it gets acted on again. If we issue */
/* a temp error the reject will be redone, which is slightly worse. */
if (*(err = qmail_close(&qq)) == '\0') {
fd = open_trunc(fnnew.s);
if (fd != -1)
close(fd);
unlink(fnmsg.s);
strnum[fmt_ulong(strnum,qmail_qp(&qq))] = 0;
strerr_die2x(0,"ezmlm-moderate: info: qp ",strnum);
} else
strerr_die4x(111,FATAL,MSG(ERR_TMP_QMAIL_QUEUE),": ",err + 1);
} else if (str_start(action,ACTION_ACCEPT)) {
fd = open_read(fnmsg.s);
if (fd == -1) {
if (errno !=error_noent)
strerr_die2sys(111,FATAL,MSG1(ERR_OPEN,fnmsg.s));
else /* shouldn't happen since we've got lock */
strerr_die3x(100,FATAL,fnmsg.s,MSG(ERR_MOD_TIMEOUT));
}
substdio_fdbuf(&sstext,read,fd,textbuf,sizeof(textbuf));
/* read "Return-Path:" line */
if (getln(&sstext,&line,&match,'\n') == -1 || !match)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
maketo(); /* extract SENDER to "to" */
env_put2("SENDER",to.s); /* set SENDER */
if (seek_begin(fd) == -1) /* rewind, since we read an entire buffer */
strerr_die2sys(111,FATAL,MSG1(ERR_SEEK,fnmsg.s));
if ((child = wrap_fork()) == 0) {
close(0);
dup(fd); /* make fnmsg.s stdin */
if (argc > opt + 1)
wrap_execvp((const char **)argv + opt);
else if (argc > opt)
wrap_execsh(argv[opt]);
else
wrap_execbin("/ezmlm-send", &sendopt, dir);
}
/* parent */
close(fd);
wrap_exitcode(child);
if (!stralloc_copys(&fnnew,"mod/accepted/")) die_nomem();
if (!stralloc_cats(&fnnew,fnbase.s)) die_nomem();
if (!stralloc_0(&fnnew)) die_nomem();
/* ignore errors */
fd = open_trunc(fnnew.s);
if (fd != -1)
close(fd);
unlink(fnmsg.s);
_exit(0);
}
}
int main(int argc,char **argv)
{
unsigned long maxmsgsize = 0L;
unsigned long minmsgsize = 0L;
unsigned long msgsize = 0L;
char linetype = ' ';
char *cp, *cpstart, *cpafter;
const char *dir;
const char *err;
const char *sender;
unsigned int len;
int match;
getconfopt(argc,argv,options,-1,&dir);
if (dir) {
startup(dir);
flagparsemime = 1; /* only if dir do we have mimeremove/reject */
if (getconf_line(&line,"msgsize",0)) {
if (!stralloc_0(&line)) die_nomem();
len = scan_ulong(line.s,&maxmsgsize);
if (line.s[len] == ':')
scan_ulong(line.s+len+1,&minmsgsize);
}
if (flagforward) {
if (!stralloc_copys(&mydtline,"Delivered-To: command forwarder for "))
die_nomem();
if (!stralloc_catb(&mydtline,outlocal.s,outlocal.len)) die_nomem();
if (!stralloc_cats(&mydtline,"@")) die_nomem();
if (!stralloc_catb(&mydtline,outhost.s,outhost.len)) die_nomem();
if (!stralloc_cats(&mydtline,"\n")) die_nomem();
}
} else {
flagtook = 1; /* if no "dir" we can't get outlocal/outhost */
flagforward = 0; /* nor forward requests */
}
sender = get_sender();
if (!sender)
die_sender();
if (!*sender)
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
if (flagparsemime) { /* set up MIME parsing */
if (getconf(&mimeremove,"mimekeep",0))
mimeremoveflag = 1;
else
getconf(&mimeremove,"mimeremove",0);
constmap_init(&mimeremovemap,mimeremove.s,mimeremove.len,0);
getconf(&mimereject,"mimereject",0);
constmap_init(&mimerejectmap,mimereject.s,mimereject.len,0);
}
if (flagheaderreject && dir) {
getconf(&headerreject,"headerreject",0);
constmap_init(&headerrejectmap,headerreject.s,headerreject.len,0);
}
for (;;) {
if (getln(&ssin,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
if (!match) break;
if (flagheaderreject && dir)
if (constmap(&headerrejectmap,line.s,byte_chr(line.s,line.len,':')))
strerr_die2x(100,FATAL,MSG(ERR_MAILING_LIST));
if (line.len == 1) break;
cp = line.s; len = line.len;
if ((*cp == ' ' || *cp == '\t')) {
switch(linetype) {
case 'T': if (!stralloc_catb(&to,cp,len-1)) die_nomem(); break;
case 'S': if (!stralloc_catb(&subject,cp,len-1)) die_nomem(); break;
case 'C': if (!stralloc_catb(&content,cp,len-1)) die_nomem(); break;
case 'P': if (!stralloc_catb(&precd,cp,len-1)) die_nomem(); break;
default: break;
}
} else {
if (!flagtook &&
(case_startb(cp,len,"to:") || case_startb(cp,len,"cc:"))) {
linetype = 'T'; /* cat so that To/Cc don't overwrite */
if (!stralloc_catb(&to,line.s + 3,line.len - 4)) die_nomem();
} else if ((flagneedsubject || flagrejectcommands) &&
case_startb(cp,len,"subject:")) {
if (!stralloc_copyb(&subject,cp+8,len-9)) die_nomem();
linetype = 'S';
} else if (case_startb(cp,len,"content-type:")) {
if (!stralloc_copyb(&content,cp+13,len-14)) die_nomem();
linetype = 'C';
} else if (case_startb(cp,len,"precedence:")) {
if (!stralloc_copyb(&precd,cp+11,len-12)) die_nomem();
linetype = 'P';
} else {
if (flagforward && line.len == mydtline.len) {
if (!byte_diff(line.s,line.len,mydtline.s))
strerr_die2x(100,FATAL,MSG(ERR_LOOPING));
}
linetype = ' ';
}
}
}
if (precd.len >= 4 &&
(!case_diffb(precd.s + precd.len - 4,4,"junk") ||
!case_diffb(precd.s + precd.len - 4,4,"bulk")))
strerr_die1x(99,MSG(ERR_JUNK)); /* ignore precedence junk/bulk */
cp = subject.s;
len = subject.len;
while (len && (cp[len-1] == ' ' || cp[len-1] == '\t')) --len;
while (len && ((*cp == ' ') || (*cp == '\t'))) { ++cp; --len; }
flaghavesubject = 1;
if (flagbody)
if ((len > 9 && case_starts(cp,"subscribe"))
|| (len > 11 && case_starts(cp,"unsubscribe")))
flaghavecommand = 1;
switch(len) {
case 0: flaghavesubject = 0; break;
case 4: if (!case_diffb("help",4,cp)) flaghavecommand = 1; break;
case 6: /* Why can't they just leave an empty subject empty? */
if (!case_diffb("(null)",6,cp))
flaghavesubject = 0;
else
if (!case_diffb("(none)",6,cp))
flaghavesubject = 0;
else
if (!case_diffb("remove",6,cp))
flaghavecommand = 1;
break;
case 9: if (!case_diffb("subscribe",9,cp)) flaghavecommand = 1; break;
case 11: if (!case_diffb("unsubscribe",11,cp)) flaghavecommand = 1; break;
case 12: if (!case_diffb("(no subject)",12,cp)) flaghavesubject = 0; break;
default: break;
}
if (!flagtook && !getto(&to))
strerr_die2x(exitquiet,FATAL,MSG(ERR_NO_ADDRESS));
if (flagneedsubject && !flaghavesubject)
strerr_die2x(100,FATAL,MSG(ERR_NO_SUBJECT));
if (flagrejectcommands && flaghavecommand) {
if (flagforward) { /* flagforward => forward */
if (qmail_open(&qq) == -1) /* open queue */
strerr_die2sys(111,FATAL,MSG(ERR_QMAIL_QUEUE));
qmail_put(&qq,mydtline.s,mydtline.len);
if (seek_begin(0) == -1)
strerr_die2sys(111,FATAL,MSG(ERR_SEEK_INPUT));
if (qmail_copy(&qq,&ssin2,copylines) != 0)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
if (!stralloc_copy(&to,&outlocal)) die_nomem();
if (!stralloc_cats(&to,"-request@")) die_nomem();
if (!stralloc_cat(&to,&outhost)) die_nomem();
if (!stralloc_0(&to)) die_nomem();
qmail_from(&qq,sender);
qmail_to(&qq,to.s);
if (*(err = qmail_close(&qq)) == '\0') {
strnum[fmt_ulong(strnum,qmail_qp(&qq))] = 0;
strerr_die2x(99,"ezmlm-request: info: forward qp ",strnum);
} else
strerr_die4x(111,FATAL,MSG(ERR_TMP_QMAIL_QUEUE),": ",err + 1);
} else
strerr_die2x(100,FATAL,MSG(ERR_SUBCOMMAND));
}
if (content.len) { /* MIME header */
cp = content.s;
len = content.len;
while (len && (*cp == ' ' || *cp == '\t')) { ++cp; --len; }
cpstart = cp;
if (*cp == '"') { /* might be commented */
++cp; cpstart = cp;
while (len && *cp != '"') { ++cp; --len; }
} else {
while (len && *cp != ' ' && *cp != '\t' && *cp != ';') {
++cp; --len;
}
}
if (flagparsemime)
if ((!!constmap(&mimeremovemap,cpstart,cp-cpstart) ^ mimeremoveflag) ||
constmap(&mimerejectmap,cpstart,cp-cpstart)) {
*(cp) = (char) 0;
strerr_die2x(100,FATAL,MSG1(ERR_BAD_TYPE,cpstart));
}
cpafter = content.s+content.len;
while((cp += byte_chr(cp,cpafter-cp,';')) != cpafter) {
++cp;
while (cp < cpafter && (*cp == ' ' || *cp == '\t')) ++cp;
if (case_startb(cp,cpafter - cp,"boundary=")) {
cp += 9; /* after boundary= */
if (cp < cpafter && *cp == '"') {
++cp;
cpstart = cp;
while (cp < cpafter && *cp != '"') ++cp;
if (cp == cpafter)
strerr_die1x(100,MSG(ERR_MIME_QUOTE));
} else {
cpstart = cp;
while (cp < cpafter &&
*cp != ';' && *cp != ' ' && *cp != '\t') ++cp;
}
if (!stralloc_copys(&boundary,"--")) die_nomem();
if (!stralloc_catb(&boundary,cpstart,cp-cpstart))
die_nomem();
break;
}
} /* got boundary, now parse for parts */
}
for (;;) {
if (getln(&ssin,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
if (!match) break;
if (line.len == 1) {
flagcheck = 0;
continue;
/* Doesn't do continuation lines. _very_ unusual, and worst */
/* case one slips through that shouldn't have */
} else if (flagcheck && case_startb(line.s,line.len,"content-type:")) {
cp = line.s + 13;
len = line.len - 14; /* zap '\n' */
while (*cp == ' ' || *cp == '\t') { ++cp; --len; }
cpstart = cp;
if (*cp == '"') { /* quoted */
++cp; cpstart = cp;
while (len && *cp != '"') { ++cp; --len; }
} else { /* not quoted */
while (len && *cp != ' ' && *cp != '\t' && *cp != ';') {
++cp; --len;
}
}
if (flagparsemime && constmap(&mimerejectmap,cpstart,cp-cpstart)) {
*cp = '\0';
strerr_die2x(100,FATAL,MSG1(ERR_BAD_PART,cpstart));
}
} else if (boundary.len && *line.s == '-' && line.len > boundary.len &&
!str_diffn(line.s,boundary.s,boundary.len)) {
flagcheck = 1;
} else {
if (!msgsize && flagbody)
if (case_startb(line.s,line.len,"subscribe") ||
case_startb(line.s,line.len,"unsubscribe"))
strerr_die2x(100,FATAL,MSG(ERR_BODYCOMMAND));
if (!flagcheck) {
msgsize += line.len;
if (maxmsgsize && msgsize > maxmsgsize) {
strnum[fmt_ulong(strnum,maxmsgsize)] = 0;
strerr_die2x(100,FATAL,MSG1(ERR_MAX_SIZE,strnum));
}
}
}
}
if (msgsize < minmsgsize) {
strnum[fmt_ulong(strnum,minmsgsize)] = 0;
strerr_die2x(100,FATAL,MSG1(ERR_MIN_SIZE,strnum));
}
_exit(0);
}
int main(int argc,char **argv)
{
char strnum[FMT_ULONG];
char *action;
char *dtline;
char *nhost;
const char *err;
unsigned int i;
int match;
int opt;
sig_pipeignore();
opt = getconfopt(argc,argv,options,1,0);
if (!(split = argv[opt]))
split = "split";
if (flagdo) {
sender = get_sender();
if (!sender) die_sender();
if (!*sender)
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
if (!sender[str_chr(sender,'@')])
strerr_die2x(100,FATAL,MSG(ERR_ANONYMOUS));
if (str_equal(sender,"#@[]"))
strerr_die2x(100,FATAL,MSG(ERR_BOUNCE));
action = env_get("DEFAULT");
if (!action) strerr_die2x(100,FATAL,MSG(ERR_NODEFAULT));
if (!stralloc_copys(&target,sender)) die_nomem();
if (action[0]) {
i = str_chr(action,'-');
if (action[i]) {
action[i] = '\0';
if (!stralloc_copys(&target,action + i + 1)) die_nomem();
i = byte_rchr(target.s,target.len,'=');
if (i < target.len)
target.s[i] = '@';
}
}
if (!stralloc_0(&target)) die_nomem();
if (case_diffs(action,ACTION_SUBSCRIBE) &&
case_diffs(action,ALT_SUBSCRIBE) &&
case_diffs(action,ACTION_UNSUBSCRIBE) &&
case_diffs(action,ALT_UNSUBSCRIBE))
_exit(0); /* not for us */
if (findname()) {
/* new sender */
if (!stralloc_copy(&from,&outlocal)) die_nomem();
if (!stralloc_cats(&from,"-return-@")) die_nomem();
if (!stralloc_cat(&from,&outhost)) die_nomem();
if (!stralloc_0(&from)) die_nomem();
nhost = name.s + str_rchr(name.s,'@'); /* name must have '@'*/
*(nhost++) = '\0';
if (!stralloc_copys(&to,name.s)) die_nomem(); /* local */
if (!stralloc_append(&to,'-')) die_nomem(); /* - */
if (!stralloc_cats(&to,action)) die_nomem(); /* subscribe */
if (!stralloc_append(&to,'-')) die_nomem(); /* - */
if (target.s[i = str_rchr(target.s,'@')])
target.s[i] = '=';
if (!stralloc_cats(&to,target.s)) die_nomem(); /* target */
if (!stralloc_append(&to,'@')) die_nomem(); /* - */
if (!stralloc_cats(&to,nhost)) die_nomem(); /* host */
if (!stralloc_0(&to)) die_nomem();
dtline = env_get("DTLINE");
if (!dtline) strerr_die2x(100,FATAL,MSG(ERR_NODTLINE));
if (qmail_open(&qq) == -1)
strerr_die2sys(111,FATAL,MSG(ERR_QMAIL_QUEUE));
qmail_puts(&qq,dtline); /* delivered-to */
if (qmail_copy(&qq,subfdin,0) != 0)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
qmail_from(&qq,from.s);
qmail_to(&qq,to.s);
if (*(err = qmail_close(&qq)) != '\0')
strerr_die4x(111,FATAL,MSG(ERR_TMP_QMAIL_QUEUE),": ",err + 1);
strnum[fmt_ulong(strnum,qmail_qp(&qq))] = 0;
strerr_die3x(99,INFO,"qp ",strnum);
}
_exit(0);
} else {
for (;;) {
if (getln(subfdin,&line,&match,'\n') == -1)
strerr_die2sys(111,FATAL,MSG(ERR_READ_INPUT));
if (!match) break;
if (line.len == 1) continue; /* ignore blank lines */
if (line.s[0] == '#') continue; /* ignore comments */
if (!stralloc_copy(&target,&line)) die_nomem();
target.s[target.len - 1] = '\0';
(void) findname();
if (!stralloc_cats(&name,": ")) die_nomem();
if (!stralloc_cats(&name,target.s)) die_nomem();
if (!stralloc_append(&name,'\n')) die_nomem();
if (substdio_put(subfdout,name.s,name.len) == -1)
strerr_die2sys(111,FATAL,MSG(ERR_WRITE_STDOUT));
}
if (substdio_flush(subfdout) == -1)
strerr_die2sys(111,FATAL,MSG(ERR_FLUSH_STDOUT));
_exit(0);
}
(void)argc;
}
