source: trunk/athena/bin/olc/server/olcd/notify.c @ 2077

/*
 * This file is part of the OLC On-Line Consulting System.
 * It contains functions for handling the daemon's I/O.
 *
 *      Win Treese
 *      Dan Morgan
 *      Bill Saphir
 *      MIT Project Athena
 *
 *      Ken Raeburn
 *      MIT Information Systems
 *
 *      Tom Coppeto
 *      MIT Project Athena
 *
 *      Copyright (c) 1988 by the Massachusetts Institute of Technology
 *
 *      $Source: /afs/dev.mit.edu/source/repository/athena/bin/olc/server/olcd/notify.c,v $
 *      $Author: tjcoppet $
 */

#ifndef lint
static char rcsid[]="$Header: /afs/dev.mit.edu/source/repository/athena/bin/olc/server/olcd/notify.c,v 1.4 1989-08-22 16:30:10 tjcoppet Exp $";
#endif


#include <olc/olc.h>
#include <olcd.h>

#ifdef ZEPHYR
#include <zephyr/zephyr.h>      /* Zephyr defs. */
#endif ZEPHYR

#include <sys/socket.h>         /* IPC socket defs. */
#include <sys/file.h>           /* File handling defs. */
#include <sys/stat.h>           /* File status defs. */
#include <sys/wait.h>           /* */
#include <netdb.h>              /* Net database defs. */
#include <pwd.h>                /* Directory defs. */
#include <signal.h>             /* System signal definitions. */
#include <sgtty.h>              /* Terminal param. definitions. */
#include <setjmp.h>


/* External Variables. */

extern char DaemonHost[];       /* Name of daemon's machine. */

int notice_timeout();
static jmp_buf env;

/*
 * Function:    write_message() uses the program "write" to send a message
 *                      from one person to another within the OLC system.
 * Arguments:   touser:         Username of person receiving the message.
 *              tomachine:      Name of machine he is using.
 *              fromuser:       Username of person sending the message.
 *              frommachine:    Name of machine she is using.
 *              message:        Ptr. to buffer containing message.
 * Returns:     SUCCESS or ERROR.
 * Notes:
 *      First try using zwrite_message() for Zephyr users; if that fails,
 *      use the standard Unix write code.
 *      This code is essentially the same as that in write.c for the
 *      program 'write'.
 *
 */

static int write_port = 0;

ERRCODE
write_message(touser, tomachine, fromuser, frommachine, message)
        char *touser, *tomachine, *fromuser, *frommachine, *message;
{
        FILE *tf = NULL;        /* Temporary file. */
        int fds;                /* Socket descriptor. */
        char buf[BUFSIZE];      /* Message buffer. */
        char error[ERRSIZE];    /* Error message. */
        struct hostent *host;   /* Host entry for receiver. */
        struct sockaddr_in sin; /* Socket address. */
        int flag = 0;

        if (touser == (char *)NULL) /* User sanity check. */
                return(ERROR);

#ifdef ZEPHYR
        /* First try using Zephyr write.  If return status is anything
         * but SUCCESS, try again using Unix write.
         */
        if (zwrite_message(touser, message) == SUCCESS)
          return(SUCCESS);
#endif ZEPHYR

        if (write_port == 0) {
                struct servent *service;
                service = getservbyname("write", "tcp");
                if (!service) {
                        log_error("write_message: Can't find 'write' service");
                        return(ERROR);
                }
                write_port = service->s_port;
        }

        host = gethostbyname(tomachine);
        if (host == (struct hostent *)NULL) {
                (void) sprintf(error, 
                               "Can't resolve name of host '%s'", tomachine);
                log_error(error);
                return(ERROR);
        }
        sin.sin_family = host->h_addrtype;
        bcopy(host->h_addr, (char *) &sin.sin_addr, host->h_length);
        sin.sin_port = write_port;
        fds = socket(host->h_addrtype, SOCK_STREAM, 0);
        if (fds < 0) {
                perror("socket");
                exit(1);
        }


        signal(SIGALRM, notice_timeout);
        alarm(OLCD_TIMEOUT);
        if(setjmp(env) != 0) {
                sprintf(error, "Unable to contact writed on %s", tomachine);
                log_error(error);
                if(tf!=NULL)
                  fclose(tf);
                close(fds);
                alarm(0);
                return(ERROR);
        }


        if (connect(fds, &sin, sizeof (sin)) < 0) {
          alarm(0);
          (void) close(fds);
          return(MACHINE_DOWN);
        }
        (void) write(fds, fromuser, strlen(fromuser));
        (void) write(fds, "@", 1);
        (void) write(fds, frommachine, strlen(frommachine));
        (void) write(fds, " ", 1);
        (void) write(fds, touser, strlen(touser));
        (void) write(fds, "\r\n", 2);
        tf = fdopen(fds, "r");
        flag++;
        while (1) {
                if (fgets(buf, sizeof(buf), tf) == (char *)NULL) {
                        (void) fclose(tf);
                        (void) close(fds);
                        alarm(0);
                        return(LOGGED_OUT);
                }
                if (buf[0] == '\n')
                        break;
                (void) write(1, buf, strlen(buf));
        }
        (void) write(fds, message, strlen(message));
        (void) write(fds, "\r\n", 2);
        (void) fclose(tf);
        (void) close(fds);
        alarm(0);
        return(SUCCESS);
}

 
int
notice_timeout(a)
     int     a;
{
    longjmp(env, 1);
}

    
/*
 * Function:    write_message_to_user() sends a message from the
 *                      daemon to a user using "write".
 * Arguments:   user:           Ptr. to user structure.
 *              message:        Ptr. to buffer containing the message.
 *              flags:          Specifies special actions.
 * Returns:     SUCCESS or ERROR.
 * Notes:
 *      First, try to write a message to the user.  If it does not
 *      succeed, notify the consultant.
 */


