home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / internet / tcpipsrc / Finger / c / fingserv < prev   
Text File  |  1995-01-13  |  8KB  |  241 lines
  1. /*
  2.  *
  3.  *      Finger support...
  4.  *
  5.  *      Finger server routines.  Written by Michael T. Horne - KA7AXD.
  6.  *      Copyright 1988 by Michael T. Horne, All Rights Reserved.
  7.  *      Permission granted for non-commercial use and copying, provided
  8.  *      that this notice is retained.
  9.  *
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include "global.h"
  16. #include "mbuf.h"
  17. #include "timer.h"
  18. #include "internet.h"
  19. #include "icmp.h"
  20. #include "netuser.h"
  21. #include "tcp.h"
  22. #include "finger.h"
  23. #include "session.h"
  24. #include "misc.h"
  25. #include "arc.h"
  26.  
  27. static void sndmsg(struct tcb *, char *);
  28.  
  29. struct tcb *fing_tcb = NULLTCB;
  30. int16 finger_notify = 1;
  31.  
  32. int finger1(int argc, char **argv)
  33. {
  34.         extern int32    ip_addr;
  35.         struct socket   lsocket;
  36.  
  37.         if (fing_tcb)
  38.                 return(0);
  39.         /* start finger daemon */
  40.         lsocket.address = ip_addr;
  41.         if(argc < 2)
  42.                 lsocket.port = FINGER_PORT;
  43.         else
  44.                 lsocket.port = atoi(argv[1]);
  45.         fing_tcb = open_tcp(&lsocket, NULLSOCK, TCP_SERVER, 0, (void(*)())rcv_fing,
  46.                 NULLVFP, (void(*)())fing_state, 0, NULL);
  47.         return(0);
  48. }
  49. /*
  50.  *      Handle incoming finger connections and closures.
  51.  *
  52.  */
  53. void fing_state(struct tcb *tcb, char old, char new)
  54. {
  55.         struct finger *fing;
  56.  
  57.         old = old;
  58.  
  59.         switch(new){
  60.         case ESTABLISHED:
  61.                 set_server_vars("finger",tcb);
  62.                 log_event(tcb,"open Finger");
  63.                 fing = (struct finger *) malloc(sizeof(struct finger));
  64.  
  65.                 tcb->user = (char *)fing;       /* Upward pointer */
  66.                 fing->tcb = tcb;                /* Downward pointer */
  67.                 if (finger_notify)  {
  68.                         cwprintf(NULL, "You're being fingered by %s!\r\n",
  69.                                 psocket(&tcb->conn.remote));
  70.                 }
  71.                 return;
  72.         case CLOSED:
  73.                 if (tcb == fing_tcb)
  74.                         fing_tcb = NULLTCB;
  75.                 if (tcb->user != NULLCHAR)
  76.                         free(tcb->user);
  77.                 del_tcp(tcb);
  78.                 break;
  79.         }
  80. }
  81.  
  82. /*
  83.  *      Stop the finger server.
  84.  */
  85.  
  86. int finger0(void)
  87. {
  88.         if (fing_tcb != NULLTCB) {
  89.                 close_tcp(fing_tcb);
  90.                 fing_tcb = NULLTCB;
  91.         }
  92.         return(0);
  93. }
  94.  
  95. /*
  96.  *      Send a short message on a tcb
  97.  */
  98.  
  99. static void sndmsg(struct tcb *tcb, char *msg)
  100. {
  101.         struct mbuf *bp;
  102.  
  103.         bp = qdata(msg,(int16)strlen(msg));
  104.         send_tcp(tcb,bp);
  105. }
  106.  
  107. /*
  108.  *      Finger receive upcall.  This is the guts of the finger server.
  109.  *      The user to finger is read from the socket.  If only a newline
  110.  *      is read, then send the remote host a list of all known 'users' on
  111.  *      this system.
  112.  */
  113.  
  114. void rcv_fing(register struct tcb *tcb, int16 ccnt)
  115. {
  116.         char badchrs[] = { "^@$&%:<>{}[]|" };
  117.         int i, valid_name;
  118.  
  119.         struct finger   *fing;
  120.         FILE            *fuser;
  121.         struct mbuf     *mbuf,
  122.                         *bp;
  123.         char            *buf,
  124.                         *who,
  125.                         *finger_file,
  126.                         *path,
  127.                         ch,
  128.                         temp[80],
  129.                         user[80];
  130.         int             cnt;
  131.         int             size;
  132.  
  133.         ccnt = ccnt;
  134.  
  135.         if ((fing = (struct finger *) tcb->user) == NULLFING)   /* uh oh! */
  136.                 return;
  137.         if(recv_tcp(tcb,&bp,FINGNAMELEN) == 0)
  138.                 return;
  139.         if ((who = malloc(FINGNAMELEN + 1)) == NULL) {
  140.                 free_p(bp);
  141.                 return;
  142.         }
  143.  
  144.         cnt = pullup(&bp, who, FINGNAMELEN);    /* get 'user' name */
  145.         who[cnt] = '\0';                        /* NULL terminate it */
  146.         free_p(bp);                             /* all done with bp */
  147.  
  148.         valid_name = 1;  /* A check to stop people reading files outside users directory */
  149.         for (i=0; i<cnt; i++)
  150.         {
  151.           if (strchr(badchrs, who[i])!=NULL)
  152.             valid_name = 0;
  153.         }
  154.  
  155.         if (*who == '\015' || *who == '\012')  /* give him a user listing */
  156.         {
  157.                 int found = 0;
  158.  
  159.                 path = (char *) malloc(strlen(fingerpath) + 5);
  160.                 /* create wildcard path to finger files */
  161.                 strcpy(path, fingerpath);
  162.  
  163.                 sndmsg(tcb, "Known users on this system:\015\012");
  164.                 for (filedir(path, 0, user); user[0] != '\0';
  165.                         filedir (path, 1, user))  {
  166.                         found++;
  167.                         sprintf(temp, "        %s\015\012", user);
  168.                         sndmsg(tcb, temp);
  169.                 }
  170.                 if (!found)
  171.                         sndmsg(tcb, "None!\015\012");
  172.  
  173.                 free(path);
  174.         }
  175.         else
  176.         {
  177.  
  178.                 buf = who;
  179.  
  180.                 while (*buf != '\015' && *buf != '\012' && *buf != '\0')
  181.                         buf++;
  182.                 *buf = '\0';
  183.                 /*
  184.                  *      Create path to user's finger file and see if the
  185.                  *      the file exists.
  186.                  */
  187.                 finger_file = malloc(strlen(fingerpath) + strlen(who) + 5);
  188.                 if (finger_file == NULL) {      /* uh oh... */
  189.                         free(who);              /* clean up */
  190.                         close_tcp(tcb);         /* close socket */
  191.                         return;
  192.                 }
  193.                 sprintf(finger_file, "%s.%s", fingerpath, who);
  194.  
  195.                 if ( !valid_name || (fuser = fopen(finger_file, "r")) == (FILE *) NULL)
  196.                 {
  197.                         sprintf(temp, "User %s not known\015\012", who);
  198.                         sndmsg(tcb, temp);
  199.                 }
  200.                 else
  201.                 {                               /* valid 'user' */
  202.                         ch = fgetc(fuser);      /* first get must be outside */
  203.                         while (!feof(fuser)) {
  204.                                 size = tcb->window;
  205.                                 if ((mbuf = alloc_mbuf(size)) == NULLBUF) {
  206.                                         fclose(fuser);  /* barf */
  207.                                         free(who);
  208.                                         free(finger_file);
  209.                                         return;
  210.                                 }
  211.                                 buf = mbuf->data;  /* pointer to buffer */
  212.                                 while(!feof(fuser) && size--) { /* loop */
  213.                                         switch(ch) {
  214.                                             case '\032':    /* NO ^Z's! */
  215.                                                     break;
  216.                                             case '\012':    /* EOL */
  217.                                                     *buf++ = '\015';
  218.                                                     *buf++ = '\012';
  219.                                                     mbuf->cnt += 2;
  220.                                                     break;
  221.                                             case '\015':
  222.                                                     break;
  223.                                             default:
  224.                                                     *buf++ = ch;
  225.                                                     mbuf->cnt++;
  226.                                                     break;
  227.                                         }
  228.                                         ch = fgetc(fuser);
  229.                                 }
  230.                                 send_tcp(tcb, mbuf);    /* send info */
  231.                         }
  232.                         fclose(fuser);
  233.                 }
  234.                 free(finger_file);
  235.         }
  236.         free(who);
  237.         close_tcp(tcb);                 /* close socket */
  238.         return;
  239. }
  240.  
  241.