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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
ftpd.c
资源名称：troll-ftpd-1.24.tar.gz　[点击查看]
上传用户：lukesailor
上传日期：2007-01-04
资源大小：27k
文件大小：41k
源码类别：

Ftp客户端

开发平台：

Unix_Linux

ftpd.c：源码内容
  1. /* $Id: ftpd.c,v 1.73 1999/02/13 15:23:41 agulbra Exp $ */
  3. #define _GNU_SOURCE
  5. #include <time.h>
  6. #include <stdio.h>
  7. #include <stdlib.h>
  8. #include <stdarg.h>
  9. #include <unistd.h>
  10. #include <signal.h>
  11. #include <ctype.h>
  12. #include <sys/time.h>
  13. #include <errno.h>
  14. #include <string.h>
  15. #include <sys/types.h>
  16. #include <sys/socket.h>
  17. #include <netinet/in.h>
  18. #include <netinet/ip.h>
  19. #include <sys/stat.h>
  20. #include <fcntl.h>
  21. #include <sys/mman.h>
  22. #include <sys/param.h>
  23. #include <sys/ioctl.h>
  24. #include <pwd.h>
  25. #include <grp.h>
  26. #include <arpa/inet.h>
  27. #include <netdb.h>
  28. #include <sys/resource.h>
  29. #include <sys/vfs.h>
  30. #ifndef _GNU_SOURCE
  31. #define _GNU_SOURCE /* for GLOB_ABEND in newer glibcs */
  32. #endif
  33. #include <glob.h>
  35. #if defined(GLOB_ABORTED) && !defined(GLOB_ABEND)
  36. #define GLOB_ABEND GLOB_ABORTED
  37. #endif
  39. #define SYSLOG_NAMES /* for -f */
  40. #include <syslog.h>
  42. #ifdef USE_SHADOW
  43. #include <shadow.h>
  44. #endif
  46. #include "ftpd.h"
  48. #if PATH_MAX < 1024
  49. #error "troll-ftpd requres that PATH_MAX be at least 1024"
  50. #endif
  52. /* include files, *sigh* */
  53. int wildmat( const char *, const char * );
  55. /* then mine */
  56. int sfgets( void );
  57. void *aborttransfer( int );
  58. void parser( void );
  59. void dobanner( void );
  60. void douser( const char *name );
  61. void dopass( const char *password );
  62. void docwd( const char *dir );
  63. void doretr( const char *name );
  64. void dorest (const char *name );
  65. void dodele( const char *name );
  66. void dostor( const char *name );
  67. void domkd( const char *name );
  68. void dormd( const char *name );
  69. void domdtm( const char *name );
  70. void dosize( const char *name );
  71. void doport( unsigned int ip, unsigned int port );
  72. void dopasv( void );
  73. void error( int n, const char *msg );
  75. void domode( const char *arg );
  76. void dostru( const char *arg );
  77. void dotype( const char *arg );
  78. void dornfr( const char *name );
  79. void dornto( const char *name );
  81. jmp_buf appropriately;
  83. int logging = 0;
  85. void sighandler( int sig )
  86. {
  87.     if ( sig == SIGUSR1 && logging < 2 )
  88. logging++;
  89.     else if ( sig == SIGUSR2 && logging > 0 )
  90. logging--;
  91. }
  93. const int window = 51200; /* window size */
  95. unsigned int downloaded = 0; /* bytes downloaded */
  96. unsigned int uploaded = 0; /* bytes uploaded */
  98. int passive;
  99. int datafd = 0; /* data connection file descriptor */
  100. struct sockaddr_in ctrlconn; /* stdin/stdout, for using the same ip number */
  102. const int cmdsize = PATH_MAX + 32;
  103. char cmd[PATH_MAX + 32]; /* command line - about 30 chars for command */
  104. char wd[PATH_MAX + 1]; /* current working directory */
  105. char *rd = NULL; /* root directory, for chroot'd environments */
  106. char * cpwd = NULL; /* crypted password of the user one logs in as */
  107. int loggedin = 0;
  108. char account[9];
  109. char * renamefrom = 0;
  111. int warez = 0; /* don't guard against warez */
  112. int debug = 0; /* don't give debug output */
  113. int guest = 0; /* if non-zero, it's a guest user */
  114. uid_t useruid = 0; /* smallest uid which can ftp */
  115. int candownload = 0; /* if non-zero, don't let the user download */
  116. double load; /* for reporting what the load was */
  118. int firstport = 0; /* first and last ports to use, if we're */
  119. int lastport = 0; /* packet filter friendly. */
  121. int type = 1; /* type - 0 = error, 1 = ascii, 2 = binary */
  123. int restartat;
  124. unsigned long int idletime = 1800;
  126. struct reply {
  127.     struct reply *prev;
  128.     char line[1];
  129. };
  131. struct reply *lastreply = 0;
  132. int replycode = 0;
  134. struct sockaddr_in peer;
  135. unsigned short int peerdataport;
  137. void addreply( int code, const char *line,... )
  138. {
  139.     struct reply *p;
  140.     struct reply *q;
  141.     char buf[PATH_MAX + 50];
  142.     va_list ap;
  143.     int offs;
  145.     if ( code )
  146. replycode = code;
  147.     q = NULL;
  149.     va_start( ap, line );
  150.     vsnprintf( buf, PATH_MAX + 50, line, ap );
  151.     va_end( ap );
  153.     offs = strlen( buf );
  154.     while ( offs-- && isspace( buf[offs] ) )
  155. buf[offs] = '';
  156.     if ( !offs && buf[0] )
  157. offs++;
  158.     while ( offs ) {
  159. while ( offs && buf[offs] != 'n' && isspace( buf[offs] ) )
  160.     buf[offs--] = '';
  161. while ( offs && buf[offs] != 'n' )
  162.     offs--;
  163. if ( offs )
  164.     offs++;
  165. p = (struct reply *)malloc( sizeof(struct reply) + strlen(buf+offs) );
  167. if ( !p ) {
  168.     printf( "421 Out of memoryrn" );
  169.     fflush( stdout );
  170.     syslog( LOG_ERR, "out of memory" );
  171.     exit( 6 );
  172. }
  173. strcpy( p->line, buf + offs );
  174. if ( q ) {
  175.     p->prev = q->prev;
  176.     q->prev = p;
  177. } else {
  178.     p->prev = lastreply;
  179.     lastreply = p;
  180. }
  181. q = p;
  182. if ( offs )
  183.     buf[--offs] = 'r';
  184.     }
  185. }
  189. void replycont( struct reply * ); /* ick */
  190. void replycont( struct reply *p )
  191. {
  192.     if ( p ) {
  193. replycont( p->prev );
  194. printf( "%3d-%srn", replycode, p->line );
  195. if ( logging > 1 )
  196.     syslog( LOG_DEBUG,  "%3d-%sn", replycode, p->line );
  197. free( (char * ) p );
  198.     }
  199. }
  202. void doreply( void )
  203. {
  204.     if ( lastreply ) {
  205. replycont( lastreply->prev );
  206. printf( "%3d %srn", replycode, lastreply->line );
  207. if ( logging > 1 )
  208.     syslog( LOG_DEBUG,  "%3d %sn", replycode, lastreply->line );
  209. free( (char * ) lastreply );
  210. lastreply = NULL;
  211. fflush( stdout );
  212.     }
  213. }
  217. /* this is dog-slow.  but now it's 100% in compliance with the protocol. */
  219. int sfgets( void )
  220. {
  221.     int l;
  222.     int nread;
  223.     fd_set rs;
  224.     struct timeval tv;
  226.     FD_ZERO( &rs );
  227.     tv.tv_sec = idletime;
  228.     tv.tv_usec = 0;
  229.     nread = 0;
  230.     l = 0;
  231.     do {
  232. if ( nread == 0 ) {
  233.     FD_SET( 0, &rs );
  234.     select( 1, &rs, NULL, NULL, &tv );
  235.     if ( ioctl( 0, FIONREAD, &nread ) < 0 )
  236. nread = 0;
  237. }
  238. if ( FD_ISSET( 0, &rs ) ) {
  239.     int i;
  240.     i = read( 0, cmd+l, 1 );
  241.     if ( i == 0 ) {
  242. syslog( LOG_INFO, "exiting due to EOF from client" );
  243. exit( 21 );
  244.     } else if ( i < 0 ) {
  245. syslog( LOG_INFO,
  246. "exiting due to read error from client: %m" );
  247. exit( 22 );
  248.     }
  249.     if ( nread )
  250. nread--;
  251.     if ( cmd[l] == 'n' ) {
  252. /* if you need to debug ftpd, you can (e.g.) connect
  253.                    to it using an ordinary client, connect to the
  254.                    process using gdb or another ptrace()-aware
  255.                    debugger, and set a breakpoint on the next
  256.                    line. ftpd will hit the breakpoint immediately
  257.                    after the next command or whever the timeout hits. */
  258. cmd[l+1] = '';
  259. return 1;
  260.     }
  261.     if ( l < cmdsize - 2 )
  262. l++;
  263. } else {
  264.     return 0;
  265. }
  266.     } while( 1 );
  267. }
  270. void parser( void )
  271. {
  272.     char *arg;
  273.     int n;
  275.     while ( 1 ) {
  276. doreply();
  278. if ( !sfgets() ) {
  279.     addreply( 421,
  280.       "Timeout - try typing a little faster next time." );
  281.     syslog( LOG_INFO, "exiting due to timeout (idle time %d)",
  282.     idletime );
  283.     return;
  284. }
  285. if ( debug )
  286.     addreply( 0, "%s", cmd );
  288. n = 0;
  289. while ( isalpha( cmd[n] ) && n < cmdsize ) {
  290.     cmd[n] = tolower( cmd[n] );
  291.     n++;
  292. }
  294. if ( n >= cmdsize ) {
  295.     addreply( 421,
  296.       "Command line maximum length exceeded." );
  297.     syslog( LOG_INFO, "found line over 1000 characters" );
  298.     return;
  299. }
  300. if ( !n ) {
  301.     addreply( 221,
  302.       "Goodbye.  You uploaded %d and downloaded %d kbytes.",
  303.       (uploaded+1023)/1024, (downloaded+1023)/1024 );
  304.     continue;
  305. }
  306. while ( isspace( cmd[n] ) && n < cmdsize )
  307.     cmd[n++] = '';
  309. arg = cmd + n;
  311. while ( cmd[n] && n < cmdsize )
  312.     n++;
  313. n--;
  315. while ( isspace( cmd[n] ) )
  316.     cmd[n--] = '';
  318. if ( logging )
  319.     syslog( LOG_DEBUG, "command %s %s",
  320.     cmd, strcasecmp( cmd, "pass" ) ? arg : "<password>" );
  322. if ( !strcasecmp( cmd, "user" ) ) {
  323.     douser( arg );
  324. } else if ( !strcasecmp( cmd, "pass" ) ) {
  325.     dopass( arg );
  326. } else if ( !strcasecmp( cmd, "quit" ) ) {
  327.     addreply( 221,
  328.       "Goodbye.  You uploaded %d and downloaded %d kbytes.",
  329.       (uploaded+1023)/1024, (downloaded+1023)/1024 );
  330.     return;
  331. } else if ( !strcasecmp( cmd, "noop" ) ) {
  332.     addreply( 200, "NOOP command successful" );
  333. } else if ( !strcasecmp( cmd, "syst" ) ) {
  334.     printf( "215 UNIX Type: L8rn" );
  335.     fflush( stdout );
  336. } else if ( !strcasecmp( cmd, "port" ) ) {
  337.     /* don't auto-login for PORT or PASV, but do auto-login
  338.        for the command which _uses_ the data connection */
  339.     unsigned int a1, a2, a3, a4, p1, p2;
  340.     if ( arg &&
  341.  6 == sscanf( arg, "%d,%d,%d,%d,%d,%d",
  342.       &a1, &a2, &a3, &a4, &p1, &p2 ) &&
  343.  a1 < 256 && a2 < 256 && a3 < 256 && a4 < 256 &&
  344.  p1 < 256 && p2 < 256 ) {
  345. doport( (a1 << 24) + (a2 << 16) + (a3 << 8) + a4,
  346. ( (p1 << 8 ) + p2 ) );
  347.     } else {
  348. addreply( 501, "Syntax error." );
  349.     }
  350. } else if ( !strcasecmp( cmd, "pasv" ) ) {
  351.     dopasv();
  352. } else if ( !strcasecmp( cmd, "pwd" ) ||
  353.     !strcasecmp( cmd, "xpwd" ) ) {
  354.     if ( loggedin )
  355. addreply( 257, ""%s"rn", wd );
  356.     else
  357. addreply( 550, "Not logged in" );
  358. } else if( !strcasecmp( cmd, "auth" ) ) {
  359.     /* RFC 2228 Page 5 Authentication/Security mechanism (AUTH) */
  360.     addreply( 502, "Security extensions not implemented" );
  361. } else {
  362.     /* from this point, all commands trigger an automatic login */
  363.     douser( NULL );
  365.     if ( !strcasecmp( cmd, "cwd" ) ) {
  366. docwd( arg );
  367.     } else if ( !strcasecmp( cmd, "cdup" ) ) {
  368. docwd( ".." );
  369.     } else if ( !strcasecmp( cmd, "retr" ) ) {
  370. if ( arg && *arg )
  371.     doretr( arg );
  372. else
  373.     printf( "501 No file namern" );
  374.     } else if ( !strcasecmp( cmd, "rest" ) ) {
  375. if (arg && *arg)
  376.     dorest(arg);
  377. else
  378.     addreply (501, "No restart point");
  379.     } else if ( !strcasecmp( cmd, "dele" ) ) {
  380. if ( arg && *arg )
  381.     dodele( arg );
  382. else
  383.     addreply( 501, "No file namern" );
  384.     } else if ( !strcasecmp( cmd, "stor" ) ) {
  385. if ( arg && *arg )
  386.     dostor( arg );
  387. else
  388.     addreply( 501, "No file name." );
  389.     } else if ( !strcasecmp( cmd, "mkd" ) ||
  390. !strcasecmp( cmd, "xmkd" ) ) {
  391. if ( arg && *arg )
  392.     domkd( arg );
  393. else
  394.     addreply( 501, "No directory name." );
  395.     } else if ( !strcasecmp( cmd, "rmd" ) ||
  396. !strcasecmp( cmd, "xrmd" ) ) {
  397. if ( arg && *arg )
  398.     dormd( arg );
  399. else
  400.     addreply( 550, "No directory name." );
  401.     } else if ( !strcasecmp( cmd, "list" ) ) {
  402. opt_l = 1;
  403. donlist( (arg && *arg ) ? arg :  "" );
  404.     } else if ( !strcasecmp( cmd, "nlst" ) ) {
  405. opt_l = 0;
  406. donlist( (arg && *arg ) ? arg :  "" );
  407.     } else if ( !strcasecmp( cmd, "type" ) ) {
  408. dotype( arg );
  409.     } else if ( !strcasecmp( cmd, "mode" ) ) {
  410. domode( arg );
  411.     } else if ( !strcasecmp( cmd, "stru" ) ) {
  412. dostru( arg );
  413.     } else if ( !strcasecmp( cmd, "abor" ) ) {
  414. addreply( 226, "Since you see this ABOR must've succeeded." );
  415.     } else if ( !strcasecmp( cmd, "site" ) ) {
  416. char *sitearg;
  418. sitearg = arg;
  419. while ( sitearg && *sitearg && !isspace( *sitearg ) )
  420.     sitearg++;
  421. if ( sitearg )
  422.     *sitearg++ = '';
  424. if ( !strcasecmp( arg, "idle" ) ) {
  425.     if ( !*sitearg ) {
  426. addreply( 501, "SITE IDLE: need argument" );
  427.     } else {
  428. unsigned long int i = 0;
  430. i = strtoul( sitearg, &sitearg, 10 );
  431. if ( sitearg && *sitearg )
  432.     addreply( 501, "Garbage ( %s ) after value ( %d )",
  433.       sitearg, i );
  434. else if ( i > 7200 )
  435.     addreply( 501, "Too large ( >7200 seconds )" );
  436. else
  437.     addreply( 200, "Idle time set to %u seconds",
  438.       ( idletime = i ) );
  439.     }
  440. } else if ( arg && *arg ) {
  441.     addreply( 500, "SITE %s unknown", arg );
  442. } else {
  443.     addreply( 500, "SITE: argument needed" );
  444. }
  445.     } else if ( !strcasecmp( cmd, "xdbg" ) ) {
  446. debug++;
  447. addreply( 200,
  448.   "XDBG command succeeded, debug level is now %d.",
  449.   debug );
  450.     } else if ( !strcasecmp( cmd, "mdtm" ) ) {
  451. domdtm( (arg && *arg ) ? arg : "" );
  452.     } else if ( !strcasecmp( cmd, "size" ) ) {
  453. dosize( (arg && *arg ) ? arg : "" );
  454.     } else if ( !strcasecmp( cmd, "rnfr" ) ) {
  455. if ( arg && *arg )
  456.     dornfr( arg );
  457. else
  458.     addreply( 550, "No file name given." );
  459.     } else if ( !strcasecmp( cmd, "rnto" ) ) {
  460. if ( arg && *arg )
  461.     dornto( arg );
  462. else
  463.     addreply( 550, "No file name given." );
  464.     } else {
  465. addreply( 500, "Unknown command." );
  466.     }
  467. }
  468.     }
  469. }
  472. /* small help routine to display a banner */
  473. void dobanner( void )
  474. {
  475.     int m;
  476.     FILE *msg;
  478.     m = 0;
  479.     if ( (msg = fopen( ".banner", "r" ) ) != NULL ) {
  480. /* if you think this is too small, send me mail.  NOTE: It should
  481.    not be unlimited.  Take a look at e.g. ftp.3com.com to see why:
  482.    at the time of writing the logon banner is 250-odd lines */
  483. char buffer[1025];
  484. int len = fread( (void * ) buffer, 1, 1024, msg );
  486. fclose( msg );
  487. if ( len > 0 && len < 1024 ) {
  488.     buffer[len] = '';
  489.     addreply( 0, "%s", buffer );
  490. }
  491.     }
  492. }
  496. void douser( const char *username )
  497. {
  498.     struct passwd *pw;
  500.     if ( loggedin ) {
  501. if ( username ) {
  502.     if ( guest )
  503. addreply( 230, "Anonymous user logged in, no "
  504.   "need for a password." );
  505.     else
  506. addreply( 530, "You're already logged in." );
  507. }
  508. return;
  509.     }
  510.     if ( username &&
  511.  strcasecmp( username, "ftp" ) &&
  512.  strcasecmp( username, "anonymous" ) ) {
  513. char *shell;
  515. if ( cpwd ) {
  516.     free( (void*) cpwd );
  517.     cpwd = NULL;
  518. }
  520. pw = getpwnam( username );
  522. setusershell();
  523. while ( (shell = getusershell() ) != NULL &&
  524. pw && strcmp( pw->pw_shell, shell ) ) ;
  525. endusershell();
  527. if ( shell && pw &&
  528.      ( pw->pw_uid >= useruid ) &&
  529.      chdir( pw->pw_dir ) == 0 ) {
  530. #ifdef USE_SHADOW
  531.     struct spwd *spw;
  533.     if ( !strcmp(pw->pw_passwd, "x") &&
  534.  (spw = getspnam( username ) ) )
  535. cpwd = strdup( spw->sp_pwdp[0] == '@' ? "*" : spw->sp_pwdp );
  536.     else
  537. #endif
  538. cpwd = strdup( pw->pw_passwd );
  539.     setfsuid( pw->pw_uid );
  540.     setregid( pw->pw_gid, pw->pw_gid );
  541.     setgroups( sizeof( pw->pw_gid ), &( pw->pw_gid ) );
  542.     initgroups( pw->pw_name, pw->pw_gid );
  543. } else {
  544.     cpwd = strdup("*");
  545. }
  546. strncpy( account, username, 8 );
  547. account[8] = '';
  548. addreply( 331, "User %s OK.  Password required.", account );
  549. loggedin = 0;
  550.     } else {
  551. if ( (pw = getpwnam( "ftp" ) ) == NULL ||
  552.      pw->pw_uid == 0 || pw->pw_gid == 0 ||
  553.      setregid( pw->pw_gid, pw->pw_gid ) ||
  554.      setgroups( sizeof( pw->pw_gid ), &( pw->pw_gid ) ) ||
  555.      chroot( pw->pw_dir ) ||
  556.      !( rd = strdup( pw->pw_dir ) ) ||
  557.      chdir( "/" ) ) {
  558.     syslog( LOG_ERR, "unable to set up secure anonymous FTP" );
  559.     printf( "421 can't set up secure anonymous FTP, abortingrn" );
  560.     fflush( stdout );
  561.     sleep( 1 );
  562.     exit( 4 );
  563. }
  564. setfsuid( pw->pw_uid );
  565. dobanner();
  566. /* the 230 will be overwritten if this is an implicit login */
  567. addreply( 230, "Anonymous user logged in." );
  568. strcpy( account, "ftp" );
  569. rd = strdup( pw->pw_dir );
  570. loggedin = guest = 1;
  571. syslog( LOG_INFO, "guest logged in" );
  572.     }
  573.     (void)getcwd( wd, PATH_MAX );
  574. }
  578. void dopass( const char *password )
  579. {
  580.     if ( loggedin ||
  581.  ( cpwd && !strcmp( cpwd, (const char *)crypt( password, cpwd ) ) ) ) {
  582. gid_t g[NGROUPS_MAX];
  583. int ngroups;
  585. /* note that the password stays around for a short while, so
  586.  root is able to find out what the user's password is */
  588. if ( !loggedin )
  589.     candownload = 1; /* real users can always download */
  591. ngroups = getgroups( NGROUPS_MAX, g );
  592. if ( ngroups > 0 ) {
  593.     char reply[80];
  594.     int p;
  595.     char *q;
  597.     sprintf( reply, "User %s has group access to:", account );
  598.     p = strlen( reply );
  599.     do {
  600. ngroups--;
  601. q = getgroup( g[ngroups] );
  602. if ( p + strlen(q) > 75 ) {
  603.     reply[p] = '';
  604.     addreply( 0, "%s", reply );
  605.     *reply = '';
  606.     p = 0;
  607. }
  608. reply[p++] = ' ';
  609. while ( q && *q && !isspace( *q ) )
  610.     reply[p++] = *q++;
  611.     } while ( ngroups > 0 );
  612.     reply[p] = '';
  613.     addreply( 0, "%s", reply );
  614. }
  615. addreply( 230, "OK.  Current directory is %s", wd );
  616. syslog( LOG_INFO, "%s logged in", account );
  617. loggedin = 1;
  618.     } else {
  619. addreply( 530, "Sorry" );
  620.     }
  621. }
  624. void docwd( const char *dir )
  625. {
  626.     char buffer[PATH_MAX + 256]; /* let's hope... */
  628.     if ( loggedin && !guest && dir && *dir == '~' ) {
  629. struct passwd *pw;
  630. int i;
  631. const char *p;
  633. i = 0;
  634. p = dir;
  635. p++;
  636. while ( *p && *p != '/' )
  637.     buffer[i++] = *p++;
  638. buffer[i] = '';
  640. if ( (pw = getpwnam( i ? buffer : account ) ) )
  641.     snprintf( buffer, PATH_MAX+255, "%s%s", pw->pw_dir, p );
  642. else
  643.     *buffer = '';
  644.     } else {
  645. *buffer = '';
  646.     }
  648.     if ( chdir( *buffer ? buffer : ( dir && *dir ? dir :  "/" ) ) ) {
  649. snprintf( buffer, PATH_MAX+255, "Can't change directory to %s: %s",
  650.   dir, strerror( errno ) );
  651. syslog( LOG_INFO, "%s", buffer );
  652. addreply( 530, "%s", buffer );
  653.     } else {
  654. int m;
  655. FILE *msg;
  657. m = 0;
  658. if ( (msg = fopen( ".message", "r" ) ) != NULL ) {
  659.     int len = fread( (void *)buffer, 1, 1024, msg );
  660.     fclose( msg );
  661.     if ( len > 0 && len < 1024 ) {
  662. buffer[len] = '';
  663. addreply( 0, "%s", buffer );
  664.     }
  665. }
  666. if ( !getcwd( wd, PATH_MAX ) ) {
  667.     if ( *dir == '/' ) {
  668. snprintf( wd, PATH_MAX, "%s", dir ); /* already checked */
  669.     } else {
  670. if ( snprintf( wd, PATH_MAX, "%s/%s", wd, dir ) < 0 ) {
  671.     printf( "421 Path too longrn" );
  672.     fflush( stdout );
  673.     syslog( LOG_ERR, "path too long" );
  674.     exit( 14 );
  675. }
  676.     }
  677. }
  678. addreply( 250, "Changed to %s", wd );
  679.     }
  680. }
  682. void dopasv( void )
  683. {
  684.     unsigned int fodder;
  685.     unsigned int a;
  686.     unsigned int p;
  687.     unsigned int on;
  688.     struct sockaddr_in dataconn; /* my data connection endpoint */
  689.     int firstporttried;
  691.     if ( datafd ) { /* for buggy clients */
  692. close( datafd );
  693. datafd = 0;
  694.     }
  696.     datafd = socket( AF_INET, SOCK_STREAM, 0 );
  697.     if ( datafd < 0 ) {
  698. error( 425, "Can't open passive connection" );
  699. datafd = 0;
  700. return;
  701.     }
  702.     on = 1;
  703.     if ( setsockopt( datafd, SOL_SOCKET, SO_REUSEADDR,
  704.      &on, sizeof(on) ) < 0 ) {
  705. error( 421, "setsockopt" );
  706. return;
  707.     }
  709.     dataconn = ctrlconn;
  710.     if ( firstport && lastport )
  711. firstporttried = firstport + ( getpid() % (lastport-firstport+1) );
  712.     else
  713. firstporttried = 0;
  715.     p = firstporttried;;
  716.     dataconn.sin_port = ntohs( p );
  717.     while ( bind( datafd,
  718.   (struct sockaddr *)&dataconn, sizeof(dataconn) ) < 0 ) {
  719. if ( firstporttried ) {
  720.     p--;
  721.     if ( p < firstport )
  722. p = lastport;
  723. }
  724. if ( firstporttried == 0 || firstporttried == p ) {
  725.     if ( firstporttried )
  726. addreply( 0, "TCP ports %d to %d inclusive are all busy",
  727.   firstport, lastport );
  728.     error( 425, "Can't bind to socket" );
  729.     close( datafd );
  730.     datafd = 0;
  731.     return;
  732. }
  733. dataconn.sin_port = ntohs( p );
  734.     }
  735.     (void)listen( datafd, 1 ); /* maybe 0 on some unices? */
  737.     fodder = sizeof( dataconn );
  738.     if ( getsockname( datafd, (struct sockaddr *)&dataconn, &fodder ) < 0 ) {
  739. error( 425, "Can't getsockname( dataconn )" );
  740. close( datafd );
  741. datafd = 0;
  742. return;
  743.     }
  744.     a = ntohl( dataconn.sin_addr.s_addr );
  745.     p = ntohs( (unsigned short int ) ( dataconn.sin_port ) );
  746.     addreply( 227, "Passive mode OK (%d,%d,%d,%d,%d,%d)",
  747.       (a >> 24) & 255, (a >> 16) & 255, (a >> 8) & 255, a & 255,
  748.       (p >> 8) & 255, p & 255 );
  749.     passive = 1;
  750.     return;
  751. }
  754. void doport( unsigned int a, unsigned int p )
  755. {
  756.     struct sockaddr_in dataconn; /* his endpoint */
  757.     int on;
  759.     if ( datafd ) { /* for buggy clients saying PORT over and over */
  760. close( datafd );
  761. datafd = 0;
  762.     }
  764.     datafd = socket( AF_INET, SOCK_STREAM, 0 );
  765.     if ( datafd < 0 ) {
  766. error( 425, "Can't make data socket" );
  767. datafd = 0;
  768. return;
  769.     }
  770.     on = 1;
  771.     if ( setsockopt( datafd, SOL_SOCKET, SO_REUSEADDR,
  772.      &on, sizeof(on) ) < 0 ) {
  773. error( 421, "setsockopt" );
  774. return;
  775.     }
  776.     dataconn = ctrlconn;
  777.     dataconn.sin_port = htons( (short ) 20 ); /* FTP data connection port */
  778.     if ( bind( datafd, (struct sockaddr *)&dataconn, sizeof(dataconn) ) < 0 ) {
  779. error( -220, "bind" );
  780. close( datafd );
  781. datafd = 0;
  782. return;
  783.     }
  785.     if ( debug )
  786. addreply( 0, "My data connection endpoint is %s:%d",
  787.   inet_ntoa( *(struct in_addr *)&dataconn.sin_addr.s_addr ),
  788.   ntohs( dataconn.sin_port ) );
  790.     peerdataport = p;
  792.     if ( htonl( a ) != peer.sin_addr.s_addr ) {
  793. addreply( 425, "Will not open connection to %d.%d.%d.%d (only to %s)",
  794.   (a >> 24) & 255, (a >> 16) & 255, (a >> 8) & 255, a & 255,
  795.   inet_ntoa( peer.sin_addr ) );
  796. close( datafd );
  797. datafd = 0;
  798. return;
  799.     }
  801.     passive = 0;
  803.     addreply( 200, "PORT command successful" );
  804.     return;
  805. }
  809. int opendata( void )
  810. {
  811.     struct sockaddr_in dataconn; /* his data connection endpoint */
  812.     int fd;
  813.     int fodder;
  815.     if ( !datafd ) {
  816. error( 425, "No data connection" );
  817. return 0;
  818.     }
  820.     if ( passive ) {
  821. fodder = sizeof( dataconn );
  822. fd = accept( datafd, (struct sockaddr *)&dataconn, &fodder );
  823. if ( fd < 0 ) {
  824.     error( 421, "accept failed" );
  825.     return 0;
  826. }
  827. addreply( 150, "Accepted data connection from %s:%d",
  828.   inet_ntoa( dataconn.sin_addr ),
  829.   ntohs((unsigned short int)dataconn.sin_port) );
  830.     } else {
  831. dataconn.sin_addr.s_addr = peer.sin_addr.s_addr;
  832. dataconn.sin_port = htons( peerdataport );
  833. dataconn.sin_family = AF_INET;
  835. if (connect(datafd, (struct sockaddr *)&dataconn, sizeof(dataconn))) {
  836.     addreply( 425, "Could not open data connection to %s port %d: %s",
  837.       inet_ntoa( dataconn.sin_addr ), peerdataport,
  838.       strerror( errno ) );
  839.     close( datafd );
  840.     datafd = 0;
  841.     return 0;
  842. }
  843. fd = datafd;
  844. datafd = 0;
  845. addreply( 150, "Connecting to %s:%d",
  846.   inet_ntoa( dataconn.sin_addr ), peerdataport );
  847.     }
  850.     fodder = IPTOS_THROUGHPUT;
  851.     if ( setsockopt( fd, SOL_IP, IP_TOS, (char *)&fodder, sizeof(int) ) < 0 )
  852.   syslog( LOG_WARNING, "setsockopt( IP_TOS ): %m" );
  854.     fodder = window;
  855.     if ( setsockopt( fd, SOL_SOCKET, SO_SNDBUF,
  856.      (char *)&fodder, sizeof(int) ) < 0 )
  857. syslog( LOG_WARNING, "setsockopt( SO_SNDBUF, %d ): %m", window );
  859.     fodder = window; /* not that important, but... */
  860.     if ( setsockopt( fd, SOL_SOCKET, SO_RCVBUF,
  861.      (char *)&fodder, sizeof(int) ) < 0 )
  862. syslog( LOG_WARNING, "setsockopt( SO_RCVBUF, %d ): %m", window );
  864.     return fd;
  865. }
  868. void dodele( const char *name )
  869. {
  870.     if ( guest ) {
  871. addreply( 550, "Anonymous users can not delete files." );
  872.     } else if ( !name || !*name ) {
  873. addreply( 501, "No file name supplied." );
  874.     } else {
  875. int successes = 0;
  876. glob_t g;
  877. int a;
  879. a = glob( name, 0, NULL, &g );
  880. if ( a == GLOB_NOSPACE ) {
  881.     addreply( 550, "Out of memory during globbing of %s", name );
  882.     addreply( 0, "(This probably means "Permission denied")" );
  883. } else if ( a == GLOB_ABEND ) {
  884.     addreply( 550, "Read error during globbing of %s", name );
  885. } else if ( a == GLOB_NOMATCH ) {
  886.     addreply( 550, "No match for %s in %s", name, wd );
  887. } else if ( a == 0 ) {
  888.     char **path;
  890.     path = g.gl_pathv;
  891.     while ( path && *path ) {
  892. if ( unlink( *path ) ) {
  893.     addreply( 0, "Could not delete %s: %s",
  894.       *path, strerror( errno ) );
  895. } else {
  896.     addreply( 250, "Deleted %s", *path );
  897.     successes++;
  898. }
  899. path++;
  900.     }
  901. }
  902. globfree( &g );
  903. /* set the reply code in case there were no successes */
  904. if ( successes == 0 )
  905.     addreply( 550, "No files deleted." );
  906.     }
  907. }
  910. void doretr( const char *name )
  911. {
  912.     int c, f, o, s, skip;
  913.     struct stat st;
  914.     char *p, *buf;
  915.     int left;
  916.     struct timeval started, ended;
  917.     double t;
  918.     double speed;
  919.     char speedstring[30];
  921.     if ( !candownload ) {
  922. addreply( 550, "The load was %3.2f when you connected.  We do not "
  923.   "allow downloadsnby anonymous users when the load is "
  924.   "that high.  Uploads are alwaysnallowed.", load );
  925. return;
  926.     }
  928.     f = open( name, O_RDONLY );
  929.     if ( f < 0 ) {
  930. char buffer[PATH_MAX + 40];
  931. snprintf( buffer, PATH_MAX+39, "Can't open %s", name );
  932. error( 550, buffer );
  933. return;
  934.     }
  935.     if ( fstat( f, &st ) ) {
  936. close( f );
  937. error( 451, "can't find file size" );
  938. return;
  939.     }
  940.     if ( restartat && ( restartat > st.st_size ) ) {
  941. addreply( 451, "Restart offset %d is too large for file size %d.n"
  942.   "Restart offset reset to 0.",
  943.   restartat, st.st_size );
  944. restartat = 0;
  945. return;
  946.     }
  947.     if ( !S_ISREG( st.st_mode ) ) {
  948. close( f );
  949. addreply( 450, "Not a regular file" );
  950. return;
  951.     }
  952.     if ( warez && ( st.st_uid == warez ) && guest ) {
  953. close( f );
  954. addreply( 550, "This file has been uploaded by an anonymous user.  "
  955.   "It has notnyet been approved for downloading by "
  956.   "the site administrators.n" );
  957. return;
  958.     }
  960.     c = opendata();
  961.     if ( !c ) {
  962. close( f );
  963. return;
  964.     }
  965.     if ( (s = fcntl( c, F_GETFL, 0 ) ) < 0 ) {
  966. error( 451, "fcntl failed" );
  967. close( f );
  968. close( c );
  969. return;
  970.     }
  971.     s |= FNDELAY;
  972.     fcntl( c, F_SETFL, s );
  974.     if ( type == 1 ) {
  975. addreply( 0,
  976.   "NOTE: ASCII mode requested, but binary mode used" );
  977. if ( (time( 0 ) % 1000000 ) == 0 )
  978.     addreply( 0, "The computer is your friend. Trust the computer" );
  979.     }
  980.     if ( st.st_size - restartat > 4096 )
  981. addreply( 0, "%.1f kbytes to download",
  982.   (st.st_size - restartat) / 1024.0 );
  984.     doreply();
  986.     (void)gettimeofday( &started, NULL );
  988.     o = restartat & ~262143;
  989.     skip = restartat - o;
  990.     while ( o < st.st_size ) {
  991. left = st.st_size - o;
  992. if ( left > 262144 )
  993.     left = 262144;
  994. buf = mmap( 0, left, PROT_READ, MAP_FILE | MAP_SHARED, f, o );
  995. if ( buf == (char *)-1 ) {
  996.     error( 451, "mmap of file failed" );
  997.     close( f );
  998.     close( c );
  999.     return;
  1000. }
  1001. p = buf;
  1002. o += left;
  1003. s = left;
  1004. while ( left > skip ) {
  1005.     size_t w;
  1007.     w = write( c, p+skip, (size_t) (left - skip) );
  1008.     if ( (int ) w < 0 ) {
  1009. if ( errno == EAGAIN ) {
  1010.     /* wait idletime seconds for progress */
  1011.     fd_set rs;
  1012.     fd_set ws;
  1013.     struct timeval tv;
  1015.     FD_ZERO( &rs );
  1016.     FD_ZERO( &ws );
  1017.     FD_SET( 0, &rs );
  1018.     FD_SET( c, &ws );
  1019.     tv.tv_sec = idletime;
  1020.     tv.tv_usec = 0;
  1021.     select( c + 1, &rs, &ws, NULL, &tv );
  1022.     if ( FD_ISSET( 0, &rs ) ) {
  1023. /* we assume is is ABRT since nothing else is legal */
  1024. addreply( 426, "Transfer aborted" );
  1025. munmap( buf, s );
  1026. close( f );
  1027. close( c );
  1028. return;
  1029.     } else if ( !( FD_ISSET( c, &ws ) ) ) {
  1030. /* client presumably gone away */
  1031. syslog( LOG_INFO,
  1032. "died: %ld seconds without download progress",
  1033. idletime );
  1034. exit( 11 );
  1035.     }
  1036.     w = 0;
  1037. } else {
  1038.     error( 450, "Error during write to data connection" );
  1039.     close( f );
  1040.     close( c );
  1041.     return;
  1042. }
  1043.     }
  1044.     left -= w;
  1045.     p += w;
  1046. }
  1047. skip = 0;
  1048. munmap( buf, s );
  1049.     }
  1051.     (void)gettimeofday( &ended, NULL );
  1052.     t = ( ended.tv_sec + ended.tv_usec / 1000000.0 ) -
  1053. ( started.tv_sec + started.tv_usec / 1000000.0 );
  1054.     addreply( 226, "File written successfully" );
  1055.     if ( t && ( st.st_size - restartat ) > 2*window )
  1056. speed = ( st.st_size - restartat - window ) / t;
  1057.     else
  1058. speed = 0.0;
  1059.     if ( speed > 524288 )
  1060. addreply( 0, "%.3f seconds (measured here), %.2f Mbytes per second",
  1061.   t, speed / 1048576 );
  1062.     else if ( speed > 512 )
  1063. addreply( 0, "%.3f seconds (measured here), %.2f Kbytes per second",
  1064.   t, speed / 1024 );
  1065.     else if ( speed > 0.1 )
  1066. addreply( 0, "%.3f seconds (measured here), %.2f bytes per second",
  1067.   t, speed );
  1068.     close( f );
  1069.     close( c );
  1071.     downloaded = downloaded + st.st_size - restartat;
  1072.     if ( restartat ) {
  1073. addreply( 0, "Restart offset reset to 0." );
  1074. restartat = 0;
  1075.     }
  1077.     sprintf( speedstring, " (%.2fKB/sec)", speed/1024 );
  1078.     syslog( LOG_INFO, "%s%s%s%s downloaded%s",
  1079.     rd ? rd :  "",
  1080.     *name == '/' ? "" : wd,
  1081.     ( *name != '/' && ( !*wd || wd[strlen( wd ) - 1] != '/' ) )
  1082.     ? "/" : "",
  1083.     name,
  1084.     speed > 0.1 ? speedstring : "" );
  1085. }
  1088. void dorest (const char *name)
  1089. {
  1090.     char *endptr;
  1091.     restartat = strtoul( name, &endptr, 10 );
  1092.     if ( *endptr ) {
  1093. restartat = 0;
  1094. addreply( 501, "RESTART needs numeric parameter." );
  1095.     } else {
  1096. syslog( LOG_NOTICE, "info: restart %d", restartat );
  1097. addreply( 350,
  1098.   "Restarting at %ld. Send STOR or RETR to initiate transfer.",
  1099.   restartat );
  1100.     }
  1101. }
  1105. /* next two functions contributed by Patrick Michael Kane <modus@asimov.net> */
  1106. void domkd( const char *name )
  1107. {
  1108.     if ( guest )
  1109. addreply( 550, "Sorry, anonymous users are not allowed to "
  1110.   "make directories." );
  1111.     else if ( (mkdir( name, 0755 ) ) < 0 )
  1112. error( 550, "Can't create directory" );
  1113.     else
  1114. addreply( 257, "MKD command successful." );
  1115. }
  1118. void dormd( const char *name )
  1119. {
  1120.     if ( guest )
  1121. addreply( 550, "Sorry, anonymous users are not allowed to "
  1122.   "remove directories." );
  1123.     else if ( (rmdir( name ) ) < 0 )
  1124. error( 550, "Can't remove directory" );
  1125.     else
  1126. addreply( 250, "RMD command successful." );
  1127. }
  1130. void dostor( const char *name )
  1131. {
  1132.     int c, f;
  1133.     char *p;
  1134.     char buf[16384];
  1135.     int r;
  1136.     static int filesize; /* static to avoid longjmp warning */
  1137.     struct statfs statfsbuf;
  1138.     struct stat st;
  1139.     // Added for ascii upload
  1140.     int i,j,k;
  1141.     char cpy[16384];
  1142.     char *q;
  1144.     filesize = 0;
  1146.     if ( type < 1 ) {
  1147. addreply( 503, "Only ASCII and binary modes are supported" );
  1148. return;
  1149.     }
  1151.     if ( !stat( name, &st ) )  {
  1152. if ( guest ) {
  1153.     addreply( 553,
  1154.       "Anonymous users may not overwrite existing files" );
  1155.     return;
  1156. }
  1157.     } else if ( errno != ENOENT ) {
  1158. error( 553, "Can't check for file presence" );
  1159. return;
  1160.     }
  1161.     f = open( name, O_CREAT | O_TRUNC | O_WRONLY, 0600 );
  1162.     if ( f < 0 ) {
  1163. error( 553, "Can't open file" );
  1164. return;
  1165.     }
  1166.     if ( restartat && lseek(f, restartat, SEEK_SET) < 0) {
  1167. error (451, "can't seek" );
  1168. return;
  1169.     }
  1171.     c = opendata();
  1172.     if ( !c ) {
  1173. close( f );
  1174. return;
  1175.     }
  1176.     doreply();
  1178.     k=0;
  1179.     do {
  1180. /* wait idletime seconds for data to be available */
  1181. fd_set rs;
  1182. struct timeval tv;
  1184. FD_ZERO( &rs );
  1185. FD_SET( 0, &rs );
  1186. FD_SET( c, &rs );
  1187. tv.tv_sec = idletime;
  1188. tv.tv_usec = 0;
  1189. select( c + 1, &rs, NULL, NULL, &tv );
  1190. if ( FD_ISSET( 0, &rs ) ) {
  1191.     addreply( 0, "ABRT is the only legal command while uploading" );
  1192.     addreply( 426, "Transfer aborted" );
  1193.     close( f );
  1194.     close( c );
  1195.     addreply( 0, "%s %s", name,
  1196.       unlink( name ) ? "partially uploaded" : "removed" );
  1197.     return;
  1198. } else if ( !( FD_ISSET( c, &rs ) ) ) {
  1199.     /* client presumably gone away */
  1200.     unlink( name );
  1201.     syslog( LOG_INFO, "died: %ld seconds without upload progress",
  1202.     idletime );
  1203.     exit( 20 );
  1204. }
  1205. r = read( c, &buf, 16384 );
  1206. if ( r > 0 ) {
  1207.     p = buf;
  1209.     filesize += r;
  1210.     while ( r ) {
  1211. size_t w;
  1213. if ( type == 1 ) {
  1214.     for (i=0,j=0;i < ( size_t ) r;i++,j++) {
  1215. if ( p[i] == 'r' ) {
  1216.     i++;
  1217.     k++;
  1218.   }
  1219. cpy[j] = buf[i];
  1220.     }
  1221.     q = cpy;
  1222.     r -= k;
  1223.     w = write( f, q, ( size_t ) r );
  1224. } else {
  1225.     w = write( f, p, ( size_t ) r );
  1226. }
  1228. if ( (signed int)w < 0 ) {
  1229.     error( -450, "Error during write to file" );
  1230.     close( f );
  1231.     close( c );
  1232.     addreply( 450, "%s %s", name,
  1233.       unlink(name)?"partially uploaded":"removed" );
  1234.     return;
  1235. }
  1236. r -= w;
  1237. p += w;
  1238.     }
  1239.     r = 1;
  1240. } else if ( r < 0 ) {
  1241.     error( -451, "Error during read from data connection" );
  1242.     close( f );
  1243.     close( c );
  1244.     addreply( 451, "%s %s", name,
  1245.       unlink( name ) ? "partially uploaded" : "removed" );
  1246.     return;
  1247. }
  1248.     } while ( r > 0 );
  1250.     fchmod( f, 0644 );
  1251.     addreply( 226, "File written successfully" );
  1253.     if ( fstatfs( f, &statfsbuf ) == 0 ) {
  1254. double space;
  1256. space = (double)statfsbuf.f_bsize * (double)statfsbuf.f_bavail;
  1257. if ( space > 524288 )
  1258.     addreply( 0, "%.1f Mbytes free disk space", space / 1048576 );
  1259. else
  1260.     addreply( 0, "%f Kbytes free disk space", space / 1024 );
  1261.     }
  1262.     close( f );
  1263.     close( c );
  1264.     uploaded += filesize;
  1265.     syslog( LOG_INFO, "%s%s%s%s uploaded",
  1266.     rd ? rd :  "",
  1267.     *name == '/' ? "" : wd,
  1268.     ( *name != '/' && ( !*wd || wd[strlen( wd ) - 1] != '/' ) )
  1269.     ? "/" : "",
  1270.     name );
  1271.     return;
  1272. }
  1276. void domdtm( const char *name )
  1277. {
  1278.     struct stat st;
  1279.     struct tm *t;
  1281.     if ( !name || !*name ) {
  1282. addreply( 500, "Command not understood" );
  1283.     } else if ( lstat( name, &st ) ) {
  1284. if ( debug )
  1285.     addreply( 0, "arg is %s, wd is %s", name, wd );
  1286. addreply( 550, "Unable to stat()" );
  1287.     } else if ( !S_ISREG( st.st_mode ) ) {
  1288. addreply( 550, "Not a regular file" );
  1289.     } else {
  1290. t = gmtime( (time_t * ) & st.st_mtime );
  1291. if ( !t ) {
  1292.     addreply( 550, "gmtime() returned NULL" );
  1293. } else {
  1294.     addreply( 213, "%04d%02d%02d%02d%02d%02d",
  1295.      t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
  1296.      t->tm_hour, t->tm_min, t->tm_sec );
  1297. }
  1298.     }
  1299.     return;
  1300. }
  1303. void dosize( const char *name )
  1304. {
  1305.     struct stat st;
  1307.     if ( !name || !*name ) {
  1308. addreply( 500, "Command not understood" );
  1309.     } else if ( lstat( name, &st ) ) {
  1310. if ( debug )
  1311.     addreply( 0, "arg is %s, wd is %s", name, wd );
  1312. addreply( 550, "Unable to stat()" );
  1313.     } else if ( !S_ISREG( st.st_mode ) ) {
  1314. addreply( 550, "Not a regular file" );
  1315.     } else {
  1316. addreply( 213, "%ld ", (long)st.st_size );
  1317.     }
  1318.     return;
  1319. }
  1322. void dotype( const char *arg )
  1323. {
  1324.     replycode = 200; /* bloody awful hack */
  1326.     if ( !arg || !*arg ) {
  1327. addreply( 501, "TYPE needs an argumentn"
  1328.  "Only A(scii), I(mage) and L(ocal) are supported" );
  1329.     } else if ( tolower(*arg) == 'a' )
  1330. type = 1;
  1331.     else if ( tolower(*arg) == 'i' )
  1332. type = 2;
  1333.     else if ( tolower(*arg) == 'l' ) {
  1334. if ( arg[1] == '8' ) {
  1335.     type = 2;
  1336. } else if ( isdigit( arg[1] ) ) {
  1337.     addreply( 504, "Only 8-bit bytes are supported" );
  1338. } else {
  1339.     addreply( 0, "Byte size not specified" );
  1340.     type = 2;
  1341. }
  1342.     } else {
  1343. addreply( 504, "Unknown TYPE: %s", arg );
  1344.     }
  1346.     addreply( 0, "TYPE is now %s", ( type > 1 ) ? "8-bit binary" : "ASCII" );
  1347. }
  1350. void dostru( const char *arg )
  1351. {
  1352.     if ( !arg || !*arg )
  1353. addreply( 500, "No argumentsn"
  1354.  "Not that it matters, only STRU F is supported" );
  1355.     else if ( strcasecmp( arg, "F" ) )
  1356. addreply( 504, "STRU %s is not supportednOnly F(ile) is supported",
  1357.  arg );
  1358.     else
  1359. addreply( 200, "F OK" );
  1360. }
  1363. void domode( const char *arg )
  1364. {
  1365.     if ( !arg || !*arg )
  1366. addreply( 500, "No argumentsn"
  1367.  "Not that it matters, only MODE S is supported" );
  1368.     else if ( strcasecmp( arg, "S" ) )
  1369. addreply( 504, "MODE %s is not supportedn"
  1370.  "Only S(tream) is supported", arg );
  1371.     else
  1372. addreply( 200, "S OK" );
  1373. }
  1376. void dornfr( const char *name )
  1377. {
  1378.     struct stat st;
  1379.     if ( guest ) {
  1380. addreply( 550,
  1381.   "Sorry, anonymous users are not allowed to rename files." );
  1382.     } else if ( ( stat( name, &st ) ) == 0 ) {
  1383. if ( renamefrom ) {
  1384.     addreply( 0, "Aborting previous rename operation." );
  1385.     (void) free( renamefrom );
  1386. }
  1387. renamefrom = strdup( name );
  1388. addreply( 350, "RNFR accepted - file exists, ready for destination." );
  1389.     } else {
  1390. addreply( 550, "File does not exist!" );
  1391.     }
  1392.     return;
  1393. }
  1396. /* rnto can return 550, which is not strictly allowed */
  1398. void dornto( const char *name )
  1399. {
  1400.     struct stat st;
  1401.     if ( guest )
  1402. addreply( 550,
  1403.   "Sorry, anonymous users are not allowed to rename files." );
  1404.     else if ( ( stat( name, &st ) ) == 0 )
  1405. addreply( 550, "RENAME Failed - destination file already exists." );
  1406.     else if ( !renamefrom )
  1407. addreply( 503, "Need RNFR before RNTO" );
  1408.     else if ( (rename( renamefrom, name ) ) < 0 )
  1409. addreply( 550, "Rename failed: %s", strerror( errno ) );
  1410.     else
  1411. addreply( 250, "File renamed." );
  1413.     if ( renamefrom )
  1414. (void) free( renamefrom );
  1415.     renamefrom = 0;
  1416.     return;
  1417. }
  1418. // end of addition
  1421. void error( int n, const char *msg )
  1422. {
  1423.     syslog( LOG_ERR, "%s: %m", msg );
  1424.     addreply( n, "%s: %s", msg, strerror( errno ) );
  1425. }
  1429. int main( int argc, char **argv )
  1430. {
  1431.     int fodder;
  1432.     struct hostent *he;
  1433.     struct passwd *pw;
  1434.     FILE *f;
  1435.     double maxload;
  1436.     time_t tmt;
  1437.     struct tm *t;
  1438.     struct rusage ru;
  1439.     int dowarez;
  1440.     unsigned long maxusers;
  1441.     struct sigaction sa;
  1443.     /* logging stuff.  use sigaction so they're not reset */
  1444.     sa.sa_handler = sighandler;
  1445.     sa.sa_mask = 0;
  1446.     sa.sa_flags = SA_RESTART;
  1447.     (void)sigaction( SIGUSR1, &sa, NULL );
  1448.     (void)sigaction( SIGUSR2, &sa, NULL );
  1449.     /* we pretend urgent data doesn't exist */
  1450.     sa.sa_handler = SIG_IGN;
  1451.     (void)sigaction( SIGURG, &sa, NULL );
  1453.     maxload = 0.0;
  1454.     maxusers = 0;
  1456.     openlog( "in.ftpd", LOG_CONS | LOG_PID, LOG_LOCAL2 );
  1458.     while ( (fodder = getopt( argc, argv, "c:df:m:p:su:" ) ) != -1 ) {
  1459. if ( fodder == 's' ) {
  1460.     if ( (pw = getpwnam( "ftp" ) ) )
  1461. warez = pw->pw_uid;
  1462.     else
  1463. syslog( LOG_ERR, "can't find ftp uid" );
  1464. } else if ( fodder == 'd' ) {
  1465.     if ( logging < 2 )
  1466. logging++;
  1467. } else if ( fodder == 'c' ) {
  1468.     char *nptr, *endptr;
  1470.     nptr = optarg;
  1471.     endptr = NULL;
  1472.     maxusers = strtoul( nptr, &endptr, 0 );
  1473.     if ( !nptr || !*nptr || !endptr || *endptr || !maxusers ) {
  1474. printf( "421 Configuration error: Illegal user limit: %srn",
  1475. optarg );
  1476. syslog( LOG_ERR, "Illegal user limit: %s", optarg );
  1477. sleep( 1 );
  1478. exit( 8 );
  1479.     }
  1480. } else if ( fodder == 'f' ) {
  1481.     int n;
  1482.     n=0;
  1483.     while( facilitynames[n].c_name &&
  1484.    strcasecmp( facilitynames[n].c_name, optarg ) )
  1485. n++;
  1486.     if ( facilitynames[n].c_name ) {
  1487. closelog();
  1488. openlog( "in.ftpd", LOG_CONS | LOG_PID,
  1489.  facilitynames[n].c_val );
  1490.     } else {
  1491. syslog( LOG_ERR, "Unknown facility name %s", optarg );
  1492.     }
  1493. } else if ( fodder == 'm' ) {
  1494.     char *nptr,
  1495. *endptr;
  1497.     nptr = optarg;
  1498.     endptr = NULL;
  1499.     maxload = strtod( nptr, &endptr );
  1500.     if ( !nptr || !*nptr || !endptr || *endptr || maxload <= 0.0 ) {
  1501. printf( "421 Configuration error: Illegal load limit: %srn",
  1502. optarg );
  1503. syslog( LOG_ERR, "Illegal load limit: %s", optarg );
  1504. sleep( 1 );
  1505. exit( 15 );
  1506.     }
  1507. } else if ( fodder == 'p' ) {
  1508.     int ret;
  1510.     ret = sscanf(optarg, "%d:%d", &firstport, &lastport);
  1511.     if ( ret != 2 ||
  1512.  firstport < 1024 ||
  1513.  lastport > 65535 ||
  1514.  lastport <= firstport ) {
  1515. printf( "421 Configuration error: Illegal port range: %srn",
  1516. optarg );
  1517. syslog( LOG_ERR, "Illegal port range: %s", optarg );
  1518. sleep( 1 );
  1519. exit( 17 );
  1520.     }
  1521. } else if ( fodder == 'u' ) {
  1522.     char *nptr, *endptr;
  1523.     long tmp;
  1525.     nptr = optarg;
  1526.     endptr = NULL;
  1527.     tmp = strtol( nptr, &endptr, 10 );
  1528.     if ( !nptr || !*nptr || !endptr || *endptr ||
  1529.  tmp > 65535 || tmp < 0 ) {
  1530. printf( "421 Configuration error: Illegal uid limit: %srn",
  1531. optarg );
  1532. syslog( LOG_ERR, "Illegal uid limit: %s", optarg );
  1533. sleep( 1 );
  1534. exit( 16 );
  1535.     }
  1536.     useruid = (uid_t) tmp;
  1537. } else if ( fodder == '?' ) {
  1538.     syslog( LOG_WARNING, "unknown option" );
  1539. }
  1540.     }
  1542.     if ( firstport || maxusers ) {
  1543. int users;
  1544. if ( firstport ) {
  1545.     int portmax;
  1546.     portmax = (lastport-firstport+1)/2;
  1547.     if ( !maxusers || maxusers > portmax )
  1548. maxusers = portmax; /* ... so we don't run out of ports */
  1549. }
  1551. users = daemons();
  1552. if ( users > maxusers ) {
  1553.     printf( "421 %d users (the maximum) are already logged inrn",
  1554.     maxusers );
  1555.     sleep( 1 );
  1556.     exit( 5 );
  1557. }
  1558. addreply( 0, "You are user number %d of %d allowed.",
  1559.   users, maxusers );
  1560.     }
  1562.     load = -1.0;
  1563.     if ( (f = fopen( "/proc/loadavg", "r" ) ) != NULL &&
  1564.  fscanf( f, "%lf", &load ) == 1 )
  1565. fclose( f );
  1567.     fodder = sizeof(struct sockaddr_in);
  1569.     if ( getsockname( 0, (struct sockaddr *)&ctrlconn, &fodder ) ) {
  1570. printf( "421 Cannot getsockname( STDIN ), errno=%drn", errno );
  1571. syslog( LOG_ERR, "Cannot getsockname( STDIN ): %s", strerror(errno) );
  1572. exit( 3 );
  1573.     }
  1574.     getnames();
  1576.     loggedin = 0;
  1578.     if ( getpeername( 0, (struct sockaddr *)&peer, &fodder ) ) {
  1579. printf( "421 Cannot getpeername( STDIN ), errno=%drn", errno );
  1580. syslog( LOG_ERR, "Cannot getpeername( STDIN ): %s", strerror(errno) );
  1581. sleep( 1 );
  1582. exit( 9 );
  1583.     }
  1584.     he = gethostbyaddr( (char *)&peer.sin_addr.s_addr,
  1585. sizeof(peer.sin_addr.s_addr),
  1586. AF_INET );
  1587.     syslog( LOG_INFO, "connection from %s",
  1588.     he && strlen( he->h_name )
  1589.     ? he->h_name : inet_ntoa( peer.sin_addr ) );
  1591.     he = gethostbyaddr( (char *)&ctrlconn.sin_addr.s_addr,
  1592. sizeof(ctrlconn.sin_addr.s_addr),
  1593. AF_INET );
  1594.     if ( he && he->h_name ) {
  1595. char name[PATH_MAX];
  1596. FILE * config;
  1598. if ( snprintf( name, PATH_MAX, "/var/adm/ftp/%s/.", he->h_name ) < 0 ){
  1599.     syslog( LOG_ERR, "host name far too long for %s",
  1600.     inet_ntoa( ctrlconn.sin_addr ) );
  1601.     exit( 15 );
  1602. }
  1603. if ( !chdir( name ) ) {
  1604.     rd = malloc( strlen( he->h_name ) + 3 );
  1605.     /* it'd be much better with a separate name here */
  1606.     if ( !rd ||
  1607.  ( pw = getpwnam( "ftp" ) ) == NULL ||
  1608.  setregid( pw->pw_gid, pw->pw_gid ) ||
  1609.  setgroups( sizeof( pw->pw_gid ), &( pw->pw_gid ) ) ||
  1610.  chroot( name ) ||
  1611.  chdir( "/" ) ) {
  1612. printf( "421 Unable to cage in anonymous user, abortingrn" );
  1613. syslog( LOG_INFO, "Unable to cage in anonymous user" );
  1614. fflush( stdout );
  1615. sleep( 1 );
  1616. exit( 10 );
  1617.     }
  1618.     sprintf( rd, "%s:", he->h_name );
  1619.     setfsuid( pw->pw_uid );
  1620.     dobanner();
  1621.     loggedin = guest = 1;
  1622.     syslog( LOG_INFO, "logged in guest of %s", he->h_name );
  1623. } else if ( (config=fopen( name, "r" )) != NULL ) {
  1624.     char line[1024];
  1625.     do {
  1626. fgets( line, 1024, config );
  1627.     } while( 0 );
  1628.     printf( "421 %s: configuration errorrn", name );
  1629.     syslog( LOG_ERR, "%s: configuration error", name );
  1630.     fflush( stdout );
  1631.     sleep( 1 );
  1632.     exit( 19 );
  1633. }
  1634. cpwd = strdup( "*" );
  1635.     }
  1637.     chdir( "/" );
  1638.     strcpy( wd, "/" );
  1640.     fodder = IPTOS_LOWDELAY;
  1641.     if ( setsockopt( 0, SOL_IP, IP_TOS, (char *)&fodder, sizeof(int) ) < 0 )
  1642. syslog( LOG_WARNING, "setsockopt ( IP_TOS ): %m" );
  1644.     fodder = 1;
  1645.     if ( setsockopt( 0, SOL_SOCKET, SO_OOBINLINE,
  1646.      (char *)&fodder, sizeof(int) ) < 0 )
  1647. syslog( LOG_WARNING, "setsockopt: %m" );
  1649.     tmt = time( NULL );
  1650.     t = localtime( (time_t *) &tmt );
  1651.     if ( t != 0 && load >= 0.0 )
  1652. addreply( 220,
  1653.   "Local time is now %02d:%02d and the load is %3.2f.",
  1654.   t->tm_hour, t->tm_min, load );
  1655.     else
  1656. syslog( LOG_ERR, "unable to read load average or current time" );
  1658.     if ( loggedin )
  1659. addreply( 220,
  1660.   "Only anonymous FTP is allowed at %s.", he->h_name );
  1662.     addreply( 220, "You will be disconnected after %d seconds of inactivity.",
  1663.       idletime );
  1665.     candownload = maxload <= 0.0 || load < maxload;
  1667.     parser();
  1669.     if ( getrusage( RUSAGE_SELF, &ru ) == 0 ) {
  1670. unsigned long s, u;
  1672. u = ( ru.ru_utime.tv_usec + ru.ru_stime.tv_usec + 500 ) / 1000;
  1673. s = ru.ru_utime.tv_sec + ru.ru_stime.tv_sec;
  1674. if ( u > 999 ) {
  1675.     u -= 1000;
  1676.     s++;
  1677. }
  1678. addreply( 0, "CPU time spent on you: %ld.%03ld seconds.", s, u );
  1679.     }
  1680.     doreply();
  1681.     sleep( 1 );
  1682.     exit( 0 );
  1683. }