ERRCODE
write_message_to_user(k, message, flags)
  KNUCKLE *k;
  char *message;
  int flags;
{
  int result;           /* Result of writing the message. */
  char msgbuf[BUFSIZE]; /* Message buffer. */
  int status;

  if (k == (KNUCKLE *) NULL)
    return(ERROR);

  if(k->user->no_knuckles > 1)
    {
      sprintf(msgbuf,"To: %s %s@%s (%d)\n",k->title,k->user->username,
              k->user->realm,k->instance);
      strcat(msgbuf,message);
      result = write_message(k->user->username, k->user->machine,
                             "OLC-Daemon", DaemonHost, msgbuf);
    }
  else
    result = write_message(k->user->username, k->user->machine,
                             "OLC-Daemon", DaemonHost, message);
  
  switch(result)
    {
    case ERROR:
      set_status(k->user, UNKNOWN_STATUS);
      (void) sprintf(msgbuf,"Unable to contact %s %s. Cause unknown", 
              k->title, k->user->username);
      if(!(flags & NO_RESPOND))
        (void) write_message_to_user(k->connected, msgbuf, NO_RESPOND);
      log_daemon(k, msgbuf);
      status = ERROR;
      break;

    case MACHINE_DOWN:
      set_status(k->user, UNKNOWN_STATUS);
      (void) sprintf(msgbuf,"Unable to contact %s %s. Host machine down.", 
              k->title, k->user->username);
      if(!(flags & NO_RESPOND))
        (void) write_message_to_user(k->connected, msgbuf, NO_RESPOND);
      log_daemon(k, msgbuf);
      status = ERROR;
      break;

    case LOGGED_OUT:
      set_status(k->user, LOGGED_OUT);
      (void) sprintf(msgbuf,"Unable to contact %s %s. User logged out.", 
              k->title, k->user->username);
      if(!(flags & NO_RESPOND))
        (void) write_message_to_user(k->connected, msgbuf, NO_RESPOND);
      log_daemon(k, msgbuf);
      status = ERROR;
      break;

    default:
      set_status(k->user,ACTIVE);
      status = SUCCESS;
      break;
    }
  return(status);
}

#define FUDGEFACTOR 20
#define MESSAGE_CLASS "MESSAGE"
#define PERSONAL_INSTANCE "PERSONAL"
#define OLC_INSTANCE "OLC"
#ifdef TEST
#define OLC_CLASS    "OLCTEST"
#else TEST
#define OLC_CLASS    "OLC"
#endif TEST

ERRCODE olc_broadcast_message(instance,message, code)
     char *instance, *message, *code;
{
#ifdef ZEPHYR  
  if(zsend_message(OLC_CLASS,instance,code,"",message,0) == ERROR)
    return(ERROR);
#endif ZEPHYR

  return(SUCCESS);
}

#ifdef ZEPHYR

/*
 * Function:    zwrite_message(username, message) writes a message to the
 *              specified user.
 * Arguments:   username:       Username of intended recipient.
 *              message:        Message to send.
 * Returns:     SUCCESS if message sent successfully, else ERROR.
 *
 * Inspired greatly by Robert French's zwrite.c (i.e. somewhat swiped).
 *
 */


ERRCODE 
zwrite_message(username, message)
     char *username;
     char *message;
{
   char error[ERRSIZE];

    /* Sanity check the username. */
  if (username == NULL)
    {
      (void) sprintf(error, "zwrite_message: null username");
      log_error(error);
      return(ERROR);
    }
  if (strlen(username) == 0)
    {
      (void) sprintf(error, "zwrite_message: zero length username");
      log_error(error);
      return(ERROR);
    }

  if(zsend_message(MESSAGE_CLASS,PERSONAL_INSTANCE,"olc hello",username,message,0) 
     == ERROR)
    return(ERROR);
   
   return(SUCCESS);
}


