Return to process.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ucb / talk

Annotation of 42BSD/ucb/talk/process.c, revision 1.1.1.1

1.1       root        1: /* $Header: process.c 1.5 83/03/28 20:16:07 moore Exp $ */
                      2: 
                      3:     /* process.c handles the requests, which can be of three types:
                      4: 
                      5:                ANNOUNCE - announce to a user that a talk is wanted
                      6: 
                      7:                LEAVE_INVITE - insert the request into the table
                      8:                
                      9:                LOOK_UP - look up to see if a request is waiting in
                     10:                          in the table for the local user
                     11: 
                     12:                DELETE - delete invitation
                     13: 
                     14:      */
                     15: 
                     16: #include "ctl.h"
                     17: char *strcpy();
                     18: CTL_MSG *find_request();
                     19: CTL_MSG *find_match();
                     20: 
                     21: process_request(request, response)
                     22: CTL_MSG *request;
                     23: CTL_RESPONSE *response;
                     24: {
                     25:     CTL_MSG *ptr;
                     26: 
                     27:     response->type = request->type;
                     28:     response->id_num = 0;
                     29: 
                     30:     switch (request->type) {
                     31: 
                     32:        case ANNOUNCE :
                     33: 
                     34:            do_announce(request, response);
                     35:            break;
                     36: 
                     37:        case LEAVE_INVITE :
                     38: 
                     39:            ptr = find_request(request);
                     40:            if (ptr != (CTL_MSG *) 0) {
                     41:                response->id_num = ptr->id_num;
                     42:                response->answer = SUCCESS;
                     43:            } else {
                     44:                insert_table(request, response);
                     45:            }
                     46:            break;
                     47: 
                     48:        case LOOK_UP :
                     49: 
                     50:            ptr = find_match(request);
                     51:            if (ptr != (CTL_MSG *) 0) {
                     52:                response->id_num = ptr->id_num;
                     53:                response->addr = ptr->addr;
                     54:                response->answer = SUCCESS;
                     55:            } else {
                     56:                response->answer = NOT_HERE;
                     57:            }
                     58:            break;
                     59: 
                     60:        case DELETE :
                     61: 
                     62:            response->answer = delete_invite(request->id_num);
                     63:            break;
                     64: 
                     65:        default :
                     66: 
                     67:            response->answer = UNKNOWN_REQUEST;
                     68:            break;
                     69: 
                     70:     }
                     71: }
                     72: 
                     73: struct hostent *gethostbyaddr();
                     74: 
                     75: do_announce(request, response)
                     76: CTL_MSG *request;
                     77: CTL_RESPONSE *response;
                     78: {
                     79:     struct hostent *hp;
                     80:     CTL_MSG *ptr;
                     81:     int result;
                     82: 
                     83:        /* see if the user is logged */
                     84: 
                     85:     result = find_user(request->r_name, request->r_tty);
                     86: 
                     87:     if (result != SUCCESS) {
                     88:        response->answer = result;
                     89:        return;
                     90:     }
                     91: 
                     92:     hp = gethostbyaddr(&request->ctl_addr.sin_addr,
                     93:                          sizeof(struct in_addr), AF_INET);
                     94: 
                     95:     if ( hp == (struct hostent *) 0 ) {
                     96:        response->answer = MACHINE_UNKNOWN;
                     97:        return;
                     98:     }
                     99: 
                    100:     ptr = find_request(request);
                    101:     if (ptr == (CTL_MSG *) 0) {
                    102:        insert_table(request,response);
                    103:        response->answer = announce(request, hp->h_name);
                    104:     } else if (request->id_num > ptr->id_num) {
                    105:            /*
                    106:             * this is an explicit re-announce, so update the id_num
                    107:             * field to avoid duplicates and re-announce the talk 
                    108:             */
                    109:        ptr->id_num = response->id_num = new_id();
                    110:        response->answer = announce(request, hp->h_name);
                    111:     } else {
                    112:            /* a duplicated request, so ignore it */
                    113:        response->id_num = ptr->id_num;
                    114:        response->answer = SUCCESS;
                    115:     }
                    116: 
                    117:     return;
                    118: }
                    119: 
                    120: #include <utmp.h>
                    121: 
                    122: /*
                    123:  * Search utmp for the local user
                    124:  */
                    125: 
                    126: find_user(name, tty)
                    127: char *name;
                    128: char *tty;
                    129: {
                    130:     struct utmp ubuf;
                    131: 
                    132:     int fd;
                    133: 
                    134:     if ((fd = open("/etc/utmp", 0)) == -1) {
                    135:        print_error("Can't open /etc/utmp");
                    136:        return(FAILED);
                    137:     }
                    138: 
                    139:     while (read(fd, (char *) &ubuf, sizeof ubuf) == sizeof(ubuf)) {
                    140:        if (strncmp(ubuf.ut_name, name, sizeof ubuf.ut_name) == 0) {
                    141:            if (*tty == '\0') {
                    142:                    /* no particular tty was requested */
                    143:                (void) strcpy(tty, ubuf.ut_line);
                    144:                close(fd);
                    145:                return(SUCCESS);
                    146:            } else if (strcmp(ubuf.ut_line, tty) == 0) {
                    147:                close(fd);
                    148:                return(SUCCESS);
                    149:            }
                    150:        }
                    151:     }
                    152: 
                    153:     close(fd);
                    154:     return(NOT_HERE);
                    155: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.