minix/commands/talk/talk.c

/* talk.c Copyright Michael Temari 08/01/1996 All Rights Reserved */

#include <sys/types.h>
#include <sys/stat.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <utmp.h>
#include <termios.h>
#include <net/gen/netdb.h>
#include <net/hton.h>
#include <net/gen/socket.h>
#include <net/gen/in.h>
#include <net/gen/inet.h>
#include <net/gen/tcp.h>
#include <net/gen/udp.h>

#include "talk.h"
#include "proto.h"
#include "net.h"
#include "screen.h"

_PROTOTYPE(int main, (int argc, char *argv[]));
_PROTOTYPE(void DoTalk, (void));

int main(argc, argv)
int argc;
char *argv[];
{
char *p;
struct hostent *hp;
struct stat st;
struct utmp utmp;
int slot;
FILE *fp;

   if(argc < 2 || argc > 3) {
   	fprintf(stderr, "Usage: talk user[@host] [tty]\n");
   	return(-1);
   }

   /* get local host name */
   if(gethostname(lhost, HOST_SIZE) < 0) {
   	fprintf(stderr, "talk: Error getting local host name\n");
   	return(-1);
   }

   /* get local user name and tty */
   if((slot = ttyslot()) < 0) {
   	fprintf(stderr, "talk: You are not on a terminal\n");
   	return(-1);
   }
   if((fp = fopen(UTMP, "r")) == (FILE *)NULL) {
   	fprintf(stderr, "talk: Could not open %s\n", UTMP);
   	return(-1);
   }
   if(fseek(fp, (off_t) sizeof(utmp) * slot, SEEK_SET)) {
   	fprintf(stderr, "talk: Could not seek %s\n", UTMP);
   	fclose(fp);
   	return(-1);
   }
   if(fread((char *)&utmp, sizeof(utmp), 1 , fp) != 1) {
   	fprintf(stderr, "talk: Could not read %s\n", UTMP);
   	fclose(fp);
   	return(-1);
   }
   fclose(fp);
   strncpy(luser, utmp.ut_user, USER_SIZE < sizeof(utmp.ut_user) ?
   				USER_SIZE : sizeof(utmp.ut_user));
   luser[USER_SIZE] = '\0';

   /* get local tty */
   if((p = ttyname(0)) == (char *)NULL) {
   	fprintf(stderr, "talk: You are not on a terminal\n");
   	return(-1);
   }
   strncpy(ltty, p+5, TTY_SIZE);
   ltty[TTY_SIZE] = '\0';

   /* check if local tty is going to be writable */
   if(stat(p, &st) < 0) {
   	perror("talk: Could not stat local tty");
   	return(-1);
   }
   if((st.st_mode & S_IWGRP) == 0) {
   	fprintf(stderr, "talk: Your terminal is not writable.  Use: mesg y\n");
   	return(-1);
   }

   /* get remote user and host name */
   if((p = strchr(argv[1], '@')) != (char *)NULL)
   	*p++ = '\0';
   else
   	p = lhost;
   strncpy(ruser, argv[1], USER_SIZE);
   ruser[USER_SIZE] = '\0';
   strncpy(rhost, p, HOST_SIZE);
   rhost[HOST_SIZE] = '\0';

   /* get remote tty */
   if(argc > 2)
   	strncpy(rtty, argv[2], TTY_SIZE);
   else
   	rtty[0] = '\0';
   rtty[TTY_SIZE] = '\0';

   if((hp = gethostbyname(rhost)) == (struct hostent *)NULL) {
   	fprintf(stderr, "talk: Could not determine address of %s\n", rhost);
   	return(-1);
   }
   memcpy((char *)&raddr, (char *)hp->h_addr, hp->h_length);

   if(NetInit()) {
   	fprintf(stderr, "talk: Error in NetInit\n");
   	return(-1);
   }

   if(ScreenInit())
   	return(-1);

   if(!TalkInit())
	DoTalk();

   ScreenEnd();

   return(0);
}

struct pdata {
	int win;
	int len;
	char buffer[64];
} pdata;

void DoTalk()
{
int s;
int s2;
int kid;
int pfd[2];
int win;
int len;
struct termios termios;
char lcc[3];
char rcc[3];

   ScreenMsg("");
   ScreenWho(ruser, rhost);

   /* Get and send edit characters */
   s = tcgetattr(0, &termios);
   if(s < 0) {
   	perror("talk: tcgetattr");
   	return;
   }
   lcc[0] = termios.c_cc[VERASE];
   lcc[1] = termios.c_cc[VKILL];
   lcc[2] = 0x17; /* Control - W */
   s = write(tcp_fd, lcc, sizeof(lcc));
   if(s != sizeof(lcc)) {
   	ScreenMsg("Connection Closing due to error");
   	return;
   }
   s = read(tcp_fd, rcc, sizeof(rcc));
   if(s != sizeof(rcc)) {
   	ScreenMsg("Connection Closing due to error");
   	return;
   }
   ScreenEdit(lcc, rcc);

   s = pipe(pfd);
   if(s < 0) {
   	ScreenMsg("Could not create pipes");
   	return;
   }

   if((kid = fork()) < 0) {
   	ScreenMsg("Could not fork");
   	close(pfd[0]);
   	close(pfd[1]);
   	return;
   }

   if(kid == 0) {
   	close(tcp_fd);
   	close(pfd[1]);
   	while(1) {
   		s = read(pfd[0], &pdata, sizeof(pdata));
   		if(s != sizeof(pdata)) {
   			close(pfd[0]);
   			exit(-1);
   		}
   		ScreenPut(pdata.buffer, pdata.len, pdata.win);
   	}
   }

   close(pfd[0]);

   if((kid = fork()) < 0) {
   	ScreenMsg("Could not fork");
   	close(pfd[1]);
   	return;
   }

   if(kid == 0) {
   	pdata.win = REMOTEWIN;
   	while(!ScreenDone) {
	   	s = read(tcp_fd, pdata.buffer, sizeof(pdata.buffer));
   		if(s <= 0)
   			break;
   		pdata.len = s;
		write(pfd[1], &pdata, sizeof(pdata));
   	}
   	close(pfd[1]);
   	close(tcp_fd);
	kill(getppid(), SIGINT);
   	exit(-1);
   }

   pdata.win = LOCALWIN;
   while(!ScreenDone) {
	s = read(0, pdata.buffer, sizeof(pdata.buffer));
	if(s <= 0)
		break;
	pdata.len = s;
	write(pfd[1], &pdata, sizeof(pdata));
	s2 = write(tcp_fd, pdata.buffer, s);
	if(s2 != s)
		break;
   }
   kill(kid, SIGINT);
   close(pfd[1]);
   close(tcp_fd);
   return;
}