brian/ratatoskr-messenger
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

adding zephyr-im master branch

Browse Source
This commit is contained in:
Brian
2022-07-25 09:01:27 -06:00
parent 61f5ed8f01
commit ee1236fa5c
311 changed files with 62265 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

730
zwgc/main.c Normal file
View File

@ -0,0 +1,730 @@
/* This file is part of the Project Athena Zephyr Notification System.
* It is one of the source files comprising zwgc, the Zephyr WindowGram
* client.
*
* Created by: Marc Horowitz <marc@athena.mit.edu>
*
* $Id$
*
* Copyright (c) 1989 by the Massachusetts Institute of Technology.
* For copying and distribution information, see the file
* "mit-copyright.h".
*/
#include <sysdep.h>
#ifdef HAVE_ARES
#include <ares.h>
#endif
#if (!defined(lint) && !defined(SABER))
static const char rcsid_main_c[] = "$Id$";
#endif
#include <netdb.h>
#include <arpa/nameser.h>
#ifdef HAVE_ARPA_NAMESER_COMPAT_H
#include <arpa/nameser_compat.h>
#endif
#include <sys/socket.h>
#include <sys/resource.h>
#include <locale.h>
#include <zephyr/mit-copyright.h>
#include <zephyr/zephyr.h>
#include "new_memory.h"
#include "zwgc.h"
#include "parser.h"
#include "node.h"
#include "exec.h"
#include "zephyr.h"
#include "notice.h"
#include "subscriptions.h"
#include "file.h"
#include "mux.h"
#include "port.h"
#include "variables.h"
#include "main.h"
#ifdef CMU_ZCTL_PUNT
#include "int_dictionary.h"
#endif
#ifdef CMU_ZWGCPLUS
#include "plus.h"
int zwgcplus = 1;
#endif
void notice_handler(ZNotice_t *);
static void process_notice(ZNotice_t *, char *);
static void setup_signals(int);
static void detach(void);
static void signal_exit(int);
#ifdef HAVE_ARES
static void notice_callback(void *, int, int, char *, char *);
#endif
/*
* Global zwgc-wide variables:
*/
#ifdef DEBUG
int zwgc_debug = 0;
#endif
static char *zwgc_version_string = "1.0";
/*
* description_filename_override - <<<>>>
*/
static char *description_filename_override = NULL;
/*
* progname - <<<>>> export!
*/
char *progname = NULL;
/*
* subscriptions_filename_override - <<<>>> export!
*/
char *subscriptions_filename_override = NULL;
/*
* location_override - <<<>>> export!
*/
char *location_override = NULL;
#ifdef HAVE_ARES
/*
* achannel - <<<>>> export!
*/
ares_channel achannel;
#endif
/****************************************************************************/
/* */
/* Code to deal with reading in the description file: */
/* */
/****************************************************************************/
/*
* program - this holds a pointer to the node representation of the
* description file once it has been read in.
*/
static struct _Node *program = NULL;
/*
* <<<>>>
*/
static void
fake_startup_packet(void)
{
ZNotice_t *notice = (ZNotice_t *)malloc(sizeof(ZNotice_t));
struct timezone tz;
char msgbuf[BUFSIZ];
extern void Z_gettimeofday(struct _ZTimeval *, struct timezone *);
var_set_variable("version", zwgc_version_string);
(void) memset(notice, 0, sizeof(ZNotice_t));
notice->z_version = "";
notice->z_class = "WG_CTL_CLASS";
notice->z_class_inst = "WG_CTL_USER<<<>>>";
notice->z_opcode = "WG_STARTUP";
notice->z_default_format = "Zwgc mark II version $version now running...\n";
notice->z_recipient = "";
notice->z_sender = "ZWGC";
Z_gettimeofday(&notice->z_time, &tz);
notice->z_port = 0;
notice->z_kind = ACKED;
notice->z_auth = ZAUTH_YES;
notice->z_charset = ZCHARSET_UNKNOWN;
sprintf(msgbuf,"Zwgc mark II version %s now running...",
zwgc_version_string);
notice->z_message = msgbuf;
notice->z_message_len = strlen(notice->z_message)+1;
#ifdef CMU_ZWGCPLUS
list_add_notice(notice);
set_notice_fake(notice, 1);
#endif
process_notice(notice, NULL);
#ifdef CMU_ZWGCPLUS
list_del_notice(notice);
#else
free(notice);
#endif
}
static void
read_in_description_file(void)
{
FILE *input_file;
char defdesc[128];
/* var_clear_all_variables(); <<<>>> */
sprintf(defdesc, "%s/zephyr/%s", DATADIR, DEFDESC);
input_file = locate_file(description_filename_override, USRDESC, defdesc);
if (input_file)
program = parse_file(input_file);
else
program = NULL;
fake_startup_packet();
}
/****************************************************************************/
/* */
/* Code to deal with argument parsing & overall control: */
/* */
/****************************************************************************/
/*
* void usage()
* Effects: Prints out an usage message on stderr then exits the
* program with error code 1.
*/
void
usage(void)
{
#ifdef DEBUG
fprintf(stderr, "\
zwgc: usage: zwgc [-debug] [-f <filename>] [-subfile <filename>]\n\
[-ttymode] [-nofork] [-reenter] [-loc text]\n\
[-default <driver>] {-disable <driver>}*\n\
[output driver options]\n");
#else
fprintf(stderr, "\
zwgc: usage: zwgc [-f <filename>] [-subfile <filename>]\n\
[-ttymode] [-nofork] [-reenter] [-loc text]\n\
[-default <driver>] {-disable <driver>}*\n\
[output driver options]\n");
#endif
exit(1);
}
/*
* <<<>>>
*/
static void
run_initprogs(void)
{
/*
* This code stolen from old zwgc: yuck. Clean up & fix. <<<>>>
* Should this fork instead of just systeming?
*/
int status;
char *iprogname = ZGetVariable("initprogs");
if (!iprogname)
return;
status = system(iprogname);
if (status == 127) {
perror("zwgc initprog exec");
fprintf(stderr,"zwgc initprog of <%s> failed: no shell.\n",
iprogname);
} else if (status!=-1 && status>>8) {
perror("zwgc initprog exec");
fprintf(stderr,"zwgc initprog of <%s> failed with status [%d].\n",
iprogname, status>>8);
}
}
/*
* main -- the program entry point. Does parsing & top level control.
*/
int
main(int argc, char **argv)
{
char **new;
register char **current;
int dofork = 1;
#ifdef HAVE_ARES
int status;
#endif
setlocale(LC_ALL, "");
progname = argv[0];
/*
* Process "-f <filename>", "-subfile <filename>", "-nofork",
* "-reenter" (which is ignored) and (if DEBUG) "-debug"
* arguments, removing then from argc, argv:
*/
for (new=current=argv+1; *current; current++) {
if (string_Eq(*current, "-debug")) {
argc--;
#ifdef DEBUG
zwgc_debug = 1;
#endif
} else if (string_Eq(*current, "-f")) {
argc -= 2; current++;
if (!*current)
usage();
description_filename_override = *current;
} else if (string_Eq(*current, "-subfile")) {
argc -= 2; current++;
if (!*current)
usage();
subscriptions_filename_override = *current;
} else if (string_Eq(*current, "-nofork")) {
argc--;
dofork = 0;
} else if (string_Eq(*current, "-reenter")) {
argc--; /* just throw it away */
} else if (string_Eq(*current, "-loc")) {
argc -= 2; current++;
if (!*current)
usage();
location_override = *current;
} else
*(new)++ = *current;
}
*new = *current;
#ifdef HAVE_ARES
/*
* Initialize resolver library
*/
status = ares_init(&achannel);
if (status != ARES_SUCCESS) {
fprintf(stderr, "Couldn't initialize resolver: %s\n",
ares_strerror(status));
return(1);
}
#endif
/*
* Initialize various subsystems in proper order:
*/
dprintf("Initializing subsystems...\n"); /*<<<>>>*/
#ifdef CMU_ZWGCPLUS
init_noticelist();
#endif
mux_init();
var_clear_all_variables(); /* <<<>>> */
init_ports(); /* <<<>>> */
dprintf("Initializing standard ports...\n");
init_standard_ports(&argc, argv);
if (argc>1)
usage();
dprintf("Initializing zephyr...\n");
setup_signals(dofork);
zephyr_init(notice_handler);
if (dofork)
detach();
/*
* Run the initprogs program(s) now that we are all set to deal:
*/
dprintf("Running initprogs program...\n");
run_initprogs();
dprintf("Test Zwgc parser.\n\n");
read_in_description_file();
dprintf("Entering main loop\n");
mux_loop();
dprintf("Returning from main loop\n");
finalize_zephyr();
return(0);
}
/****************************************************************************/
/* */
/* : */
/* */
/****************************************************************************/
#define USER_SUPPRESS "SUPPRESS"
#define USER_UNSUPPRESS "UNSUPPRESS"
#ifdef CMU_ZCTL_PUNT
#define USER_LIST_SUPPRESSED "LIST-SUPPRESSED"
#define PUNT_INC 1024
extern int_dictionary puntable_addresses_dict;
ZNotice_t punt_reply;
static void
create_punt_reply(int_dictionary_binding *punt_ent)
{
int key_len = strlen(punt_ent->key);
char *tmp;
if (!punt_reply.z_message) {
punt_reply.z_message = (char *)malloc(PUNT_INC);
punt_reply.z_message[0] = 0;
}
if ((punt_reply.z_message_len + key_len + 1) / PUNT_INC >
(punt_reply.z_message_len + PUNT_INC - 1) / PUNT_INC) {
char *new_message = (char *)malloc((punt_reply.z_message_len
/ PUNT_INC + 1) * PUNT_INC);
strcpy(new_message, punt_reply.z_message);
free(punt_reply.z_message);
punt_reply.z_message = new_message;
}
tmp = punt_reply.z_message + strlen(punt_reply.z_message);
strcat (punt_reply.z_message, punt_ent->key);
strcat (punt_reply.z_message, "\n");
punt_reply.z_message_len += key_len + 1;
while (*tmp != '\001') tmp++;
*tmp = ',';
while (*tmp != '\001') tmp++;
*tmp = ',';
}
#endif /* CMU_ZCTL_PUNT */
void
notice_handler(ZNotice_t *notice)
{
#ifndef HAVE_ARES
int ret;
char node[NS_MAXDNAME];
#endif
#if defined(CMU_ZWGCPLUS)
list_add_notice(notice);
#endif
#ifdef HAVE_ARES
ares_getnameinfo(achannel,
(const struct sockaddr *)&(notice->z_sender_sockaddr),
notice->z_sender_sockaddr.sa.sa_family == AF_INET ?
sizeof(struct sockaddr_in) :
notice->z_sender_sockaddr.sa.sa_family == AF_INET6 ?
sizeof(struct sockaddr_in6) :
sizeof(notice->z_sender_sockaddr), ARES_NI_LOOKUPHOST,
notice_callback, notice);
#else
ret = getnameinfo((const struct sockaddr *)&(notice->z_sender_sockaddr),
notice->z_sender_sockaddr.sa.sa_family == AF_INET ?
sizeof(struct sockaddr_in) :
notice->z_sender_sockaddr.sa.sa_family == AF_INET6 ?
sizeof(struct sockaddr_in6) :
sizeof(notice->z_sender_sockaddr),
node, sizeof(node), NULL, 0, 0);
if (ret != 0)
strcpy(node, "?");
process_notice(notice, node);
#ifdef CMU_ZWGCPLUS
/* Let list_del_notice clean up for us. */
#else
ZFreeNotice(notice);
free(notice);
#endif
#endif
}
#ifdef HAVE_ARES
/*
static void
notice_callback(void *arg,
int status,
int timeouts,
struct hostent *fromhost)
*/
static void
notice_callback(void *arg,
int status,
int timeouts,
char *node,
char *service)
{
ZNotice_t *notice = (ZNotice_t *) arg;
#ifdef CMU_ZWGCPLUS
plus_set_hname(notice, node);
#endif
process_notice(notice, node);
#ifdef CMU_ZWGCPLUS
list_del_notice(notice);
#else
ZFreeNotice(notice);
free(notice);
#endif
}
#endif
static void
process_notice(ZNotice_t *notice,
char *hostname)
{
char *control_opcode;
dprintf("Got a message\n");
control_opcode = decode_notice(notice, hostname);
if (control_opcode) {
#ifdef DEBUG
printf("got control opcode <%s>.\n", control_opcode);
#endif
if (!strcasecmp(control_opcode, USER_REREAD)) {
read_in_description_file();
} else if (!strcasecmp(control_opcode, USER_SHUTDOWN))
zwgc_shutdown();
else if (!strcasecmp(control_opcode, USER_STARTUP)) {
#ifdef DEBUG_MEMORY
report_memory_usage(); /* <<<>>> */
#endif
zwgc_startup();
} else if (!strcasecmp(control_opcode, USER_SUPPRESS)) {
string class = get_field(notice->z_message,
notice->z_message_len, 1);
string instance = get_field(notice->z_message,
notice->z_message_len, 2);
string recipient = get_field(notice->z_message,
notice->z_message_len, 3);
punt(class, instance, recipient);
free(class);
free(instance);
free(recipient);
} else if (!strcasecmp(control_opcode, USER_UNSUPPRESS)) {
string class = get_field(notice->z_message,
notice->z_message_len, 1);
string instance = get_field(notice->z_message,
notice->z_message_len, 2);
string recipient = get_field(notice->z_message,
notice->z_message_len, 3);
unpunt(class, instance, recipient);
free(class);
free(instance);
free(recipient);
#ifdef CMU_ZCTL_PUNT
} else if (!strcasecmp(control_opcode, USER_LIST_SUPPRESSED)) {
struct sockaddr_in old, to;
int retval;
if (!notice->z_port) {
printf("zwgc: can't reply to LIST-SUPPRESSED request\n");
return;
}
memset((char *) &punt_reply, 0, sizeof(ZNotice_t));
punt_reply.z_kind = CLIENTACK;
punt_reply.z_class = WG_CTL_CLASS;
punt_reply.z_class_inst = "WG_REPLY";
punt_reply.z_recipient = "zctl?";
punt_reply.z_sender = "Zwgc";
punt_reply.z_default_format = "";
punt_reply.z_opcode = USER_LIST_SUPPRESSED;
punt_reply.z_port = notice->z_port;
punt_reply.z_message = NULL;
punt_reply.z_message_len = 0;
if (puntable_addresses_dict) {
int_dictionary_Enumerate(puntable_addresses_dict,
create_punt_reply);
}
old = ZGetDestAddr();
to = old;
to.sin_port = notice->z_port;
if ((retval = ZSetDestAddr(&to)) != ZERR_NONE) {
com_err("zwgc",retval,"while setting destination address");
exit(1);
}
ZSendNotice(&punt_reply, ZNOAUTH);
if ((retval = ZSetDestAddr(&old)) != ZERR_NONE) {
com_err("zwgc",retval,"while resetting destination address");
exit(1);
}
if (punt_reply.z_message) {
free(punt_reply.z_message);
punt_reply.z_message = NULL;
}
#endif
} else if (!strcasecmp(control_opcode, USER_EXIT)) {
signal_exit(0);
} else
printf("zwgc: unknown control opcode %s.\n", control_opcode);
goto cleanup;
}
if (!zwgc_active) {
#ifdef DEBUG
if (zwgc_debug)
printf("NON-ACTIVE: PUNTED <%s>!!!!\n", notice->z_class_inst);
#endif
goto cleanup;
}
if (puntable_address_p(notice->z_class,
notice->z_class_inst,
notice->z_recipient)) {
#ifdef DEBUG
if (zwgc_debug)
printf("PUNTED <%s>!!!!\n", notice->z_class_inst);
#endif
goto cleanup;
}
exec_process_packet(program, notice);
cleanup:
return;
}
#ifdef CMU_ZWGCPLUS
void
reprocess_notice(ZNotice_t *notice, char *hostname)
{
list_add_notice(notice);
process_notice(notice, hostname);
list_del_notice(notice);
}
#endif
/***************************************************************************/
/*
*
*/
static void
signal_exit(int ignored)
{
mux_end_loop_p = 1;
}
/* clean up ALL the waiting children, in case we get hit with
multiple SIGCHLD's at once, and don't process in time. */
static RETSIGTYPE
signal_child(int ignored)
{
#ifdef HAVE_WAITPID
int status;
#else
union wait status;
#endif
int pid, old_errno = errno;
do {
#ifdef HAVE_WAITPID
pid = waitpid(-1, &status, WNOHANG);
#else
pid = wait3(&status, WNOHANG, (struct rusage *)0);
#endif
} while (pid != 0 && pid != -1);
errno = old_errno;
}
/* rewrite the wgfile in case it has gone away */
static RETSIGTYPE
signal_usr1(int ignored)
{
write_wgfile();
}
static void
setup_signals(int dofork)
{
#ifdef _POSIX_VERSION
struct sigaction sa;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
if (dofork) {
sa.sa_handler = SIG_IGN;
sigaction(SIGINT, &sa, (struct sigaction *)0);
sigaction(SIGTSTP, &sa, (struct sigaction *)0);
sigaction(SIGQUIT, &sa, (struct sigaction *)0);
sigaction(SIGTTOU, &sa, (struct sigaction *)0);
} else {
/* clean up on SIGINT; exiting on logout is the user's problem, now. */
sa.sa_handler = signal_exit;
sigaction(SIGINT, &sa, (struct sigaction *)0);
}
/* behavior never changes */
sa.sa_handler = signal_exit;
sigaction(SIGTERM, &sa, (struct sigaction *)0);
sigaction(SIGHUP, &sa, (struct sigaction *)0);
sa.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &sa, (struct sigaction *)0);
sa.sa_handler = signal_child;
sigaction(SIGCHLD, &sa, (struct sigaction *)0);
sa.sa_handler = signal_usr1;
sigaction(SIGUSR1, &sa, (struct sigaction *)0);
#else /* !POSIX */
if (dofork) {
/* Ignore keyboard signals if forking. Bad things will happen. */
signal(SIGINT, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
} else {
/* clean up on SIGINT; exiting on logout is the user's problem, now. */
signal(SIGINT, signal_exit);
}
/* behavior never changes */
signal(SIGTERM, signal_exit);
signal(SIGHUP, signal_exit);
signal(SIGCHLD, signal_child);
signal(SIGPIPE, SIG_IGN); /* so that Xlib gets an error */
signal(SIGUSR1, signal_usr1);
#endif
}
/* detach() taken from old zwgc, with lots of stuff ripped out */
static void
detach(void)
{
/* detach from terminal and fork. */
register int i;
/* Attempt to join the process group of the session leader. This
* will get us a HUP if the session leader is in the foreground at
* logout time (which is often the case) or if the shell is running
* under telnetd or xterm (both of which HUP the process group of
* their child process). If we have getsid(), that's the best way
* of finding the session leader; otherwise use the process group of
* the parent process, which is a good guess. */
#if defined(HAVE_GETSID)
setpgid(0, getsid(0));
#elif defined(HAVE_GETPGID)
setpgid(0, getpgid(getppid()));
#elif !defined(GETPGRP_VOID)
setpgid(0, getpgrp(getppid()));
#endif
/* fork off and let parent exit... */
i = fork();
if (i) {
if (i < 0) {
perror("zwgc: cannot fork, aborting:");
exit(1);
}
exit(0);
}
}