Logo Search packages:      
Sourcecode: ncpfs version File versions  Download package

nwmsg.c

/*
    nwmsg.c - Fetch NetWare broadcast messages and write to the user
    Copyright (C) 1996 by Volker Lendecke
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA


    Revision history:

      0.00  1996              Volker Lendecke
            Initial revision.

      0.01  1999              Petr Vandrovec <vandrove@vc.cvut.cz>
            Checking for 'mesg n' on all terminals.

      1.00  1999, November 20       Petr Vandrovec <vandrove@vc.cvut.cz>
            Added license.
  
 */

#include <pwd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <unistd.h>
#include <syslog.h>
#include <signal.h>
#include <paths.h>
#include <utmp.h>
#include <mntent.h>
#include <string.h>
#include <errno.h>
#include <ncp/nwcalls.h>

#include "private/libintl.h"
#define _(X) gettext(X)

static int search_utmp(const char *user, char *tty);

static char *progname;

int
main(int argc, char *argv[])
{
      struct ncp_conn *conn;
      char message[256];
      char *mount_point;
      uid_t uid;
      struct passwd *pwd;
      char tty_path[256];
      FILE *tty_file;
      long err;
      char sn[256];

      setlocale(LC_ALL, "");
      bindtextdomain(NCPFS_PACKAGE, LOCALEDIR);
      textdomain(NCPFS_PACKAGE);

      progname = argv[0];

      openlog("nwmsg", LOG_PID, LOG_LPR);

      if (argc != 2)
      {
            fprintf(stderr, _("usage: %s mount-point\n"),
                  progname);
            exit(1);
      }
      mount_point = argv[1];
      if ((err = ncp_open_mount(mount_point, &conn)) != 0)
      {
            com_err(progname, err, _("in ncp_open_mount"));
            exit(1);
      }
      if (ncp_get_broadcast_message(conn, message) != 0)
      {
            fprintf(stderr, _("%s: could not get broadcast message\n"),
                  progname);
            ncp_close(conn);
            exit(1);
      }
      if (strlen(message) == 0)
      {
            ncp_close(conn);
            syslog(LOG_DEBUG, _("no message"));
            exit(0);
      }
#if 0
      syslog(LOG_DEBUG, _("message: %s"), message);
#endif

      if (NWCCGetConnInfo(conn, NWCC_INFO_MOUNT_UID, sizeof(uid), &uid)) {
            fprintf(stderr, _("%s: could not get uid on connection: %s\n"),
                  progname, strerror(errno));
            ncp_close(conn);
            exit(1);
      }
      if (NWCCGetConnInfo(conn, NWCC_INFO_SERVER_NAME, sizeof(sn), sn)) {
            strcpy(sn, _("<unknown>"));
      }
      ncp_close(conn);

      if ((pwd = getpwuid(uid)) == NULL)
      {
            fprintf(stderr, _("%s: user %d not known\n"),
                  progname, uid);
            exit(1);
      }
      if (search_utmp(pwd->pw_name, tty_path) != 0)
      {
            exit(1);
      }
      if ((tty_file = fopen(tty_path, "w")) == NULL)
      {
            fprintf(stderr, _("%s: cannot open %s: %s\n"),
                  progname, tty_path, strerror(errno));
            exit(1);
      }
      fprintf(tty_file, _("\r\n\007\007\007Message from NetWare Server: %s\r\n%s\r\n"),
            sn, message);
      fclose(tty_file);
      if (fork() == 0) {
            char val[256 + 256 + 256];
            
            sprintf(val, _("Message from Netware Server: %s\n%s"), sn, message);
            execl("/usr/bin/tknwmsg", "/usr/bin/tknwmsg", "-display", ":0", val, NULL);
      }
      return 0;
}

/* The following routines have been taken from util-linux-2.5's write.c */

/*
 * term_chk - check that a terminal exists, and get the message bit
 *     and the access time
 */
static int
term_chk(const char *path, int *msgsokP, time_t * atimeP, int *showerror)
{
      struct stat s;

      if (stat(path, &s) < 0)
      {
            if (showerror)
                  (void) fprintf(stderr,
                            _("write: %s: %s\n"), path, strerror(errno));
            return (1);
      }
      *msgsokP = (s.st_mode & (S_IWRITE >> 3)) != 0;  /* group write bit */
      *atimeP = s.st_atime;
      return (0);
}

/*
 * search_utmp - search utmp for the "best" terminal to write to
 *
 * Ignores terminals with messages disabled, and of the rest, returns
 * the one with the most recent access time.  Returns as value the number
 * of the user's terminals with messages enabled, or -1 if the user is
 * not logged in at all.
 *
 * Special case for writing to yourself - ignore the terminal you're
 * writing from, unless that's the only terminal with messages enabled.
 */
static int
search_utmp(const char *user, char *tty)
{
      struct utmp u;
      time_t bestatime, atime;
      int ufd, nloggedttys, nttys, msgsok;

      char atty[5 + sizeof(u.ut_line) + 1];

      if ((ufd = open(_PATH_UTMP, O_RDONLY)) < 0)
      {
            perror(_("utmp"));
            return -1;
      }
      nloggedttys = nttys = 0;
      bestatime = 0;
      memcpy(atty, "/dev/", 5);
      while (read(ufd, (char *) &u, sizeof(u)) == sizeof(u))
            if (strncmp(user, u.ut_name, sizeof(u.ut_name)) == 0)
            {
                  ++nloggedttys;

                  strncpy(atty + 5, u.ut_line, sizeof(u.ut_line));
                  atty[5 + sizeof(u.ut_line)] = '\0';

                  if (u.ut_type != USER_PROCESS)
                        continue;   /* it's not a valid entry */
                  if (term_chk(atty, &msgsok, &atime, 0))
                        continue;   /* bad term? skip */
                  if (!msgsok)
                        continue;   /* skip ttys with msgs off */

                  ++nttys;
                  if (atime > bestatime)
                  {
                        bestatime = atime;
                        (void) strcpy(tty, atty);
                  }
            }
      (void) close(ufd);
      if (nloggedttys == 0)
      {
            (void) fprintf(stderr, _("nwmsg: %s is not logged in\n"), user);
            return -1;
      }
      if (!bestatime)
      {
            (void) fprintf(stderr, _("nwmsg: %s ignores messages\n"), user);
            return -1;
      }
      return 0;
}

Generated by  Doxygen 1.6.0   Back to index