netkit-ntalk-0.11/ 40755 2000 1004 0 6702751434 13605 5ustar dhollanddhollandnetkit-ntalk-0.11/talk/ 40755 2000 1004 0 6702751434 14540 5ustar dhollanddhollandnetkit-ntalk-0.11/talk/Makefile100644 2000 1004 1006 6627502515 16272 0ustar dhollanddhollandall: talk include ../MCONFIG include ../MRULES ifeq ($(USE_GLIBC),1) CFLAGS += -DGNU_LIBC -D_GNU_SOURCE endif CFLAGS += -I../include OBJS = ctl.o ctl_transact.o display.o get_addrs.o get_names.o \ init_disp.o invite.o io.o look_up.o msgs.o talk.o LIBS += $(LIBCURSES) talk: $(OBJS) $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ $(OBJS): talk.h ../include/prot_talkd.h install: talk install -s -m$(BINMODE) talk $(INSTALLROOT)$(BINDIR) install -m$(MANMODE) talk.1 $(INSTALLROOT)$(MANDIR)/man1/ clean: rm -f *.o talk netkit-ntalk-0.11/talk/ctl.c100644 2000 1004 5346 6627502476 15601 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)ctl.c 5.7 (Berkeley) 3/1/91 */ char ctl_rcsid[] = "$Id: ctl.c,v 1.11 1998/11/27 10:55:58 dholland Exp $"; /* * This file handles haggling with the various talk daemons to * get a socket to talk to. sockt is opened and connected in * the progress */ #include #include #include #include "talk.h" /* inet address of the remote machine */ struct in_addr his_machine_addr; u_short daemon_port; /* port number of the talk daemon */ int sockt; int invitation_waiting = 0; CTL_MSG msg; void open_sockt(void) { sockt = socket(AF_INET, SOCK_STREAM, 0); if (sockt <= 0) p_error("Bad socket"); } #if 0 /* print_addr is a debug print routine */ void print_addr(struct sockaddr_in addr) { int i; printf("addr = %x, port = %o, family = %o zero = ", addr.sin_addr.s_addr, addr.sin_port, addr.sin_family); for (i = 0; i<8;i++) printf("%o ", (int)addr.sin_zero[i]); putchar('\n'); } #endif /* 0 */ netkit-ntalk-0.11/talk/ctl_transact.c100644 2000 1004 15436 6627504402 17510 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)ctl_transact.c 5.8 (Berkeley) 3/1/91 */ char ctlt_rcsid[] = "$Id: ctl_transact.c,v 1.11 1998/11/27 11:12:02 dholland Exp $"; #include #include #include #include #include #include #include #include #include "talk.h" #define CTL_WAIT 2 /* time to wait for a response, in seconds */ /* We now make two UDP sockets, one for the local talkd, one for the remote. */ static int to_local_talkd; static int to_remote_talkd; static u_int32_t local_addr_for_remote; /* open the ctl sockets */ void open_ctl(void) { struct sockaddr_in loc, rem; size_t length; int on=1; to_local_talkd = socket(AF_INET, SOCK_DGRAM, 0); to_remote_talkd = socket(AF_INET, SOCK_DGRAM, 0); if (to_local_talkd < 0 || to_remote_talkd < 0) { p_error("Bad socket"); } #ifdef SO_BSDCOMPAT /* * Linux does some async error return stuff that * really disagrees with us. So we disable it. */ setsockopt(to_local_talkd, SOL_SOCKET, SO_BSDCOMPAT, &on, sizeof(on)); setsockopt(to_remote_talkd, SOL_SOCKET, SO_BSDCOMPAT, &on, sizeof(on)); #endif /* * Explicitly talk to the local daemon over loopback. */ memset(&loc, 0, sizeof(loc)); loc.sin_family = AF_INET; loc.sin_port = htons(0); loc.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (bind(to_local_talkd, (struct sockaddr *)&loc, sizeof(loc))<0) { p_error("Couldn't bind local control socket"); } memset(&loc, 0, sizeof(loc)); loc.sin_family = AF_INET; loc.sin_port = daemon_port; loc.sin_addr.s_addr = htonl(INADDR_LOOPBACK); if (connect(to_local_talkd, (struct sockaddr *)&loc, sizeof(loc))<0) { p_error("Couldn't connect local control socket"); } /* * Now the trick - don't bind the remote socket. Instead * just do a UDP connect on it to force it to talk to the * remote talkd. The neat side effect of this is that * we can then get the correct local IP back from it * with getsockname. */ memset(&rem, 0, sizeof(rem)); rem.sin_family = AF_INET; rem.sin_port = daemon_port; rem.sin_addr = his_machine_addr; if (connect(to_remote_talkd, (struct sockaddr *)&rem, sizeof(rem))<0) { p_error("Couldn't connect remote control socket"); } length = sizeof(rem); if (getsockname(to_remote_talkd, (struct sockaddr *)&rem, &length)<0) { p_error("getsockname"); } local_addr_for_remote = rem.sin_addr.s_addr; } static void send_packet(CTL_MSG *msg, int sock) { int cc; cc = send(sock, msg, sizeof(*msg), 0); if (cc<0 && errno == EINTR) { return; } else if (cc<0) { p_error("Error on write to talk daemon"); } else if (cc != sizeof(*msg)) { p_error("Short write to talk daemon"); } } static void clean_up_packet(int sock, CTL_MSG *msg, int type) { struct sockaddr_in here; size_t len = sizeof(here); msg->vers = TALK_VERSION; msg->type = type; msg->answer = 0; msg->pad = 0; if (getsockname(sock, (struct sockaddr *)&here, &len)<0) { p_error("getsockname"); } msg->ctl_addr.ta_family = htons(AF_INET); msg->ctl_addr.ta_port = here.sin_port; msg->ctl_addr.ta_addr = here.sin_addr.s_addr; msg->addr.ta_family = htons(AF_INET); msg->addr.ta_addr = local_addr_for_remote; } void send_one_delete(int ismydaemon, int id) { CTL_MSG tmp = msg; int sock = ismydaemon ? to_local_talkd : to_remote_talkd; tmp.id_num = htonl(id); clean_up_packet(sock, &tmp, DELETE); send_packet(&tmp, sock); } /* * SOCKDGRAM is unreliable, so we must repeat messages if we have * not received an acknowledgement within a reasonable amount * of time */ static void do_transact(int sock, CTL_MSG *mesg, CTL_RESPONSE *rp) { fd_set read_mask, ctl_mask; int nready=0, cc; struct timeval wait; FD_ZERO(&ctl_mask); FD_SET(sock, &ctl_mask); /* * Keep sending the message until a response of * the proper type is obtained. */ do { /* resend message until a response is obtained */ do { send_packet(mesg, sock); read_mask = ctl_mask; wait.tv_sec = CTL_WAIT; wait.tv_usec = 0; nready = select(sock+1, &read_mask, 0, 0, &wait); if (nready < 0) { if (errno == EINTR) continue; p_error("Error waiting for daemon response"); } } while (nready == 0); /* * Keep reading while there are queued messages * (this is not necessary, it just saves extra * request/acknowledgements being sent) */ do { cc = recv(sock, (char *)rp, sizeof (*rp), 0); if (cc < 0) { if (errno == EINTR) continue; p_error("Error on read from talk daemon"); } read_mask = ctl_mask; /* an immediate poll */ timerclear(&wait); nready = select(sock+1, &read_mask, 0, 0, &wait); } while (nready > 0 && (rp->vers != TALK_VERSION || rp->type != mesg->type)); } while (rp->vers != TALK_VERSION || rp->type != mesg->type); } void ctl_transact(int ismydaemon, CTL_MSG mesg, int type, CTL_RESPONSE *rp) { int sock; sock = ismydaemon ? to_local_talkd : to_remote_talkd; clean_up_packet(sock, &mesg, type); do_transact(sock, &mesg, rp); rp->id_num = ntohl(rp->id_num); rp->addr.ta_family = ntohs(rp->addr.ta_family); } netkit-ntalk-0.11/talk/display.c100644 2000 1004 12530 6627506543 16474 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)display.c 5.4 (Berkeley) 6/1/90 */ char display_rcsid[] = "$Id: display.c,v 1.7 1998/11/27 11:30:43 dholland Exp $"; /* * The window 'manager', initializes curses and handles the actual * displaying of text */ #include "talk.h" static void xscroll(xwin_t *win, int flag); static int readwin(WINDOW *win, int line, int col); xwin_t my_win; xwin_t his_win; WINDOW *line_win; int curses_initialized = 0; /* * max HAS to be a function, it is called with * a argument of the form --foo at least once. */ static inline int max(int a, int b) { return (a > b ? a : b); } /* * Display some text on somebody's window, processing some control * characters while we are at it. */ void display(xwin_t *win, unsigned char *text, int size) { int j; unsigned char cch; for (j = 0; j < size; j++) { if (*text == '\n') { xscroll(win, 0); text++; continue; } /* someday erase characters will work properly in unix */ if (*text == '\b' || *text == 127) *text = win->cerase; /* erase character */ if (*text == win->cerase) { wmove(win->x_win, win->x_line, max(--win->x_col, 0)); getyx(win->x_win, win->x_line, win->x_col); waddch(win->x_win, ' '); wmove(win->x_win, win->x_line, win->x_col); getyx(win->x_win, win->x_line, win->x_col); text++; continue; } /* * On word erase search backwards until we find * the beginning of a word or the beginning of * the line. */ if (*text == win->werase) { int endcol, xcol, i, c; endcol = win->x_col; xcol = endcol - 1; while (xcol >= 0) { c = readwin(win->x_win, win->x_line, xcol); if (c != ' ') break; xcol--; } while (xcol >= 0) { c = readwin(win->x_win, win->x_line, xcol); if (c == ' ') break; xcol--; } wmove(win->x_win, win->x_line, xcol + 1); for (i = xcol + 1; i < endcol; i++) waddch(win->x_win, ' '); wmove(win->x_win, win->x_line, xcol + 1); getyx(win->x_win, win->x_line, win->x_col); continue; } /* line kill */ if (*text == win->kill) { wmove(win->x_win, win->x_line, 0); wclrtoeol(win->x_win); getyx(win->x_win, win->x_line, win->x_col); text++; continue; } if (*text == '\f') { if (win == &my_win) wrefresh(curscr); text++; continue; } if (*text == '\a') { beep(); wrefresh(curscr); text++; continue; } if (win->x_col == COLS-1) { /* check for wraparound */ xscroll(win, 0); } if ((*text & 0x7F) < ' ' && *text != '\t') { waddch(win->x_win, '^'); getyx(win->x_win, win->x_line, win->x_col); if (win->x_col == COLS-1) /* check for wraparound */ xscroll(win, 0); cch = (*text & 63) + 64; waddch(win->x_win, cch); } else waddch(win->x_win, *text); getyx(win->x_win, win->x_line, win->x_col); text++; } wrefresh(win->x_win); } /* * Read the character at the indicated position in win */ static int readwin(WINDOW *win, int line, int col) { int oldline, oldcol; register int c; getyx(win, oldline, oldcol); wmove(win, line, col); c = winch(win); wmove(win, oldline, oldcol); return (c); } /* * Scroll a window, blanking out the line following the current line * so that the current position is obvious */ static void xscroll(xwin_t *win, int flag) { if (flag == -1) { wmove(win->x_win, 0, 0); win->x_line = 0; win->x_col = 0; return; } win->x_line = (win->x_line + 1) % win->x_nlines; win->x_col = 0; wmove(win->x_win, win->x_line, win->x_col); wclrtoeol(win->x_win); wmove(win->x_win, (win->x_line + 1) % win->x_nlines, win->x_col); wclrtoeol(win->x_win); wmove(win->x_win, win->x_line, win->x_col); } netkit-ntalk-0.11/talk/get_addrs.c100644 2000 1004 5336 6627502476 16752 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)get_addrs.c 5.7 (Berkeley) 3/1/91 */ char ga_rcsid[] = "$Id: get_addrs.c,v 1.10 1998/11/27 10:55:58 dholland Exp $"; #include #include #include #include #include #include #include #include #include "talk.h" void get_addrs(const char *his_machine_name) { struct hostent *hp; struct servent *sp; msg.pid = htonl(getpid()); hp = gethostbyname(his_machine_name); if (hp == NULL) { fprintf(stderr, "talk: %s: ", his_machine_name); herror((char *)NULL); exit(-1); } if (hp->h_length > (int)sizeof(his_machine_addr)) { hp->h_length = sizeof(his_machine_addr); } memcpy(&his_machine_addr, hp->h_addr, hp->h_length); /* find the server's port */ sp = getservbyname("ntalk", "udp"); if (sp == 0) { fprintf(stderr, "talk: %s/%s: service is not registered.\n", "ntalk", "udp"); exit(-1); } daemon_port = sp->s_port; } netkit-ntalk-0.11/talk/get_names.c100644 2000 1004 7150 6627504402 16743 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)get_names.c 5.9 (Berkeley) 3/1/91 */ char gn_rcsid[] = "$Id: get_names.c,v 1.9 1998/11/27 11:12:02 dholland Exp $"; #include #include #include #include #include #include "talk.h" /* * Determine the local and remote user, tty, and machines */ void get_names(int argc, char *argv[]) { char hostname[MAXHOSTNAMELEN]; char *his_name, *my_name; char *my_machine_name, *his_machine_name; const char *his_tty; register char *cp; char *names; if (argc < 2) { printf("Usage: talk user [ttyname]\n"); exit(1); } if (!isatty(0)) { printf("Standard input must be a tty, not a pipe or a file\n"); exit(1); } if ((my_name = getlogin()) == NULL || my_name[0] == 0) { struct passwd *pw; if ((pw = getpwuid(getuid())) == NULL) { printf("You don't exist. Go away.\n"); exit(1); } my_name = pw->pw_name; } gethostname(hostname, sizeof (hostname)); my_machine_name = hostname; /* check for, and strip out, the machine name of the target */ names = strdup(argv[1]); for (cp = names; *cp && !index("@:!.", *cp); cp++) ; if (*cp == '\0') { /* this is a local to local talk */ his_name = names; his_machine_name = my_machine_name; } else { if (*cp++ == '@') { /* user@host */ his_name = names; his_machine_name = cp; } else { /* host.user or host!user or host:user */ his_name = cp; his_machine_name = names; } *--cp = '\0'; } if (argc > 2) his_tty = argv[2]; /* tty name is arg 2 */ else his_tty = ""; get_addrs(his_machine_name); /* * Initialize the message template. */ msg.id_num = htonl(0); strncpy(msg.l_name, my_name, NAME_SIZE); msg.l_name[NAME_SIZE - 1] = 0; strncpy(msg.r_name, his_name, NAME_SIZE); msg.r_name[NAME_SIZE - 1] = 0; strncpy(msg.r_tty, his_tty, TTY_SIZE); msg.r_tty[TTY_SIZE - 1] = 0; } netkit-ntalk-0.11/talk/init_disp.c100644 2000 1004 11503 6346611177 17006 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)init_disp.c 5.4 (Berkeley) 6/1/90 */ char id_rcsid[] = "$Id: init_disp.c,v 1.9 1997/06/08 20:13:51 dholland Exp $"; /* * Initialization code for the display package, * as well as the signal handling routines. */ #include #include #include #include #include "talk.h" static void sig_sent(int); /* * Set up curses, catch the appropriate signals, * and build the various windows. */ void init_display(void) { struct sigaction sigac; LINES = COLS = 0; if (initscr() == NULL) { printf("initscr failed: TERM is unset or unknown terminal type.\n"); exit(-1); } (void) sigaction(SIGTSTP, NULL, &sigac); sigaddset(&sigac.sa_mask, SIGALRM); (void) sigaction(SIGTSTP, &sigac, NULL); curses_initialized = 1; clear(); refresh(); noecho(); cbreak(); signal(SIGINT, sig_sent); signal(SIGPIPE, sig_sent); /* curses takes care of SIGTSTP (^Z) */ my_win.x_nlines = LINES / 2; my_win.x_ncols = COLS; my_win.x_win = newwin(my_win.x_nlines, my_win.x_ncols, 0, 0); scrollok(my_win.x_win, FALSE); wclear(my_win.x_win); his_win.x_nlines = LINES / 2 - 1; his_win.x_ncols = COLS; his_win.x_win = newwin(his_win.x_nlines, his_win.x_ncols, my_win.x_nlines+1, 0); scrollok(his_win.x_win, FALSE); wclear(his_win.x_win); line_win = newwin(1, COLS, my_win.x_nlines, 0); box(line_win, '-', '-'); wrefresh(line_win); /* let them know we are working on it */ current_state = "No connection yet"; } /* * Trade edit characters with the other talk. By agreement * the first three characters each talk transmits after * connection are the three edit characters. */ void set_edit_chars(void) { char buf[3]; int cc; struct termios tios; tcgetattr(0, &tios); my_win.cerase = tios.c_cc[VERASE]; my_win.kill = tios.c_cc[VKILL]; my_win.werase = tios.c_cc[VWERASE]; if ((unsigned char)my_win.werase == 0xff) { my_win.werase = '\027'; /* control W */ } buf[0] = my_win.cerase; buf[1] = my_win.kill; buf[2] = my_win.werase; cc = write(sockt, buf, sizeof(buf)); if (cc != sizeof(buf) ) p_error("Lost the connection"); cc = read(sockt, buf, sizeof(buf)); if (cc != sizeof(buf) ) p_error("Lost the connection"); his_win.cerase = buf[0]; his_win.kill = buf[1]; his_win.werase = buf[2]; } void sig_sent(int signum) { (void)signum; message("Connection closing. Exiting"); quit(1); } /* * All done talking...hang up the phone and reset terminal thingy */ void quit(int direct) { const char *rmcup, *smcup; if (curses_initialized) { rmcup = tigetstr("rmcup"); smcup = tigetstr("smcup"); if ((direct != 1) && (rmcup || smcup)) { raw(); signal(SIGALRM, SIG_IGN); signal(SIGINT, SIG_DFL); wmove(my_win.x_win, current_line%my_win.x_nlines+1, 0); wprintw(my_win.x_win, "[Press any key to continue]\n"); wrefresh(my_win.x_win); /* alternative screen, prompt before exit */ wgetch(my_win.x_win); } wmove(his_win.x_win, his_win.x_nlines-1, 0); wclrtoeol(his_win.x_win); wrefresh(his_win.x_win); endwin(); } if (invitation_waiting) { send_delete(); } exit(0); } netkit-ntalk-0.11/talk/invite.c100644 2000 1004 13221 6627502476 16324 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)invite.c 5.8 (Berkeley) 3/1/91 */ char inv_rcsid[] = "$Id: invite.c,v 1.11 1998/11/27 10:55:58 dholland Exp $"; #include #include #include #include #include #include #include #include #include "talk.h" static void announce_invite(void); /* * There wasn't an invitation waiting, so send a request containing * our sockt address to the remote talk daemon so it can invite * him */ /* * The msg.id's for the invitations * on the local and remote machines. * These are used to delete the * invitations. */ int local_id, remote_id; void re_invite(int); sigjmp_buf invitebuf; void invite_remote(void) { /*volatile int nfd, read_mask, template;*/ volatile int new_sockt; struct itimerval itimer; CTL_RESPONSE response; struct sockaddr_in sn; size_t size = sizeof(sn); itimer.it_value.tv_sec = RING_WAIT; itimer.it_value.tv_usec = 0; itimer.it_interval = itimer.it_value; if (listen(sockt, 5) != 0) { p_error("Error on attempt to listen for caller"); } getsockname(sockt, (struct sockaddr *)&sn, &size); /* copy new style sockaddr to old */ msg.addr.ta_family = htons(AF_INET); msg.addr.ta_port = sn.sin_port; msg.addr.ta_addr = 0; /* will be patched up in ctl_transact */ msg.id_num = htonl(-1); /* an impossible id_num */ invitation_waiting = 1; announce_invite(); /* * Shut off the automatic messages for a while, * so we can use the interupt timer to resend the invitation */ end_msgs(); setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0); message("Waiting for your party to respond"); signal(SIGALRM, re_invite); (void) sigsetjmp(invitebuf, 1); while ((new_sockt = accept(sockt, 0, 0)) < 0) { if (errno == EINTR) continue; p_error("Unable to connect with your party"); } close(sockt); sockt = new_sockt; /* * Have the daemons delete the invitations now that we * have connected. */ current_state = "Waiting for your party to respond"; start_msgs(); msg.id_num = htonl(local_id); ctl_transact(MY_DAEMON, msg, DELETE, &response); msg.id_num = htonl(remote_id); ctl_transact(HIS_DAEMON, msg, DELETE, &response); invitation_waiting = 0; } /* * Routine called on interupt to re-invite the callee */ void re_invite(int ignore) { (void)ignore; signal(SIGALRM, re_invite); message("Ringing your party again"); current_line++; /* force a re-announce */ msg.id_num = htonl(remote_id + 1); announce_invite(); siglongjmp(invitebuf, 1); } static const char *answers[] = { "answer #0", /* SUCCESS */ "Your party is not logged on", /* NOT_HERE */ "Target machine is too confused to talk to us", /* FAILED */ "Target machine does not recognize us", /* MACHINE_UNKNOWN */ "Your party is refusing messages", /* PERMISSION_REFUSED */ "Target machine can not handle remote talk", /* UNKNOWN_REQUEST */ "Target machine indicates protocol mismatch", /* BADVERSION */ "Target machine indicates protocol botch (addr)",/* BADADDR */ "Target machine indicates protocol botch (ctl_addr)",/* BADCTLADDR */ }; #define NANSWERS (sizeof (answers) / sizeof (answers[0])) /* * Transmit the invitation and process the response */ static void announce_invite(void) { CTL_RESPONSE response; current_state = "Trying to connect to your party's talk daemon"; ctl_transact(HIS_DAEMON, msg, ANNOUNCE, &response); remote_id = response.id_num; if (response.answer != SUCCESS) { if (response.answer < NANSWERS) message(answers[response.answer]); quit(0); } /* leave the actual invitation on my talk daemon */ ctl_transact(MY_DAEMON, msg, LEAVE_INVITE, &response); local_id = response.id_num; } /* * Tell the daemon to remove your invitation */ void send_delete(void) { /* * This is just a extra clean up, so just send it * and don't wait for an answer */ send_one_delete(HIS_DAEMON, remote_id); send_one_delete(MY_DAEMON, local_id); } netkit-ntalk-0.11/talk/io.c100644 2000 1004 7720 6346611177 15421 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)io.c 5.6 (Berkeley) 3/1/91 */ char io_rcsid[] = "$Id: io.c,v 1.10 1997/06/08 20:13:51 dholland Exp $"; /* * This file contains the I/O handling and the exchange of * edit characters. This connection itself is established in * ctl.c */ #include #include #include #include #include #include #include "talk.h" /* * The routine to do the actual talking */ void talk(void) { fd_set read_set; int nb; unsigned char buf[BUFSIZ]; message("Connection established"); beep(); wrefresh(curscr); current_line = 0; /* * Wait on both the other process and standard input */ for (;;) { FD_ZERO(&read_set); FD_SET(0, &read_set); FD_SET(sockt, &read_set); nb = select(sockt+1, &read_set, NULL, NULL, NULL); if (nb <= 0) { if (errno == EINTR) { continue; } /* panic, we don't know what happened */ p_error("Unexpected error from select"); quit(0); } if (FD_ISSET(sockt, &read_set)) { /* There is data on sockt */ nb = read(sockt, buf, sizeof(buf)); if (nb <= 0) { message("Connection closed. Exiting"); quit(0); } display(&his_win, buf, nb); } if (FD_ISSET(0, &read_set)) { buf[0] = getch(); nb = 1; display(&my_win, buf, nb); /* might lose data here because sockt is nonblocking */ write(sockt, buf, nb); } } } /* * p_error prints the system error message on the standard location * on the screen and then exits. (i.e. a curses version of perror) */ void p_error(const char *string) { const char *rmcup, *smcup, *amsg=""; rmcup = tigetstr("rmcup"); smcup = tigetstr("smcup"); if (rmcup || smcup) { amsg = ". Press any key..."; } wmove(my_win.x_win, current_line%my_win.x_nlines, 0); wprintw(my_win.x_win, "[%s : %s (%d)%s]\n", string, strerror(errno), errno, amsg); wrefresh(my_win.x_win); move(LINES-1, 0); refresh(); if (rmcup || smcup) { /* alternative screen, prompt before exit */ getch(); } quit(0); } /* * Display string in the standard location */ void message(const char *string) { wmove(my_win.x_win, current_line%my_win.x_nlines, 0); wprintw(my_win.x_win, "[%s]\n", string); wrefresh(my_win.x_win); } netkit-ntalk-0.11/talk/look_up.c100644 2000 1004 7036 6627502476 16465 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)look_up.c 5.7 (Berkeley) 3/1/91 */ char lu_rcsid[] = "$Id: look_up.c,v 1.6 1998/11/27 10:55:58 dholland Exp $"; #include #include #include #include #include #include "talk.h" static int look_for_invite(CTL_RESPONSE *rp); /* * See if the local daemon has an invitation for us. */ int check_local(void) { CTL_RESPONSE response; register CTL_RESPONSE *rp = &response; /* must be initiating a talk */ if (!look_for_invite(rp)) return 0; /* * There was an invitation waiting for us, * so connect with the other (hopefully waiting) party */ current_state = "Waiting to connect with caller"; do { if (rp->addr.ta_family != AF_INET) p_error("Response uses invalid network address"); errno = 0; if (connect(sockt, (struct sockaddr *)&rp->addr, sizeof (rp->addr)) != -1) return 1; } while (errno == EINTR); if (errno == ECONNREFUSED) { /* * The caller gave up, but his invitation somehow * was not cleared. Clear it and initiate an * invitation. (We know there are no newer invitations, * the talkd works LIFO.) */ ctl_transact(HIS_DAEMON, msg, DELETE, rp); close(sockt); open_sockt(); return 0; } p_error("Unable to connect with initiator"); /*NOTREACHED*/ return 0; } /* * Look for an invitation on 'machine' */ static int look_for_invite(CTL_RESPONSE *rp) { /* struct in_addr machine_addr; */ current_state = "Checking for invitation on caller's machine"; ctl_transact(HIS_DAEMON, msg, LOOK_UP, rp); /* the switch is for later options, such as multiple invitations */ switch (rp->answer) { case SUCCESS: msg.id_num = htonl(rp->id_num); return (1); default: /* there wasn't an invitation waiting for us */ return (0); } } netkit-ntalk-0.11/talk/msgs.c100644 2000 1004 6006 6627502476 15762 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)msgs.c 5.6 (Berkeley) 3/1/91 */ char msgs_rcsid[] = "$Id: msgs.c,v 1.6 1998/11/27 10:55:58 dholland Exp $"; /* * A package to display what is happening every MSG_INTERVAL seconds * if we are slow connecting. */ #include #include #include #include "talk.h" #define MSG_INTERVAL 4 const char *current_state; int current_line = 0; static void disp_msg(int ignore) { (void)ignore; message(current_state); } void start_msgs(void) { struct itimerval itimer; struct sigaction act; message(current_state); act.sa_handler = disp_msg; act.sa_flags = SA_RESTART; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask, SIGALRM); sigaction(SIGALRM, &act, NULL); itimer.it_value.tv_sec = itimer.it_interval.tv_sec = MSG_INTERVAL; itimer.it_value.tv_usec = itimer.it_interval.tv_usec = 0; setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0); } void end_msgs(void) { struct itimerval itimer; struct sigaction act; timerclear(&itimer.it_value); timerclear(&itimer.it_interval); setitimer(ITIMER_REAL, &itimer, (struct itimerval *)0); act.sa_handler = SIG_DFL; act.sa_flags = SA_RESTART; sigemptyset(&act.sa_mask); sigaddset(&act.sa_mask, SIGALRM); sigaction(SIGALRM, &act, NULL); } netkit-ntalk-0.11/talk/talk.1100644 2000 1004 10632 6346611177 15677 0ustar dhollanddholland.\" Copyright (c) 1983, 1990 The Regents of the University of California. .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" 3. All advertising materials mentioning features or use of this software .\" must display the following acknowledgement: .\" This product includes software developed by the University of .\" California, Berkeley and its contributors. .\" 4. Neither the name of the University nor the names of its contributors .\" may be used to endorse or promote products derived from this software .\" without specific prior written permission. .\" .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" .\" from: @(#)talk.1 6.6 (Berkeley) 4/22/91 .\" $Id: talk.1,v 1.2 1997/06/08 20:13:51 dholland Exp $ .\" .Dd April 22, 1991 .Dt TALK 1 .Os BSD 4.2 .Sh NAME .Nm talk .Nd talk to another user .Sh SYNOPSIS .Nm talk .Ar person .Op Ar ttyname .Sh DESCRIPTION .Nm Talk is a visual communication program which copies lines from your terminal to that of another user. .Pp Options available: .Bl -tag -width ttyname .It Ar person If you wish to talk to someone on your own machine, then .Ar person is just the person's login name. If you wish to talk to a user on another host, then .Ar person is of the form .Ql user@host . .It Ar ttyname If you wish to talk to a user who is logged in more than once, the .Ar ttyname argument may be used to indicate the appropriate terminal name, where .Ar ttyname is of the form .Ql ttyXX . .El .Pp When first called, .Nm talk sends the message .Bd -literal -offset indent -compact Message from TalkDaemon@his_machine... talk: connection requested by your_name@your_machine. talk: respond with: talk your_name@your_machine .Ed .Pp to the user you wish to talk to. At this point, the recipient of the message should reply by typing .Pp .Dl talk \ your_name@your_machine .Pp It doesn't matter from which machine the recipient replies, as long as his login-name is the same. Once communication is established, the two parties may type simultaneously, with their output appearing in separate windows. Typing control-L .Ql ^L will cause the screen to be reprinted, while your erase, kill, and word kill characters will behave normally. To exit, just type your interrupt character; .Nm talk then moves the cursor to the bottom of the screen and restores the terminal to its previous state. .Pp Permission to talk may be denied or granted by use of the .Xr mesg 1 command. At the outset talking is allowed. Certain commands, in particular .Xr nroff 1 and .Xr pr 1 , disallow messages in order to prevent messy output. .Pp .Sh FILES .Bl -tag -width /var/run/utmp -compact .It Pa /etc/hosts to find the recipient's machine .It Pa /var/run/utmp to find the recipient's tty .El .Sh SEE ALSO .Xr mail 1 , .Xr mesg 1 , .Xr who 1 , .Xr write 1 .Sh BUGS The version of .Xr talk 1 released with .Bx 4.3 uses a protocol that is incompatible with the protocol used in the version released with .Bx 4.2 (SunOS/Solaris uses this old protocol). +.PP Another problem might occur with talk connections over point-to-point links (SLIP/PPP). To get it working you have to change the hostname to the hostname matching the IP address of the SLIP/PPP interface while the connection exist. .Sh HISTORY The .Nm command appeared in .Bx 4.2 . netkit-ntalk-0.11/talk/talk.c100644 2000 1004 5334 6172606346 15743 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ char copyright[] = "@(#) Copyright (c) 1983 Regents of the University of California.\n" "All rights reserved.\n"; /* * From: @(#)talk.c 5.5 (Berkeley) 6/1/90 */ char talk_rcsid[] = "$Id: talk.c,v 1.2 1996/07/16 03:30:46 dholland Exp $"; #include "talk.h" /* * talk: A visual form of write. Using sockets, a two way * connection is set up between the two people talking. * With the aid of curses, the screen is split into two * windows, and each users text is added to the window, * one character at a time... * * Written by Kipp Hickman * * Modified to run under 4.1a by Clem Cole and Peter Moore * Modified to run between hosts by Peter Moore, 8/19/82 * Modified to run under 4.1c by Peter Moore 3/17/83 */ int main(int argc, char *argv[]) { get_names(argc, argv); init_display(); open_ctl(); open_sockt(); start_msgs(); if (!check_local()) invite_remote(); end_msgs(); set_edit_chars(); talk(); return 0; } netkit-ntalk-0.11/talk/talk.h100644 2000 1004 5737 6627502476 15763 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)talk.h 5.7 (Berkeley) 3/1/91 * $Id: talk.h,v 1.13 1998/11/27 10:55:58 dholland Exp $ */ #include #include #include #include "prot_talkd.h" extern int sockt; extern int curses_initialized; extern int invitation_waiting; extern const char *current_state; extern int current_line; typedef struct xwin { WINDOW *x_win; int x_nlines; int x_ncols; int x_line; int x_col; char kill; char cerase; char werase; } xwin_t; extern xwin_t my_win; extern xwin_t his_win; extern WINDOW *line_win; void p_error(const char *string); void quit(int); void message(const char *mesg); void get_names(int argc, char *argv[]); void get_addrs(const char *); void init_display(void); void open_ctl(void); void open_sockt(void); void start_msgs(void); int check_local(void); void invite_remote(void); void end_msgs(void); void set_edit_chars(void); void talk(void); void send_delete(void); void display(xwin_t *, unsigned char *, int); #define HIS_DAEMON 0 #define MY_DAEMON 1 void send_one_delete(int ismydaemon, int); void ctl_transact(int ismydaemon, CTL_MSG, int, CTL_RESPONSE *); extern struct in_addr his_machine_addr; extern u_short daemon_port; extern CTL_MSG msg; netkit-ntalk-0.11/BUGS100644 2000 1004 763 6702536674 14362 0ustar dhollanddhollandtalk: - long-standing curses bugs associated with going off right side of screen. (These appear to no longer happen now though.) - support word-wrap. - handle backspacing intelligently. - there are reports that it sometimes goes into a one-line-only mode where it only prints to the top line of the screen. I can't reproduce this, I'm afraid... insight welcome. talkd: - talk request messages should check for 8 bit tty and not clear to 7 bits. - doesn't log flash attempts. netkit-ntalk-0.11/ChangeLog100644 2000 1004 6772 6633525461 15472 0ustar dhollanddholland9-Dec-1998: We don't need to check for BSD signal semantics now; updated MCONFIG and regenerated configure script. 26-Nov-1998: Fixed bug: the talkd announce message is passed as the format string to fprintf, so if it has %'s in it, we probably crash. Copied into include directory, because we need to fiddle with it. Rearrange/clean up talkd source. Removed mytalkd.h. Added lots of checking and paranoia to packet handling. Don't reply to the ctl_addr in the packet; reply to where the packet came from. Created framework for working with bogus packets. Beefed up talkd's debug logging. Cleanup in talk. Removed talk_ctl.h. Fixed the problem where talk goes and blindly binds things to the wrong local addresses. We don't need talk.FvK.patch any more, either. Filter high-ascii control characters in talk as well as regular ones. (Olaf Kirch, okir@caldera.de) Don't zoom off the end of the string fields of the input packet in talkd. (Olaf Kirch, okir@caldera.de) 22-Sep-1997: Fix talkd to use WIFEXITED et al. rather than assume things about the bits returned by wait. 12-Jun-1997: netkit-ntalk-0.10 released. 08-Jun-1997: Pause before clearing the screen on exit. (Peter Tobias, tobias@et-inf.fho-emden.de) 19-May-1997: glibc fixes from Red Hat. 05-Apr-1997: Added configure script to generate MCONFIG. Fix problem in talkd that issued PERMISSION_DENIED instead of NOT_HERE. (Joerg Kleuver, kleuver@shadowgate.rhein.de, via Debian) Talk accepts ^H and ^? as erase characters regardless of stty settings. Better utmp handling in talkd. 08-Mar-1997: Split from full NetKit package. Generated this change log from NetKit's. 29-Dec-1996 NetKit-0.09 released. Assorted alpha/glibc patches. (Erik Troan, ewt@redhat.com) Assorted bug fixes from Debian. (Peter Tobias, tobias@et-inf.fho-emden.de) Hardened programs against DNS h_length spoofing attacks. Use inet_aton() everywhere instead of inet_addr(). 8-bit fixes to talk. (Christer Weinigel, wingel@dumburk.signum.se) Assorted fixes to talk. (Florian La Roche) Talk handles ^Z correctly now. 22-Aug-1996 NetKit-B-0.08 released. (almost) everything now compiles with lots of warnings turned on. talk now beeps correctly with ncurses (fix from Marek Rouchal .) 25-Jul-1996 NetKit-B-0.07A released. 23-Jul-1996 NetKit-B-0.07 released. Integrated a collection of patches that had been lurking on the net, including the 256-ptys support for telnetd and passive mode ftp. Major security fixes, including to fingerd, lpr, rlogin, rsh, talkd, and telnetd. Do *not* use the sliplogin from earlier versions of this package, either. talkd is flashproof. Much of the code builds without libbsd.a or bsd includes. Massive code cleanup. Almost everything compiles clean with gcc -Wall now. rusers and rusersd do not; patches to rpcgen to fix this would be appreciated if anyone feels like it. New maintainer: David A. Holland, dholland@hcs.harvard.edu date not known NetKit-B-0.06 released. Have talk be interruptable by Ctrl-Z from John Tombs (haven't tested this) date not known NetKit-B-0.05 released. Fixed talk connection problem for multihomed hosts (Pauline Middelink) This patch must be activated by editing the Makefile of "talk" as this is not the correct way to set up a linux host/solve this problem... date not known NetKit-B-0.04 released. Changes to talk and talkd from newer NetBSD versions. date not known NetKit-B-0.03 released. netkit-ntalk-0.11/MCONFIG100644 2000 1004 1463 6633525271 14714 0ustar dhollanddholland# Generated by configure on Wed Dec 9 11:51:29 EST 1998 # # Directory for user binaries BINDIR=/usr/bin # Directory for man page tree MANDIR=/usr/man # Directory for system binaries SBINDIR=/usr/sbin # Install into chroot area found here INSTALLROOT= # Mode for user binaries BINMODE=755 # Mode for daemon binaries DAEMONMODE=755 # Mode for manual pages MANMODE=644 # Compiler to use CC=gcc # Compiler warnings WARNINGS= -Wall -W -Wpointer-arith -Wbad-function-cast -Wcast-qual -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations -Wnested-externs -Winline -Wcast-align # Compiler flags to use CFLAGS= -pipe -O2 $(WARNINGS) # Link-time flags to use LDFLAGS= -s # Additional link libraries LIBS= # Curses library to use LIBCURSES=-lncurses # Work around GNU libc lossage USE_GLIBC=0 netkit-ntalk-0.11/MRULES100644 2000 1004 173 6310314570 14604 0ustar dhollanddholland# Standard compilation rules (don't use make builtins) %.o: %.c $(CC) $(CFLAGS) $< -c %.o: %.cc $(CC) $(CFLAGS) $< -c netkit-ntalk-0.11/Makefile100644 2000 1004 665 6310314570 15320 0ustar dhollanddholland# You can do "make SUB=blah" to make only a few, or edit here, or both # You can also run make directly in the subdirs you want. SUB = talk talkd %.build: $(MAKE) -C $(patsubst %.build, %, $@) %.install: $(MAKE) -C $(patsubst %.install, %, $@) install %.clean: $(MAKE) -C $(patsubst %.clean, %, $@) clean all: $(patsubst %, %.build, $(SUB)) install: $(patsubst %, %.install, $(SUB)) clean: $(patsubst %, %.clean, $(SUB)) netkit-ntalk-0.11/README100644 2000 1004 5523 6702751301 14560 0ustar dhollanddhollandThis is netkit-ntalk-0.11. This package updates netkit-ntalk-0.10. It contains the talk client, talk, and the talk daemon, talkd. It is the current version of the talk and talkd that were distributed in NetKit-0.09. This is an interim release. Another release is expected before too long. Contents: This package contains the programs talk and talkd. If you're reading this off a CD, go right away and check the net archives for later versions and security fixes. Requirements: (These are known to work; you can probably use much earlier versions of libc, gcc, or the kernel.) libc 5.4 or higher Older libc versions will work but anything before 5.4.6 includes some nasty security bugs. All the NetKit programs are believed immune to these, but the rest of your system probably isn't... Note: libc 5.0.x is not supported and won't work. glibc 2.0.x and 2.1.x are expected to work with this release. linux 2.0 or higher NetKit itself will probably work with anything since 0.99pl14, although some hacking would probably be required. gcc 2.7.2 or higher Please get the strength-reduce fix if you don't have it. libncurses Any recent version should be ok. Please make sure your header files in /usr/include match your libc version installed in /lib and /usr/lib. If you have weird problems this is the most likely culprit. Installation: Do "./configure", or edit MCONFIG to set the configuration options. Do "make". Do "make install" as root to install everything. Save backup copies of important tools, or confirm the new ones work first. Etc. We warned you. Security: This release contains no security fixes relative to the talk and talkd from NetKit-0.09. Versions prior to NetKit-0.09 should not be used. Features: talk should now work correctly on multihomed machines (those with multiple IP addresses). talkd now contains code to hopefully detect and handle certain kinds of mangled talk packets that you may encounter. It also now has an option to log talk packets it doesn't understand; see the man page. Hopefully this will be useful if you run into interoperability problems. Other notes: Use of the "wordwrap.patch" patch is neither recommended nor discouraged. Apply it at your discretion. Bugs: If something doesn't compile for you, send diffs. If you can't send diffs, send the compiler's error output. If it compiles but doesn't work, send as complete a bug report as you can. Patches and fixes are welcome, as long as you describe adequately what they're supposed to fix. Please, one patch per distinct fix. Be sure to send all correspondence in e-mail. Postings to netnews will not be seen due to the enormous volume. Please don't report known bugs (see the BUGS file(s)) unless you are including fixes. :-) Philip Copeland David A. Holland Al Howat netbug@ftp.uk.linux.org 7 April 1999 netkit-ntalk-0.11/configure100755 2000 1004 26544 6633525120 15636 0ustar dhollanddholland#!/bin/sh # # This file was generated by confgen. # Do not edit. # PREFIX='/usr' #EXECPREFIX='$PREFIX' INSTALLROOT='' BINMODE='755' #DAEMONMODE='$BINMODE' MANMODE='644' while [ x$1 != x ]; do case $1 in --help) cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "nope. Using cc." CC=cc else echo "found" fi rm -f __conftest __conftest.c echo -n "Checking that $CC works..." cat <__conftest.c #include int main(int argc, char *argv[]) { printf("Hello from %s\n", argv[0]); return argc; } EOF $CC $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "nope, doesn't run." echo "Sorry." exit 1 fi TEMP=`./__conftest 1 2 3` if [ $? != 4 ]; then echo "nope, doesn't work." echo "Sorry." exit 1 fi if [ "x$TEMP" != "xHello from ./__conftest" ]; then echo "nope, doesn't work." echo "Sorry." exit 1 fi echo 'ok' rm -f __conftest __conftest.c ######################################################################## echo -n "Checking if $CC accepts -Wall..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wall $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wall" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -W..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -W $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -W" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wpointer-arith..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wpointer-arith $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wpointer-arith" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wbad-function-cast..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wbad-function-cast $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wbad-function-cast" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wcast-qual..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wcast-qual $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wcast-qual" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wstrict-prototypes..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wstrict-prototypes $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wstrict-prototypes" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wmissing-prototypes..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wmissing-prototypes $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wmissing-prototypes" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wmissing-declarations..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wmissing-declarations $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wmissing-declarations" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wnested-externs..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wnested-externs $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wnested-externs" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Winline..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Winline $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Winline" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -Wcast-align..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -Wcast-align $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" WARNINGS="${WARNINGS} -Wcast-align" fi rm -f __conftest __conftest.c ######################################################################## echo -n "Checking if $CC accepts -pipe..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -pipe $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" CFLAGS="${CFLAGS} -pipe" fi rm -f __conftest __conftest.c if [ x$DEBUG != x ]; then echo -n "Checking if $CC accepts -g..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -g $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" CFLAGS="${CFLAGS} -g" fi rm -f __conftest __conftest.c else echo -n "Checking if $CC accepts -O2..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -O2 $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" CFLAGS="${CFLAGS} -O2" fi rm -f __conftest __conftest.c echo -n "Checking if $CC accepts -s..." cat <__conftest.c #include int main() { printf("Hello\n"); return 0; } EOF $CC -s $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" LDFLAGS="${LDFLAGS} -s" fi rm -f __conftest __conftest.c fi ######################################################################## echo -n "Checking for GNU libc..." cat <__conftest.c #include #if defined(__GLIBC__) && (__GLIBC__ >= 2) int tester; #endif int main() { tester=6; return 0; } EOF $CC $CFLAGS $WARNINGS $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" USE_GLIBC=0 else echo "yes" USE_GLIBC=1 fi rm -f __conftest __conftest.c echo -n "Checking for correctly installed ncurses..." cat <__conftest.c #include #include #ifndef KEY_DOWN syntax error. /* not ncurses */ #endif int main() { endwin(); return 0; } EOF $CC $CFLAGS $WARNINGS -lncurses $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" HAS_NCURSES=0 else echo "yes" HAS_NCURSES=1 fi rm -f __conftest __conftest.c if [ $HAS_NCURSES = 0 ]; then echo -n "Trying -I/usr/include/ncurses..." cat <__conftest.c #include #include #ifndef KEY_DOWN syntax error. /* not ncurses */ #endif int main() { endwin(); return 0; } EOF $CC -I/usr/include/ncurses $CFLAGS $WARNINGS -lncurses $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "no" else echo "yes" HAS_NCURSES=1 CFLAGS="${CFLAGS} -I/usr/include/ncurses" fi rm -f __conftest __conftest.c fi if [ $HAS_NCURSES = 1 ]; then echo 'Using ncurses for curses' LIBCURSES=-lncurses else echo -n "Looking for curses and termcap libraries..." cat <__conftest.c #include #include #include int main() { tgetent(NULL, NULL); endwin(); return 0; } EOF $CC $CFLAGS $WARNINGS -lcurses -ltermcap $LIBS __conftest.c -o __conftest >/dev/null 2>&1 if [ $? != 0 ]; then echo "not found" echo 'Sorry.' exit 1 else echo "found" LIBCURSES=-lcurses -ltermcap fi rm -f __conftest __conftest.c fi ######################################################################## CFLAGS="${CFLAGS} "'$(WARNINGS)' echo 'Generating MCONFIG...' mv -f MCONFIG MCONFIG.old echo -n '# Generated by configure on ' >MCONFIG date >> MCONFIG echo '#' >>MCONFIG echo >>MCONFIG echo "# Directory for user binaries" >>MCONFIG echo "BINDIR=$BINDIR" >>MCONFIG echo >>MCONFIG echo "# Directory for man page tree" >>MCONFIG echo "MANDIR=$MANDIR" >>MCONFIG echo >>MCONFIG echo "# Directory for system binaries" >>MCONFIG echo "SBINDIR=$SBINDIR" >>MCONFIG echo >>MCONFIG echo "# Install into chroot area found here" >>MCONFIG echo "INSTALLROOT=$INSTALLROOT" >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo "# Mode for user binaries" >>MCONFIG echo "BINMODE=$BINMODE" >>MCONFIG echo >>MCONFIG echo "# Mode for daemon binaries" >>MCONFIG echo "DAEMONMODE=$DAEMONMODE" >>MCONFIG echo >>MCONFIG echo "# Mode for manual pages" >>MCONFIG echo "MANMODE=$MANMODE" >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo "# Compiler to use" >>MCONFIG echo "CC=$CC" >>MCONFIG echo >>MCONFIG echo "# Compiler warnings" >>MCONFIG echo "WARNINGS=$WARNINGS" >>MCONFIG echo >>MCONFIG echo "# Compiler flags to use" >>MCONFIG echo "CFLAGS=$CFLAGS" >>MCONFIG echo >>MCONFIG echo "# Link-time flags to use" >>MCONFIG echo "LDFLAGS=$LDFLAGS" >>MCONFIG echo >>MCONFIG echo "# Additional link libraries" >>MCONFIG echo "LIBS=$LIBS" >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo "# Curses library to use" >>MCONFIG echo "LIBCURSES=$LIBCURSES" >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo "# Work around GNU libc lossage" >>MCONFIG echo "USE_GLIBC=$USE_GLIBC" >>MCONFIG echo >>MCONFIG echo >>MCONFIG echo >>MCONFIG netkit-ntalk-0.11/wordwrap.patch100644 2000 1004 5772 6627513202 16576 0ustar dhollanddhollandThis patch is not applied because it implements wordwrap in a way that makes the local screen (where both your text and the other guy's text get wordwrapped) differ from the remote screen (where they don't). I'm not convinced this is a good idea. However, because the patch might be useful, it is included here. (The diffs were modified by dholland to fix some minor bugs.) Date: Fri, 17 Apr 1998 18:21:17 -0500 From: Dale Osowski Subject: talk program I have added a word wrap feature to "talk" today. I have attached the diffs to this email. I hope there isn't a problem with how I did it. I added to members to the xwin_t struct in order to keep track of where a word starts. -- Dale Osowski dosowski0474@vax2.winona.msus.edu http://web.winona.msus.edu/~dosowski --- display.c 1998/11/27 11:30:43 1.7 +++ display.c 1998/11/27 12:03:08 @@ -40,8 +40,9 @@ /* * The window 'manager', initializes curses and handles the actual * displaying of text */ +#include #include "talk.h" static void xscroll(xwin_t *win, int flag); static int readwin(WINDOW *win, int line, int col); @@ -62,8 +63,37 @@ return (a > b ? a : b); } + +/* + * Wordwrap added by Dale Osowski (dosowski0474@vax2.winona.msus.edu) + * on 4/17/98 + */ +static void +wordwrap(xwin_t *win) +{ + int oldline = win->x_lspaceline; + int oldcol = win->x_lspacecol; + int i, n = COLS-1-oldcol-1; + char *tomovedown = malloc(n); + + wmove(win->x_win, oldline, oldcol+1); + for (i=0; ix_win, oldline, i+oldcol+1); + } + + wmove(win->x_win, oldline, oldcol+1); + wclrtoeol(win->x_win); + wmove(win->x_win, oldline, oldcol+1); + xscroll(win, 0); + for (i=0; ix_win, tomovedown[i]); + } + free(tomovedown); +} + + /* * Display some text on somebody's window, processing some control * characters while we are at it. */ @@ -79,8 +109,14 @@ text++; continue; } + /* Mark position of last space. For wordwrap */ + if (*text == ' ') + { + getyx(win->x_win, win->x_lspaceline, win->x_lspacecol); + } + /* someday erase characters will work properly in unix */ if (*text == '\b' || *text == 127) *text = win->cerase; /* erase character */ @@ -142,10 +178,16 @@ text++; continue; } if (win->x_col == COLS-1) { - /* check for wraparound */ - xscroll(win, 0); + /* check for wraparound -- wordwrap */ + if (win->x_lspaceline == win->x_line && + win->x_lspacecol > 1) { + wordwrap(win); + } + else { + xscroll(win, 0); + } } if ((*text & 0x7F) < ' ' && *text != '\t') { waddch(win->x_win, '^'); getyx(win->x_win, win->x_line, win->x_col); --- talk.h 1998/11/27 10:55:58 1.13 +++ talk.h 1998/11/27 11:55:52 @@ -55,8 +55,10 @@ int x_col; char kill; char cerase; char werase; + int x_lspacecol; /* column of last space character */ + int x_lspaceline; /* line of last space character */ } xwin_t; extern xwin_t my_win; extern xwin_t his_win; netkit-ntalk-0.11/include/ 40755 2000 1004 0 6702751433 15227 5ustar dhollanddhollandnetkit-ntalk-0.11/include/prot_talkd.h100644 2000 1004 12057 6627425005 17664 0ustar dhollanddholland/* * Copyright (c) 1983, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)talkd.h 8.1 (Berkeley) 6/2/93 */ #ifndef _PROTOCOLS_TALKD_H #define _PROTOCOLS_TALKD_H /* * This describes the protocol used by the talk server and clients. * * The talk server acts a repository of invitations, responding to * requests by clients wishing to rendezvous for the purpose of * holding a conversation. In normal operation, a client, the caller, * initiates a rendezvous by sending a CTL_MSG to the server of * type LOOK_UP. This causes the server to search its invitation * tables to check if an invitation currently exists for the caller * (to speak to the callee specified in the message). If the lookup * fails, the caller then sends an ANNOUNCE message causing the server * to broadcast an announcement on the callee's login ports requesting * contact. When the callee responds, the local server uses the * recorded invitation to respond with the appropriate rendezvous * address and the caller and callee client programs establish a * stream connection through which the conversation takes place. */ #include /* * This is a copy of 4.3BSD struct sockaddr. */ struct talk_addr { u_int16_t ta_family; u_int16_t ta_port; u_int32_t ta_addr; u_int32_t ta_junk1; u_int32_t ta_junk2; }; /* * Client->server request message format. */ #define NAME_SIZE 12 #define TTY_SIZE 16 typedef struct { u_int8_t vers; /* protocol version */ u_int8_t type; /* request type, see below */ u_int8_t answer; /* not used */ u_int8_t pad; u_int32_t id_num; /* message id */ struct talk_addr addr; /* address of client tcp port */ struct talk_addr ctl_addr; /* address of client udp port */ u_int32_t pid; /* caller's process id */ char l_name[NAME_SIZE];/* caller's name */ char r_name[NAME_SIZE];/* callee's name */ char r_tty[TTY_SIZE];/* callee's tty name */ } CTL_MSG; /* * Server->client response message format. */ typedef struct { u_int8_t vers; /* protocol version */ u_int8_t type; /* type of request message, see below */ u_int8_t answer; /* respose to request message, see below */ u_int8_t pad; u_int32_t id_num; /* message id */ struct talk_addr addr; /* address for establishing conversation */ } CTL_RESPONSE; #define TALK_VERSION 1 /* protocol version */ /* message type values */ #define LEAVE_INVITE 0 /* leave invitation with server */ #define LOOK_UP 1 /* check for invitation by callee */ #define DELETE 2 /* delete invitation by caller */ #define ANNOUNCE 3 /* announce invitation by caller */ /* answer values */ #define SUCCESS 0 /* operation completed properly */ #define NOT_HERE 1 /* callee not logged in */ #define FAILED 2 /* operation failed for unexplained reason */ #define MACHINE_UNKNOWN 3 /* caller's machine name unknown */ #define PERMISSION_DENIED 4 /* callee's tty doesn't permit announce */ #define UNKNOWN_REQUEST 5 /* request has invalid type value */ #define BADVERSION 6 /* request has invalid protocol version */ #define BADADDR 7 /* request has invalid addr value */ #define BADCTLADDR 8 /* request has invalid ctl_addr value */ /* * Operational parameters. * RING_WAIT should be 10's of seconds less than MAX_LIFE */ #define MAX_LIFE 60 /* max time daemon saves invitations */ #define RING_WAIT 30 /* time to wait before resending invitation */ #endif /* !_PROTOCOLS_TALKD_H */ netkit-ntalk-0.11/talkd/ 40755 2000 1004 0 6702751434 14704 5ustar dhollanddhollandnetkit-ntalk-0.11/talkd/Makefile100644 2000 1004 1276 6627507776 16465 0ustar dhollanddhollandall: talkd include ../MCONFIG include ../MRULES ifeq ($(USE_GLIBC),1) CFLAGS += -DGNU_LIBC -D_GNU_SOURCE endif CFLAGS += -I../include OBJS = talkd.o announce.o process.o table.o print.o repairs.o talkd: $(OBJS) $(CC) $(LDFLAGS) $^ $(LIBS) -o $@ $(OBJS): proto.h ../include/prot_talkd.h install: talkd install -s -m$(DAEMONMODE) talkd $(INSTALLROOT)$(SBINDIR)/in.ntalkd ln -sf in.ntalkd $(INSTALLROOT)$(SBINDIR)/in.talkd install -m$(MANMODE) talkd.8 $(INSTALLROOT)$(MANDIR)/man8/in.ntalkd.8 ln -sf in.ntalkd.8 $(INSTALLROOT)$(MANDIR)/man8/in.talkd.8 ln -sf in.ntalkd.8 $(INSTALLROOT)$(MANDIR)/man8/ntalkd.8 ln -sf in.talkd.8 $(INSTALLROOT)$(MANDIR)/man8/talkd.8 clean: rm -f *.o talkd netkit-ntalk-0.11/talkd/announce.c100644 2000 1004 14250 6627447746 17013 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)announce.c 5.9 (Berkeley) 2/26/91 */ char ann_rcsid[] = "$Id: announce.c,v 1.7 1998/11/27 07:08:22 dholland Exp $"; #include #include #include #include #include #include #include #include #include #include #include #include #include "prot_talkd.h" #include "proto.h" /* * Announce an invitation to talk. * * Because the tty driver insists on attaching a terminal-less * process to any terminal that it writes on, we must fork a child * to protect ourselves. * * That hasn't been true since, hrm, 4.2BSD maybe? Even in System V, * we can use O_NOCTTY. On the other hand, forking is a good idea in * case the tty hangs. But at present we don't take advantage of that; * we'd wait() forever. */ /* * Reject control codes and other crap. * FUTURE: don't clear high ascii if the tty is in 8-bit mode * Note that we don't need to let through tabs or newlines here. */ static int safechar(int ch) { if (ch>127 || ch<32) ch = '?'; return ch; } #define max(a,b) ( (a) > (b) ? (a) : (b) ) #define N_LINES 5 #define N_CHARS 120 /* * Build a block of characters containing the message. * It is sent blank filled and in a single block to * try to keep the message in one piece if the recipient * is in, say, vi at the time. */ static void print_mesg(int fd, CTL_MSG *request, const char *remote_machine) { struct timeval clocc; struct timezone zone; struct tm *localclock; char line_buf[N_LINES][N_CHARS]; int sizes[N_LINES]; char big_buf[N_LINES*N_CHARS]; char *bptr, *lptr; int i, j, max_size; time_t footime; i = 0; max_size = 0; gettimeofday(&clocc, &zone); footime = clocc.tv_sec; localclock = localtime(&footime); snprintf(line_buf[i], N_CHARS, " "); sizes[i] = strlen(line_buf[i]); max_size = max(max_size, sizes[i]); i++; snprintf(line_buf[i], N_CHARS, "Message from Talk_Daemon@%s at %d:%02d ...", ourhostname, localclock->tm_hour, localclock->tm_min); sizes[i] = strlen(line_buf[i]); max_size = max(max_size, sizes[i]); i++; snprintf(line_buf[i], N_CHARS, "talk: connection requested by %s@%s.", request->l_name, remote_machine); sizes[i] = strlen(line_buf[i]); max_size = max(max_size, sizes[i]); i++; snprintf(line_buf[i], N_CHARS, "talk: respond with: talk %s@%s", request->l_name, remote_machine); sizes[i] = strlen(line_buf[i]); max_size = max(max_size, sizes[i]); i++; snprintf(line_buf[i], N_CHARS, " "); sizes[i] = strlen(line_buf[i]); max_size = max(max_size, sizes[i]); i++; bptr = big_buf; *bptr++ = ''; /* send something to wake them up */ *bptr++ = '\r'; /* add a \r in case of raw mode */ *bptr++ = '\n'; for (i = 0; i < N_LINES; i++) { /* copy the line into the big buffer */ lptr = line_buf[i]; while (*lptr != '\0') *(bptr++) = safechar(*(lptr++)); /* pad out the rest of the lines with blanks */ for (j = sizes[i]; j < max_size + 2; j++) *(bptr++) = ' '; *(bptr++) = '\r'; /* add a \r in case of raw mode */ *(bptr++) = '\n'; } *bptr = 0; write(fd, big_buf, strlen(big_buf)); } /* * See if the user is accepting messages. If so, announce that * a talk is requested. */ static int announce_proc(CTL_MSG *request, const char *remote_machine) { char full_tty[32]; int fd; struct stat stbuf; snprintf(full_tty, sizeof(full_tty), "%s/%s", _PATH_DEV, request->r_tty); if (access(full_tty, F_OK) != 0) return FAILED; fd = open(full_tty, O_WRONLY|O_NOCTTY); if (fd<0) { return (PERMISSION_DENIED); } if (fstat(fd, &stbuf) < 0) { return (PERMISSION_DENIED); } if ((stbuf.st_mode&020) == 0) { return (PERMISSION_DENIED); } print_mesg(fd, request, remote_machine); close(fd); return SUCCESS; } int announce(CTL_MSG *request, const char *remote_machine) { int pid, val, status; pid = fork(); if (pid==-1) { /* fork failed */ return FAILED; } if (pid==0) { /* child */ status = announce_proc(request, remote_machine); _exit(status); } /* we are the parent, so wait for the child */ do { val = wait(&status); if (val == -1) { if (errno == EINTR || errno == EAGAIN) continue; /* shouldn't happen */ syslog(LOG_WARNING, "announce: wait: %m"); return (FAILED); } } while (val != pid); if (WIFSIGNALED(status)) { /* we were killed by some signal */ return FAILED; } /* Send back the exit/return code */ return (WEXITSTATUS(status)); } netkit-ntalk-0.11/talkd/print.c100644 2000 1004 11756 6627455667 16352 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)print.c 5.8 (Berkeley) 2/26/91 */ char print_rcsid[] = "$Id: print.c,v 1.7 1998/11/27 07:58:47 dholland Exp $"; /* debug print routines */ #include #include #include #include #include #include #include #include #include #include #include #include #include "prot_talkd.h" #include "proto.h" #ifndef _PATH_VAR_LOG #define _PATH_VAR_LOG "/var/log/" #endif #define NTYPES 4 static const char *types[NTYPES] = { "LEAVE_INVITE", "LOOK_UP", "DELETE", "ANNOUNCE" }; #define NANSWERS 9 static const char *answers[NANSWERS] = { "SUCCESS", "NOT_HERE", "FAILED", "MACHINE_UNKNOWN", "PERMISSION_DENIED", "UNKNOWN_REQUEST", "BADVERSION", "BADADDR", "BADCTLADDR" }; static int logging, badpackets; static int logfd, packfd; void set_debug(int l, int b) { const char *file; logging = l; badpackets = b; if (logging) { file = _PATH_VAR_LOG "talkd.log"; logfd = open(file, O_WRONLY|O_APPEND); if (logfd<0) { syslog(LOG_WARNING, "%s: %s", file, strerror(errno)); logging = 0; } } if (badpackets) { file = _PATH_VAR_LOG "talkd.packets"; packfd = open(file, O_WRONLY|O_APPEND); if (packfd<0) { syslog(LOG_WARNING, "%s: %s", file, strerror(errno)); badpackets = 0; } } } static const char * print_type(int type) { static char rv[80]; if (type > NTYPES) { snprintf(rv, sizeof(rv), "type %d", type); return rv; } return types[type]; } static const char * print_answer(int answer) { static char rv[80]; if (answer > NANSWERS) { snprintf(rv, sizeof(rv), "answer %d", answer); return rv; } return answers[answer]; } void print_request(const char *cp, const CTL_MSG *mp) { char lu[NAME_SIZE+1], ru[NAME_SIZE+1], tt[TTY_SIZE+1]; char buf[1024]; const char *tp; if (!logging) return; tp = print_type(mp->type); strncpy(lu, mp->l_name, sizeof(lu)); strncpy(ru, mp->r_name, sizeof(ru)); strncpy(tt, mp->r_tty, sizeof(tt)); lu[sizeof(lu)-1]=0; ru[sizeof(ru)-1]=0; tt[sizeof(tt)-1]=0; snprintf(buf, sizeof(buf), "%s: %s: id %lu, l_user %s, r_user %s, r_tty %s\n", cp, tp, mp->id_num, lu, ru, tt); write(logfd, buf, strlen(buf)); } void print_response(const char *cp, const CTL_RESPONSE *rp) { char buf[1024]; const char *tp, *ap; if (!logging) return; tp = print_type(rp->type); ap = print_answer(rp->answer); snprintf(buf, sizeof(buf), "%s: %s <-- %s, id %d\n", cp, tp, ap, ntohl(rp->id_num)); write(logfd, buf, strlen(buf)); } void debug(const char *format, ...) { char buf[1024]; va_list ap; if (!logging) return; va_start(ap, format); vsnprintf(buf, sizeof(buf), format, ap); va_end(ap); write(logfd, buf, strlen(buf)); } void print_broken_packet(const char *pack, size_t len, struct sockaddr_in *from) { size_t i; char tmp[4], buf[128]; if (!badpackets) return; snprintf(buf, sizeof(buf), "From: %s [%lu]", inet_ntoa(from->sin_addr), from->sin_addr.s_addr); write(packfd, buf, strlen(buf)); for (i=0; i #include #include #include #include #include #include #include #include #include #include #include "prot_talkd.h" #include "proto.h" static int check_one_utmp(const struct utmp *ut, const char *name) { /* * We've got uptr->ut_name, and name, neither of which is * necessarily null-terminated. Worse, either might be larger, * depending on libc version. name came from a talkd * structure, so it's at most NAME_SIZE. ut->ut_name is at * most UT_NAMESIZE. So the sum is guaranteed to hold * either... * Worse, strncmp isn't good enough. Suppose UT_NAMESIZE is 6 and * NAME_SIZE is 4, and ut_name is "abcdef" and name is "abcd". * We don't really want those to match. Now, NAME_SIZE is 12, but * UT_NAMESIZE is 256 on some platforms. I suppose maybe you *want* * to be able to have name be a prefix of ut_name in this case, or * you can't talk request people with huge names at all, but suppose * there are several such people? Argh. *punt* */ char nametmp1[UT_NAMESIZE+NAME_SIZE+1]; char nametmp2[UT_NAMESIZE+NAME_SIZE+1]; strncpy(nametmp1, name, NAME_SIZE); strncpy(nametmp2, ut->ut_name, UT_NAMESIZE); nametmp1[NAME_SIZE] = 0; nametmp2[UT_NAMESIZE] = 0; if (strcmp(nametmp1, nametmp2)!=0) { debug("utmp: %s!=%s\n", nametmp1, nametmp2); return NOT_HERE; } debug("utmp: %s==%s\n", nametmp1, nametmp2); return SUCCESS; } static int check_tty_perms(const char *tty, time_t *atime) { struct stat statb; /* our current dir is /dev, no need to prepend it */ if (stat(tty, &statb) != 0) { return FAILED; } if (!(statb.st_mode & 020)) { return PERMISSION_DENIED; } *atime = statb.st_atime; return SUCCESS; } /* * Search utmp for the local user */ static int find_user(const char *name, char *tty) { struct utmp *uptr; int found=0, ok=0, ret; time_t best_time = 0, this_time; char besttty[PATH_MAX]; *besttty = 0; setutent(); while ((uptr = getutent())!=NULL) { #ifdef USER_PROCESS if (uptr->ut_type!=USER_PROCESS) continue; #endif ret = check_one_utmp(uptr, name); if (ret!=SUCCESS) { /* wrong user */ continue; } if (*tty && !strcmp(tty, uptr->ut_line)) { /* asked for a tty, found it */ endutent(); return SUCCESS; } ret = check_tty_perms(uptr->ut_line, &this_time); if (ret != SUCCESS) { found = 1; /* but don't set ok */ continue; } found = ok = 1; if (this_time > best_time) { best_time = this_time; strcpy(besttty, uptr->ut_line); } } endutent(); strcpy(tty, besttty); return !found ? NOT_HERE : (!ok ? PERMISSION_DENIED : SUCCESS); } static void do_announce(CTL_MSG *mp, CTL_RESPONSE *rp, const char *fromhost) { CTL_MSG *ptr; int result; u_int32_t temp; /* * See if the user is logged in. * Clobbers mp->r_tty, replacing it with the tty to page them on. * (If mp->r_tty is not empty, should only return that tty, or fail.) */ result = find_user(mp->r_name, mp->r_tty); if (result != SUCCESS) { rp->answer = result; return; } ptr = find_request(mp); if (ptr == NULL) { insert_table(mp, rp); rp->answer = announce(mp, fromhost); return; } /* * Voodoo #1: if the client is opposite-endian and old/broken, * it will have added one to the id while it was byte-swapped. * Try undoing this. If it matches the id we have on file, it * was a broken attempt to re-announce. * We don't use ntohl because if we're big-endian ntohl is a nop. */ temp = byte_swap32(byte_swap32(mp->id_num)-1); if (mp->id_num > ptr->id_num || temp==ptr->id_num) { /* * This is an explicit re-announce, so update the id_num * field to avoid duplicates and re-announce the talk. */ ptr->id_num = new_id(); rp->id_num = htonl(ptr->id_num); rp->answer = announce(mp, fromhost); } else { /* duplicated or garbage request, so ignore it */ rp->id_num = htonl(ptr->id_num); rp->answer = SUCCESS; } } void process_request(CTL_MSG *mp, CTL_RESPONSE *rp, const char *fromhost) { CTL_MSG *ptr; /* Ensure null-termination */ mp->l_name[sizeof(mp->l_name)-1] = 0; mp->r_name[sizeof(mp->r_name)-1] = 0; mp->r_tty[sizeof(mp->r_tty)-1] = 0; rp->vers = TALK_VERSION; rp->type = mp->type; rp->id_num = htonl(0); if (mp->vers != TALK_VERSION) { syslog(LOG_WARNING, "Bad protocol version %d", mp->vers); rp->answer = BADVERSION; return; } mp->id_num = ntohl(mp->id_num); mp->pid = ntohl(mp->pid); print_request("process_request", mp); switch (mp->type) { case ANNOUNCE: do_announce(mp, rp, fromhost); break; case LEAVE_INVITE: ptr = find_request(mp); if (ptr != NULL) { rp->id_num = htonl(ptr->id_num); rp->answer = SUCCESS; } else insert_table(mp, rp); break; case LOOK_UP: ptr = find_match(mp); if (ptr != NULL) { rp->id_num = htonl(ptr->id_num); rp->addr = ptr->addr; rp->addr.ta_family = htons(ptr->addr.ta_family); rp->answer = SUCCESS; } else rp->answer = NOT_HERE; break; case DELETE: rp->answer = delete_invite(mp->id_num); break; default: rp->answer = UNKNOWN_REQUEST; break; } print_response("process_request", rp); } netkit-ntalk-0.11/talkd/proto.h100644 2000 1004 1560 6627455667 16336 0ustar dhollanddhollandstruct sockaddr_in; extern char ourhostname[]; /* print.c */ void print_request(const char *cp, const CTL_MSG *mp); void print_response(const char *cp, const CTL_RESPONSE *rp); void print_broken_packet(const char *pack, size_t len, struct sockaddr_in *); void debug(const char *fmt, ...); void set_debug(int logging, int badpackets); /* table.c */ void insert_table(CTL_MSG *request, CTL_RESPONSE *response); CTL_MSG *find_request(CTL_MSG *request); CTL_MSG *find_match(CTL_MSG *request); /* repairs.c */ u_int32_t byte_swap32(u_int32_t); int rationalize_packet(char *buf, size_t len, struct sockaddr_in *); size_t irrationalize_reply(char *buf, size_t maxbuf, int quirk); /* other */ int announce(CTL_MSG *request, const char *remote_machine); void process_request(CTL_MSG *mp, CTL_RESPONSE *rp, const char *fromhost); int new_id(void); int delete_invite(unsigned id_num); netkit-ntalk-0.11/talkd/repairs.c100644 2000 1004 5277 6627455667 16644 0ustar dhollanddholland/* * Copyright 1998 David A. Holland. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the copyright holder(s) nor the names of their * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ char repairs_rcsid[] = "$Id: repairs.c,v 1.2 1998/11/27 07:58:47 dholland Exp $"; /* * Most, but not quite all, of the voodoo for detecting and handling * malformed packets goes here. * * Basically anything which we can detect by examining the packet we * try to do in rationalize_packet(). We return a quirk code for what * we did so we can send back replies that will make sense to the other * end. That's irrationalize_reply(). */ #include #include "prot_talkd.h" #include "proto.h" u_int32_t byte_swap32(u_int32_t k) { return (k<<24) | ((k&0xff00) << 8) | ((k>>8) & 0xff00) | (k>>24); } #if 0 static u_int16_t byte_swap16(u_int16_t k) { return (k<<8) | (k>>8); } #endif /* * Return 0 if the packet's normal, -1 if we can't figure it out, * otherwise a quirk code from the quirk list. * * For now, we don't support any quirks. Need more data. */ int rationalize_packet(char *buf, size_t len, struct sockaddr_in *sn) { (void)buf; (void)sn; if (len == sizeof(CTL_MSG)) { return 0; } return -1; } size_t irrationalize_reply(char *buf, size_t maxlen, int quirk) { (void)buf; (void)maxlen; (void)quirk; return sizeof(CTL_RESPONSE); } netkit-ntalk-0.11/talkd/table.c100644 2000 1004 13132 6627455667 16273 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* * From: @(#)table.c 5.7 (Berkeley) 2/26/91 */ char table_rcsid[] = "$Id: table.c,v 1.9 1998/11/27 07:58:47 dholland Exp $"; /* * Routines to handle insertion, deletion, etc on the table * of requests kept by the daemon. Nothing fancy here, linear * search on a double-linked list. A time is kept with each * entry so that overly old invitations can be eliminated. * * Consider this a mis-guided attempt at modularity */ #include #include #include #include #include #include #include #include #include #include "prot_talkd.h" #include "proto.h" #define MAX_ID 16000 /* << 2^15 so I don't have sign troubles */ typedef struct table_entry { struct table_entry *next; struct table_entry *last; CTL_MSG request; time_t time; } TABLE_ENTRY; static TABLE_ENTRY *table = NULL; /* * Generate a unique non-zero sequence number */ int new_id(void) { static int current_id = 0; current_id = (current_id + 1) % MAX_ID; /* 0 is reserved, helps to pick up bugs */ if (current_id == 0) current_id = 1; return current_id; } /* * Classic delete from a double-linked list */ static void deleteit(TABLE_ENTRY *ptr) { print_request("deleteit", &ptr->request); if (table == ptr) { table = ptr->next; } else if (ptr->last != NULL) { ptr->last->next = ptr->next; } if (ptr->next != NULL) { ptr->next->last = ptr->last; } free(ptr); } /* * Go through the table and chuck out anything out of date */ static void expire(void) { time_t current_time = time(NULL); TABLE_ENTRY *ptr; for (ptr = table; ptr != NULL; ptr = ptr->next) { if ((current_time - ptr->time) > MAX_LIFE) { /* the entry is too old */ print_request("deleting expired entry", &ptr->request); deleteit(ptr); } } } /* * Look in the table for an invitation that matches the current * request looking for an invitation */ CTL_MSG * find_match(CTL_MSG *request) { TABLE_ENTRY *ptr; expire(); print_request("find_match", request); for (ptr = table; ptr != NULL; ptr = ptr->next) { print_request("", &ptr->request); if (strcmp(request->l_name, ptr->request.r_name) == 0 && strcmp(request->r_name, ptr->request.l_name) == 0 && ptr->request.type == LEAVE_INVITE) return (&ptr->request); } return NULL; } /* * Look for an identical request, as opposed to a complementary * one as find_match does */ CTL_MSG * find_request(CTL_MSG *request) { TABLE_ENTRY *ptr; expire(); /* * See if this is a repeated message. */ print_request("find_request", request); for (ptr = table; ptr != NULL; ptr = ptr->next) { print_request("", &ptr->request); if (strcmp(request->r_name, ptr->request.r_name) == 0 && strcmp(request->l_name, ptr->request.l_name) == 0 && request->type == ptr->request.type && request->pid == ptr->request.pid) { /* update the time if we 'touch' it */ ptr->time = time(NULL); return (&ptr->request); } } return NULL; } void insert_table(CTL_MSG *request, CTL_RESPONSE *response) { TABLE_ENTRY *ptr; request->id_num = new_id(); response->id_num = htonl(request->id_num); /* insert a new entry into the top of the list */ ptr = malloc(sizeof(TABLE_ENTRY)); if (ptr == NULL) { syslog(LOG_ERR, "insert_table: Out of memory"); _exit(1); } ptr->time = time(NULL); ptr->request = *request; ptr->next = table; if (ptr->next != NULL) { ptr->next->last = ptr; } ptr->last = NULL; table = ptr; } /* * Delete the invitation with id 'id_num' */ int delete_invite(unsigned id_num) { TABLE_ENTRY *ptr; ptr = table; debug("delete_invite(%d)\n", id_num); for (ptr = table; ptr != NULL; ptr = ptr->next) { if (ptr->request.id_num == id_num) break; print_request("", &ptr->request); } if (ptr != NULL) { deleteit(ptr); return SUCCESS; } return NOT_HERE; } netkit-ntalk-0.11/talkd/talkd.8100644 2000 1004 6523 6627455770 16211 0ustar dhollanddholland.\" Copyright (c) 1983, 1991 The Regents of the University of California. .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" 3. All advertising materials mentioning features or use of this software .\" must display the following acknowledgement: .\" This product includes software developed by the University of .\" California, Berkeley and its contributors. .\" 4. Neither the name of the University nor the names of its contributors .\" may be used to endorse or promote products derived from this software .\" without specific prior written permission. .\" .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" .\" from: @(#)talkd.8 6.5 (Berkeley) 3/16/91 .\" $Id: talkd.8,v 1.2 1998/11/27 07:59:52 dholland Exp $ .\" .Dd March 16, 1991 .Dt TALKD 8 .Os BSD 4.3 .Sh NAME .Nm talkd .Nd remote user communication server .Sh SYNOPSIS .Nm talkd .Op Fl dp .Sh DESCRIPTION .Nm Talkd is the server that notifies a user that someone else wants to initiate a conversation. It acts a repository of invitations, responding to requests by clients wishing to rendezvous to hold a conversation. In normal operation, a client, the caller, initiates a rendezvous by sending a .Tn CTL_MSG to the server of type .Tn LOOK_UP (see .Aq Pa protocols/talkd.h ) . This causes the server to search its invitation tables to check if an invitation currently exists for the caller (to speak to the callee specified in the message). If the lookup fails, the caller then sends an .Tn ANNOUNCE message causing the server to broadcast an announcement on the callee's login ports requesting contact. When the callee responds, the local server uses the recorded invitation to respond with the appropriate rendezvous address and the caller and callee client programs establish a stream connection through which the conversation takes place. .Sh OPTIONS .Op Fl d Debug mode; writes copious logging and debugging information to .Pa /var/adm/talkd.log . .Pp .Op Fl p Packet logging mode; writes copies of malformed packets to .Pa /var/adm/talkd.packets . This is useful for debugging interoperability problems. .Sh SEE ALSO .Xr talk 1 , .Xr write 1 .Sh HISTORY The .Nm command appeared in .Bx 4.3 . netkit-ntalk-0.11/talkd/talkd.c100644 2000 1004 22605 6627507676 16306 0ustar dhollanddholland/* * Copyright (c) 1983 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ char copyright[] = "@(#) Copyright (c) 1983 Regents of the University of California.\n" "All rights reserved.\n"; /* * From: @(#)talkd.c 5.8 (Berkeley) 2/26/91 */ char talkd_rcsid[] = "$Id: talkd.c,v 1.8 1998/11/27 11:40:46 dholland Exp $"; /* * talkd - internet talk daemon * loops waiting for and processing requests until idle for a while, * then exits. */ #include #include #include #include #include #include #include #include #include /*#include */ #include #include #include #include #include "prot_talkd.h" #include "proto.h" #define TIMEOUT 30 #define MAXIDLE 120 char ourhostname[MAXHOSTNAMELEN]; static time_t lastmsgtime; static void timeout(int ignore) { (void)ignore; if (time(NULL) - lastmsgtime >= MAXIDLE) _exit(0); signal(SIGALRM, timeout); alarm(TIMEOUT); } /* * Returns true if the address belongs to the local host. If it's * not a loopback address, try binding to it. */ static int is_local_address(u_int32_t addr) { struct sockaddr_in sn; int sock, ret; if (addr == htonl(INADDR_LOOPBACK)) { return 1; } sock = socket(AF_INET, SOCK_DGRAM, 0); if (sock<0) { syslog(LOG_WARNING, "socket: %s", strerror(errno)); return 0; } memset(&sn, 0, sizeof(sn)); sn.sin_family = AF_INET; sn.sin_port = htons(0); sn.sin_addr.s_addr = addr; ret = bind(sock, (struct sockaddr *)&sn, sizeof(sn)); close(sock); return ret==0; } static void send_packet(CTL_RESPONSE *response, struct sockaddr_in *sn, int quirk) { char buf[2*sizeof(CTL_RESPONSE)]; size_t sz = sizeof(CTL_RESPONSE); int cc, err=0; memcpy(buf, response, sz); if (quirk) { sz = irrationalize_reply(buf, sizeof(buf), quirk); } while (sz > 0) { cc = sendto(1, buf, sz, 0, (struct sockaddr *)sn, sizeof(*sn)); if (cc<0) { syslog(LOG_WARNING, "sendto: %s", strerror(errno)); if (err) return; err = 1; } else sz -= cc; } } /* * Issue an error packet. Should not assume anything other than the * header part (the u_int8_t's) of mp is valid, and assume as little * as possible about that, since it might have been a packet we * couldn't dequirk. */ static void send_reject_packet(CTL_MSG *mp, struct sockaddr_in *sn, int code, int quirk) { CTL_RESPONSE rsp; memset(&rsp, 0, sizeof(rsp)); rsp.vers = TALK_VERSION; rsp.type = mp->type; rsp.answer = code; send_packet(&rsp, sn, quirk); } static void do_one_packet(void) { char inbuf[2*sizeof(CTL_MSG)]; int quirk = 0; CTL_RESPONSE response; CTL_MSG *mp; char theirhost[MAXHOSTNAMELEN]; const char *theirip; struct hostent *hp; struct sockaddr_in sn; int cc, i, ok; size_t addrlen; addrlen = sizeof(sn); cc = recvfrom(0, inbuf, sizeof(inbuf), 0, (struct sockaddr *)&sn, &addrlen); if (cc<0) { if (errno==EINTR || errno==EAGAIN) { return; } syslog(LOG_WARNING, "recvfrom: %s", strerror(errno)); return; } /* * This should be set on any input, even trash, because even * trash input will cause us to be restarted if we exit. */ lastmsgtime = time(NULL); if (addrlen!=sizeof(sn)) { syslog(LOG_WARNING, "recvfrom: bogus address length"); return; } if (sn.sin_family!=AF_INET) { syslog(LOG_WARNING, "recvfrom: bogus address family"); return; } /* * If we get here we have an address we can reply to, although * it may not be good for much. If possible, reply to it, because * if we just drop the packet the remote talk client will keep * throwing junk at us. */ theirip = inet_ntoa(sn.sin_addr); mp = (CTL_MSG *)inbuf; /* * Check they're not being weenies. * We should look into using libwrap here so hosts.deny works. * Wrapping talkd with tcpd isn't very useful. */ hp = gethostbyaddr((char *)&sn.sin_addr, sizeof(struct in_addr), AF_INET); if (hp == NULL) { syslog(LOG_WARNING, "%s: bad dns", theirip); send_reject_packet(mp, &sn, MACHINE_UNKNOWN, 0); return; } strncpy(theirhost, hp->h_name, sizeof(theirhost)); theirhost[sizeof(theirhost)-1] = 0; hp = gethostbyname(theirhost); if (hp == NULL) { syslog(LOG_WARNING, "%s: bad dns", theirip); send_reject_packet(mp, &sn, MACHINE_UNKNOWN, 0); return; } for (i=ok=0; hp->h_addr_list[i] && !ok; i++) { if (!memcmp(hp->h_addr_list[i], &sn.sin_addr, sizeof(sn.sin_addr))) ok = 1; } if (!ok) { syslog(LOG_WARNING, "%s: bad dns", theirip); send_reject_packet(mp, &sn, MACHINE_UNKNOWN, 0); return; } /* * Make sure we know what we're getting into. * Note that since mp.vers is the first byte of the packet, * it would be *very hard* for anything the quirk table can * manage to alter it. */ if (mp->vers!=TALK_VERSION) { syslog(LOG_WARNING, "%s (%s): bad protocol version %d", theirhost, theirip, mp->vers); send_reject_packet(mp, &sn, BADVERSION, 0); return; } /* * Try to straighten out bad packets. */ quirk = rationalize_packet(inbuf, cc, &sn); if (quirk<0) { print_broken_packet(inbuf, cc, &sn); syslog(LOG_WARNING, "%s (%s): unintelligible packet", theirhost, theirip); send_reject_packet(mp, &sn, UNKNOWN_REQUEST, 0); return; } /* * LEAVE_INVITE messages should only come from localhost. * Of course, old talk clients send from our hostname's IP * rather than localhost, complicating the issue... */ if (mp->type==LEAVE_INVITE && !is_local_address(sn.sin_addr.s_addr)) { syslog(LOG_WARNING, "%s (%s) sent invite packet", theirhost, theirip); send_reject_packet(mp, &sn, MACHINE_UNKNOWN, quirk); return; } /* * Junk the reply address they reported for themselves. Write * the real one over it because announce.c gets it from there. */ mp->ctl_addr.ta_family = AF_INET; mp->ctl_addr.ta_port = sn.sin_port; mp->ctl_addr.ta_addr = sn.sin_addr.s_addr; /* * Since invite messages only come from localhost, and nothing * but invite messages use the TCP address, force it to be our * address. * * Actually, if it's a local address, leave it alone. talk has * to play games to figure out the right interface address to * use, and we don't want to get into that - they can work it * out, but we can't since we don't know who they're trying to * talk to. * * If it's not a local address, someone's trying to play games * with us. Rather than trying to pick a local address to use, * reject the packet. */ if (mp->type==LEAVE_INVITE) { mp->addr.ta_family = AF_INET; if (!is_local_address(mp->addr.ta_addr)) { syslog(LOG_WARNING, "invite packet had bad return address"); send_reject_packet(mp, &sn, BADADDR, quirk); return; } } else { /* non-invite packets don't use this field */ memset(&mp->addr, 0, sizeof(mp->addr)); } process_request(mp, &response, theirhost); /* can block here, is this what I want? */ send_packet(&response, &sn, quirk); } int main(int argc, char *argv[]) { struct sockaddr_in sn; size_t sz = sizeof(sn); int do_debug=0, do_badpackets=0, ch; /* make sure we're a daemon */ if (getsockname(0, (struct sockaddr *)&sn, &sz)) { const char *msg = strerror(errno); write(2, msg, strlen(msg)); exit(1); } openlog("talkd", LOG_PID, LOG_DAEMON); if (gethostname(ourhostname, sizeof(ourhostname) - 1) < 0) { syslog(LOG_ERR, "gethostname: %s", strerror(errno)); exit(1); } if (chdir(_PATH_DEV) < 0) { syslog(LOG_ERR, "chdir: %s: %s", _PATH_DEV, strerror(errno)); exit(1); } while ((ch = getopt(argc, argv, "dp"))!=-1) { switch (ch) { case 'd': do_debug=1; break; case 'p': do_badpackets=1; break; } } set_debug(do_debug, do_badpackets); signal(SIGALRM, timeout); alarm(TIMEOUT); for (;;) { do_one_packet(); } return 0; }