home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / internet / tcpipsrc / h / if / Main / c / main < prev    next >
Encoding:
Text File  |  1995-02-05  |  26.3 KB  |  1,065 lines
  1. /* Main network program - provides both client and server functions */
  2.  
  3. #define HOSTNAMELEN 32          /* changed from 16 by Bdale 860812 */
  4.  
  5. #define ESC 29
  6.  
  7. extern char config[];    /* File to read setup from */
  8. extern char startup[];   /* File to read startup commands from */
  9. extern char alternate[]; /* Directory for alternate startup commands */
  10. extern char scripts[];   /* Directory for command files for source command */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include <time.h>
  16. #include <stdarg.h>
  17. #include <ctype.h>
  18.  
  19. #include "wimp.h"
  20. #include "wimpt.h"
  21. #include "visdelay.h"
  22.  
  23. #include "config.h"
  24. #include "global.h"
  25. #include "mbuf.h"
  26. #include "netuser.h"
  27. #include "timer.h"
  28. #include "icmp.h"
  29. #include "iface.h"
  30. #include "ip.h"
  31. #include "tcp.h"
  32. #include "ax25.h"
  33. #include "netrom.h"
  34. #include "remote.h"
  35. #include "ftp.h"
  36. #include "telnet.h"
  37. #include "session.h"
  38. #include "cmdparse.h"
  39. #include "asy.h"
  40. #include "chat.h"
  41. #include "slip.h"
  42. #include "nrs.h"
  43. #include "trace.h"
  44. #include "mem.h"
  45. #include "arp.h"
  46. #include "ax_mbx.h"
  47. #include "finger.h"
  48. #include "ident.h"
  49. #include "dns.h"
  50. #include "internet.h"
  51. #include "kiss.h"
  52. #include "lapb.h"
  53. #include "nr4.h"
  54. #include "ping.h"
  55. #include "pop.h"
  56. #include "nntp.h"
  57. #include "smtp.h"
  58. #include "NetTime.h"
  59. #include "udp.h"
  60. #include "misc.h"
  61. #include "domain.h"
  62. #include "arc.h"
  63. #include "driver.h"
  64. #include "pppdriver.h"
  65. #include "alarm.h"
  66. #include "var.h"
  67.  
  68. extern varlist global_vars;
  69.  
  70. extern int (*driver_load(char*))(int,...);
  71.  
  72. /* Dummy structure for loopback tracing */
  73. struct interface loopback = {
  74.   NULLIF, "loopback" };
  75.  
  76. extern struct interface *ifaces;
  77. extern char version[];
  78. extern struct mbuf *loopq;
  79.  
  80. extern Terminal *MWin;
  81.  
  82. int mode;
  83.  
  84. char badhost[] = "Unknown host %s\r\n";
  85. char hostname[HOSTNAMELEN];
  86. unsigned nsessions = NSESSIONS;
  87. int16 lport    = 1001;
  88. char *prompt   = "net> ";
  89. char nospace[] = "No space!!\r\n";        /* Generic malloc fail message */
  90. int attended = 1;
  91. int ttyflow = 1;                        /* tty flow control */
  92. int initialisation_completed = FALSE;
  93.  
  94. static char *ttybuf;
  95. static int quiet = FALSE;  /* Echo startup files */
  96.  
  97. extern int doresolve(int, char **);
  98. extern int dotransfer(int, char **);
  99.  
  100. static int doexit(int, char **);
  101. static int doattach(int, char **);
  102. static int doecho(int, char **);
  103. static int doeol(int, char **);
  104. static int dohostname(int, char **);
  105. static int dolog(int, char **);
  106. static int dohelp(int, char **);
  107. static int domode(int, char **);
  108. static int doparam(int, char **);
  109. static int doremote(int, char **);
  110. static int dostart(int, char **);
  111. static int dostop(int, char **);
  112. static int dotrace(int, char **);
  113. static int dosource(int, char **);
  114. static int dounattend(int, char **);
  115. static int dofiler(int, char **);
  116.  
  117. static int filer_open(int, char **);
  118. static int filer_run(int, char **);
  119.  
  120. extern int docredits(int argc, char **argv);
  121. extern int doterm(int argc, char **argv);
  122.  
  123. extern int doslipstat(int argc, char **argv);
  124.  
  125. extern int dosetvar(int argc, char **argv); /* In command parse */
  126. extern int dosetosvar(int argc, char **argv); /* In command parse */
  127. extern int doshowvar(int argc, char **argv); /* In command parse */
  128.  
  129. extern int doident(int argc, char **argv);
  130.  
  131. static void showtrace(struct interface *);
  132. static int  asy_attach(int, char **);
  133. extern int ether_attach(int argc, char **argv);
  134.  
  135. struct cmds cmds[] = {
  136.   /* The "go" command must be first */
  137.   "",             go,             0, NULLCHAR,    NULLCHAR,
  138.   "arp",          doarp,          0, NULLCHAR,    NULLCHAR,
  139.   "asystat",      doasystat,      0, NULLCHAR,    NULLCHAR,
  140.   "ax25",         doax25,         0, NULLCHAR,    NULLCHAR,
  141.   "attach",       doattach,       2, "attach <hardware> <hw specific options>", NULLCHAR,
  142.   /* This one is out of alpabetical order to allow abbreviation to "c" */
  143.   "connect",      doconnect,      3,"connect <interface> <callsign> [digipeaters]",
  144.   NULLCHAR,
  145.   "chat",         dochat,         0, "chat <interface> <error-send> [expect-send pairs]",    NULLCHAR,
  146.   "chattrace",    chat_trace,     0, NULLCHAR,    NULLCHAR,
  147.   "close",        doclose,        0, NULLCHAR,    NULLCHAR,
  148.   "credits",      docredits,      0, NULLCHAR,    NULLCHAR,
  149.   "disconnect",   doclose,        0, NULLCHAR,    NULLCHAR,
  150.   "domain",       dodomain,       0, NULLCHAR,    NULLCHAR,
  151.   "echo",         doecho,         0, NULLCHAR,    "echo [refuse|accept]",
  152.   "eol",          doeol,          0, NULLCHAR,    "eol options: unix, standard",
  153.   "exit",         doexit,         0, NULLCHAR,    NULLCHAR,
  154.   "finger",       dofinger,       0, NULLCHAR,    NULLCHAR,
  155.   "filer",        dofiler,        1, "open|run <file>",    NULLCHAR,
  156.   "forward",      doforward,      0, NULLCHAR,    NULLCHAR,
  157.   "ftp",          doftp,          2, "ftp <address> [ \\ <switches>[ \\ <chat strings>]]",     NULLCHAR,
  158.   "help",         dohelp,         0, NULLCHAR,    NULLCHAR,
  159.   "hop",          dohop,      0, NULLCHAR,    NULLCHAR,
  160.   "hostname",     dohostname,     0, NULLCHAR,    NULLCHAR,
  161.   "kick",         dokick,         0, NULLCHAR,    NULLCHAR,
  162.   "log",          dolog,          0, NULLCHAR,    NULLCHAR,
  163.   "ip",           doip,           0, NULLCHAR,    NULLCHAR,
  164.   "ident",        doident,        1, NULLCHAR,    NULLCHAR,
  165.   "mbox",         dombox,         0, NULLCHAR,    NULLCHAR,
  166.   "mem",          domem,          0, NULLCHAR,    NULLCHAR,
  167.   "mode",         domode,         2, "mode <interface>",  NULLCHAR,
  168.   "netrom",       donetrom,       0, NULLCHAR,    NULLCHAR,
  169.   "nntp",         donntp,         0, NULLCHAR,    NULLCHAR,
  170. /*  "nntp2",        donntp2,        0, NULLCHAR,    NULLCHAR, */
  171.   "nrstat",       donrstat,       0, NULLCHAR,    NULLCHAR,
  172.   "nsquery",      dodns,          0, "nsquery <options> [<namesever>] [<name>] [<type>]", NULLCHAR,
  173.   "param",        doparam,        2, "param <interface>", NULLCHAR,
  174.   "ping",         doping,         0, NULLCHAR,    NULLCHAR,
  175.   "pop",          dopop,          0, NULLCHAR,    NULLCHAR,
  176.   "quit",         doexit,         0, NULLCHAR,    NULLCHAR,
  177.   "record",       dorecord,       0, NULLCHAR,    NULLCHAR,
  178.   "remote",       doremote,       4, "remote <address> <port> <command>", NULLCHAR,
  179.   "reset",        doreset,        0, NULLCHAR,    NULLCHAR,
  180.   "resolve",      doresolve,      0, NULLCHAR,    NULLCHAR,
  181.   "route",        doroute,        0, NULLCHAR,    NULLCHAR,
  182.   "session",      dosession,      0, NULLCHAR,    NULLCHAR,
  183.   "setvar",       dosetvar,       3, "setvar <variable> <value_string>", NULLCHAR,
  184.   "setosvar",     dosetosvar,     3, "setvar <variable> <os variable name>", NULLCHAR,
  185.   "showvar",      doshowvar,      0, "showvar [<variable>]", NULLCHAR,
  186.   "smtp",         dosmtp,         0, NULLCHAR,    NULLCHAR,
  187.   "slipstat",     doslipstat,     2, "slipstat <interface>",    NULLCHAR,
  188.   "source",       dosource,       2, "source <filename>", NULLCHAR,
  189.   "start",        dostart,        2, "start <servername>",NULLCHAR,
  190.   "stop",         dostop,         2, "stop <servername>", NULLCHAR,
  191.   "tcp",          dotcp,          0, NULLCHAR,    NULLCHAR,
  192.   "telnet",       dotelnet,       2, "telnet <address> [<port>] [ \\ <switches>[ \\ <chat strings>]]",  NULLCHAR,
  193.   "time",         dotime,         1, NULLCHAR,  NULLCHAR,
  194.   "trace",        dotrace,        0, NULLCHAR,    NULLCHAR,
  195.   "trf",          dotransfer,     4, "trf <site> <port> <command>", NULLCHAR,
  196.   "udp",          doudp,          0, NULLCHAR,    NULLCHAR,
  197.   "unattended",   dounattend,     0, NULLCHAR,    NULLCHAR,
  198.   "upload",       doupload,       0, NULLCHAR,    NULLCHAR,
  199.   "window",       dowin,          0, NULLCHAR,    NULLCHAR,
  200.   "terminal",     doterm,         1, "terminal [*] <switches>[ \\ <chat strings>]",    NULLCHAR,
  201.   "?",            dohelp,         0, NULLCHAR,    NULLCHAR,
  202.   NULLCHAR,       NULLFP,         0,
  203.   "Unknown command; type \"?\" for list",   NULLCHAR,
  204. };
  205.  
  206. /* "start" and "stop" subcommands */
  207.  
  208. static struct cmds startcmds[] = {
  209.   "discard",      dis1,           0, NULLCHAR, NULLCHAR,
  210.   "echo",         echo1,          0, NULLCHAR, NULLCHAR,
  211.   "finger",       finger1,        0, NULLCHAR, NULLCHAR,
  212.   "ftp",          ftp1,           0, NULLCHAR, NULLCHAR,
  213.   "smtp",         smtp1,          0, NULLCHAR, NULLCHAR,
  214.   "telnet",       tn1,            0, NULLCHAR, NULLCHAR,
  215.   "ident",        ident1,         0, NULLCHAR, NULLCHAR,
  216.   NULLCHAR,       NULLFP,         0,
  217.   "start options: discard, echo, finger, ftp, smtp, telnet", NULLCHAR,
  218. };
  219.  
  220. static struct cmds stopcmds[] = {
  221.   "discard",      dis0,           0, NULLCHAR, NULLCHAR,
  222.   "echo",         echo0,          0, NULLCHAR, NULLCHAR,
  223.   "finger",       finger0,        0, NULLCHAR, NULLCHAR,
  224.   "ftp",          ftp0,           0, NULLCHAR, NULLCHAR,
  225.   "smtp",         smtp0,          0, NULLCHAR, NULLCHAR,
  226.   "telnet",       tn0,            0, NULLCHAR, NULLCHAR,
  227.   "ident",        ident0,         0, NULLCHAR, NULLCHAR,
  228.   NULLCHAR,       NULLFP,         0,
  229.   "stop options: discard, echo, finger, ftp, smtp, telnet", NULLCHAR,
  230. };
  231.  
  232. static struct cmds filercmds[] = {
  233.   "open",         filer_open,     0, NULLCHAR, NULLCHAR,
  234.   "run",          filer_run,      1, NULLCHAR, NULLCHAR,
  235.   NULLCHAR,       NULLFP,         0,
  236.   "filer commands: open, run", NULLCHAR,
  237. };
  238.  
  239.  
  240. static void AutoExec(int at, void *handle)
  241. {
  242.   char *args[3], buffer[256];
  243.   char *exec_file = (char *) handle;
  244.  
  245.   if (exec_file == NULL || exec_file[0] == '\0')
  246.     strcpy(buffer, startup);
  247.   else
  248.     sprintf(buffer, "%s%s", alternate, exec_file);
  249.   args[1] = buffer;
  250.   args[2] = "q";
  251.   dosource((quiet)?3:2, args);
  252.   initialisation_completed = TRUE;
  253. }
  254.  
  255. void net_init(int argc, char *argv[])
  256. {
  257.   int n;
  258.  
  259.   char *args[3], buffer[256];
  260.   char *config_file = NULL;
  261.   char *exec_file = NULL;
  262.  
  263.   if (argc>=1 && argv[0][0]=='-')
  264.   {
  265.     quiet = (tolower(argv[0][1])=='q');
  266.     --argc;  ++argv;
  267.   }
  268.  
  269.   if (argc>=1)
  270.     config_file = argv[0];
  271.   if (argc>=2)
  272.     exec_file = argv[1];
  273.  
  274.   sessions = (struct session *) calloc(nsessions, sizeof(struct session));
  275.   memset(udps, NUDP * sizeof(struct udp_cb *), '\0');
  276.   ttydriv('\n',&ttybuf); /* Initialise the keyboard buffer */
  277.  
  278.   Read_Domain_File();
  279.  
  280.   docredits(0, NULL);
  281.  
  282.  /* read default start_up file */
  283.   if (config_file == NULL || config_file[0] == '\0')
  284.     strcpy(buffer, config);
  285.   else
  286.     sprintf(buffer, "%s%s", alternate, config_file);
  287.   args[1] = buffer;
  288.   args[2] = "q";
  289.   dosource((quiet)?3:2, args);
  290.   cmdmode();
  291.   alarm_set(alarm_timenow() + 100, AutoExec, (void *) exec_file);
  292. }
  293.  
  294. void net_keyboard(int c)
  295. {
  296.   int16 cnt;
  297.  
  298.   /* c == 0x1CA means the command escape key (F10) */
  299.   if(c == 0x1CA || c == ESC)
  300.   {
  301.     if(mode != CMD_MODE)
  302.     {
  303.       cwprintf(NULL, "\r\n");
  304.       cmdmode();
  305.     }
  306.     return;
  307.   }
  308.   if ((cnt = ttydriv(c,&ttybuf)) == 0)
  309.   {
  310.     ttyflow = 0;    /* stop output to screen */
  311.     return;
  312.   }
  313.   else
  314.       {
  315.     ttyflow = 1;    /* restart output again */
  316.     if(mode != CMD_MODE)
  317.       go(NULL);   /* display pending chars */
  318.   }
  319.  
  320.   switch(mode)
  321.   {
  322.   case CMD_MODE:
  323.     cmdparse(cmds, ttybuf, NULL);
  324.     break;
  325.   case CONV_MODE:
  326.     if(current->parse != NULLVFP)
  327.       (*current->parse)(NULL, ttybuf, cnt);
  328.     break;
  329.   }
  330.   if(mode == CMD_MODE)
  331.     cwprintf(NULL, prompt);
  332. }
  333.  
  334. void net_poll(void)
  335. {
  336.   struct interface *ifp;
  337.   struct mbuf *bp;
  338.   struct ip ip;
  339.  
  340.   /* Service the loopback queue */
  341.   if((bp = dequeue(&loopq)) != NULLBUF)
  342.   {
  343.     dump(&loopback, IF_TRACE_IN, TRACE_IP, bp);  /* Extract IP header */
  344.     ntohip(&ip,&bp);
  345.     ip_recv(&ip,bp,0);
  346.   }
  347.   /* Service the interfaces */
  348.   for (ifp = ifaces; ifp != NULLIF; ifp = ifp->next)
  349.   {
  350.     if (ifp->recv != NULLVFP)
  351.     {
  352.       (*ifp->recv)(ifp);
  353.       if (ifp->driver != NULL)
  354.         (*ifp->driver)(DRIVER_POLL, ifp->subdevice);
  355.     }
  356.   }
  357.  
  358.   /* Service the clock if it has ticked */
  359.   check_time();
  360. }
  361.  
  362. /* Standard commands called from main */
  363.  
  364. /* Enter command mode */
  365. int cmdmode(void)
  366. {
  367.   if (mode != CMD_MODE)
  368.   {
  369.     mode = CMD_MODE;
  370.     cooked();
  371.     cwprintf(MWin, prompt);
  372.   }
  373.   return 0;
  374. }
  375.  
  376. static int doexit(int argc, char **argv)
  377. {
  378.   argc = argc;
  379.   argv = argv;
  380.  
  381.   net_exit();
  382.  
  383.   return(0);
  384. }
  385.  
  386. void net_exit(void)
  387. {
  388.   iostop();
  389.   exit(0);
  390. }
  391.  
  392. static int dohostname(int argc, char **argv)
  393. {
  394.   if(argc < 2)
  395.     cwprintf(NULL, "%s\r\n",hostname);
  396.   else
  397.     strncpy(hostname,argv[1],HOSTNAMELEN);
  398.   return 0;
  399. }
  400.  
  401. static char logname[80];
  402.  
  403. static int dolog(int argc, char **argv)
  404. {
  405.   if(argc < 2)
  406.   {
  407.     if(logname[0])
  408.       cwprintf(NULL, "Logging to %s\r\n", logname);
  409.     else
  410.         cwprintf(NULL, "Logging off\r\n");
  411.     return 0;
  412.   }
  413.   if(strcmp(argv[1], "stop") != 0)
  414.   {
  415.     strcpy(logname, argv[1]);
  416.   }
  417.   else
  418.       {
  419.     logname[0] = '\0';
  420.   }
  421.   return 0;
  422. }
  423.  
  424. static int dohelp(int argc, char **argv)
  425. {
  426.   register struct cmds *cmdp;
  427.   register char *s;
  428.   int i, j;
  429.  
  430.   argc = argc;
  431.   argv = argv;
  432.  
  433.   if ((s = malloc(2000)) == NULL) return 0;
  434.  
  435.   sprintf(s, "Main commands:\r\n");
  436.  
  437.   for (i = 0, cmdp = cmds; cmdp->name != NULL; cmdp++, i++)
  438.   {
  439.     strcat(s, cmdp->name);
  440.  
  441.     if ((i % 4) == 3)
  442.     {
  443.       strcat(s, "\r\n");
  444.     }
  445.     else {
  446.       for (j = strlen(cmdp->name); j < 16; j++)
  447.         strcat(s, " ");
  448.     }
  449.   }
  450.  
  451.   if ((i % 4) != 0) strcat(s, "\r\n");
  452.  
  453.   cwputs(NULL, s);
  454.  
  455.   free(s);
  456.  
  457.   return 0;
  458. }
  459.  
  460. static int doecho(int argc, char **argv)
  461. {
  462.   extern int refuse_echo;
  463.  
  464.   if(argc < 2)
  465.   {
  466.     if(refuse_echo)
  467.       cwprintf(NULL, "Refuse\r\n");
  468.     else
  469.       cwprintf(NULL, "Accept\r\n");
  470.   }
  471.   else
  472.   {
  473.     if(argv[1][0] == 'r')
  474.       refuse_echo = 1;
  475.     else if(argv[1][0] == 'a')
  476.       refuse_echo = 0;
  477.     else
  478.       return -1;
  479.   }
  480.   return 0;
  481. }
  482.  
  483. static int doremote(int argc, char **argv)
  484. {
  485.   struct socket fsock, lsock;
  486.   struct mbuf *bp;
  487.  
  488.   argc = argc;
  489.  
  490.   lsock.address = ip_addr;
  491.   fsock.address = resolve(argv[1]);
  492.   lsock.port    = fsock.port = atoi(argv[2]);
  493.   bp = alloc_mbuf(1);
  494.   if (strcmp(argv[3], "reset") == 0)
  495.   {
  496.     *bp->data = SYS_RESET;
  497.   }
  498.   else if (strcmp(argv[3], "exit") == 0)
  499.   {
  500.     *bp->data = SYS_EXIT;
  501.   }
  502.   else if (strcmp(argv[3], "kick") == 0)
  503.   {
  504.     *bp->data = SYS_KICK;
  505.   }
  506.   else
  507.   {
  508.     cwprintf(NULL, "Unknown command %s\r\n", argv[3]);
  509.     return(1);
  510.   }
  511.   bp->cnt = 1;
  512.   send_udp(&lsock, &fsock, 0, 0, bp, 0, 0, 0);
  513.   return(0);
  514. }
  515.  
  516. /* if unattended mode is set - restrict ax25 and telnet sessions */
  517. static int dounattend(int argc, char **argv)
  518. {
  519.   if(argc < 2)
  520.   {
  521.     if(attended)
  522.       cwprintf(NULL, "System in attended operation.\r\n");
  523.     else
  524.         cwprintf(NULL, "System in unattended operation.\r\n");
  525.   }
  526.   else
  527.       {
  528.     if(argv[1][0] == 'y')
  529.     {
  530.       attended = 0;
  531.       cwprintf(NULL, "System now in unattended operation.\r\n");
  532.     }
  533.     else if(argv[1][0] == 'n')
  534.     {
  535.       attended = 1;
  536.       cwprintf(NULL, "System now in attended operation.\r\n");
  537.     }
  538.     else
  539.     {
  540.       cwprintf(NULL, "Usage : unattended y|n\r\n");
  541.       return -1;
  542.     }
  543.   }
  544.   return 0;
  545. }
  546.  
  547. /* set for unix end of line for remote echo mode telnet */
  548. static int doeol(int argc, char **argv)
  549. {
  550.   extern int unix_line_mode;
  551.  
  552.   if(argc < 2){
  553.     if(unix_line_mode)
  554.       cwprintf(NULL, "Unix\r\n");
  555.     else
  556.         cwprintf(NULL, "Standard\r\n");
  557.   }
  558.   else {
  559.     if(strcmp(argv[1],"unix") == 0)
  560.       unix_line_mode = 1;
  561.     else if(strcmp(argv[1],"standard") == 0)
  562.       unix_line_mode = 0;
  563.     else {
  564.       return -1;
  565.     }
  566.   }
  567.   return 0;
  568. }
  569. /* Attach an interface
  570.  * Syntax: attach <hw type> <hw name> <mode> <label> <bufsize> [<speed>]
  571.  */
  572. static int doattach(int argc, char **argv)
  573. {
  574.   extern struct cmds attab[];
  575.  
  576.   return subcmd(attab,argc,argv);
  577. }
  578. /* Manipulate I/O device parameters */
  579. static int doparam(int argc, char **argv)
  580. {
  581.   register struct interface *ifp;
  582.  
  583.   for(ifp=ifaces;ifp != NULLIF;ifp = ifp->next)
  584.   {
  585.     if(strcmp(argv[1],ifp->name) == 0)
  586.       break;
  587.   }
  588.   if(ifp == NULLIF)
  589.   {
  590.     cwprintf(NULL, "Interface \"%s\" unknown\r\n",argv[1]);
  591.     return 1;
  592.   }
  593.   if(ifp->ioctl == NULLFP)
  594.   {
  595.     cwprintf(NULL, "Not supported\r\n");
  596.     return 1;
  597.   }
  598.   /* Pass rest of args to device-specific code */
  599.   return (*ifp->ioctl)(ifp,argc-2,argv+2);
  600. }
  601.  
  602. void set_server_vars(char *name, struct tcb *tcb)
  603. {
  604.   char ipa[16];
  605.   char buf[32];
  606.  
  607.   sprintf(ipa, "%u.%u.%u.%u",
  608.           hibyte(hiword(tcb->conn.remote.address)),
  609.           lobyte(hiword(tcb->conn.remote.address)),
  610.           hibyte(loword(tcb->conn.remote.address)),
  611.           lobyte(loword(tcb->conn.remote.address)) );
  612.  
  613.   sprintf(buf, "%s_caller", name);
  614.   var_create_string(global_vars, buf, 0, ipa);
  615.   var_create_string(global_vars, "last_caller", 0, ipa);
  616. }
  617.  
  618. /* Log messages of the form
  619.  * Tue Jan 31 00:00:00 1987 44.64.0.7:1003 open FTP
  620.  */
  621. void log_event(struct tcb *tcb, char *fmt, ...)
  622. {
  623.   va_list argptr;
  624.   char *cp;
  625.   time_t t;
  626.   FILE *logfp;
  627.  
  628.   if (logname[0] == '\0')
  629.     return;
  630.   if (logfp = fopen(logname, "a+"), logfp == NULLFILE)
  631.     return;
  632.   time(&t);
  633.   cp = ctime(&t);
  634.   rip(cp);
  635.   if (tcb)
  636.     fprintf(logfp, "%s %s - ", cp, psocket(&tcb->conn.remote));
  637.   va_start(argptr,fmt);
  638.   vfprintf(logfp,fmt,argptr);
  639.   va_end(argptr);
  640.   fprintf(logfp,"\n");
  641.   fclose(logfp);
  642. }
  643. /* Configuration-dependent code */
  644.  
  645. /* List of supported hardware devices */
  646.  
  647. struct cmds attab[] = {
  648.  
  649.   /* Ordinary asynchronous adaptor */
  650.   "asy", asy_attach, 8,
  651.   "attach asy <driver> <subdevice> slip|ax25|nrs <label> <buffers> <mtu> <speed>\r\n        <nrs call>",
  652.   "Could not attach asy",
  653.  
  654.   /* PPP driver */
  655.   "ppp", ppp_attach, 1,
  656.   "attach ppp",
  657.   "Could not attach ppp",
  658.  
  659.   /* fake netrom interface */
  660.   "netrom", nr_attach, 1,
  661.   "attach netrom",
  662.   "Could not attach netrom",
  663.  
  664.   /* DCI Drivers for Ethernet */
  665.   "ether", ether_attach, 4,
  666.   "attach ether <port> <label> <mtu>",
  667.   "Could not attach ether",
  668.  
  669.   NULLCHAR, NULLFP, 0,
  670.   "Unknown device",
  671.   NULLCHAR,
  672. };
  673.  
  674. /* Protocol tracing function pointers */
  675. void (*tracef[])() = {
  676.   ax25_dump,
  677.  
  678.   NULLVFP,
  679.   ip_dump,
  680.  
  681.  
  682.   NULLVFP,
  683. };
  684.  
  685.  
  686. /* Attach a serial interface to the system
  687.  * argv[0]: hardware type, must be "asy"
  688.  * argv[1]: async adapter type, e.g. internal
  689.  * argv[2]: async adapter port number
  690.  * argv[3]: mode, may be:
  691.  *          "slip" (point-to-point SLIP)
  692.  *          "ax25" (AX.25 frame format in SLIP for raw TNC)
  693.  *          "nrs" (NET/ROM format serial protocol)
  694.  * argv[4]: interface label, e.g., "sl0"
  695.  * argv[5]: receiver ring buffer size in bytes
  696.  * argv[6]: maximum transmission unit, bytes
  697.  * argv[7]: interface speed, e.g, "9600"
  698.  * argv[8]: optional ax.25 callsign (NRS only)
  699.  */
  700. static int asy_attach(int argc, char **argv)
  701. {
  702.   register struct interface *if_asy;
  703.   extern struct interface *ifaces;
  704.   int dev;
  705.   int mode;
  706.   struct ax25_addr addr ;
  707.  
  708.   if (nasy >= ASY_MAX)
  709.   {
  710.     cwprintf(NULL, "Too many asynch controllers\r\n");
  711.     return -1;
  712.   }
  713.   dev = nasy++;
  714.  
  715.   /* Create interface structure and fill in details */
  716.   if_asy = (struct interface *) malloc(sizeof(struct interface));
  717.   memset(if_asy, '\0', sizeof(struct interface));
  718.   if_asy->name = strdup(argv[4]);
  719.  
  720.   if_asy->mtu  = atoi(argv[6]);
  721.   if_asy->dev  = dev;
  722.   if_asy->recv = doslip;
  723.   if_asy->stop = asy_stop;
  724.  
  725.   /* Get driver */
  726.   if (if_asy->driver = driver_load(argv[1]), if_asy->driver ==NULL)
  727.   {
  728.     cwprintf(NULL, "can't load asy driver \"%s\"\r\n", argv[1]);
  729.     return -1;
  730.   }
  731.   if_asy->subdevice = atoi(argv[2]);
  732.  
  733.   if (!strcmp(argv[3], "slip") || !strcmp(argv[3], "cslip"))
  734.     mode = SLIP_MODE;
  735.   else if (!strcmp(argv[3], "ax25"))
  736.     mode = AX25_MODE;
  737.   else if (!strcmp(argv[3], "nrs"))
  738.     mode = NRS_MODE;
  739.   else
  740.     mode = UNKNOWN;
  741.  
  742.   switch(mode)
  743.   {
  744.   case SLIP_MODE:
  745.     if_asy->ioctl = asy_ioctl;
  746.     if_asy->send = (int(*)())slip_send;
  747.     if_asy->output = NULLFP;        /* ARP isn't used */
  748.     if_asy->raw = slip_raw;
  749.     if_asy->flags = 0;
  750.     slip[dev].recv = slip_recv;
  751.     slip[dev].slcomp = NULL;
  752.     slip[dev].cslip_mode = 0;
  753.     slip[dev].stat_ip_sent = 0;
  754.     slip[dev].stat_tcp_compressed_sent = 0;
  755.     slip[dev].stat_tcp_uncompressed_sent = 0;
  756.     slip[dev].stat_ip_recvd = 0;
  757.     slip[dev].stat_tcp_compressed_recvd = 0;
  758.     slip[dev].stat_tcp_uncompressed_recvd = 0;
  759.     slip[dev].stat_bad_recvd = 0;
  760.  
  761.     if (!strcmp(argv[3], "cslip"))
  762.       sl_compress_init(&slip[dev].slcomp);
  763.     break;
  764.   case AX25_MODE:  /* Set up a SLIP link to use AX.25 */
  765.     axarp();
  766.     if(argc < 9)
  767.     {
  768.       /* no call sign supplied */
  769.       if(mycall.call[0] == '\0')
  770.       {
  771.         cwprintf(NULL, "set mycall first or specify in attach statement\r\n");
  772.         free(if_asy->name);
  773.         free((char *)if_asy);
  774.         nasy--;
  775.         return -1;
  776.       }
  777.       else
  778.           {
  779.         addr = mycall;
  780.       }
  781.     }
  782.     else
  783.     {
  784.       /* callsign supplied on attach line */
  785.       if(setcall(&addr,argv[8]) == -1)
  786.       {
  787.         cwprintf (NULL, "bad callsign on attach line\r\n");
  788.         free(if_asy->name);
  789.         free((char *)if_asy);
  790.         nasy--;
  791.         return -1;
  792.       }
  793.     }
  794.     if_asy->ioctl = kiss_ioctl;
  795.     if_asy->send = (int(*)())ax_send;
  796.     if_asy->output = (int(*)())ax_output;
  797.     if_asy->raw = kiss_raw;
  798.     if(if_asy->hwaddr == NULLCHAR)
  799.       if_asy->hwaddr = malloc(sizeof(addr));
  800.     memcpy(if_asy->hwaddr,(char *)&addr,sizeof(addr));
  801.     slip[dev].recv = kiss_recv;
  802.     break;
  803.   case NRS_MODE: /* Set up a net/rom serial interface */
  804.     if(argc < 9)
  805.     {
  806.       /* no call supplied? */
  807.       if(mycall.call[0] == '\0')
  808.       {
  809.         /* try to use default */
  810.         cwprintf(NULL, "set mycall first or specify in attach statement\r\n");
  811.         return -1;
  812.       }
  813.       else
  814.           addr = mycall;
  815.     }
  816.     else
  817.     {
  818.       /* callsign supplied on attach line */
  819.       if(setcall(&addr,argv[8]) == -1){
  820.         cwprintf (NULL, "bad callsign on attach line\r\n");
  821.         free(if_asy->name);
  822.         free((char *)if_asy);
  823.         nasy--;
  824.         return -1;
  825.       }
  826.     }
  827.     if_asy->recv = nrs_recv;
  828.     if_asy->ioctl = asy_ioctl;
  829.     if_asy->send = (int(*)())ax_send;
  830.     if_asy->output = (int(*)())ax_output;
  831.     if_asy->raw = nrs_raw;
  832.     if(if_asy->hwaddr == NULLCHAR)
  833.       if_asy->hwaddr = malloc(sizeof(addr));
  834.     memcpy(if_asy->hwaddr,(char *)&addr,sizeof(addr));
  835.     nrs[dev].iface = if_asy;
  836.     break;
  837.   default:
  838.     cwprintf(NULL, "Mode %s unknown for interface %s\r\n",
  839.     argv[2],argv[4]);
  840.     free(if_asy->name);
  841.     free((char *)if_asy);
  842.     nasy--;
  843.     return -1;
  844.   }
  845.   if_asy->next = ifaces;
  846.   ifaces = if_asy;
  847.   asy_init(dev, if_asy, (unsigned)atoi(argv[5]));
  848.   if (argc>7)
  849.     asy_speed(dev, atoi(argv[7]));
  850.   if (argc>8)
  851.     asy_flowctrl(dev, atoi(argv[8]));
  852.   return 0;
  853. }
  854.  
  855.  
  856. /* Display or set IP interface control flags */
  857. static int domode(int argc, char **argv)
  858. {
  859.   register struct interface *ifp;
  860.  
  861.   for(ifp=ifaces;ifp != NULLIF;ifp = ifp->next){
  862.     if(strcmp(argv[1],ifp->name) == 0)
  863.       break;
  864.   }
  865.   if(ifp == NULLIF){
  866.     cwprintf(NULL, "Interface \"%s\" unknown\r\n",argv[1]);
  867.     return 1;
  868.   }
  869.   if(argc < 3){
  870.     cwprintf(NULL, "%s: %s\r\n",ifp->name,
  871.     (ifp->flags & CONNECT_MODE) ? "VC mode" : "Datagram mode");
  872.     return 0;
  873.   }
  874.   switch(argv[2][0]){
  875.   case 'v':
  876.   case 'c':
  877.   case 'V':
  878.   case 'C':
  879.     ifp->flags = CONNECT_MODE;
  880.     break;
  881.   case 'd':
  882.   case 'D':
  883.     ifp->flags = DATAGRAM_MODE;
  884.     break;
  885.   default:
  886.     cwprintf(NULL, "Usage: %s [vc | datagram]\r\n",argv[0]);
  887.     return 1;
  888.   }
  889.   return 0;
  890. }
  891.  
  892. static int dostart(int argc, char **argv)
  893. {
  894.   return subcmd(startcmds,argc,argv);
  895. }
  896.  
  897. static int dostop(int argc, char **argv)
  898. {
  899.   return subcmd(stopcmds,argc,argv);
  900. }
  901.  
  902. static int dotrace(int argc, char **argv)
  903. {
  904.   struct interface *ifp;
  905.   struct interface *ifpp;
  906.   int tracing = 0;
  907.  
  908.   if(argc < 2){
  909.     showtrace(&loopback);
  910.     for(ifp = ifaces; ifp != NULLIF; ifp = ifp->next)
  911.       showtrace(ifp);
  912.     return 0;
  913.   }
  914.   if(strcmp("loopback",argv[1]) == 0)
  915.     ifp = &loopback;
  916.   else
  917.       for(ifp = ifaces; ifp != NULLIF; ifp = ifp->next)
  918.     if(strcmp(ifp->name,argv[1]) == 0)
  919.       break;
  920.  
  921.   if(ifp == NULLIF){
  922.     cwprintf(NULL, "Interface %s unknown\r\n",argv[1]);
  923.     return 1;
  924.   }
  925.   if(argc >= 3){
  926.     if ((ifp->trace = htoi(argv[2])) > 0)
  927.     {
  928.       twopen();
  929.     }
  930.     else {
  931.       for(ifpp = ifaces; ifpp != NULLIF; ifpp = ifpp->next)
  932.         if (ifpp->trace > 0)
  933.           tracing = 1;
  934.       if (loopback.trace > 0)
  935.         tracing = 1;
  936.       if (!tracing)
  937.         twclose();
  938.     }
  939.   }
  940.   showtrace(ifp);
  941.   return 0;
  942. }
  943. /* Display the trace flags for a particular interface */
  944. static void showtrace(register struct interface *ifp)
  945. {
  946.   if(ifp == NULLIF)
  947.     return;
  948.   cwprintf(NULL, "%s:",ifp->name);
  949.   if(ifp->trace & (IF_TRACE_IN | IF_TRACE_OUT)){
  950.     if(ifp->trace & IF_TRACE_IN)
  951.       cwprintf(NULL, " input");
  952.     if(ifp->trace & IF_TRACE_OUT)
  953.       cwprintf(NULL, " output");
  954.  
  955.     if(ifp->trace & IF_TRACE_HEX)
  956.       cwprintf(NULL, " (Hex/ASCII dump)");
  957.     else if(ifp->trace & IF_TRACE_ASCII)
  958.       cwprintf(NULL, " (ASCII dump)");
  959.     else
  960.         cwprintf(NULL, " (headers only)");
  961.     cwprintf(NULL, "\r\n");
  962.   }
  963.   else
  964.       cwprintf(NULL, " tracing off\r\n");
  965. }
  966.  
  967. void stoptrace(void)
  968. {
  969.   struct interface *ifp;
  970.  
  971.   loopback.trace = 0;
  972.   for(ifp = ifaces; ifp != NULLIF; ifp = ifp->next)
  973.     ifp->trace = 0;
  974. }
  975.  
  976.  
  977. static int dosource(int argc, char **argv)
  978. {
  979.   static char inbuf[500], savebuf[500];
  980.   char filename[256];                 /* for error messages */
  981.   int linenum = 0;
  982.   FILE *fp;
  983.   int quiet = FALSE;
  984.  
  985.   if (argc>2 && tolower(*argv[2])=='q')
  986.     quiet = TRUE;
  987.  
  988.   argc = argc;
  989.  
  990.   if (!strchr(argv[1], '.') && !strchr(argv[1], ':'))
  991.     sprintf(filename, "%s.%s", scripts, argv[1]);
  992.   else
  993.     strcpy(filename, argv[1]);
  994.  
  995.   if ((fp = fopen(filename, "r")) == NULLFILE)
  996.   {
  997.     cwprintf(NULL, "%s: cannot open\r\n", filename);
  998.     return 1;
  999.   }
  1000.  
  1001.   cwprintf(NULL, "Source: %s\r\n", filename);
  1002.  
  1003.   while (fgets(inbuf, sizeof(inbuf),fp) != NULLCHAR)
  1004.   {
  1005.     char * ptr ;
  1006.     rip(inbuf);
  1007.     strcpy(savebuf, inbuf);
  1008.     linenum++;
  1009.     /* Do a quick check for comments - no point in calling cmdparse */
  1010.     for ( ptr = inbuf ; isspace(* ptr) ; ptr ++ ) ;
  1011.     if ( * ptr == '#' || * ptr == '\0' )
  1012.       continue ;
  1013.  
  1014.     if (!quiet)
  1015.       cwprintf(NULL, "%s\r\n", inbuf);
  1016.     if (cmdparse(cmds, inbuf, NULL) != 0)
  1017.       cwprintf(NULL, "*** file \"%s\", line %d: %s\r\n", filename, linenum, savebuf);
  1018.   }
  1019.   fclose(fp);
  1020.   return 0;
  1021. }
  1022.  
  1023. static int dofiler(int argc, char **argv)
  1024. {
  1025.   return subcmd(filercmds,argc,argv);
  1026. }
  1027.  
  1028. static int filer_open(int argc, char **argv)
  1029. {
  1030.   os_error *e;
  1031.   char buf[256];
  1032.  
  1033.   if (argc>1)
  1034.   {
  1035.     if (strpbrk(argv[1], "$:<>"))
  1036.       sprintf(buf, "Filer_OpenDir %s", argv[1]);
  1037.     else
  1038.       sprintf(buf, "Filer_OpenDir %s.%s", "<TCPIP$Dir>", argv[1]);
  1039.   }
  1040.   else
  1041.     sprintf(buf, "Filer_OpenDir %s", "<TCPIP$Dir>");
  1042.  
  1043.   visdelay_begin();
  1044.   e = wimp_starttask(buf);
  1045.   visdelay_end();
  1046.   wimpt_complain(e);
  1047.   return 0;
  1048. }
  1049.  
  1050. static int filer_run(int argc, char **argv)
  1051. {
  1052.   os_error *e;
  1053.   char buf[256];
  1054.  
  1055.   if (strpbrk(argv[1], "$:<>"))
  1056.     sprintf(buf, "Filer_Run %s", argv[1]);
  1057.   else
  1058.     sprintf(buf, "Filer_Run %s.%s", "<TCPIP$Dir>", argv[1]);
  1059.   visdelay_begin();
  1060.   e = wimp_starttask(buf);
  1061.   visdelay_end();
  1062.   wimpt_complain(e);
  1063.   return 0;
  1064. }
  1065.