home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / network / src_1218.zip / SESSION.C < prev    next >
C/C++ Source or Header  |  1991-09-22  |  9KB  |  438 lines
  1. /* NOS User Session control
  2.  * Copyright 1991 Phil Karn, KA9Q
  3.  */
  4. #include <stdio.h>
  5. #include "global.h"
  6. #include "mbuf.h"
  7. #include "proc.h"
  8. #include "ftpcli.h"
  9. #include "icmp.h"
  10. #include "telnet.h"
  11. #include "tty.h"
  12. #include "session.h"
  13. #include "hardware.h"
  14. #include "socket.h"
  15. #include "cmdparse.h"
  16. #include "commands.h"
  17. #include "main.h"
  18.  
  19. struct session *Sessions;
  20. struct session *Command;
  21. struct session *Current;
  22. struct session *Lastcurr;
  23. int Row;
  24. int Morewait;
  25.  
  26. char Notval[] = "Not a valid control block\n";
  27. static char Badsess[] = "Invalid session\n";
  28. char *Sestypes[] = {
  29.     "",
  30.     "Telnet",
  31.     "FTP",
  32.     "AX25",
  33.     "Finger",
  34.     "Ping",
  35.     "NET/ROM",
  36.     "Command",
  37.     "More",
  38.     "Hopcheck",
  39.     "Tip",
  40.     "PPP PAP",
  41.     "Dial",
  42.     "Query",
  43.     "Cache"
  44. };
  45.  
  46. /* Convert a character string containing a decimal session index number
  47.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  48.  * If the index is out of range or unused, return NULLSESSION.
  49.  */
  50. struct session *
  51. sessptr(cp)
  52. char *cp;
  53. {
  54.     register struct session *sp;
  55.     unsigned int i;
  56.  
  57.     if(cp == NULLCHAR){
  58.         sp = Lastcurr;
  59.     } else {
  60.         i = (unsigned)atoi(cp);
  61.         if(i >= Nsessions)
  62.             sp = NULLSESSION;
  63.         else
  64.             sp = &Sessions[i];
  65.     }
  66.     if(sp == NULLSESSION || sp->type == FREE)
  67.         sp = NULLSESSION;
  68.  
  69.     return sp;
  70. }
  71.  
  72. /* Select and display sessions */
  73. int
  74. dosession(argc,argv,p)
  75. int argc;
  76. char *argv[];
  77. void *p;
  78. {
  79.     struct session *sp;
  80.     struct sockaddr fsocket;
  81.     int i,k,s;
  82.     int r,t;
  83.     char *cp;
  84.  
  85.     sp = (struct session *)p;
  86.  
  87.     if(argc > 1){
  88.         if((sp = sessptr(argv[1])) != NULLSESSION){
  89.             go(0,NULL,sp);
  90.         } else
  91.             tprintf("Session %s not active\n",argv[1]);
  92.         return 0;
  93.     }
  94.     tprintf(" #  S#  Type     Rcv-Q Snd-Q State        Remote socket\n");
  95.     for(sp=Sessions; sp < &Sessions[Nsessions];sp++){
  96.         if(sp->type == FREE || sp->type == COMMAND)
  97.             continue;
  98.  
  99.         /* Rcv-Q includes output pending at the screen driver */
  100.         r = socklen(sp->output,1);
  101.         t = 0;
  102.         cp = NULLCHAR;
  103.         if((s = sp->s) != -1){
  104.             i = SOCKSIZE;
  105.             s = sp->s;
  106.             k = getpeername(s,(char *)&fsocket,&i);
  107.             r += socklen(s,0);
  108.             t += socklen(s,1);
  109.             cp = sockstate(s);
  110.         }
  111.         tprintf("%c", (Lastcurr == sp)? '*':' ');
  112.         tprintf("%-3u", (unsigned)(sp - Sessions));
  113.         tprintf("%-4d%-8s%6d%6d %-13s",
  114.          s,
  115.          Sestypes[sp->type],
  116.          r,
  117.          t,
  118.          (cp != NULLCHAR) ? cp : "");
  119.         if(sp->name != NULLCHAR)
  120.             tprintf("%s ",sp->name);
  121.         if(sp->s != -1 && k == 0)
  122.             tprintf("(%s)",psocket(&fsocket));
  123.  
  124.         tprintf("\n");
  125.         if(sp->type == FTP && (s = sp->cb.ftp->data) != -1){
  126.             /* Display data channel, if any */
  127.             i = SOCKSIZE;
  128.             k = getpeername(s,(char *)&fsocket,&i);
  129.             r = socklen(s,0);
  130.             t = socklen(s,1);
  131.             cp = sockstate(s);
  132.             tprintf("    %-4d%-8s%6d%6d %-13s%s",
  133.              s,
  134.              Sestypes[sp->type],
  135.              r,
  136.              t,
  137.              (cp != NULLCHAR) ? cp : "",
  138.              (sp->name != NULLCHAR) ? sp->name : "");
  139.             if(k == 0)
  140.                 tprintf(" (%s)",psocket(&fsocket));
  141.             if(tprintf("\n") == EOF)
  142.                 break;
  143.         }
  144.         if(sp->rfile != NULLCHAR)
  145.             tprintf("    Record: %s\n",sp->rfile);
  146.         if(sp->ufile != NULLCHAR)
  147.             tprintf("    Upload: %s\n",sp->ufile);
  148.     }
  149.     return 0;
  150. }
  151. /* Resume current session, and wait for it */
  152. int
  153. go(argc,argv,p)
  154. int argc;
  155. char *argv[];
  156. void *p;
  157. {
  158.     struct session *sp;
  159.  
  160.     sp = (struct session *)p;
  161.     if(sp == NULLSESSION || sp->type == FREE || sp->type == COMMAND)
  162.         return 0;
  163.     Current = sp;
  164.     swapscreen(Command,sp);
  165.     psignal(sp,0);
  166.     return 0;
  167. }
  168. int
  169. doclose(argc,argv,p)
  170. int argc;
  171. char *argv[];
  172. void *p;
  173. {
  174.     struct session *sp;
  175.  
  176.     sp = (struct session *)p;
  177.     if(argc > 1)
  178.         sp = sessptr(argv[1]);
  179.  
  180.     if(sp == NULLSESSION){
  181.         tprintf(Badsess);
  182.         return -1;
  183.     }
  184.     shutdown(sp->s,1);
  185.     return 0;
  186. }
  187. int
  188. doreset(argc,argv,p)
  189. int argc;
  190. char *argv[];
  191. void *p;
  192. {
  193.     struct session *sp;
  194.  
  195.     sp = (struct session *)p;
  196.     if(argc > 1)
  197.         sp = sessptr(argv[1]);
  198.  
  199.     if(sp == NULLSESSION){
  200.         tprintf(Badsess);
  201.         return -1;
  202.     }
  203.     /* Unwedge anyone waiting for a domain resolution, etc */
  204.     alert(sp->proc,EABORT);
  205.     shutdown(sp->s,2);
  206.     if(sp->type == FTP)
  207.         shutdown(sp->cb.ftp->data,2);
  208.     return 0;
  209. }
  210. int
  211. dokick(argc,argv,p)
  212. int argc;
  213. char *argv[];
  214. void *p;
  215. {
  216.     struct session *sp;
  217.  
  218.     sp = (struct session *)p;
  219.     if(argc > 1)
  220.         sp = sessptr(argv[1]);
  221.  
  222.     if(sp == NULLSESSION){
  223.         tprintf(Badsess);
  224.         return -1;
  225.     }
  226.     sockkick(sp->s);
  227.     if(sp->type == FTP)
  228.         sockkick(sp->cb.ftp->data);
  229.     return 0;
  230. }
  231.  
  232. struct session *
  233. newsession(name,type)
  234. char *name;
  235. int type;
  236. {
  237.     register struct session *sp;
  238.     int i;
  239.  
  240.     for(i=0,sp=Sessions;i < Nsessions;sp++,i++)
  241.         if(sp->type == FREE)
  242.             break;
  243.     if(i == Nsessions)
  244.         return NULLSESSION;
  245.  
  246.     sp->type = type;
  247.     sp->s = -1;
  248.     if(name != NULLCHAR)
  249.         sp->name = strdup(name);
  250.     sp->proc = Curproc;
  251.     /* Create standard input and output sockets. Output is
  252.      * translated to local end-of-line by default
  253.      */
  254.     Curproc->input =  sp->input = socket(AF_LOCAL,SOCK_STREAM,0);
  255.     seteol(Curproc->input,Eol);
  256.     sockmode(Curproc->input,SOCK_BINARY);
  257.     Curproc->output = sp->output = socket(AF_LOCAL,SOCK_STREAM,0);
  258.     seteol(Curproc->output,Eol);
  259.     sockmode(Curproc->output,SOCK_ASCII);
  260.  
  261.     /* on by default */
  262.     sp->ttystate.crnl = sp->ttystate.edit = sp->ttystate.echo = 1;
  263.     sp->flowmode = 0;    /* Off by default */
  264.     sp->row = MOREROWS;
  265.     sp->morewait = 0;
  266.     newscreen(sp);
  267.     swapscreen(Current,sp);
  268.     Current = sp;
  269.     return sp;
  270. }
  271. void
  272. freesession(sp)
  273. struct session *sp;
  274. {
  275.     if(sp == NULLSESSION)
  276.         return;
  277.     pwait(NULL);    /* Wait for any pending output to go */
  278.     rflush();
  279.  
  280.     if(sp->proc1 != NULLPROC)
  281.         killproc(sp->proc1);
  282.     sp->proc1 = NULLPROC;
  283.     if(sp->proc2 != NULLPROC)
  284.         killproc(sp->proc2);
  285.     sp->proc2 = NULLPROC;
  286.  
  287.     free_p(sp->ttystate.line);
  288.     sp->ttystate.line = NULLBUF;
  289.     if(sp->s != -1)
  290.         close_s(sp->s);
  291.     if(sp->record != NULLFILE){
  292.         fclose(sp->record);
  293.         sp->record = NULLFILE;
  294.     }
  295.     free(sp->rfile);
  296.     sp->rfile = NULLCHAR;
  297.     if(sp->upload != NULLFILE){
  298.         fclose(sp->upload);
  299.         sp->upload = NULLFILE;
  300.     }
  301.     free(sp->ufile);
  302.     sp->ufile = NULLCHAR;
  303.     free(sp->name);
  304.     sp->name = NULLCHAR;
  305.     sp->type = FREE;
  306.  
  307.     close_s(sp->input);
  308.     sp->input = -1;
  309.     sp->proc->input = -1;
  310.     close_s(sp->output);
  311.     sp->output = -1;
  312.     sp->proc->output = -1;
  313.  
  314.     freescreen(sp);
  315.     if(Current == sp){
  316.         Current = Command;
  317.         swapscreen(NULLSESSION,Command);
  318.         alert(Display,1);
  319.     }
  320.     if(Lastcurr == sp)
  321.         Lastcurr = NULLSESSION;
  322. }
  323. /* Control session recording */
  324. int
  325. dorecord(argc,argv,p)
  326. int argc;
  327. char *argv[];
  328. void *p;
  329. {
  330.     struct session *sp;
  331.     char *mode;
  332.  
  333.     sp = (struct session *)p;
  334.     if(sp == NULLSESSION){
  335.         tprintf("No current session\n");
  336.         return 1;
  337.     }
  338.     if(argc > 1){
  339.         if(sp->rfile != NULLCHAR){
  340.             fclose(sp->record);
  341.             free(sp->rfile);
  342.             sp->record = NULLFILE;
  343.             sp->rfile = NULLCHAR;
  344.         }
  345.         /* Open new record file, unless file name is "off", which means
  346.          * disable recording
  347.          */
  348.         if(strcmp(argv[1],"off") != 0){
  349.             if(sockmode(sp->output,-1) == SOCK_ASCII)
  350.                 mode = APPEND_TEXT;
  351.             else
  352.                 mode = APPEND_BINARY;
  353.  
  354.             if((sp->record = fopen(argv[1],mode)) == NULLFILE)
  355.                 tprintf("Can't open %s: %s\n",argv[1],sys_errlist[errno]);
  356.             else
  357.                 sp->rfile = strdup(argv[1]);
  358.         }
  359.     }
  360.     if(sp->rfile != NULLCHAR)
  361.         tprintf("Recording into %s\n",sp->rfile);
  362.     else
  363.         tprintf("Recording off\n");
  364.     return 0;
  365. }
  366. /* Control file transmission */
  367. int
  368. doupload(argc,argv,p)
  369. int argc;
  370. char *argv[];
  371. void *p;
  372. {
  373.     register struct session *sp;
  374.  
  375.     sp = (struct session *)p;
  376.     if(sp == NULLSESSION){
  377.         tprintf("No current session\n");
  378.         return 1;
  379.     }
  380.     if(argc < 2){
  381.         if(sp->ufile != NULLCHAR)
  382.             tprintf("Uploading %s\n",sp->ufile);
  383.         else
  384.             tprintf("Uploading off\n");
  385.         return 0;
  386.     }
  387.     if(strcmp(argv[1],"stop") == 0 && sp->upload != NULLFILE){
  388.         /* Abort upload */
  389.         fclose(sp->upload);
  390.         sp->upload = NULLFILE;
  391.         free(sp->ufile);
  392.         sp->ufile = NULLCHAR;
  393.         killproc(sp->proc2);
  394.         sp->proc2 = NULLPROC;
  395.         return 0;
  396.     }
  397.     /* Open upload file */
  398.     if((sp->upload = fopen(argv[1],READ_TEXT)) == NULLFILE){
  399.         tprintf("Can't read %s: %s\n",argv[1],sys_errlist[errno]);
  400.         return 1;
  401.     }
  402.     sp->ufile = strdup(argv[1]);
  403.     /* All set, invoke the upload process */
  404.     sp->proc2 = newproc("upload",1024,upload,0,sp,NULL,0);
  405.     return 0;
  406. }
  407. /* File uploading task */
  408. void
  409. upload(unused,sp1,p)
  410. int unused;
  411. void *sp1;
  412. void *p;
  413. {
  414.     struct session *sp;
  415.     int oldf;
  416.     char *buf;
  417.  
  418.     sp = (struct session *)sp1;
  419.  
  420.     /* Disable newline buffering for the duration */
  421.     oldf = setflush(sp->s,-1);
  422.  
  423.     buf = mallocw(BUFSIZ);
  424.     while(fgets(buf,BUFSIZ,sp->upload) != NULLCHAR)
  425.         if(usputs(sp->s,buf) == EOF)
  426.             break;
  427.  
  428.     free(buf);
  429.     usflush(sp->s);
  430.     setflush(sp->s,oldf);
  431.     fclose(sp->upload);
  432.     sp->upload = NULLFILE;
  433.     free(sp->ufile);
  434.     sp->ufile = NULLCHAR;
  435.     sp->proc2 = NULLPROC;
  436. }
  437.  
  438.