开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
FTPD.C
资源名称：ertos.rar　[点击查看]
上传用户：sunrenlu
上传日期：2022-06-13
资源大小：1419k
文件大小：28k
源码类别：

操作系统开发

开发平台：

DOS

FTPD.C：源码内容
  1. /*
  2.  * Copyright (c) 1990, 1999 Erick Engelke
  3.  */
  4. #include <stdio.h>
  5. #include <string.h>
  6. #include <stdlib.h>
  7. #include <sys/stat.h>
  8. #include <fcntl.h>
  9. #include <time.h>
  10. #include <ctype.h>
  11. #include <io.h>
  12. #include <mem.h>
  13. #include <rtos.h>
  14. #include <net.h>
  15. #include <dir.h>
  16. #include <dos.h>
  17. #include <share.h>
  19. #if defined(__DJGPP__)
  20. #include <unistd.h>
  22. #define ltoa( x, buf, radix ) itoa( x, buf, radix )
  24. #define min(x,y) ( ( x < y ) ? x : y )
  26. #define movmem( x, y, len ) memmove( y, x, len )    /* reverse order */
  28. #endif  // DJGPP
  31. #define S_INIT  0
  32. #define S_WAIT  1
  33. #define S_CONN  2   /* connected and talking */
  34. #define S_DATA  4
  35. #define S_CLOS  5
  36. #define S_HALT  6   /* halt service */
  37. #define DIR_DELIM       '/'
  39. char *cmds[] = {
  40.     "ABOR", "QUIT", "PASS", "HELP", "NOOP", "USER", 
  41.     "MKD",  "XMKD", "RMD",  "XRMD", "CWD",  "XCWD", "PWD",  "XPWD",
  42.     "SITE", "DEL" , "TYPE", "SIZE", "PORT", "LIST", "NLST", "STOR", "RETR",
  43.     "RNFR", "RNTO"
  44.     };
  45. enum {
  46.      ABOR,   QUIT,   PASS,   HELP,   NOOP,   USER,
  47.      MKD,    XMKD,   RMD,    XRMD,   CWD,    XCWD,   PWD,    XPWD,
  48.      SITE,   DEL,    TYPE,   SIZE,   PORT,   LIST,   NLST,   STOR,   RETR,
  49.      RNFR,   RNTO,
  50.      ENDLIST };
  53. #define FTPDWELCOME "FTPD.WELCOME"
  54. #define FTPDPASS   "FTPD.PASSWORD"
  55. #define FTPDBUFSIZ "FTPD.BUFSIZ"
  56. #define FTPDPORT    21
  58. #define FTP_OP_DIR  0
  59. #define FTP_OP_GET  1
  60. #define FTP_OP_PUT  2
  61. #define FTP_OP_DON  3
  62. #define FTP_OP_NOP  4
  64. #define FTPDIRLEN  65
  65. #define FTPPATHLEN 81
  66. #define FTPD_BUF_MIN 512
  67. #define FTPD_BUF_NORM 2048
  69. typedef struct {
  70.     int         status;
  71.     tcp_Socket socket;
  72.     int         dstatus;
  73.     int         doperation;
  74.     int         dcmd;
  75.     tcp_Socket  dsocket;
  76.     struct ffblk ffblk;
  77.     int         dhandle;        /* for file transfer */
  78.     int         gotpass;
  80.     int         ascii;         /* 1 is ascii */
  81.     longword    biglen;         /* for file transfer completion stats */
  82.     word        bufhead;
  83.     word        buftail;
  85.     longword    hisip;          /* used for data connections */
  86.     word        hisport;
  87.     char       *errmsg;
  88.     char        dirpath[ FTPDIRLEN ];
  89.     char        filepath[ FTPPATHLEN ];
  90.     char       *ftpdbuffer;
  91. } ftpdses;
  93. int   ftpdbufferlen = FTPD_BUF_NORM;
  95. // static ftpdses *ftpd;
  96. char ftpdpassword[ 128 ];
  97. char ftpdwelcome[ 128 ];
  99. extern void *getvalue( char * p );
  100. extern int cmdcompare( char *p, char *command );
  103. typedef struct dostimedate {
  104.     unsigned xxx  : 5;
  105.     unsigned min  : 6;
  106.     unsigned hour : 5;
  107.     unsigned date : 5;
  108.     unsigned mon  : 4;
  109.     unsigned year : 7;
  110. };
  112. static char *dos2unix( char *src, char *dest)
  113. {
  114.     char ch;
  115.     char *r = dest;
  116.     while ( (ch = *src++ ) != 0 ) {
  117.         if ( ch == '\' ) ch = '/';
  118.         *dest ++ = ch;
  119.     }
  120.     *dest = 0;
  121.     return( r );
  122. }
  124. /*
  125.  * handlerrs - install an error handler which simply returns as though fail
  126.  *             was sellected by the user
  127.  */
  128. static void interrupt (*olderrhandler)();
  130. #if defined(__TURBOC__)||defined(__BORLANDC__)
  131. #pragma warn -par
  133. /*
  134.  * handlerrs - it prevents abort,retry,ignore,...
  135.  *      - coded Borland specific
  136.  *      - start = nonzero installs handler, zero resets it
  137.  */
  138. static void handlerrs( int start )
  139. {
  140.     dos_enter();
  141.     if ( start ) {
  142. olderrhandler = getvect( 0x24 );
  143. harderr( (int (*)()) hardretn );
  144.     } else
  145. setvect( 0x24, olderrhandler );
  146.     dos_exit();
  147. }
  149. #endif  // BORLANDC
  155. /*
  156.  * strins - copy little_string into big_string
  157.  *
  158.  * eg. strins( "0123456", "abcd", 2 ) creates "ab23456"
  159.  */
  160. static void strins( char *big, char *little, int len )
  161. {
  162.     int movlen;
  163.     movlen = min( strlen( little ), ((len > 0) ? len : -len));
  164.     if ( len > 0 ) movmem( little, big, movlen );
  165.     else movmem( little, big - (len + movlen), movlen );
  166. }
  168. /*
  169.  * dirformblock - create a unix "ls -l" style of output for this dir entry
  170.  *              - uses several DOS functions or single memory buffers
  171.  *                wrap with dos_enter() / dos_exit();
  172.  */
  174. static
  175. void
  176. dirformblock( struct ffblk* ff, char* formatted)
  177. {
  178.   struct dostimedate* pdos_time = (struct dostimedate*) &ff->ff_ftime;
  179.   struct tm unix_time;
  180.   time_t timer = time( NULL );
  181.   int current_year = localtime( &timer )->tm_year + 1900; /* UNIX year bias */
  182.   char buf[16];
  183.   int i;
  185.   memset(&unix_time, 0, sizeof(unix_time));
  186.   unix_time.tm_min  = pdos_time->min;
  187.   unix_time.tm_hour = pdos_time->hour;
  188.   unix_time.tm_mday = pdos_time->date;
  189.   unix_time.tm_mon  = pdos_time->mon - 1; /* DOS months 1-12, UNIX months 0-11 */
  190.   unix_time.tm_year = pdos_time->year + 1980 /* DOS year bias */ - 1900 /* UNIX year bias */;
  191.   
  192.   sprintf( formatted, "%c", ff->ff_attrib & FA_DIREC ? 'd' : '-' );
  193.   sprintf( buf, "r%cx", !(ff->ff_attrib & FA_RDONLY) ? 'w' : '-' );
  194.   for(i = 0; i<3; i++)
  195.     strcat( formatted, buf );
  197.   sprintf( strchr(formatted, 0), " 1 user users %10s ", ltoa( ff->ff_fsize, buf, 10 ) );
  198.   strftime( strchr(formatted, 0), -1,
  199.     pdos_time->year + 1980 == current_year ? "%b %d %H:%M " : "%b %d  %Y ", &unix_time
  200.   );
  201.   strcat(formatted, ff->ff_name);
  202.   strcat(formatted, "rn");
  203. }
  205. /*
  206.  * functions to handle paths
  207.  */
  208. static char *pathfile( ftpdses *f, char *fname )
  209. {
  210.     char *p;
  211.     /* better return bad name than overwrite buffers */
  212.     if ( (strlen( f->dirpath ) + strlen( fname ) - 2) >= FTPPATHLEN )
  213.         return( fname );
  215.     /* support hard coded D:xxx */
  216.     if ( f->dirpath[0] && (f->dirpath[1] == ':'))
  217.       f->filepath[0] = 0;
  218.     else
  219.       strcpy( f->filepath, ".\");
  221.     if ( *f->dirpath ) {
  222.         strcat( f->filepath, f->dirpath );
  223.         p = strchr( f->filepath , 0 );
  224.         p--;
  225.         if ( *p != '\' )
  226.           strcat( f->filepath, "\");
  227.     }
  228.     strcat( f->filepath, fname );
  229.     return( f->filepath );
  230. }
  231. static int changedir( ftpdses *f, char *path)
  232. {
  233.     struct stat st;
  234.     char *p;
  235.     int i;
  236.     int len;
  238.     /* fix unix styled slashes */
  240.     while ( (p = strchr( path, '/' )) != NULL ) *p = '\';
  242.     /* handle up one dir */
  243.     if ( (path[0] == '.') && (path[1] == '.' )) {
  244.         /* go up a subdir */
  245.         if ( (p = strrchr( f->dirpath, '\' ))!= NULL) {
  246.             *p = 0;
  247.         } else
  248.             f->dirpath[0] = 0;
  249.         if ( f->dirpath[0] && ( f->dirpath[1] == ':') && !f->dirpath[2] ) {
  250.             /* need trailing / */
  251.             strcat( f->dirpath,"\");
  252.         }
  254.         return( 0 );    /* say it was successful */
  255.     }
  257.     /*  root is . */
  258.     if ( (path[0] == DIR_DELIM ) && ( path[1] == 0 )) {
  259.         *f->dirpath = 0;
  260.         return( 0 );
  261.     }
  263.     /* AGW 2000.7.17 remove trailing /  */
  264.     if ((len = strlen( path )) > 0 ) {
  265.         char *p;
  266.         p = &path[ len - 1];
  267.         if ( *p == DIR_DELIM ) *p = 0; // if trailing \ then remove
  268.     }
  269.     /* if they didn't specify  then assume we are adding to path */
  270.     if ( *path == DIR_DELIM )
  271.         path++;     /* skip leading  for relative directory */
  272.     /* handle Drive:path... condition */
  273.     else if ( (path[0] != 0) && (path[1] == ':')) {
  274.         // do nothing, this is a good path
  275.     } else {
  276.         strcpy( f->filepath, f->dirpath );
  277.         if ( *f->dirpath )
  278.             strcat( f->filepath, "/");
  279.         strcat( f->filepath, path );
  280.         path = f->filepath;
  281.     }
  283.     /* convert to DOS path */
  284.     while ( (p = strchr( path, DIR_DELIM )) != NULL ) *p = '\';
  286.     dos_enter();
  287.     i = stat( path, &st );      /* no such file or directory */
  288.     dos_exit();
  289.     if ( i != 0 )
  290.         return( 1 );
  292.     if ((st.st_mode & S_IFDIR ) == 0 )
  293.         return( 1 ); /* not a directory */
  295.     /* use new directory path */
  296.     strncpy( f->dirpath, path, FTPDIRLEN - 1 );
  297.     f->dirpath[ FTPDIRLEN - 1] = 0;
  298.     return( 0 );
  299. }
  302. /*
  303.  * data_op_... operations on data socket
  304.  */
  306. /*
  307.  * data_op_get - does a "GET"
  308.  *             - could be optimized for speed by allocing a second
  309.  *               buffer and performing the DOS read while waiting for
  310.  *               the remote host to ack the data
  311.  */
  312. static void data_op_get( ftpdses *f, tcp_Socket *t )
  313. {
  314. //    int len;
  315.     unsigned diff, wrote, ofs;
  316.     int i;
  317.     if ( sock_tbused( t ) == 0 ){
  318.         diff = 0;
  319.         dos_enter();
  320.         i = _dos_read( f->dhandle, f->ftpdbuffer, ftpdbufferlen, &diff );
  321.         dos_exit();
  322.         if ( i != 0 ) {
  323.             f->errmsg = "550 Error while trying to read filern";
  324.             f->doperation = FTP_OP_DON;
  325.         } else if ( diff == 0 ) /* eof or possibly error condition */
  326.     f->doperation = FTP_OP_DON;
  327.         else {
  328.             // was good, sit in loop writing it out
  329.             wrote = ofs = 0;
  330.             do {
  331.                 sock_mode( t, TCP_MODE_NONAGLE );
  332.                 wrote = sock_fastwrite( t, f->ftpdbuffer + ofs, diff );
  333.                 ofs += wrote;
  334.                 diff -= wrote;
  335.                 if ( wrote == 0 ) rt_sleep( 0 );
  336.             } while ( diff > 0 );
  337.         }
  338.     }
  339. }
  341. static void data_op_init( ftpdses *f, word operation )
  342. {
  343.     f->doperation = operation;
  344.     f->dstatus = S_INIT;
  345.     f->status = S_DATA;
  346.     f->biglen = 0;
  347.     f->bufhead = f->buftail = 0;
  348.     f->errmsg = "250 Donern";
  350.     sock_puts( &f->socket, "150 Openning data connectionrn");
  351. }
  354. static void c_op_dir( ftpdses *f, char *path )
  355. {
  356.     char buffer[ 81 ];
  357.     // char  p;
  358.     int status;
  360.     f->dhandle = 0;
  362.     /* support pseudo-standard -L */
  363.     if ( path != NULL ) {
  364.         if ( !strnicmp( path, "-L", 2 )) {
  365.             path += 2;
  366.             if ( !*path ) path = NULL;
  367.         }
  368.     }
  370.     /* new for directories */
  371.     if ( path != NULL ) strcpy( buffer, pathfile( f, path ));
  372.     else strcpy( buffer, pathfile( f, "*.*" ));
  373. //    if (path != NULL ) movmem( path, buffer, sizeof(buffer) - 1 );
  374. //    else strcpy( buffer, "*.*" );
  376.     buffer[ sizeof( buffer ) - 1 ] = 0;
  377.     status = findfirst( buffer, &f->ffblk, FA_DIREC);
  379.     if ( !strchr( buffer, '*' ) &&
  380.          !strchr( buffer, '?' ) &&
  381.          !status                &&
  382.          (f->ffblk.ff_attrib & FA_DIREC ) &&
  383.          *f->ffblk.ff_name != '.') {
  385. strcat( buffer, "\*.*");
  386.         dos_enter();
  387. status = findfirst( buffer, &f->ffblk, FA_DIREC);
  388.         dos_exit();
  389.     }
  390.     if (!status) data_op_init( f, FTP_OP_DIR );
  391.     else sock_puts(&f->socket, "550 File or directory not foundrn");
  392. }
  394. static void (*oldinit)(char *, char *);
  395. static void newinit( char *directive, char *value )
  396. {
  397.     char *p;
  398.     if (!strcmp( directive, FTPDWELCOME )) {
  399.         strcpy( ftpdwelcome, "220-");
  400.         p = strchr( ftpdwelcome, 0 );
  401.         strncpy( p, value, sizeof( ftpdwelcome) -1 - strlen( ftpdwelcome) );
  402.         ftpdwelcome[ sizeof( ftpdwelcome ) - 1] = 0;
  403.     }
  404.     if (!strcmp( directive, FTPDPASS )) {
  405.         strncpy( ftpdpassword, value, sizeof(ftpdpassword)-1);
  406.         ftpdpassword[ sizeof(ftpdpassword) - 1] = 0;
  407.     } else if (!strcmp( directive, FTPDBUFSIZ ))
  408.         ftpdbufferlen = atoi( value );
  409.     else
  410.         if (oldinit) (*oldinit)( directive, value );
  411. }
  414. /*
  415.  * getport - reads the FTP port negotiation stuff
  416.  *         - return nonzero on success
  417.  *
  418.  */
  419. static int getport( ftpdses *f, char *text )
  420. {
  421.     byte a[6], *p;
  422.     int i;
  424.     for ( i = 0 ; (i < 6) && text ; ++i ) {
  425.         if (( p = strchr( text , ',' )) != NULL) *p++ = 0;
  426.         a[i] = atoi( text );
  427.         text = p;
  428.     }
  429.     if ( i == 6 ) {
  430.         f->hisip = intel( *(longword*)a );
  431.         f->hisport = intel16( *(word*)&a[4] );
  432.     } else {
  433.         f->hisip = 0L;          /* should be gained from his structure */
  434.         f->hisport = 0;
  435.     }
  436.     return( i == 6 );
  437. }
  440. /*
  441.  * parseftpline - called with a particular session and some data
  442.  *              - note, this baby supports multiple FTP sessions
  443.  *                by calling with different ftpdses values
  444.  */
  447. static void parseftpline( ftpdses *f, tcp_Socket *s, char *line )
  448. {
  449.     char *p, *q;
  450.     int cmdnum;
  451.     FILE* file;
  453.     /* remove blanks from line - p points to parameters */
  454.     p = strchr( line, ' ');
  455.     if ( p == NULL ) q = NULL;
  456.     else {
  457.         while ( *p == ' ') *p++ = 0;
  458.         if ((q = strchr( p, ' '))!=NULL)
  459.             while ( *q == ' ' ) *q++ = 0;
  460.     }
  462.     if (!*line) return;     /* nothing there */
  463.     for ( cmdnum = 0 ; cmdnum < ENDLIST ; ++cmdnum )
  464.         if ( !strnicmp( line, cmds[ cmdnum ], strlen( cmds[ cmdnum ] )))
  465.             break;
  467.     if ( cmdnum == ENDLIST ) {
  468.         sock_puts( s, "500 Command not understood: ");
  469.         sock_puts( s, line );
  470.         sock_puts( s, "rn");
  472.         /* check for unprivileged access */
  473.     } else if ( cmdnum > USER && f->gotpass == 0 )
  474.         sock_puts( s, "530 You are not logged in yetrn");
  476.         /* file commands need a port number */
  477.     else if ( cmdnum > PORT && ( f->hisport == 0 || f->hisip ==0L ))
  478.         sock_puts( s, "425 Sorry, need PORT command firstrn");
  480.         /* do the normal thing */
  481.     else switch( f->dcmd = cmdnum ) {
  482.         case ABOR   :
  483.             if (f->status == S_DATA ) {
  484.                 sock_abort( &f->dsocket );
  485.                 sock_puts( s, "426 Aborting at users requestrn");
  486.             } else
  487.                 sock_puts( s, "550 Abort what?rn");
  488.             break;
  490.         case QUIT   :
  491.             sock_puts( s, "221 Goodbyern");
  492.             sock_close( s );
  493.             sock_close( &f->dsocket );    /* if necessary */
  494.             tcp_tick( NULL );
  495.             f->status = S_CLOS;
  496.             break;
  498.         case USER   :
  499.             sock_puts( s, "331 Password requiredrn");
  500.             break;
  502.         case PASS   :
  503.             if ( (*ftpdpassword && *line && !strcmp( p, ftpdpassword )) || !*ftpdpassword ) {
  504.                 f->gotpass = 1;
  505.                 sock_puts( s, "230 User logged inrn");
  506.             } else {
  507.                 sock_puts( s, "530 Not quitern");
  508.                 f->gotpass = 0;
  509.             }
  510.             break;
  512.         case HELP   :
  513.             sock_puts( s, "214-HELP - list of command accepted by WATTCP FTP daemonrn");
  514.             sock_puts( s, "    ABOR  QUIT  USER  PASS  HELP  NOOP  DEL   TYPE  PORTrn");
  515.             sock_puts( s, "    LIST  NLST  SIZE  STOR  RETR  SITErn");
  516.             sock_puts( s, "    RMD   XRMD  MKD   XMKD  CWD   XCWD  PWD   XPWDrn");
  517.             sock_puts( s, "    RNFR  RNTOrn");
  518.             sock_puts( s, "214 OKrn");
  519.             break;
  521.         case RMD    :
  522.         case XRMD   :
  523.             dos_enter();
  524.             if ( rmdir( pathfile(f,p) ) == 0 )
  525.               sock_puts( s, "250 RMD workedrn");
  526.             else
  527.               sock_puts( s, "550 RMD failedrn");
  528.             dos_exit();
  529.             break;
  530.         case MKD    :
  531.         case XMKD   :
  532.             dos_enter();
  534. #if defined(__TURBOC__) || defined(__BORLANDC__)
  535.             if ( mkdir( pathfile(f,p)) == 0 )
  536. #elif defined(__DJGPP__)
  537.             /* posix needs a mode */
  538.             if ( mkdir( pathfile(f,p),0 ) == 0 )
  539. #endif
  540.               sock_puts( s, "250 MKD workedrn");
  541.             else
  542.               sock_puts( s, "550 MKD failedrn");
  543.             dos_exit();
  544.             break;
  545.         case PWD    :
  546.         case XPWD   :
  547.             // AGW 2000.6.17 added leading /
  548.             sock_puts( s, "257 "/");
  549.             // EE 2001.5.28 convert to Unix filename format
  550.             sock_puts( s, dos2unix( f->dirpath, f->ftpdbuffer ));
  551.             sock_puts( s, "" is current directory.rn");
  552.             break;
  553.         case CWD    :
  554.         case XCWD   :
  555.             if ( !changedir( f, p )) {
  556.                 sock_puts( s, "250 changed directory to ");
  557.                 sock_puts( s, dos2unix( f->dirpath, f->ftpdbuffer) );
  558.                 sock_puts( s, "rn");
  559.             } else
  560.                 sock_puts( s, "550 CWD failedrn");
  561.             break;
  563.         case DEL    :
  564.             dos_enter();
  565.             sock_puts( s, (!unlink(pathfile(f,p))) ?
  566.                 "250 File deleted - "" : "550 Not Deleted - "" );
  567.             dos_exit();
  568.             sock_puts( s, p );
  569.             sock_puts( s, ""rn");
  570.             break;
  572.         case PORT   :
  573.             if ( getport( f, p ))
  574.                 sock_puts( s, "200 Port command successfulrn");
  575.             else
  576.                 sock_puts( s, "501 Bad port commandrn");
  577.             break;
  579.         case NLST :
  580.         case LIST   :
  581.             c_op_dir( f, p );       /* start directory */
  582.             break;
  584.         case STOR   :               /* start a put */
  585.             dos_enter();
  586.             unlink( pathfile(f, p) );
  588. #if defined(__TURBOC__)||defined(__BORLANDC__)
  589.             if ( (f->dhandle =  open( pathfile(f,p), O_RDWR | O_CREAT |
  590.                 ((f->ascii) ? O_TEXT : O_BINARY) | O_DENYNONE, S_IWRITE)) == -1) {
  591. #elif defined(__DJGPP__)
  592.             if ( (f->dhandle =  open( pathfile(f,p), O_RDWR | O_CREAT |
  593.                 ((f->ascii) ? O_TEXT : O_BINARY) , S_IWRITE)) == -1) {
  594. #endif
  595.                 dos_exit();
  596.                 sock_puts( &f->socket, "550 Could not create file '");
  597.                 sock_puts( &f->socket, p );
  598.                 sock_puts( &f->socket, "'.rn");
  599.             } else {
  600.                 dos_exit();
  601.                 data_op_init( f, FTP_OP_PUT );
  602.             }
  603.             break;
  605.         case RETR   :               /* start a get */
  606.             dos_enter();
  607. #if defined(__TURBOC__)||defined(__BORLANDC__)
  608.             if ( (f->dhandle = open( pathfile(f,p), O_RDONLY ||
  609.                 ( /* (f->ascii) ? O_TEXT : */ O_BINARY))) == -1) {
  610. #elif defined(__DJGPP__)
  611.             if ( (f->dhandle = open( pathfile(f,p), O_RDONLY ||
  612.                 ( /* (f->ascii) ? O_TEXT : */ O_BINARY))) == -1) {
  613. #endif
  614.                 dos_exit();
  615.                 sock_puts( &f->socket, "550 Could not open file '");
  616.                 sock_puts( &f->socket, p );
  617.                 sock_puts( &f->socket, "' for readingrn");
  618.             } else {
  619.                 dos_exit();
  620.                 data_op_init( f, FTP_OP_GET );
  621.             }
  622.             break;
  624.         case SIZE   :
  625.             dos_enter();
  626.             file = fopen( p, "rb" );
  627.             if ( file == 0 || fseek( file, 0, SEEK_END ) != 0 ) {
  628.                 sock_puts( &f->socket, "550 Could not open file '");
  629.                 sock_puts( &f->socket, p );
  630.                 sock_puts( &f->socket, "' for readingrn");
  631.             } else {
  632.                 long int fsize = ftell(file);
  633.                 sock_puts( &f->socket, "213 " );
  634.                 ltoa( fsize, f->ftpdbuffer, 10 );
  635.                 sock_puts( &f->socket, f->ftpdbuffer );
  636.                 sock_puts( &f->socket, "n" );
  637.                 fclose( file );                
  638.             }
  639.             dos_exit();
  640.             break;
  641.             
  642.         case TYPE   :
  643.             *p = toupper( *p );
  644.             if ( *p == 'B' || *p == 'I' ) f->ascii = 0;
  645.             else if ( *p == 'A' ) f->ascii = 1;
  646.             else if ( *p == 'L' && *q == '8' ) f->ascii = 0;
  647.             else {
  648.                 sock_puts( s, "550 Type not understoodrn");
  649.                 p = NULL;
  650.             }
  651.             if (p)
  652.                 sock_puts( s, (f->ascii)? "200 ASCII modern":"200 Binary modern");
  653.             break;
  654.         case NOOP  :
  655.             sock_puts( s, "200 NOOPrn");
  656.             break;
  657.         case SITE :
  658.             if ( !strnicmp( p, "HALT", 4 )) {
  659.                 sock_puts( s, "221 Goodbye! Halting servicern");
  660.                 sock_close( s );
  661.                 sock_close( &f->dsocket );  /* if necessary */
  662.                 f->status = S_HALT;
  663.             } else {
  664.                 sock_puts( s, "500 command not understood 'SITE ");
  665.                 sock_puts( s, p );
  666.                 sock_puts( s, "'rn");
  667.             }
  668.             break;
  669.         case RNFR :  // Rename file from ...
  670.             pathfile( f, p ); // remember name and path in f->filepath
  671.             sock_puts( &f->socket, "350 File name pendingrn");
  672.             break;
  673.         case RNTO :  // Rename file to ...
  674.             {
  675.                 char *from_name = kstrdup( f->filepath );
  676.                 int err;
  677.                 dos_enter();
  678.                 err = rename( from_name, pathfile(f,p));
  679.                 dos_exit();
  680.                 kfree( from_name );
  681.                 if ( err )
  682.                     sock_puts( &f->socket, "550 File rename failedrn");
  683.                 else
  684.                     sock_puts( &f->socket, "250 File rename okrn");
  685.                 break;
  686.             }
  687.     }
  688. }
  690. /*
  691.  * ftpd_alt_tick - processes data when we are doing something and not
  692.  *                 awaiting user input
  693.  */
  694. static void ftpd_alt_tick( ftpdses *f)
  695. {
  696.     tcp_Socket *t;
  697.     int len, wlen;
  699.     t = &f->dsocket;
  701.     switch ( f->dstatus ) {
  702.         case S_INIT :
  703.                 tcp_open( t, FTPDPORT-1, f->hisip, f->hisport, NULL );
  704.                 f->dstatus = S_WAIT;
  706.         case S_WAIT :
  707.                 if ( sock_established( t )) f->dstatus = S_CONN;
  708.                 break;
  710.         case S_CONN :
  711.                 switch ( f->doperation ) {
  713.                     case FTP_OP_DIR :   /* directory operation */
  714.                             while ( sock_tbleft( t ) > 80 ) {
  715.                                 if( f->dcmd == NLST ) {
  716.                                     sock_puts( t, f->ffblk.ff_name );
  717.                                     sock_puts( t, "n" );
  718.                                 } else {
  719.                                     dos_enter();
  720.                                     dirformblock( &f->ffblk, f->ftpdbuffer );
  721.                                     dos_exit();
  722.                                     sock_puts( t, f->ftpdbuffer );
  723.                                 }
  724.                                 dos_enter();
  725.                                 if ( findnext( &f->ffblk ))
  726.                                     f->doperation = FTP_OP_DON;
  727.                                 dos_exit();
  728.                                 break;
  729.                             }
  730.                             break;
  732.                     case FTP_OP_PUT :   /* part of put */
  733.                             if ( (len = sock_fastread( t, f->ftpdbuffer, ftpdbufferlen)) > 0 ) {
  734.                                 dos_enter();
  735.                                 wlen = write( f->dhandle, f->ftpdbuffer, len );
  736.                                 dos_exit();
  737.                                 if (wlen < len || wlen == -1 ) {
  738.                                     f->doperation = FTP_OP_DON;
  739.                                     f->errmsg = "550 Error incurred while writing filern";
  740.                                 }
  741.                             }
  742.                             break;
  744.                     case FTP_OP_GET : data_op_get(f,t); break;
  746.                     case FTP_OP_DON : /* close socket .... */
  747.                             sock_close( t );
  748.                             dos_enter();
  749.                             if (f->dhandle) close( f->dhandle );
  750.                             dos_exit();
  751.                             f->dhandle = 0;
  752.                             sock_puts( &f->socket, f->errmsg );
  753.                             f->doperation = FTP_OP_NOP;
  754.                             break;
  756.                     case FTP_OP_NOP : break;
  757.                 }
  758.                 if (!tcp_tick( t )) {
  759.                     if ( f->doperation < FTP_OP_DON )
  760.                         f->doperation = FTP_OP_DON;
  761.                     else {
  762.                         sock_close( t );
  763.                         f->status = S_CONN;
  764.                         f->dstatus = S_INIT;
  765.                     }
  766.                 }
  767.                 break;
  768.     }
  769. }
  773. /*
  774.  * ftpd_tick - call this whenever you have a free moment
  775.  *           - modify this routine to use several ftpdses
  776.  *             structures if you wish
  777.  */
  778. void ftpd_tick( ftpdses *ftpd )
  779. {
  780.     tcp_Socket *t;
  781.     char *temp;
  783.     t = &ftpd->socket;
  785.     switch ( ftpd->status ) {
  786.         case S_INIT :   /* welcome */
  787.                         sock_abort( t );
  788.                         sock_abort( &ftpd->dsocket );
  789.                         /* save ftpdbuf */
  790.                         temp = ftpd->ftpdbuffer;
  791.                         memset( ftpd, 0, sizeof( ftpdses ));
  792.                         ftpd->ftpdbuffer = temp;
  793.                         ftpd->ascii = 0;
  794.                         tcp_listen( t, FTPDPORT, 0L, 0, NULL, 0 );
  795.                         ftpd->status = S_WAIT;
  796.                         break;
  797.         case S_WAIT :   if ( sock_established( t )) {
  798.                             sock_puts(t,"220-FTP Serverrn");
  799.                             if (*ftpdwelcome) {
  800.                                 sock_puts(t,ftpdwelcome);
  801. sock_puts(t,"rn");
  802.                             }
  803.                             sock_puts(t,"220 Loginrn");
  804.                             ftpd->status = S_CONN;
  805.                             sock_mode( t, TCP_MODE_ASCII );
  806.                         }
  807.                         if ( !tcp_tick( t ))
  808.                             ftpd->status = S_CONN;
  810.                         break;
  811.         case S_DATA :   sock_mode( t, TCP_MODE_BINARY );
  812.                         ftpd_alt_tick( ftpd );
  813.                         sock_mode( t, TCP_MODE_ASCII );
  814.                         /* fall through */
  815.                         if ( !tcp_tick( t )) {
  816.                             sock_abort( t );
  817.                             sock_abort( &ftpd->dsocket );
  818.                             ftpd->status = S_CLOS;
  819.                         }
  821. case S_CONN :   if ( sock_dataready( t )) {
  822.                             sock_gets( t, ftpd->ftpdbuffer, ftpdbufferlen);
  823.                             sock_mode( t, TCP_MODE_BINARY );
  824.                             parseftpline( ftpd, t, ftpd->ftpdbuffer );
  825.                             sock_mode( t, TCP_MODE_ASCII );
  826.                         }
  827. if (!tcp_tick( t )) {
  828.                             sock_close( t );
  829.                             ftpd->status = S_CLOS;
  830.                         }
  831.                         break;
  832.         case S_CLOS :   if ( !tcp_tick( t ) ) {
  833.                             ftpd->status = S_INIT;
  834.                             sock_close( t );
  835.                         }
  836.                         break;
  837.         case S_HALT :   break;
  838.     }
  839. }
  841. #ifdef __DJGPP__
  842. __attribute__((constructor))
  843. #endif
  845. static void ftpd_init()
  846. {
  847.     *ftpdpassword = 0;
  848.     *ftpdwelcome = 0;
  850. #if defined(__TURBOC__)||defined(__BORLANDC__)
  851.     oldinit = usr_init;
  852.     usr_init = newinit;
  853. #elif defined(__DJGPP__)
  854.     oldinit = _w32_usr_init;
  855.     _w32_usr_init = newinit;
  856. #endif
  857. }
  859. #pragma startup ftpd_init 100
  861. void ftpdthread( DWORD x )
  862. {
  863.     ftpdses *ftpd;
  865.     if (ftpdbufferlen < FTPD_BUF_MIN ) ftpdbufferlen = FTPD_BUF_MIN;
  867.     if ((ftpd = kcalloc( sizeof( ftpdses ), 1 )) == NULL )
  868.         rt_halt("allocating memory");
  870.     ftpd->status = S_INIT;
  872.     if ((ftpd->ftpdbuffer = kcalloc( 1, ftpdbufferlen)) == NULL )
  873.         rt_halt("allocating buffers");
  875. #if defined(__TURBOC__) || defined(__BORLANDC__)
  876.     handlerrs( 1 );
  877. #endif
  879.     if ( *ftpdpassword == 0 )
  880.         puts("WARNING: ftpd.password is not set in config file, any password will matchrn");
  882.     while (1) {
  883.         ftpd_tick( ftpd );
  885.         /* improve response only while doing real stuff */
  886.         if ( ftpd->status == S_HALT ) break;
  887.         else if ( ftpd->status == S_DATA ) rt_sleep(0);
  888.         else rt_sleep( 100 );
  889.     }
  891.     /* if SITE was used to halt us */
  892.     while ( tcp_tick( &ftpd->socket )) rt_sleep( 100 );
  893.     kfree( ftpd->ftpdbuffer );
  894.     kfree( ftpd );
  895. #if defined(__TURBOC__) || defined(__BORLANDC__)
  896.     handlerrs( 0 );
  897. #endif
  898. }