ERRCODE 
zsend_message(class,instance,opcode,username,message, flags)
     char *class,*instance,*opcode,*username,*message;
     int flags;
{
  ZNotice_t notice;             /* Zephyr notice */
  int ret;                      /* return value, length */
  char error[ERRSIZE];
  char buf[BUFSIZ];
  char *signature = "From: OLC Service \n";

#ifdef lint
  flags = flags;
  opcode = opcode;
#endif lint;

  if ((ret = ZInitialize()) != ZERR_NONE)
    {
      (void) sprintf(error, "zwrite_message: couldn't ZInitialize");
      log_error(error);
      return(ERROR);            /* Oops, couldn't initialize. */
    }
  
  bzero(&notice, sizeof(ZNotice_t));

  notice.z_kind = ACKED;
  notice.z_port = 0;
  notice.z_class = class;
  notice.z_class_inst = instance;
  notice.z_sender = 0;
  notice.z_message_len = 0;
  notice.z_recipient = username;
  notice.z_default_format = "Message $message";
  notice.z_opcode = opcode;

  (void) strcpy(buf,signature);
  (void) strcat(buf,message);


  /* Watch the moving pointer.... */
  notice.z_message = buf;     
  notice.z_message_len = strlen(buf) + 1;
  ret = zsend(&notice); /* send real message */

  return(ret);  
}
  
/*
 * Function:    zsend(&notice, isreal): Send a Zephyr notice.
 * Arguments:   notice: Zephyr notice to send.
 * Returns:     SUCCESS on success, else ERROR
 */

ERRCODE 
zsend(notice)
     ZNotice_t *notice;
{
  int ret;
  ZNotice_t retnotice;

  if ((ret = ZSendNotice(notice, ZAUTH)) != ZERR_NONE)
    {
      /* Some sort of unknown communications error. */
      fprintf(stderr, "zsend: error %d from ZSendNotice", ret);
      return(ERROR);
    }

  if ((ret = ZIfNotice(&retnotice, (struct sockaddr_in *) 0,
                       ZCompareUIDPred, (char *) &notice->z_uid)) !=
      ZERR_NONE)
    {
      /* Server acknowledgement error here. */
      fprintf(stderr, "zsend: error %d from ZIfNotice", ret);
      ZFreeNotice(&retnotice);
      return(ERROR);
    }

  if (retnotice.z_kind == SERVNAK)
    {
      fprintf(stderr, "zsend: authentication failure");
      ZFreeNotice(&retnotice);
      return(ERROR);
    }

  if (retnotice.z_kind != SERVACK || !retnotice.z_message_len)
    {
      fprintf(stderr, "zsend: server failure during SERVACK");
      ZFreeNotice(&retnotice);
      return(ERROR);
    }

  if (! strcmp(retnotice.z_message, ZSRVACK_SENT))
    {
      ZFreeNotice(&retnotice);
      return(SUCCESS);          /* Message made it */
    }
  else
    {
#ifdef TEST
      printf("zsend: unknown error sending Zephyr message");
#endif
      ZFreeNotice(&retnotice);
      return(ERROR);    /* Some error, probably not using Zephyr */
    }
}



#endif ZEPHYR

/*
 * Function:    perror() similar to that of the C library, except that
 *      a datestamp precedes the message printed.
 * Arguments:   msg:    Message to print.
 * Returns:     nothing
 *
 */

#include <sys/uio.h>
extern int sys_nerr;
extern char *sys_errlist[];
extern int errno;
static char time_buf[20];

perror(msg)
        char *msg;
{
        register int error_number;
        struct iovec iov[6];
        register struct iovec *v = iov;

        error_number = errno;

        time_now(time_buf);
        v->iov_base = time_buf;
        v->iov_len = strlen(time_buf);
        v++;

        v->iov_base = " ";
        v->iov_len = 1;
        v++;

        if (msg) {
                if (*msg) {
                        v->iov_base = msg;
                        v->iov_len = strlen(msg);
                        v++;
                        v->iov_base = ": ";
                        v->iov_len = 2;
                        v++;
                }
        }

        if (error_number < sys_nerr)
                v->iov_base = sys_errlist[error_number];
        else
                v->iov_base = "Unknown error";
        v->iov_len = strlen(v->iov_base);
        v++;

        v->iov_base = "\n";
        v->iov_len = 1;
        (void) writev(2, iov, (v - iov) + 1);
}